@lucent-lang/lucent 0.0.4

package/dist/compiler.js

@@ -0,0 +1,4 @@
+import { n as Explanations, r as docsUrl, t as Codes } from "./codes-CIuwXt1S.js";
+import { A as formatDiagnostic, C as extractionCount, D as sdkModule, E as sdkAvailable, O as sdkModules, S as cachedModules, T as prefetch, _ as usesPlatforms, a as inputsKey, b as coverage, c as withGradleDependencies, d as coreJsPath, f as coreTypesPath, g as projectFiles, h as platformOf, i as report, k as sdkNames, l as writeNativePackage, m as moduleNameOf, n as compile, o as isUpToDate, p as findLucentFiles, r as compileDirectory, s as runtimeDir, t as checkSources, u as LUCENT_EXTENSION, v as moduleNamespace, w as forgetLoadedSdks, x as podsSearchPaths, y as sdkDts } from "./src-BD7f1_aZ.js";
+import { a as satisfies, i as nativeDependencies, n as lucentPackages, r as lucentVersion } from "./packages-HyskKIsY.js";
+export { Codes, Explanations, LUCENT_EXTENSION, cachedModules, checkSources, compile, compileDirectory, coreJsPath, coreTypesPath, docsUrl, extractionCount, findLucentFiles, forgetLoadedSdks, formatDiagnostic, inputsKey, isUpToDate, lucentPackages, lucentVersion, moduleNameOf, moduleNamespace, nativeDependencies, platformOf, podsSearchPaths, prefetch as prefetchSdk, projectFiles, report, runtimeDir, satisfies, sdkAvailable, coverage as sdkCoverage, sdkDts, sdkModule, sdkModules, sdkNames, usesPlatforms, withGradleDependencies, writeNativePackage };

package/dist/confirm-BYF5eY3q.js

@@ -0,0 +1,34 @@
+import { t as renderDiff } from "./diff-BTDo3Sro.js";
+import { Box, Static, Text, useInput } from "ink";
+import { useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/cli/init/confirm.tsx
+function Confirm({ changes, theme, onDone }) {
+	const [answers, setAnswers] = useState([]);
+	useInput((input, key) => {
+		const yes = input === "y" || input === "Y" || key.return;
+		if (!yes && !(input === "n" || input === "N") || answers.length >= changes.length) return;
+		const next = [...answers, yes];
+		setAnswers(next);
+		if (next.length === changes.length) onDone(next);
+	});
+	const current = changes[answers.length];
+	const decided = answers.map((yes, i) => ({
+		yes,
+		change: changes[i]
+	}));
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Static, {
+		items: decided,
+		children: ({ yes, change }, i) => /* @__PURE__ */ jsx(Text, { children: `${yes ? theme.success(theme.symbols.ok) : theme.dim(theme.symbols.off)} ${change.file}  ${theme.dim(yes ? change.why : "skipped")}` }, i)
+	}), current ? /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		marginTop: 1,
+		children: [
+			/* @__PURE__ */ jsx(Text, { children: `${theme.bold(current.file)}${current.before === void 0 ? theme.dim(" (new)") : ""}  ${theme.dim(current.why)}` }),
+			/* @__PURE__ */ jsx(Text, { children: renderDiff(current.before ?? "", current.after, theme) }),
+			/* @__PURE__ */ jsx(Text, { children: `Apply? ${theme.dim("(Y/n)")}` })
+		]
+	}) : null] });
+}
+//#endregion
+export { Confirm };

package/dist/dashboard-B-NzjjaN.js

