@lucent-lang/lucent 0.0.4

package/dist/doctor-DdR4JnVc.js

@@ -0,0 +1,30 @@
+import { n as version } from "./version-bqpIO5sP.js";
+import { i as table } from "./format-D9fnIMEx.js";
+import { n as systemProbe, t as diagnose } from "./doctor-C0PrfWT6.js";
+//#region src/cli/commands/doctor.ts
+function run({ root, out }) {
+	const checks = diagnose(root, systemProbe(version()));
+	const failures = checks.filter((c) => c.status === "fail").length;
+	const warnings = checks.filter((c) => c.status === "warn").length;
+	if (out.json) {
+		out.data({
+			ok: failures === 0,
+			checks
+		});
+		return failures ? 1 : 0;
+	}
+	const t = out.theme;
+	const symbol = (c) => c.status === "ok" ? t.success(t.symbols.ok) : c.status === "fail" ? t.error(t.symbols.fail) : c.status === "warn" ? t.warn(t.symbols.warn) : t.dim(t.symbols.off);
+	out.print(`${t.brand(t.symbols.brand)} ${t.bold("lucent doctor")} ${t.dim(version())}\n`);
+	const rows = table(checks.map((c) => [`${symbol(c)} ${c.label}`, c.status === "skip" ? t.dim(c.detail) : c.detail]));
+	checks.forEach((c, i) => {
+		out.print(rows[i]);
+		if (c.fix) out.print(`    ${c.status === "fail" ? t.error("fix") : t.warn("fix")}  ${c.fix}`);
+	});
+	out.print("");
+	const summary = [failures && t.error(`${failures} problem${failures === 1 ? "" : "s"}`), warnings && t.warn(`${warnings} warning${warnings === 1 ? "" : "s"}`)].filter(Boolean).join(` ${t.dim("·")} `);
+	out.print(summary || t.success("everything Lucent needs is in place"));
+	return failures ? 1 : 0;
+}
+//#endregion
+export { run };

package/dist/explain--vV1oaRl.js

@@ -0,0 +1,35 @@
+import { n as Explanations, r as docsUrl } from "./codes-CIuwXt1S.js";
+import { i as table, r as link } from "./format-D9fnIMEx.js";
+//#region src/cli/commands/explain.ts
+function run({ positionals, out }) {
+	const t = out.theme;
+	const [wanted] = positionals;
+	if (!wanted) {
+		for (const line of table(Object.entries(Explanations).map(([code, e]) => [t.bold(code), e.title]))) out.print(line);
+		out.print(t.dim("\nlucent explain <code> for one of them"));
+		return 0;
+	}
+	const code = `LUCENT${wanted.replace(/^lucent/i, "")}`;
+	const e = Explanations[code];
+	if (!e) {
+		out.error(`${t.error(t.symbols.fail)} no ${code}: run lucent explain for the list of codes`);
+		return 1;
+	}
+	const indent = (text) => text.trimEnd().split("\n").map((l) => `    ${l}`).join("\n");
+	out.print(`${t.bold(code)}  ${e.title}\n`);
+	out.print(`${e.details}\n`);
+	out.print(`${t.success("fix")}  ${e.fix}\n`);
+	for (const [label, files, paint] of [[
+		"wrong",
+		e.wrong,
+		t.error
+	], [
+		"right",
+		e.right,
+		t.success
+	]]) for (const [file, source] of Object.entries(files)) out.print(`${paint(`${label === "wrong" ? t.symbols.fail : t.symbols.ok} ${label}`)}  ${t.dim(file)}\n${indent(source)}\n`);
+	out.print(t.dim(link(docsUrl(code), docsUrl(code), t.terminal)));
+	return 0;
+}
+//#endregion
+export { run };

package/dist/format-D9fnIMEx.js

