@lucent-lang/lucent 0.0.4

package/dist/pipeline-CH7-2cxu.js

@@ -0,0 +1,232 @@
+import { C as extractionCount, D as sdkModule, E as sdkAvailable, _ as usesPlatforms, a as inputsKey, g as projectFiles, h as platformOf, l as writeNativePackage, m as moduleNameOf, n as compile, o as isUpToDate, v as moduleNamespace } from "./src-BD7f1_aZ.js";
+import { i as nativeDependencies, n as lucentPackages } from "./packages-HyskKIsY.js";
+import { a as resolveAndroidDependencies, i as projectSdk, n as mapLucentPaths, o as sdkImports, r as missingInfoPlistKeys, s as writeGradleDependencies, t as backgroundPrefetch } from "./project-D8tEet0k.js";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+//#region src/cli/pipeline.ts
+const NONE = {
+	rebuild: false,
+	podInstall: false,
+	reload: false
+};
+async function buildProject(root, options, steps, notify) {
+	const t0 = Date.now();
+	const build = options.mode === "build";
+	let files = [];
+	let native;
+	const outcome = (o) => ({
+		ok: false,
+		upToDate: false,
+		files,
+		modules: moduleSummary(files, void 0),
+		diagnostics: [],
+		next: NONE,
+		ms: Date.now() - t0,
+		...o
+	});
+	try {
+		files = projectFiles(root);
+		native = nativeDependencies(lucentPackages(root));
+	} catch (e) {
+		return outcome({ fatal: e.message });
+	}
+	const sdk = projectSdk(root);
+	const outDir = path.resolve(root, options.out ?? ".lucent/native");
+	let platforms = options.platforms;
+	let deferAndroid = false;
+	if (build && (!platforms || platforms.includes("android"))) {
+		writeGradleDependencies(outDir, native);
+		steps.start("android-dependencies", "Android dependencies");
+		await steps.flush();
+		const t = Date.now();
+		const deps = resolveAndroidDependencies(root, files, sdk, native, !!options.force);
+		const label = "Android dependencies";
+		if (deps.status === "resolved") steps.finish({
+			name: "android-dependencies",
+			label,
+			status: "ok",
+			detail: "resolved with Gradle",
+			ms: Date.now() - t
+		});
+		else if (deps.status === "cached") steps.finish({
+			name: "android-dependencies",
+			label,
+			status: "cached"
+		});
+		else if (deps.status === "failed") steps.finish({
+			name: "android-dependencies",
+			label,
+			status: "failed",
+			detail: deps.detail
+		});
+		else if (deps.status === "deferred") {
+			deferAndroid = true;
+			steps.finish({
+				name: "android-dependencies",
+				label,
+				status: "skipped",
+				detail: "resolved by the Gradle build"
+			});
+			notify({
+				level: "warn",
+				text: "the app's Android dependencies are not resolved yet: skipped Android here; the Gradle build compiles it (its lucentBuild task)"
+			});
+		}
+	}
+	if (!platforms && files.some((f) => platformOf(f) || usesPlatforms(f))) {
+		const installed = ["ios", "android"].filter((p) => sdkAvailable(p, sdk) && !(p === "android" && deferAndroid));
+		for (const p of ["ios", "android"]) {
+			if (installed.includes(p) || p === "android" && deferAndroid) continue;
+			const why = sdkModule(p, p === "ios" ? "Foundation" : "android.os", sdk);
+			notify({
+				level: "warn",
+				text: `${"missing" in why ? why.missing : `no ${p} SDK`}; skipped ${p === "ios" ? "iOS" : "Android"} (build it with --platforms ${p} once the SDK is installed)`
+			});
+		}
+		if (!installed.length) return outcome({ fatal: "no platform SDK is installed" });
+		platforms = installed;
+		if (build && options.prefetch) backgroundPrefetch(root, files);
+	}
+	if (build && outDir === path.join(root, ".lucent/native")) {
+		const mapped = mapLucentPaths(root);
+		if (mapped) notify(mapped);
+	}
+	const modules = moduleSummary(files, platforms);
+	const moduleCount = modules.length;
+	const key = inputsKey(files, outDir) + (platforms ? `:${platforms.join(",")}` : "") + `:${createHash("sha256").update(JSON.stringify(native)).digest("hex").slice(0, 12)}`;
+	const checked = path.join(root, ".lucent/check.json");
+	if (!build && !options.force) {
+		if ((fs.existsSync(checked) ? JSON.parse(fs.readFileSync(checked, "utf8")) : {}).inputs === key) return outcome({
+			ok: true,
+			upToDate: true,
+			modules
+		});
+	}
+	if (build && !options.force && isUpToDate(outDir, key)) {
+		steps.finish({
+			name: "up-to-date",
+			label: "Up to date",
+			status: "ok",
+			detail: `${plural(moduleCount, "module")}, nothing to build`,
+			ms: Date.now() - t0
+		});
+		return outcome({
+			ok: true,
+			upToDate: true,
+			modules
+		});
+	}
+	const imports = sdkImports(files);
+	const wanted = ["ios", "android"].flatMap((p) => (platforms ?? []).includes(p) ? imports[p].map((m) => [p, m]) : []);
+	if (wanted.length) {
+		const names = wanted.map(([, m]) => m);
+		const listed = names.length > 3 ? `${names.slice(0, 3).join(" · ")} +${names.length - 3} more` : names.join(" · ");
+		steps.start("sdk", `SDK bindings  ${listed}`);
+		await steps.flush();
+		const t = Date.now();
+		const before = extractionCount();
+		for (const [p, m] of wanted) sdkModule(p, m, sdk);
+		const extracted = extractionCount() - before;
+		steps.finish({
+			name: "sdk",
+			label: "SDK bindings",
+			status: extracted ? "ok" : "cached",
+			detail: listed,
+			ms: extracted ? Date.now() - t : void 0
+		});
+	}
+	steps.start("check", `Checking ${plural(moduleCount, "module")}`);
+	await steps.flush();
+	const tCheck = Date.now();
+	const result = compile(files, {
+		platforms,
+		sdk
+	});
+	const diagnostics = result.diagnostics.map((d) => ({
+		...d,
+		file: d.file && path.relative(root, d.file)
+	}));
+	if (!result.ok) {
+		steps.finish({
+			name: "check",
+			label: `Checked ${plural(moduleCount, "module")}`,
+			status: "failed",
+			detail: plural(diagnostics.length, "error"),
+			ms: Date.now() - tCheck
+		});
+		return outcome({
+			modules,
+			diagnostics
+		});
+	}
+	const names = [...result.proxies.keys()];
+	steps.finish({
+		name: "check",
+		label: `Checked ${plural(names.length, "module")}`,
+		status: "ok",
+		ms: Date.now() - tCheck
+	});
+	if (!build) {
+		fs.mkdirSync(path.dirname(checked), { recursive: true });
+		fs.writeFileSync(checked, `${JSON.stringify({ inputs: key })}\n`);
+		return outcome({
+			ok: true,
+			modules
+		});
+	}
+	const tWrite = Date.now();
+	const w = writeNativePackage(result, outDir, {
+		inputsKey: key,
+		native
+	});
+	const written = new Set(w.written.map((f) => path.relative(outDir, f)));
+	const changed = names.filter((n) => [...written].some((f) => f.startsWith("cpp/generated/") && path.basename(f).startsWith(`${moduleNamespace(n)}.`))).length;
+	steps.finish({
+		name: "generate",
+		label: "Generated C++",
+		status: "ok",
+		detail: changed === names.length ? `${changed} changed` : `${changed} changed, ${names.length - changed} cached`,
+		ms: Date.now() - tWrite
+	});
+	steps.finish({
+		name: "package",
+		label: "Native package",
+		status: "ok",
+		detail: path.relative(root, outDir) || "."
+	});
+	for (const n of missingInfoPlistKeys(root, native)) notify(n);
+	const nativeChanged = w.removed.length > 0 || [...written].some((f) => !f.startsWith("js/") && f !== "manifest.json");
+	return outcome({
+		ok: true,
+		modules,
+		next: {
+			rebuild: nativeChanged,
+			podInstall: w.structureChanged,
+			reload: !nativeChanged && [...written].some((f) => f.startsWith("js/"))
+		}
+	});
+}
+function moduleSummary(files, platforms) {
+	const built = (platforms ?? ["ios", "android"]).filter((p) => p !== "host");
+	const byModule = /* @__PURE__ */ new Map();
+	for (const f of files) {
+		const set = byModule.get(moduleNameOf(f)) ?? /* @__PURE__ */ new Set();
+		const p = platformOf(f);
+		if (p) set.add(p);
+		else if (usesPlatforms(f)) for (const b of built) set.add(b);
+		byModule.set(moduleNameOf(f), set);
+	}
+	return [...byModule].map(([name, set]) => ({
+		name,
+		platforms: set.size ? ["ios", "android"].filter((p) => set.has(p)) : ["shared"]
+	}));
+}
+function plural(n, word) {
+	return `${n} ${word}${n === 1 ? "" : "s"}`;
+}
+function nextText(next) {
+	return next.rebuild ? `rebuild the app${next.podInstall ? " (iOS: pod install first)" : ""}` : next.reload ? "reload the app" : "nothing to do: the native package did not change";
+}
+//#endregion
+export { nextText as n, plural as r, buildProject as t };