@@ -0,0 +1,91 @@
+import { i as table, n as duration, t as codeFrame } from "./format-D9fnIMEx.js";
+import { n as nextText } from "./pipeline-CH7-2cxu.js";
+import { Box, Text, render, useApp, useInput } from "ink";
+import { useState, useSyncExternalStore } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/cli/dev/dashboard.tsx
+const ENTER = "\x1B[?1049h";
+const LEAVE = "\x1B[?1049l\x1B[?25h";
+async function dashboard(options) {
+	const stdout = options.stdout ?? process.stdout;
+	stdout.write(ENTER);
+	const app = render(/* @__PURE__ */ jsx(Dashboard, { ...options }), {
+		stdout,
+		stdin: options.stdin ?? process.stdin,
+		exitOnCtrlC: false,
+		patchConsole: false,
+		interactive: true
+	});
+	const restore = () => stdout.write(LEAVE);
+	process.once("exit", restore);
+	try {
+		await app.waitUntilExit();
+	} finally {
+		options.session.stop();
+		process.off("exit", restore);
+		restore();
+	}
+}
+function Dashboard({ session, theme: t, root, open, doctor }) {
+	const s = useSyncExternalStore(session.store.subscribe, session.store.get);
+	const { exit } = useApp();
+	const [selected, setSelected] = useState(0);
+	const [checks, setChecks] = useState(void 0);
+	const problem = s.problems[Math.min(selected, s.problems.length - 1)];
+	useInput((input, key) => {
+		if (input === "q" || key.ctrl && input === "c") exit();
+		else if (input === "r") session.rebuild();
+		else if (input === "c") session.clearCache();
+		else if (input === "d") setChecks(checks ? void 0 : doctor());
+		else if (input === "o" && problem?.file) open(problem.file, problem.line ?? 1);
+		else if (key.upArrow) setSelected((i) => Math.max(0, i - 1));
+		else if (key.downArrow) setSelected((i) => Math.min(s.problems.length - 1, i + 1));
+	});
+	const cell = (state) => state === "ok" ? t.success(t.symbols.on) : state === "error" ? t.error(t.symbols.fail) : state === "building" ? t.progress(t.symbols.off) : " ";
+	const last = s.lastBuild;
+	const when = s.building ? t.progress(`building${t.symbols.ellipsis}`) : last ? `${last.at.toLocaleTimeString("en-GB")}  ${duration(last.ms)}` : "";
+	const rows = table([[
+		t.dim("MODULE"),
+		t.dim("IOS"),
+		t.dim("ANDROID"),
+		t.dim("LAST BUILD")
+	], ...s.modules.map((m) => [
+		m.name,
+		cell(m.platforms.ios),
+		cell(m.platforms.android),
+		when
+	])], 3);
+	const status = last?.fatal ? t.error(`${t.symbols.fail} ${last.fatal}`) : last?.ok && last.next?.rebuild ? t.warn(`next: ${nextText(last.next)}`) : "";
+	const rule = (title) => t.dim(`${t.symbols.rule} ${title} ${t.symbols.rule.repeat(Math.max(3, t.terminal.width - title.length - 4))}`);
+	return /* @__PURE__ */ jsxs(Box, {
+		flexDirection: "column",
+		children: [
+			/* @__PURE__ */ jsx(Text, { children: `${t.brand(t.symbols.brand)} ${t.bold("lucent dev")}   ${t.dim(`watching ${s.watching.join(" · ") || root}`)}` }),
+			/* @__PURE__ */ jsx(Text, { children: " " }),
+			s.modules.length ? /* @__PURE__ */ jsx(Text, { children: rows.join("\n") }) : /* @__PURE__ */ jsx(Text, { children: t.dim(s.building ? `building${t.symbols.ellipsis}` : "no *.lucent.ts modules yet") }),
+			status ? /* @__PURE__ */ jsx(Text, { children: `\n${status}` }) : null,
+			s.problems.length ? /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				children: [
+					/* @__PURE__ */ jsx(Text, { children: rule(`problems (${s.problems.length})`) }),
+					s.problems.map((d, i) => /* @__PURE__ */ jsx(Text, { children: `${d === problem ? t.brand("›") : " "} ${d.file ? `${d.file}${d.line ? `:${d.line}` : ""}  ` : ""}${t.bold(d.code)}  ${d.message}` }, i)),
+					problem?.fix ? /* @__PURE__ */ jsx(Text, { children: `  ${t.success("fix")}  ${problem.fix}` }) : null,
+					problem?.source !== void 0 && problem.line ? /* @__PURE__ */ jsx(Text, { children: codeFrame(problem.source, {
+						line: problem.line,
+						column: problem.column ?? 1,
+						length: problem.length ?? 1
+					}, t) }) : null
+				]
+			}) : null,
+			checks ? /* @__PURE__ */ jsxs(Box, {
+				flexDirection: "column",
+				marginTop: 1,
+				children: [/* @__PURE__ */ jsx(Text, { children: rule("doctor") }), checks.filter((c) => c.status !== "skip").map((c, i) => /* @__PURE__ */ jsx(Text, { children: `${c.status === "ok" ? t.success(t.symbols.ok) : c.status === "fail" ? t.error(t.symbols.fail) : t.warn(t.symbols.warn)} ${c.label}  ${t.dim(c.detail)}${c.fix ? `\n    fix: ${c.fix}` : ""}` }, i))]
+			}) : null,
+			/* @__PURE__ */ jsx(Text, { children: `\n${t.dim("[r] rebuild  [c] clear cache  [d] doctor  [o] open  [q] quit")}` })
+		]
+	});
+}
+//#endregion
+export { dashboard };