@@ -0,0 +1,53 @@
+//#region src/cli/ui/format.ts
+const ANSI = /\x1b\[[0-9;]*m|\x1b\]8;;[^\x1b]*\x1b\\/g;
+function visibleWidth(s) {
+	return [...s.replace(ANSI, "")].length;
+}
+function pad(s, width) {
+	return s + " ".repeat(Math.max(0, width - visibleWidth(s)));
+}
+function duration(ms) {
+	if (ms < 1e3) return `${Math.round(ms)} ms`;
+	if (ms < 6e4) return `${(ms / 1e3).toFixed(1)} s`;
+	const s = Math.round(ms / 1e3);
+	return `${Math.floor(s / 60)} m ${s % 60} s`;
+}
+function table(rows, gap = 2) {
+	const widths = [];
+	for (const r of rows) r.forEach((cell, i) => widths[i] = Math.max(widths[i] ?? 0, visibleWidth(cell)));
+	return rows.map((r) => r.map((cell, i) => i === r.length - 1 ? cell : pad(cell, widths[i] + gap)).join(""));
+}
+function link(text, url, terminal) {
+	return terminal.links ? `\x1b]8;;${url}\x1b\\${text}\x1b]8;;\x1b\\` : text;
+}
+function codeFrame(source, span, theme) {
+	const lines = source.split("\n");
+	const first = Math.max(1, span.line - 1);
+	const last = Math.min(lines.length, span.line + 1);
+	const gutter = String(last).length;
+	const { bar, ellipsis } = theme.symbols;
+	const indent = "    ";
+	const room = Math.max(20, theme.terminal.width - 4 - gutter - 3);
+	const start = Math.max(0, Math.min(span.column - 1 - Math.floor(room / 3), (lines[span.line - 1] ?? "").length - room));
+	const cut = (text) => {
+		let s = text.slice(start, start + room);
+		if (start > 0) s = ellipsis + s.slice(ellipsis.length);
+		if (text.length > start + room) s = s.slice(0, room - ellipsis.length) + ellipsis;
+		return s;
+	};
+	const out = [];
+	for (let n = first; n <= last; n++) {
+		const text = (lines[n - 1] ?? "").replace(/\t/g, " ");
+		if (n === last && text.trim() === "" && n !== span.line) continue;
+		const num = String(n).padStart(gutter);
+		out.push(`${indent}${n === span.line ? theme.bold(num) : theme.dim(num)} ${theme.dim(bar)} ${cut(text)}`);
+		if (n === span.line) {
+			const at = span.column - 1 - start;
+			const width = Math.max(1, Math.min(span.length, room - at));
+			out.push(`${indent}${" ".repeat(gutter)} ${theme.dim(bar)} ${" ".repeat(Math.max(0, at))}${theme.error("^".repeat(width))}`);
+		}
+	}
+	return out.join("\n");
+}
+//#endregion
+export { visibleWidth as a, table as i, duration as n, link as r, codeFrame as t };

package/dist/init-gIabu1S_.js