package/dist/project-D8tEet0k.js

@@ -0,0 +1,150 @@
+import { t as packageFile } from "./version-bqpIO5sP.js";
+import { c as withGradleDependencies, s as runtimeDir, w as forgetLoadedSdks, x as podsSearchPaths } from "./src-BD7f1_aZ.js";
+import { t as withLucentPaths } from "./tsconfig-S4uyLNzf.js";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+//#region src/cli/project.ts
+function mapLucentPaths(root) {
+	const file = path.join(root, "tsconfig.json");
+	if (!fs.existsSync(file)) return void 0;
+	let text;
+	try {
+		text = withLucentPaths(fs.readFileSync(file, "utf8"));
+	} catch (e) {
+		return {
+			level: "warn",
+			text: `${e.message}; add "paths": { "lucent:*": ["./.lucent/native/types/*"] } to its compilerOptions yourself`
+		};
+	}
+	if (text === void 0) return void 0;
+	fs.writeFileSync(file, text);
+	return {
+		level: "ok",
+		text: "mapped lucent:* in tsconfig.json"
+	};
+}
+function projectSdk(root) {
+	const pods = podsSearchPaths(path.join(root, "ios"));
+	return {
+		android: { classpath: path.join(root, ".lucent/android-classpath.json") },
+		...pods ? { ios: pods } : {}
+	};
+}
+function resolveAndroidDependencies(root, files, sdk, native, force) {
+	const android = path.join(root, "android");
+	const gradlew = path.join(android, process.platform === "win32" ? "gradlew.bat" : "gradlew");
+	if (!sdkImports(files).android.length || !fs.existsSync(gradlew)) return { status: "none" };
+	if (process.env.LUCENT_GRADLE_CLASSPATH) return { status: "cached" };
+	if (process.env.LUCENT_NO_GRADLE) return fs.existsSync(sdk.android.classpath) ? { status: "cached" } : { status: "deferred" };
+	const stateFile = path.join(root, ".lucent/android-classpath.state.json");
+	const inputs = gradleInputsHash(root, native);
+	const state = fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, "utf8")) : {};
+	if (!force && state.inputs === inputs && state.ok === false) return {
+		status: "failed",
+		detail: "Gradle could not resolve them for these build files before; lucent build --force retries"
+	};
+	if (!force && state.inputs === inputs && fs.existsSync(sdk.android.classpath)) return { status: "cached" };
+	const script = packageFile("gradle/lucent-classpath.init.gradle");
+	const r = spawnSync(gradlew, [
+		"-q",
+		"--init-script",
+		script,
+		":app:lucentClasspath"
+	], {
+		cwd: android,
+		encoding: "utf8"
+	});
+	fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+	fs.writeFileSync(stateFile, JSON.stringify({
+		inputs,
+		ok: r.status === 0
+	}) + "\n");
+	forgetLoadedSdks();
+	if (r.status === 0) return { status: "resolved" };
+	return {
+		status: "failed",
+		detail: `Gradle could not resolve them (retried when the build files or the lockfile change, or with lucent build --force):\n${(r.stderr || r.stdout).trim().split("\n").slice(-8).join("\n")}`
+	};
+}
+function writeGradleDependencies(out, native) {
+	const file = path.join(out, "android/build.gradle");
+	const text = withGradleDependencies(fs.readFileSync(path.join(runtimeDir(), "native/android/build.gradle"), "utf8"), native);
+	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === text) return;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	fs.writeFileSync(file, text);
+}
+function missingInfoPlistKeys(root, native) {
+	const keys = Object.entries(native.infoPlist);
+	const out = [];
+	if (!keys.length) return out;
+	const ios = path.join(root, "ios");
+	const plists = fs.existsSync(ios) ? fs.readdirSync(ios).map((d) => path.join(ios, d, "Info.plist")).filter((f) => fs.existsSync(f)) : [];
+	for (const plist of plists) {
+		const text = fs.readFileSync(plist, "utf8");
+		for (const [key, { from }] of keys) if (!text.includes(`<key>${key}</key>`)) out.push({
+			level: "warn",
+			text: `${from} needs ${key} in ${path.relative(root, plist)} (the Expo config plugin adds it)`
+		});
+	}
+	return out;
+}
+function gradleInputsHash(root, native) {
+	const android = path.join(root, "android");
+	const gradle = [
+		"settings.gradle",
+		"settings.gradle.kts",
+		"build.gradle",
+		"build.gradle.kts",
+		"app/build.gradle",
+		"app/build.gradle.kts",
+		"gradle.properties",
+		"gradle/libs.versions.toml"
+	].map((f) => path.join(android, f));
+	const h = createHash("sha256");
+	for (const f of [...gradle, ...lockfiles(root)]) h.update(`${f}\0${fs.existsSync(f) ? fs.readFileSync(f) : ""}\0`);
+	h.update(JSON.stringify(native.gradle));
+	return h.digest("hex").slice(0, 16);
+}
+function lockfiles(root) {
+	const names = [
+		"package-lock.json",
+		"yarn.lock",
+		"pnpm-lock.yaml",
+		"bun.lock",
+		"bun.lockb"
+	];
+	for (let dir = path.resolve(root);; dir = path.dirname(dir)) {
+		const found = names.map((n) => path.join(dir, n)).filter((f) => fs.existsSync(f));
+		if (found.length || path.dirname(dir) === dir) return found;
+	}
+}
+function sdkImports(files) {
+	const out = {
+		ios: /* @__PURE__ */ new Set(),
+		android: /* @__PURE__ */ new Set()
+	};
+	for (const f of files) for (const m of fs.readFileSync(f, "utf8").matchAll(/["']lucent:(ios|android)\/([\w.]+)["']/g)) out[m[1]].add(m[2]);
+	return {
+		ios: [...out.ios].sort(),
+		android: [...out.android].sort()
+	};
+}
+function backgroundPrefetch(root, files) {
+	const imports = sdkImports(files);
+	for (const p of ["ios", "android"]) for (const m of imports[p]) spawn(process.execPath, [
+		process.argv[1],
+		"sdk",
+		"prefetch",
+		`--${p}`,
+		m,
+		"--root",
+		root
+	], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+}
+//#endregion
+export { resolveAndroidDependencies as a, projectSdk as i, mapLucentPaths as n, sdkImports as o, missingInfoPlistKeys as r, writeGradleDependencies as s, backgroundPrefetch as t };

package/dist/sdk-coverage-BoW_3Efd.js

@@ -0,0 +1,64 @@
+import { D as sdkModule, O as sdkModules, b as coverage, g as projectFiles } from "./src-BD7f1_aZ.js";
+import { i as table } from "./format-D9fnIMEx.js";
+import { i as projectSdk, o as sdkImports } from "./project-D8tEet0k.js";
+import fs from "node:fs";
+//#region src/cli/commands/sdk-coverage.ts
+function run({ root, flags, out }) {
+	const t = out.theme;
+	const sdk = projectSdk(root);
+	const list = (flag) => (typeof flags[flag] === "string" ? flags[flag] : "").split(",").filter(Boolean);
+	const wanted = {
+		ios: list("ios"),
+		android: list("android")
+	};
+	if (!wanted.ios.length && !wanted.android.length) Object.assign(wanted, sdkImports(projectFiles(root)));
+	const reports = [];
+	for (const platform of ["ios", "android"]) {
+		const listed = () => {
+			const all = sdkModules(platform, sdk);
+			return "missing" in all ? [] : all;
+		};
+		const modules = wanted[platform].flatMap((m) => m.endsWith(".*") ? listed().filter((x) => x.startsWith(m.slice(0, -1))) : [m]);
+		for (const m of modules) {
+			const r = sdkModule(platform, m, sdk);
+			if ("missing" in r) {
+				out.error(`${t.error(t.symbols.fail)} ${r.missing}`);
+				return 1;
+			}
+			reports.push(coverage(r.schema));
+		}
+	}
+	if (flags.json) out.data(reports);
+	else {
+		const pct = (n, t) => `${t ? (100 * n / t).toFixed(1) : "0.0"}%`;
+		const rows = reports.map((c) => [
+			c.module,
+			String(c.total),
+			String(c.idiomatic),
+			String(c.raw),
+			`${c.unrepresentable} (${pct(c.unrepresentable, c.total)})`
+		]);
+		for (const line of table([[
+			"module",
+			"total",
+			"idiomatic",
+			"raw",
+			"unrepresentable"
+		].map((h) => t.dim(h)), ...rows])) out.print(line);
+	}
+	const baselineFile = typeof flags.check === "string" ? flags.check : "";
+	if (!baselineFile) return 0;
+	const baseline = new Map(JSON.parse(fs.readFileSync(baselineFile, "utf8")).map((c) => [c.module, c]));
+	const share = (c) => c.total ? 100 * c.unrepresentable / c.total : 0;
+	let dropped = false;
+	for (const c of reports) {
+		const b = baseline.get(c.module);
+		if (b && share(c) > share(b) + .05) {
+			process.stderr.write(`${t.symbols.fail} ${c.module}: ${share(c).toFixed(2)}% unrepresentable, ${share(b).toFixed(2)}% in the baseline\n`);
+			dropped = true;
+		}
+	}
+	return dropped ? 1 : 0;
+}
+//#endregion
+export { run };

package/dist/sdk-prefetch-mo04JDZV.js

@@ -0,0 +1,89 @@
+import { C as extractionCount, D as sdkModule, O as sdkModules, g as projectFiles } from "./src-BD7f1_aZ.js";
+import { i as projectSdk, o as sdkImports } from "./project-D8tEet0k.js";
+import { t as plainSteps } from "./steps--_h-FFS7.js";
+//#region src/cli/commands/sdk-prefetch.ts
+async function run({ root, flags, out }) {
+	const t = out.theme;
+	const listed = (p) => typeof flags[p] === "string" ? flags[p].split(",").filter(Boolean) : void 0;
+	let wanted = {
+		ios: listed("ios"),
+		android: listed("android")
+	};
+	if (!wanted.ios && !wanted.android && !flags.all) wanted = sdkImports(projectFiles(root));
+	const sdk = projectSdk(root);
+	const jobs = [];
+	let failed = 0;
+	for (const p of ["ios", "android"]) {
+		let modules = wanted[p];
+		if (flags.all || flags[p] === "") {
+			const everything = sdkModules(p, sdk);
+			if (!Array.isArray(everything)) {
+				out.error(`${t.error(t.symbols.fail)} ${everything.missing}`);
+				failed++;
+				continue;
+			}
+			modules = everything;
+		}
+		for (const m of modules ?? []) jobs.push([p, m]);
+	}
+	const steps = out.json ? plainSteps(() => {}, t) : out.terminal.interactive ? (await import("./live-steps-BGcWFM9M.js")).liveSteps(t) : plainSteps((l) => out.print(l), t);
+	let extracted = 0;
+	let cached = 0;
+	try {
+		for (const [i, [p, m]] of jobs.entries()) {
+			const name = `lucent:${p}/${m}`;
+			steps.start(name, `${name}  ${t.dim(`${i + 1}/${jobs.length}`)}`);
+			await steps.flush();
+			const t0 = Date.now();
+			const before = extractionCount();
+			const r = sdkModule(p, m, sdk);
+			if ("missing" in r) {
+				steps.finish({
+					name,
+					label: name,
+					status: "failed",
+					detail: r.missing
+				});
+				failed++;
+			} else if (extractionCount() > before) {
+				steps.finish({
+					name,
+					label: name,
+					status: "ok",
+					ms: Date.now() - t0
+				});
+				extracted++;
+			} else {
+				steps.finish({
+					name,
+					label: name,
+					status: "cached"
+				});
+				cached++;
+			}
+		}
+	} finally {
+		await steps.close();
+	}
+	if (out.json) {
+		out.data({
+			ok: failed === 0,
+			modules: steps.results.map((s) => ({
+				module: s.name,
+				status: s.status,
+				...s.ms !== void 0 ? { ms: s.ms } : {},
+				...s.detail ? { error: s.detail } : {}
+			}))
+		});
+		return failed ? 1 : 0;
+	}
+	const parts = [
+		extracted && `${extracted} extracted`,
+		cached && `${cached} cached`,
+		failed && t.error(`${failed} failed`)
+	].filter(Boolean);
+	out.print(`\n${jobs.length} module${jobs.length === 1 ? "" : "s"}: ${parts.join(", ") || "nothing to do"}`);
+	return failed ? 1 : 0;
+}
+//#endregion
+export { run };

package/dist/sdk-search-Iv4K3-8a.js

@@ -0,0 +1,124 @@
+import { D as sdkModule, E as sdkAvailable, S as cachedModules, g as projectFiles, k as sdkNames } from "./src-BD7f1_aZ.js";
+import { i as table } from "./format-D9fnIMEx.js";
+import { i as projectSdk, o as sdkImports } from "./project-D8tEet0k.js";
+//#region src/cli/commands/sdk-search.ts
+function run({ root, positionals, out }) {
+	const t = out.theme;
+	const term = positionals.join(" ").trim();
+	if (!term) {
+		out.error(`${t.error(t.symbols.fail)} search for a name: lucent sdk search <term>`);
+		return 2;
+	}
+	const needle = term.toLowerCase();
+	const hit = (name) => name.toLowerCase().includes(needle);
+	const sdk = projectSdk(root);
+	let imports = {
+		ios: [],
+		android: []
+	};
+	try {
+		imports = sdkImports(projectFiles(root));
+	} catch {}
+	const matches = [];
+	let searched = 0;
+	let total = 0;
+	for (const platform of ["ios", "android"]) {
+		if (!sdkAvailable(platform, sdk)) continue;
+		const cached = cachedModules(platform, sdk);
+		const withSchema = [.../* @__PURE__ */ new Set([...imports[platform], ..."missing" in cached ? [] : cached.schemas])].sort();
+		const namesOnly = "missing" in cached ? [] : cached.names.filter((m) => !withSchema.includes(m));
+		total += withSchema.length + namesOnly.length;
+		const importLine = (module, name) => `import { ${name} } from "lucent:${platform}/${module}";`;
+		for (const module of withSchema) {
+			const r = sdkModule(platform, module, sdk);
+			if ("missing" in r) continue;
+			searched++;
+			matches.push(...schemaMatches(r.schema, platform, hit, importLine));
+		}
+		for (const module of namesOnly) {
+			const r = sdkNames(platform, module, sdk);
+			if ("missing" in r) continue;
+			searched++;
+			for (const [name, info] of Object.entries(r.names.types)) if (hit(name)) matches.push({
+				platform,
+				module,
+				kind: info.kind === "protocol" ? "protocol" : info.kind === "class" ? "class" : info.kind === "enum" ? "enum" : "struct",
+				name,
+				import: importLine(module, name)
+			});
+		}
+	}
+	if (out.json) {
+		out.data({
+			term,
+			searched,
+			matches
+		});
+		return 0;
+	}
+	const groups = /* @__PURE__ */ new Map();
+	for (const m of matches) groups.set(`${m.platform}\0${m.module}`, [...groups.get(`${m.platform}\0${m.module}`) ?? [], m]);
+	const LIMIT = 12;
+	for (const [key, list] of groups) {
+		const [platform, module] = key.split("\0");
+		out.print(`${t.brand(platform)}  ${t.bold(module)}`);
+		const shown = list.slice(0, LIMIT);
+		const types = new Set(shown.filter((m) => !m.name.includes(".")).map((m) => m.name));
+		for (const line of table(shown.map((m) => [
+			`  ${t.dim(m.kind)}`,
+			m.name,
+			types.has(m.name) ? t.dim(m.import) : ""
+		]))) out.print(line.trimEnd());
+		if (list.length > LIMIT) out.print(t.dim(`  … ${list.length - LIMIT} more (lucent sdk search ${term} --json lists them all)`));
+		out.print("");
+	}
+	if (!matches.length) out.print(`${t.dim(t.symbols.off)} nothing named like ${term}`);
+	out.print(t.dim(`searched ${searched} module${searched === 1 ? "" : "s"}${total > searched ? ` of ${total}` : ""} (your imports and the SDK cache; lucent sdk prefetch --all to search every module)`));
+	return 0;
+}
+function schemaMatches(schema, platform, hit, importLine) {
+	const out = [];
+	const module = schema.module;
+	for (const type of schema.types) {
+		const kind = type.kind === "class" ? type.interface ? platform === "ios" ? "protocol" : "interface" : "class" : type.kind;
+		if (hit(type.name)) out.push({
+			platform,
+			module,
+			kind,
+			name: type.name,
+			import: importLine(module, type.name)
+		});
+		if (type.kind !== "class") continue;
+		for (const m of type.methods ?? []) if (hit(m.name)) out.push({
+			platform,
+			module,
+			kind: "method",
+			name: `${type.name}.${m.name}(${m.params.map((p) => p.name).join(", ")})`,
+			import: importLine(module, type.name)
+		});
+		for (const p of type.properties ?? []) if (hit(p.name)) out.push({
+			platform,
+			module,
+			kind: "property",
+			name: `${type.name}.${p.name}`,
+			import: importLine(module, type.name)
+		});
+	}
+	for (const f of schema.functions ?? []) if (hit(f.name)) out.push({
+		platform,
+		module,
+		kind: "function",
+		name: `${f.name}(${f.params.map((p) => p.name).join(", ")})`,
+		import: importLine(module, f.name)
+	});
+	for (const c of schema.constants ?? []) if (hit(c.name)) out.push({
+		platform,
+		module,
+		kind: "constant",
+		name: c.name,
+		import: importLine(module, c.name)
+	});
+	return out;
+}
+//#endregion
+export { run };