package/dist/dev-BYWMP7oC.js

@@ -0,0 +1,221 @@
+import { t as createTheme } from "./theme-uv5bc0aK.js";
+import { n as version } from "./version-bqpIO5sP.js";
+import { h as platformOf, m as moduleNameOf, u as LUCENT_EXTENSION } from "./src-BD7f1_aZ.js";
+import { n as lucentPackages } from "./packages-HyskKIsY.js";
+import { n as nextText, r as plural, t as buildProject } from "./pipeline-CH7-2cxu.js";
+import { t as plainSteps } from "./steps--_h-FFS7.js";
+import { n as systemProbe, t as diagnose } from "./doctor-C0PrfWT6.js";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+//#region src/cli/dev/compact.ts
+function compact(session, out) {
+	const t = out.theme;
+	let shown;
+	return session.store.subscribe(() => {
+		const s = session.store.get();
+		const last = s.lastBuild;
+		if (!last || last === shown || s.building) return;
+		shown = last;
+		const time = t.dim(`[${last.at.toLocaleTimeString("en-GB")}]`);
+		for (const n of s.notices ?? []) out.print(`${time} ${n.level === "ok" ? t.success(t.symbols.ok) : t.warn(t.symbols.warn)} ${n.text}`);
+		if (last.fatal) {
+			out.error(`${time} ${t.error(t.symbols.fail)} ${last.fatal}`);
+			return;
+		}
+		if (last.ok) {
+			const next = last.next?.rebuild ? ` ${t.dim("·")} ${nextText(last.next)}` : "";
+			out.print(`${time} ${t.success(t.symbols.ok)} ${plural(s.modules.length, "module")}  ${t.dim(`${last.ms} ms`)}${next}`);
+			return;
+		}
+		out.error(`${time} ${t.error(t.symbols.fail)} ${plural(s.problems.length, "error")}`);
+		for (const d of s.problems) {
+			const where = d.file ? `${d.file}${d.line ? `:${d.line}:${d.column ?? 1}` : ""}  ` : "";
+			out.error(`  ${where}${t.bold(d.code)}  ${d.message}`);
+			if (d.fix) out.error(`    ${t.dim(`fix: ${d.fix}`)}`);
+		}
+	});
+}
+//#endregion
+//#region src/cli/dev/session.ts
+function createStore(initial = {
+	building: false,
+	watching: [],
+	modules: [],
+	problems: []
+}) {
+	let state = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get: () => state,
+		set(next) {
+			state = next;
+			for (const l of [...listeners]) l();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
+	};
+}
+const DEBOUNCE_MS = 40;
+function startSession(root) {
+	const store = createStore();
+	const theme = createTheme({
+		color: false,
+		interactive: false,
+		unicode: true,
+		links: false,
+		width: 80
+	});
+	let building = false;
+	let queued;
+	let timer;
+	const build = async (force) => {
+		if (building) {
+			queued = { force: force || !!queued?.force };
+			return;
+		}
+		building = true;
+		store.set({
+			...store.get(),
+			building: true,
+			modules: store.get().modules.map((m) => ({
+				...m,
+				platforms: mapPlatforms(m.platforms, (s) => s === "none" ? s : "building")
+			}))
+		});
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		const notices = [];
+		const at = /* @__PURE__ */ new Date();
+		const r = await buildProject(root, {
+			mode: "build",
+			force
+		}, plainSteps(() => {}, theme), (n) => notices.push(n));
+		const failing = /* @__PURE__ */ new Map();
+		for (const d of r.diagnostics) {
+			if (!d.file) continue;
+			const name = moduleNameOf(path.resolve(root, d.file));
+			const p = platformOf(d.file);
+			const set = failing.get(name) ?? /* @__PURE__ */ new Set();
+			for (const q of p ? [p] : ["ios", "android"]) set.add(q);
+			failing.set(name, set);
+		}
+		const sources = /* @__PURE__ */ new Map();
+		const source = (file) => {
+			if (!sources.has(file)) sources.set(file, fs.existsSync(path.resolve(root, file)) ? fs.readFileSync(path.resolve(root, file), "utf8") : void 0);
+			return sources.get(file);
+		};
+		store.set({
+			...store.get(),
+			building: false,
+			modules: r.modules.map((m) => {
+				const has = (p) => m.platforms.includes(p) || m.platforms.includes("shared");
+				const state = (p) => !has(p) ? "none" : failing.get(m.name)?.has(p) ? "error" : r.ok ? "ok" : "none";
+				return {
+					name: m.name,
+					platforms: {
+						ios: state("ios"),
+						android: state("android")
+					}
+				};
+			}),
+			lastBuild: {
+				at,
+				ms: r.ms,
+				ok: r.ok,
+				next: r.ok && !r.upToDate ? r.next : void 0,
+				fatal: r.fatal
+			},
+			problems: r.diagnostics.map((d) => ({
+				...d,
+				source: d.file ? source(d.file) : void 0
+			})),
+			notices
+		});
+		building = false;
+		if (queued) {
+			const again = queued;
+			queued = void 0;
+			build(again.force);
+		}
+	};
+	const changed = (name) => {
+		if (!name || !LUCENT_EXTENSION.test(name) || name.split(path.sep).some((part) => part === "node_modules" || part.startsWith("."))) return;
+		clearTimeout(timer);
+		timer = setTimeout(() => void build(false), DEBOUNCE_MS);
+	};
+	let packages = [];
+	try {
+		packages = lucentPackages(root).map((p) => p.sources).filter((dir) => path.relative(root, dir).startsWith(".."));
+	} catch {}
+	const watchers = [root, ...packages].map((dir) => fs.watch(dir, { recursive: true }, (_event, name) => changed(name)));
+	store.set({
+		...store.get(),
+		watching: [root, ...packages].map((d) => path.relative(root, d) || ".")
+	});
+	build(false);
+	return {
+		store,
+		rebuild: () => void build(true),
+		clearCache() {
+			fs.rmSync(path.join(root, ".lucent/native/manifest.json"), { force: true });
+			fs.rmSync(path.join(root, ".lucent/check.json"), { force: true });
+			build(true);
+		},
+		stop() {
+			clearTimeout(timer);
+			for (const w of watchers) w.close();
+		}
+	};
+}
+function mapPlatforms(p, f) {
+	return {
+		ios: f(p.ios),
+		android: f(p.android)
+	};
+}
+//#endregion
+//#region src/cli/commands/dev.ts
+async function run({ root, flags, out }) {
+	const session = startSession(root);
+	if (flags.compact || !out.terminal.interactive) {
+		compact(session, out);
+		await new Promise((resolve) => {
+			for (const signal of ["SIGINT", "SIGTERM"]) process.on(signal, () => resolve());
+		});
+		session.stop();
+		return 0;
+	}
+	const { dashboard } = await import("./dashboard-B-NzjjaN.js");
+	await dashboard({
+		session,
+		theme: out.theme,
+		root,
+		open: (file, line) => openInEditor(path.resolve(root, file), line),
+		doctor: () => diagnose(root, systemProbe(version()))
+	});
+	return 0;
+}
+function openInEditor(file, line) {
+	const editor = process.env.VISUAL || process.env.EDITOR || "code";
+	const name = path.basename(editor.split(" ")[0]);
+	const args = [
+		"code",
+		"cursor",
+		"codium",
+		"windsurf",
+		"zed",
+		"subl"
+	].includes(name) ? ["-g", `${file}:${line}`] : name === "idea" || name === "webstorm" ? [
+		"--line",
+		String(line),
+		file
+	] : [`+${line}`, file];
+	spawn(editor.split(" ")[0], [...editor.split(" ").slice(1), ...args], {
+		stdio: "ignore",
+		detached: true
+	}).unref();
+}
+//#endregion
+export { run };