@@ -0,0 +1,207 @@
+import { t as packageFile } from "./version-bqpIO5sP.js";
+import { n as withLucentTsconfig } from "./tsconfig-S4uyLNzf.js";
+import { n as runner, t as packageManagerOf } from "./package-manager-BnxwCySi.js";
+import { t as renderDiff } from "./diff-BTDo3Sro.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/init/patch.ts
+const plugin = createRequire(import.meta.url)(packageFile("app.plugin.js"));
+const GRADLE_LINE = plugin.GRADLE_LINE;
+const applyGradleTask = plugin.applyGradleTask;
+const METRO_REQUIRE = "const { withLucent } = require(\"@lucent-lang/lucent/metro\");";
+function metroConfig(expo) {
+	return expo ? `const { getDefaultConfig } = require("expo/metro-config");\n${METRO_REQUIRE}\n\nmodule.exports = withLucent(getDefaultConfig(__dirname));\n` : `const { getDefaultConfig, mergeConfig } = require("@react-native/metro-config");\n${METRO_REQUIRE}\n\nmodule.exports = withLucent(mergeConfig(getDefaultConfig(__dirname), {}));\n`;
+}
+function wrapMetro(text) {
+	if (text.includes("@lucent-lang/lucent/metro") && /withLucent\(/.test(text)) return void 0;
+	const m = /^module\.exports\s*=\s*([\s\S]+?);?\s*$/m.exec(text);
+	if (!m || text.slice(m.index + m[0].length).trim()) return "manual";
+	const lines = `${text.slice(0, m.index)}module.exports = withLucent(${m[1].trim()});\n`.split("\n");
+	const lastRequire = lines.reduce((at, l, i) => /^(const|let|var) .*=\s*require\(/.test(l) ? i : at, -1);
+	lines.splice(lastRequire + 1, 0, METRO_REQUIRE);
+	return lines.join("\n");
+}
+function addExpoPlugin(text) {
+	const json = JSON.parse(text);
+	const target = json.expo ?? json;
+	const plugins = target.plugins ?? [];
+	if (plugins.some((p) => p === "@lucent-lang/lucent" || Array.isArray(p) && p[0] === "@lucent-lang/lucent")) return void 0;
+	target.plugins = [...plugins, "@lucent-lang/lucent"];
+	const indent = /^[ \t]+(?=")/m.exec(text)?.[0] ?? "  ";
+	return `${JSON.stringify(json, null, indent)}\n`;
+}
+const RN_ENTRY = `"lucent": { root: require("path").join(__dirname, ".lucent", "native") }`;
+function linkNativePackage(text) {
+	if (text === void 0) return `module.exports = {\n  dependencies: {\n    ${RN_ENTRY},\n  },\n};\n`;
+	if (text.includes("\"lucent-native\"")) return text.replace("\"lucent-native\"", "\"lucent\"");
+	if (/["']?lucent["']?\s*:\s*\{\s*root:/.test(text)) return void 0;
+	const deps = /dependencies\s*:\s*\{/.exec(text);
+	if (!deps) return "manual";
+	const at = deps.index + deps[0].length;
+	return `${text.slice(0, at)}\n    ${RN_ENTRY},${text.slice(at)}`;
+}
+const RN_CONFIG_SNIPPET = `module.exports = {\n  dependencies: {\n    ${RN_ENTRY},\n  },\n};`;
+function ignoreNativePackage(text) {
+	const current = text ?? "";
+	if (current.split("\n").some((l) => l.trim() === ".lucent/" || l.trim() === ".lucent" || l.trim() === "/.lucent")) return void 0;
+	return `${current}${current && !current.endsWith("\n") ? "\n" : ""}# Lucent's generated native package\n.lucent/\n`;
+}
+const HELLO = `// A Lucent module: this runs as C++, and JavaScript calls it like any function:
+//
+//   import { hello } from "./src/hello.lucent";
+//   hello("Ada"); // "Hello, Ada, from native code"
+export function hello(name: string): string {
+  return \`Hello, \${name}, from native code\`;
+}
+`;
+//#endregion
+//#region src/cli/init/plan.ts
+const read = (root, file) => fs.existsSync(path.join(root, file)) ? fs.readFileSync(path.join(root, file), "utf8") : void 0;
+const first = (root, files) => files.find((f) => fs.existsSync(path.join(root, f)));
+function planInit(root) {
+	const pkg = JSON.parse(read(root, "package.json") ?? "{}");
+	const kind = "expo" in {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	} ? "expo" : "bare";
+	const packageManager = packageManagerOf(root)?.name ?? "npm";
+	const changes = [];
+	const manual = [];
+	const change = (file, why, after) => {
+		if (after !== void 0) changes.push({
+			file,
+			why,
+			before: read(root, file),
+			after
+		});
+	};
+	const metro = first(root, [
+		"metro.config.js",
+		"metro.config.cjs",
+		"metro.config.mjs",
+		"metro.config.ts"
+	]);
+	const wrapped = metro ? wrapMetro(read(root, metro)) : metroConfig(kind === "expo");
+	const metroWhy = "bundle each *.lucent.ts as the proxy of its native module";
+	if (wrapped === "manual") manual.push({
+		file: metro,
+		why: metroWhy,
+		snippet: "const { withLucent } = require(\"@lucent-lang/lucent/metro\");\n// …\nexport default withLucent(config);"
+	});
+	else change(metro ?? "metro.config.js", metroWhy, wrapped);
+	if (kind === "expo") {
+		const pluginWhy = "compile the modules during expo prebuild, and link the native package";
+		if (fs.existsSync(path.join(root, "app.json"))) change("app.json", pluginWhy, addExpoPlugin(read(root, "app.json")));
+		else {
+			const config = first(root, ["app.config.ts", "app.config.js"]);
+			if (config && !read(root, config).includes("@lucent-lang/lucent")) manual.push({
+				file: config,
+				why: pluginWhy,
+				snippet: "plugins: [\"@lucent-lang/lucent\"]"
+			});
+		}
+	} else {
+		const gradleWhy = "run lucent build before every Android build";
+		if (fs.existsSync(path.join(root, "android/app/build.gradle"))) change("android/app/build.gradle", gradleWhy, applyGradleTask(read(root, "android/app/build.gradle")));
+		else if (fs.existsSync(path.join(root, "android/app/build.gradle.kts")) && !read(root, "android/app/build.gradle.kts").includes("lucent.gradle")) manual.push({
+			file: "android/app/build.gradle.kts",
+			why: gradleWhy,
+			snippet: `apply(from = ${GRADLE_LINE.replace(/^apply from: /, "")})`
+		});
+		const linked = linkNativePackage(read(root, "react-native.config.js"));
+		const linkWhy = "autolink the generated native package (.lucent/native)";
+		if (linked === "manual") manual.push({
+			file: "react-native.config.js",
+			why: linkWhy,
+			snippet: RN_CONFIG_SNIPPET
+		});
+		else change("react-native.config.js", linkWhy, linked);
+	}
+	const tsconfig = read(root, "tsconfig.json");
+	if (tsconfig !== void 0) {
+		const tsWhy = "let editors and tsc resolve lucent:* and check indexing as the compiler does";
+		try {
+			change("tsconfig.json", tsWhy, withLucentTsconfig(tsconfig));
+		} catch (e) {
+			manual.push({
+				file: "tsconfig.json",
+				why: `${tsWhy} (${e.message})`,
+				snippet: "\"noUncheckedIndexedAccess\": true,\n\"paths\": { \"lucent:*\": [\"./.lucent/native/types/*\"] }"
+			});
+		}
+	}
+	change(".gitignore", "the native package is generated, like a build output", ignoreNativePackage(read(root, ".gitignore")));
+	if (!hasModules(root)) change("src/hello.lucent.ts", "a first module to try", HELLO);
+	const x = runner(packageManager);
+	return {
+		kind,
+		packageManager,
+		changes,
+		manual,
+		next: kind === "expo" ? `${x} expo run:ios` : `${x} lucent build && ${x} react-native run-ios`
+	};
+}
+function hasModules(root) {
+	const walk = (dir) => fs.readdirSync(dir, { withFileTypes: true }).some((e) => {
+		if (e.name === "node_modules" || e.name.startsWith(".") || e.name === "ios" || e.name === "android") return false;
+		return e.isDirectory() ? walk(path.join(dir, e.name)) : /\.lucent\.tsx?$/.test(e.name);
+	});
+	return walk(root);
+}
+function applyChanges(root, changes) {
+	for (const c of changes) {
+		fs.mkdirSync(path.dirname(path.join(root, c.file)), { recursive: true });
+		fs.writeFileSync(path.join(root, c.file), c.after);
+	}
+}
+//#endregion
+//#region src/cli/commands/init.ts
+async function run({ root, flags, out }) {
+	const t = out.theme;
+	const plan = planInit(root);
+	out.print(`${t.brand(t.symbols.brand)} ${t.bold("lucent init")}  ${t.dim(`${plan.kind === "expo" ? "Expo app" : "bare React Native app"} · ${plan.packageManager}`)}\n`);
+	const nextLine = () => out.print(`\n${t.dim("next")}  ${plan.next}`);
+	const manual = () => {
+		for (const m of plan.manual) out.print(`${t.warn(t.symbols.warn)} ${m.file}  ${t.dim(m.why)}; add by hand:\n${m.snippet.split("\n").map((l) => `    ${l}`).join("\n")}`);
+	};
+	if (!plan.changes.length) {
+		out.print(`${t.success(t.symbols.ok)} already set up`);
+		manual();
+		nextLine();
+		return 0;
+	}
+	let accepted;
+	if (flags.yes) accepted = plan.changes;
+	else if (out.terminal.interactive) {
+		const [{ render }, { createElement }, { Confirm }] = await Promise.all([
+			import("ink"),
+			import("react"),
+			import("./confirm-BYF5eY3q.js")
+		]);
+		const answers = await new Promise((resolve) => {
+			const app = render(createElement(Confirm, {
+				changes: plan.changes,
+				theme: t,
+				onDone: (a) => setTimeout(() => (app.unmount(), resolve(a)), 20)
+			}), { interactive: true });
+		});
+		accepted = plan.changes.filter((_, i) => answers[i]);
+		applyChanges(root, accepted);
+		manual();
+		nextLine();
+		return 0;
+	} else {
+		for (const c of plan.changes) out.print(`${t.bold(c.file)}${c.before === void 0 ? t.dim(" (new)") : ""}  ${t.dim(c.why)}\n${renderDiff(c.before ?? "", c.after, t)}\n`);
+		manual();
+		out.error(`${t.warn(t.symbols.warn)} nothing was changed: run lucent init --yes to apply these, or run lucent init in a terminal to choose`);
+		return 1;
+	}
+	applyChanges(root, accepted);
+	for (const c of accepted) out.print(`${t.success(t.symbols.ok)} ${c.file}  ${t.dim(c.why)}`);
+	manual();
+	nextLine();
+	return 0;
+}
+//#endregion
+export { run };

package/dist/live-steps-BGcWFM9M.js

@@ -0,0 +1,79 @@
+import { n as stepLine } from "./steps--_h-FFS7.js";
+import { Static, Text, render } from "ink";
+import { useEffect, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/cli/ui/live-steps.tsx
+const FRAMES = [
+	"◐",
+	"◓",
+	"◑",
+	"◒"
+];
+function StepList({ store, theme }) {
+	const state = useSyncExternalStore(store.subscribe, store.get);
+	const [frame, setFrame] = useState(0);
+	useEffect(() => {
+		const timer = setInterval(() => setFrame((f) => (f + 1) % FRAMES.length), 120);
+		return () => clearInterval(timer);
+	}, []);
+	const spinner = theme.terminal.unicode ? FRAMES[frame] : theme.symbols.busy;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Static, {
+		items: state.done,
+		children: (r, i) => /* @__PURE__ */ jsx(Text, { children: stepLine(r, theme) }, i)
+	}), state.running ? /* @__PURE__ */ jsx(Text, { children: `${theme.progress(spinner)} ${state.running.label}${theme.dim(theme.symbols.ellipsis)}` }) : null] });
+}
+function createStore() {
+	let state = { done: [] };
+	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);
+		}
+	};
+}
+function liveSteps(theme, stdout = process.stdout) {
+	const store = createStore();
+	const app = render(/* @__PURE__ */ jsx(StepList, {
+		store,
+		theme
+	}), {
+		patchConsole: false,
+		stdout,
+		interactive: true
+	});
+	const results = [];
+	let closed = false;
+	return {
+		results,
+		start(_name, label) {
+			store.set({
+				...store.get(),
+				running: { label }
+			});
+		},
+		finish(r) {
+			results.push(r);
+			store.set({ done: [...store.get().done, r] });
+		},
+		flush: () => new Promise((resolve) => setTimeout(resolve, 20)),
+		async close() {
+			if (closed) return;
+			closed = true;
+			store.set({
+				...store.get(),
+				running: void 0
+			});
+			await new Promise((resolve) => setTimeout(resolve, 20));
+			app.unmount();
+			await app.waitUntilExit();
+		}
+	};
+}
+//#endregion
+export { liveSteps };

package/dist/new-module-C2mtb0op.js

@@ -0,0 +1,66 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/commands/new-module.ts
+const platforms = ["ios", "android"];
+const branches = {
+	ios: {
+		label: "iOS",
+		imports: ["import { UIDevice } from \"lucent:ios/UIKit\";", "import { main } from \"lucent:thread\";"],
+		body: ["const system = await main(() => UIDevice.current.systemName);", "return `Hello, ${name}, from ${system}`;"]
+	},
+	android: {
+		label: "Android",
+		imports: ["import { Build_VERSION } from \"lucent:android/android.os\";"],
+		body: ["return `Hello, ${name}, from Android ${Build_VERSION.RELEASE ?? \"\"}`;"]
+	}
+};
+const unimplemented = (p) => [`throw error("ERR_UNIMPLEMENTED", "hello is not implemented on ${branches[p].label} yet");`];
+function platformModule(name, wanted) {
+	const missing = platforms.filter((p) => !wanted.includes(p));
+	const imports = [
+		"import { PLATFORM } from \"lucent:platform\";",
+		...wanted.flatMap((p) => branches[p].imports),
+		...missing.length ? ["import { error } from \"lucent:core\";"] : []
+	];
+	const body = (p) => (wanted.includes(p) ? branches[p].body : unimplemented(p)).map((l) => `    ${l}`).join("\n");
+	return `// Runs natively on each platform; JavaScript imports it from "./src/${name}.lucent".
+${imports.join("\n")}
+
+export async function hello(name: string): Promise<string> {
+  if (PLATFORM === "ios") {
+${body("ios")}
+  } else {
+${body("android")}
+  }
+}
+`;
+}
+const sharedModule = (name) => `// Runs as C++; JavaScript imports it from "./src/${name}.lucent".
+export function hello(name: string): string {
+  return \`Hello, \${name}, from native code\`;
+}
+`;
+function run({ root, flags, positionals, out }) {
+	const t = out.theme;
+	const [name] = positionals;
+	if (!name || !/^[A-Za-z_$][\w$]*$/.test(name)) {
+		out.error(`${t.error(t.symbols.fail)} ${name ? `${name} is not a module name: use letters, digits and _, like a JavaScript name` : "name the module: lucent new module <name>"}`);
+		return 2;
+	}
+	const wanted = platforms.filter((p) => flags[p]);
+	const file = `src/${name}.lucent.ts`;
+	const target = path.join(root, file);
+	if (fs.existsSync(target)) {
+		out.error(`${t.error(t.symbols.fail)} ${file} exists; nothing was written`);
+		return 1;
+	}
+	fs.mkdirSync(path.dirname(target), { recursive: true });
+	fs.writeFileSync(target, wanted.length ? platformModule(name, wanted) : sharedModule(name));
+	out.print(`${t.success(t.symbols.ok)} ${file}`);
+	const missing = wanted.length ? platforms.find((p) => !wanted.includes(p)) : void 0;
+	if (missing) out.print(t.dim(`\nThe ${branches[missing].label} branch throws until you implement it.`));
+	out.print(`\n${t.dim("use it")}  import { hello } from "./src/${name}.lucent";`);
+	return 0;
+}
+//#endregion
+export { run };