package/dist/diagnostic-BM9sXmwl.js

@@ -0,0 +1,30 @@
+import { r as link, t as codeFrame } from "./format-D9fnIMEx.js";
+//#region src/cli/ui/diagnostic.ts
+function wrap(text, width, indent) {
+	const lines = [];
+	let line = "";
+	for (const word of text.split(" ")) if (line && line.length + 1 + word.length > width) {
+		lines.push(line);
+		line = word;
+	} else line = line ? `${line} ${word}` : word;
+	lines.push(line);
+	return lines.join(`\n${indent}`);
+}
+function renderDiagnostic(d, source, theme) {
+	const width = theme.terminal.width;
+	const out = [`${`  ${theme.error("error")} ${theme.bold(d.code)}  `}${wrap(d.message.split("\n").join(" "), Math.max(20, width - 2 - 6 - d.code.length - 2), " ".repeat(6 + d.code.length + 4))}`];
+	if (d.file) {
+		out.push("", `    ${theme.dim(d.line ? `${d.file}:${d.line}:${d.column ?? 1}` : d.file)}`);
+		if (source !== void 0 && d.line) out.push(codeFrame(source, {
+			line: d.line,
+			column: d.column ?? 1,
+			length: d.length ?? 1
+		}, theme));
+	}
+	if (d.fix || d.docs) out.push("");
+	if (d.fix) out.push(`  ${theme.success("fix")}  ${wrap(d.fix, Math.max(20, width - 7), "       ")}`);
+	if (d.docs) out.push(`  ${theme.progress("docs")} lucent explain ${link(d.code, d.docs, theme.terminal)}`);
+	return out.join("\n");
+}
+//#endregion
+export { renderDiagnostic as t };