package/dist/package-manager-BnxwCySi.js

@@ -0,0 +1,30 @@
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/package-manager.ts
+const LOCKFILES = [
+	["pnpm-lock.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"],
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"]
+];
+function packageManagerOf(root) {
+	for (let dir = path.resolve(root);; dir = path.dirname(dir)) {
+		const found = LOCKFILES.find(([f]) => fs.existsSync(path.join(dir, f)));
+		if (found) return {
+			name: found[1],
+			lockfile: path.join(dir, found[0])
+		};
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+function runner(pm) {
+	return {
+		npm: "npx",
+		pnpm: "pnpm exec",
+		yarn: "yarn",
+		bun: "bunx"
+	}[pm];
+}
+//#endregion
+export { runner as n, packageManagerOf as t };

package/dist/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/packages-HyskKIsY.js

@@ -0,0 +1,150 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region ../compiler/src/packages.ts
+function nativeDependencies(packages) {
+	const out = {
+		pods: {},
+		gradle: {},
+		permissions: [],
+		infoPlist: {}
+	};
+	const owners = /* @__PURE__ */ new Map();
+	const merge = (kind, into, key, value, from) => {
+		const id = `${kind} ${key}`;
+		if (into[key] !== void 0 && into[key] !== value) throw new Error(`${kind}${key}: ${owners.get(id)} wants ${into[key]}, ${from} wants ${value}`);
+		into[key] = value;
+		if (!owners.has(id)) owners.set(id, from);
+	};
+	for (const p of packages) {
+		for (const [pod, version] of Object.entries(p.native?.ios?.pods ?? {})) merge("pod ", out.pods, pod, version, p.name);
+		for (const [artifact, version] of Object.entries(p.native?.android?.dependencies ?? {})) merge("", out.gradle, artifact, version, p.name);
+		for (const perm of p.native?.android?.permissions ?? []) if (!out.permissions.includes(perm)) out.permissions.push(perm);
+		for (const [key, value] of Object.entries(p.native?.ios?.infoPlist ?? {})) {
+			merge("Info.plist ", Object.fromEntries(Object.entries(out.infoPlist).map(([k, v]) => [k, v.value])), key, value, p.name);
+			out.infoPlist[key] ??= {
+				value,
+				from: p.name
+			};
+		}
+	}
+	out.permissions.sort();
+	return out;
+}
+const read = (file) => {
+	try {
+		return JSON.parse(fs.readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+};
+function lucentPackageOf(file) {
+	for (let dir = path.dirname(path.resolve(file));; dir = path.dirname(dir)) {
+		const pkg = read(path.join(dir, "package.json"));
+		if (pkg) {
+			if (!pkg.lucent || !pkg.name) return void 0;
+			const native = fs.existsSync(path.join(dir, "lucent.json")) ? JSON.parse(fs.readFileSync(path.join(dir, "lucent.json"), "utf8")) : void 0;
+			return {
+				name: pkg.name,
+				version: pkg.version ?? "0.0.0",
+				dir,
+				sources: path.join(dir, pkg.lucent.sources ?? "."),
+				compatible: pkg.lucent.compatible,
+				...native ? { native } : {}
+			};
+		}
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+function lucentPackages(root) {
+	const found = /* @__PURE__ */ new Map();
+	const visit = (from, deps) => {
+		for (const name of Object.keys(deps)) {
+			const dir = resolvePackage(from, name);
+			if (!dir || found.has(dir)) continue;
+			const pkg = lucentPackageOf(path.join(dir, "package.json"));
+			if (!pkg || pkg.dir !== dir) continue;
+			if (pkg.compatible && !satisfies(lucentVersion(), pkg.compatible)) throw new Error(`${pkg.name}@${pkg.version} supports Lucent ${pkg.compatible}, not ${lucentVersion()}: update one of them`);
+			found.set(dir, pkg);
+			visit(dir, read(path.join(dir, "package.json"))?.dependencies ?? {});
+		}
+	};
+	visit(root, read(path.join(root, "package.json"))?.dependencies ?? {});
+	return [...found.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+function resolvePackage(from, name) {
+	for (let dir = path.resolve(from);; dir = path.dirname(dir)) {
+		const candidate = path.join(dir, "node_modules", name);
+		if (fs.existsSync(path.join(candidate, "package.json"))) return fs.realpathSync(candidate);
+		if (path.dirname(dir) === dir) return void 0;
+	}
+}
+let version;
+function lucentVersion() {
+	version ??= read(path.join(path.dirname(fileURLToPath(import.meta.url)), "../package.json"))?.version ?? "0.0.0";
+	return version;
+}
+function satisfies(version, range) {
+	const v = parse(version);
+	return range.split("||").some((alt) => alt.trim().split(/\s+/).filter(Boolean).every((c) => comparator(v, c)));
+}
+function parse(v) {
+	const [a = 0, b = 0, c = 0] = v.replace(/^v/, "").split("-")[0].split(".").map((x) => /^\d+$/.test(x) ? Number(x) : 0);
+	return [
+		a,
+		b,
+		c
+	];
+}
+function cmp(a, b) {
+	for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return 0;
+}
+function comparator(v, c) {
+	const m = /^(\^|~|>=|<=|>|<|=)?v?([\dxX*]+)(?:\.([\dxX*]+))?(?:\.([\dxX*]+))?/.exec(c);
+	if (!m) return false;
+	const op = m[1] ?? "";
+	const parts = [
+		m[2],
+		m[3],
+		m[4]
+	];
+	const wild = parts.findIndex((p) => p === void 0 || /[xX*]/.test(p));
+	const nums = parts.map((p) => p === void 0 || /[xX*]/.test(p) ? 0 : Number(p));
+	if (op === "" || op === "=") {
+		if (wild === -1) return cmp(v, nums) === 0;
+		return nums.slice(0, wild).every((n, i) => v[i] === n);
+	}
+	if (op === "^") {
+		const upper = nums[0] > 0 || wild === 1 ? [
+			nums[0] + 1,
+			0,
+			0
+		] : nums[1] > 0 || wild === 2 ? [
+			0,
+			nums[1] + 1,
+			0
+		] : [
+			0,
+			0,
+			nums[2] + 1
+		];
+		return cmp(v, nums) >= 0 && cmp(v, upper) < 0;
+	}
+	if (op === "~") {
+		const upper = wild === 1 ? [
+			nums[0] + 1,
+			0,
+			0
+		] : [
+			nums[0],
+			nums[1] + 1,
+			0
+		];
+		return cmp(v, nums) >= 0 && cmp(v, upper) < 0;
+	}
+	const d = cmp(v, nums);
+	return op === ">=" ? d >= 0 : op === ">" ? d > 0 : op === "<=" ? d <= 0 : d < 0;
+}
+//#endregion
+export { satisfies as a, nativeDependencies as i, lucentPackages as n, lucentVersion as r, lucentPackageOf as t };