package/dist/diff-BTDo3Sro.js

@@ -0,0 +1,44 @@
+//#region src/cli/ui/diff.ts
+function diffLines(before, after) {
+	const a = before === "" ? [] : before.replace(/\n$/, "").split("\n");
+	const b = after.replace(/\n$/, "").split("\n");
+	const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const out = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length || j < b.length) if (i < a.length && j < b.length && a[i] === b[j]) {
+		out.push({
+			kind: " ",
+			text: a[i++]
+		});
+		j++;
+	} else if (i < a.length && (j >= b.length || lcs[i + 1][j] >= lcs[i][j + 1])) out.push({
+		kind: "-",
+		text: a[i++]
+	});
+	else out.push({
+		kind: "+",
+		text: b[j++]
+	});
+	return out;
+}
+function renderDiff(before, after, theme) {
+	const lines = diffLines(before, after);
+	const near = (k) => lines.slice(Math.max(0, k - 2), k + 3).some((l) => l.kind !== " ");
+	const out = [];
+	let skipped = false;
+	lines.forEach((l, k) => {
+		if (l.kind === " " && !near(k)) {
+			if (!skipped) out.push(theme.dim(`    ${theme.symbols.ellipsis}`));
+			skipped = true;
+			return;
+		}
+		skipped = false;
+		const text = `    ${l.kind} ${l.text}`;
+		out.push(l.kind === "+" ? theme.success(text) : l.kind === "-" ? theme.error(text) : theme.dim(text));
+	});
+	return out.join("\n");
+}
+//#endregion
+export { renderDiff as t };

package/dist/doctor-C0PrfWT6.js

@@ -0,0 +1,230 @@
+import { n as lucentPackages } from "./packages-HyskKIsY.js";
+import { t as packageManagerOf } from "./package-manager-BnxwCySi.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { spawnSync } from "node:child_process";
+//#region src/cli/doctor.ts
+function systemProbe(cliVersion) {
+	return {
+		platform: process.platform,
+		env: process.env,
+		home: os.homedir(),
+		nodeVersion: process.version,
+		cliVersion,
+		run: (cmd, args) => {
+			const r = spawnSync(cmd, args, {
+				encoding: "utf8",
+				timeout: 2e4
+			});
+			return {
+				status: r.error ? null : r.status,
+				stdout: r.stdout ?? "",
+				stderr: r.stderr ?? ""
+			};
+		}
+	};
+}
+const read = (file) => fs.existsSync(file) ? fs.readFileSync(file, "utf8") : void 0;
+const json = (file) => {
+	const text = read(file);
+	return text === void 0 ? void 0 : JSON.parse(text);
+};
+function parse(version) {
+	return (/(\d+)\.(\d+)(?:\.(\d+))?/.exec(version) ?? []).slice(1, 4).map((n) => Number(n ?? 0));
+}
+function atLeast(version, min) {
+	const [a, b] = [parse(version), parse(min)];
+	for (let i = 0; i < 3; i++) if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
+	return true;
+}
+function installed(root, name) {
+	for (let dir = root;; dir = path.dirname(dir)) {
+		const pkg = json(path.join(dir, "node_modules", name, "package.json"));
+		if (pkg?.version) return pkg.version;
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+const ok = (id, label, detail) => ({
+	id,
+	label,
+	status: "ok",
+	detail
+});
+const fail = (id, label, detail, fix) => ({
+	id,
+	label,
+	status: "fail",
+	detail,
+	fix
+});
+const warn = (id, label, detail, fix) => ({
+	id,
+	label,
+	status: "warn",
+	detail,
+	fix
+});
+const skip = (id, label, detail) => ({
+	id,
+	label,
+	status: "skip",
+	detail
+});
+function diagnose(root, probe) {
+	const pkg = json(path.join(root, "package.json")) ?? {};
+	const expo = "expo" in {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	const mac = probe.platform === "darwin";
+	return [
+		node(probe),
+		packageManager(root),
+		reactNative(root),
+		expo ? expoSdk(root) : skip("expo", "Expo SDK", "not an Expo app"),
+		...mac ? [
+			xcode(probe),
+			simulator(probe),
+			cocoapods(probe)
+		] : [skip("xcode", "Xcode", "iOS builds need a Mac")],
+		...android(probe),
+		jdk(probe),
+		gradleTask(root, expo),
+		metro(root),
+		tsconfig(root),
+		sdkCache(probe),
+		versions(root, probe)
+	];
+}
+const REQUIREMENTS = {
+	node: "22.12",
+	reactNative: "0.88",
+	expoSdk: 58,
+	jdk: {
+		min: 17,
+		max: 21
+	}
+};
+function node(probe) {
+	const need = REQUIREMENTS.node;
+	return atLeast(probe.nodeVersion, `${need}.0`) ? ok("node", "Node.js", probe.nodeVersion) : fail("node", "Node.js", `${probe.nodeVersion}; Lucent needs ${need} or later`, `install Node.js ${need} or later (nodejs.org, or your version manager)`);
+}
+function packageManager(root) {
+	const pm = packageManagerOf(root);
+	if (!pm) return warn("package-manager", "Package manager", "no lockfile", "install the app's dependencies (npm install, pnpm install, …)");
+	return ok("package-manager", "Package manager", `${pm.name} (${path.relative(root, pm.lockfile)})`);
+}
+function reactNative(root) {
+	const v = installed(root, "react-native");
+	const need = REQUIREMENTS.reactNative;
+	if (!v) return fail("react-native", "React Native", "not installed", `install react-native ${need} or later in the app`);
+	return atLeast(v, `${need}.0`) ? ok("react-native", "React Native", v) : fail("react-native", "React Native", `${v}; Lucent needs ${need} or later (the New Architecture's C++ TurboModules)`, `upgrade react-native to ${need} or later`);
+}
+function expoSdk(root) {
+	const v = installed(root, "expo");
+	if (!v) return fail("expo", "Expo SDK", "expo is a dependency but is not installed", "install the app's dependencies");
+	const need = REQUIREMENTS.expoSdk;
+	return atLeast(v, `${need}.0.0`) ? ok("expo", "Expo SDK", `${parse(v)[0]} (expo ${v})`) : fail("expo", "Expo SDK", `expo ${v}; Lucent needs SDK ${need} or later`, `upgrade to Expo SDK ${need} (npx expo install expo@^${need})`);
+}
+function xcode(probe) {
+	const r = probe.run("xcodebuild", ["-version"]);
+	if (r.status !== 0) return fail("xcode", "Xcode", "not found", "install Xcode from the App Store, then: sudo xcode-select -s /Applications/Xcode.app");
+	return ok("xcode", "Xcode", r.stdout.split("\n")[0].replace(/^Xcode /, ""));
+}
+function simulator(probe) {
+	const r = probe.run("xcrun", [
+		"simctl",
+		"list",
+		"runtimes",
+		"--json"
+	]);
+	const ios = (r.status === 0 ? JSON.parse(r.stdout).runtimes ?? [] : []).filter((rt) => rt.isAvailable !== false && (rt.platform === "iOS" || rt.name.startsWith("iOS")));
+	return ios.length ? ok("simulator", "iOS simulator runtime", ios.map((rt) => rt.name).join(", ")) : warn("simulator", "iOS simulator runtime", "none installed", "install one in Xcode: Settings > Components");
+}
+function cocoapods(probe) {
+	const r = probe.run("pod", ["--version"]);
+	return r.status === 0 ? ok("cocoapods", "CocoaPods", r.stdout.trim()) : fail("cocoapods", "CocoaPods", "not installed", "brew install cocoapods (or: sudo gem install cocoapods)");
+}
+function android(probe) {
+	const sdk = [
+		probe.env.ANDROID_HOME,
+		probe.env.ANDROID_SDK_ROOT,
+		path.join(probe.home, probe.platform === "darwin" ? "Library/Android/sdk" : "Android/Sdk")
+	].filter((d) => !!d).find((d) => fs.existsSync(path.join(d, "platforms")));
+	if (!sdk) return [fail("android-sdk", "Android SDK", "not found", "install Android Studio (or the command-line tools), then set ANDROID_HOME to the SDK (e.g. ~/Library/Android/sdk)"), skip("ndk", "Android NDK", "needs the Android SDK")];
+	const platforms = fs.readdirSync(path.join(sdk, "platforms")).filter((p) => /^android-\d+/.test(p)).sort((a, b) => Number(b.slice(8)) - Number(a.slice(8)));
+	const sdkCheck = platforms.length ? ok("android-sdk", "Android SDK", `${platforms[0]} at ${sdk.replace(probe.home, "~")}`) : fail("android-sdk", "Android SDK", `no platform installed at ${sdk}`, "install one with Android Studio's SDK Manager, or: sdkmanager 'platforms;android-36'");
+	const envSet = probe.env.ANDROID_HOME || probe.env.ANDROID_SDK_ROOT;
+	const ndks = fs.existsSync(path.join(sdk, "ndk")) ? fs.readdirSync(path.join(sdk, "ndk")).sort() : [];
+	const ndkCheck = ndks.length ? ok("ndk", "Android NDK", ndks.at(-1)) : fail("ndk", "Android NDK", "not installed", "install it with Android Studio's SDK Manager (SDK Tools > NDK), or: sdkmanager 'ndk;27.1.12297006'");
+	if (sdkCheck.status === "ok" && !envSet) return [{
+		...sdkCheck,
+		status: "warn",
+		fix: `export ANDROID_HOME=${sdk.replace(probe.home, "$HOME")} (Gradle and adb find the SDK through it)`
+	}, ndkCheck];
+	return [sdkCheck, ndkCheck];
+}
+function jdk(probe) {
+	const r = probe.run("java", ["-version"]);
+	const { min, max } = REQUIREMENTS.jdk;
+	if (r.status !== 0) return fail("jdk", "JDK", "not found", `install JDK ${min} or ${max} (e.g. brew install --cask zulu@${max}) and set JAVA_HOME`);
+	const m = /version "(\d+)(?:\.(\d+))?/.exec(r.stderr + r.stdout);
+	const major = m ? Number(m[1] === "1" ? m[2] : m[1]) : 0;
+	if (major >= min && major <= max) return ok("jdk", "JDK", String(major));
+	return warn("jdk", "JDK", `${major || "unknown version"}; React Native's Gradle build needs ${min} to ${max}`, `set JAVA_HOME to JDK ${min} or ${max} (macOS: export JAVA_HOME=$(/usr/libexec/java_home -v ${max}))`);
+}
+function gradleTask(root, expo) {
+	const file = ["android/app/build.gradle", "android/app/build.gradle.kts"].map((f) => path.join(root, f)).find((f) => fs.existsSync(f));
+	if (!file) return skip("gradle-task", "Lucent Gradle task", expo ? "no android/ yet (expo prebuild adds it)" : "no android/app/build.gradle");
+	const text = read(file);
+	return /lucent\.gradle/.test(text) ? ok("gradle-task", "Lucent Gradle task", "applied in android/app") : fail("gradle-task", "Lucent Gradle task", "android/app/build.gradle does not apply it, so Gradle builds may use an old .lucent/native", expo ? "run expo prebuild again (the Lucent config plugin adds it), or lucent init" : "run lucent init");
+}
+function metro(root) {
+	const file = [
+		"metro.config.js",
+		"metro.config.cjs",
+		"metro.config.mjs",
+		"metro.config.ts"
+	].map((f) => path.join(root, f)).find((f) => fs.existsSync(f));
+	const fix = "wrap the config: const { withLucent } = require(\"@lucent-lang/lucent/metro\"); module.exports = withLucent(config);";
+	if (!file) return fail("metro", "Metro config", "no metro.config.js", fix);
+	const text = read(file);
+	return /withLucent/.test(text) && /@lucent-lang\/lucent\/metro/.test(text) ? ok("metro", "Metro config", `${path.basename(file)} uses withLucent`) : fail("metro", "Metro config", `${path.basename(file)} does not use withLucent from @lucent-lang/lucent/metro, so Metro bundles *.lucent.ts as TypeScript`, fix);
+}
+function tsconfig(root) {
+	const text = read(path.join(root, "tsconfig.json"));
+	if (text === void 0) return skip("tsconfig", "tsconfig paths", "no tsconfig.json");
+	return text.includes("\"lucent:*\"") ? ok("tsconfig", "tsconfig paths", "lucent:* mapped") : warn("tsconfig", "tsconfig paths", "lucent:* is not mapped, so editors cannot resolve lucent:core or the SDK modules", "run lucent build (or lucent init): it maps lucent:* in tsconfig.json");
+}
+function sdkCache(probe) {
+	const dir = probe.env.LUCENT_CACHE_DIR || path.join(probe.env.XDG_CACHE_HOME || path.join(probe.home, ".cache"), "lucent");
+	const sdk = path.join(dir, "sdk");
+	if (!fs.existsSync(sdk)) return ok("sdk-cache", "SDK cache", `empty (${dir.replace(probe.home, "~")}); lucent sdk prefetch fills it ahead of time`);
+	let bytes = 0;
+	let modules = 0;
+	const walk = (d) => {
+		for (const e of fs.readdirSync(d, { withFileTypes: true })) {
+			const f = path.join(d, e.name);
+			if (e.isDirectory()) walk(f);
+			else {
+				bytes += fs.statSync(f).size;
+				if (e.name.endsWith(".json") && !e.name.endsWith(".names.json")) modules++;
+			}
+		}
+	};
+	walk(sdk);
+	return ok("sdk-cache", "SDK cache", `${modules} modules, ${(bytes / 1e6).toFixed(0)} MB (${dir.replace(probe.home, "~")})`);
+}
+function versions(root, probe) {
+	const app = installed(root, "@lucent-lang/lucent");
+	if (app && app !== probe.cliVersion) return fail("versions", "Lucent versions", `the app has @lucent-lang/lucent ${app}, this lucent is ${probe.cliVersion}`, "run the app's own lucent (npx lucent …), or install the same version");
+	try {
+		const packages = lucentPackages(root);
+		return ok("versions", "Lucent versions", `${probe.cliVersion}${packages.length ? `; ${packages.length} Lucent package${packages.length === 1 ? "" : "s"} compatible` : ""}`);
+	} catch (e) {
+		return fail("versions", "Lucent versions", e.message, "update the Lucent package or @lucent-lang/lucent so their versions match");
+	}
+}
+//#endregion
+export { systemProbe as n, diagnose as t };