@lucent-lang/lucent 0.0.4 → 0.1.1

package/dist/project-BKNoTEEp.js

@@ -0,0 +1,342 @@
+import { t as packageFile } from "./version-bqpIO5sP.js";
+import { J as forgetLoadedSdks, W as podsSearchPaths, c as sdkModules, f as runtimeDir, g as libraryBuildGradle, v as resolveNative, x as fileHashes } from "./src-ChnmWLwn.js";
+import { n as lucentPackages } from "./packages-CSmKeaAh.js";
+import { t as withLucentPaths } from "./tsconfig-S4uyLNzf.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { createHash } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+//#region ../bindgen/src/vendored.ts
+function frameworkSearchPath(framework) {
+	if (!framework.endsWith(".xcframework")) return path.dirname(framework);
+	const slice = xcframeworkLibraries(framework).find((l) => l.platform === "ios" && l.variant === "simulator" && l.identifier && l.path);
+	if (!slice) return void 0;
+	const dir = path.join(framework, slice.identifier);
+	return fs.existsSync(path.join(dir, slice.path)) ? dir : void 0;
+}
+function xcframeworkLibraries(framework) {
+	const plist = path.join(framework, "Info.plist");
+	if (!fs.existsSync(plist)) return [];
+	const text = fs.readFileSync(plist, "utf8");
+	const start = /<key>AvailableLibraries<\/key>\s*<array>/.exec(text);
+	if (!start) return [];
+	const tags = /<(\/?)array>/g;
+	tags.lastIndex = start.index + start[0].length;
+	let end = text.length;
+	for (let depth = 1, m = tags.exec(text); m; m = tags.exec(text)) {
+		depth += m[1] ? -1 : 1;
+		if (depth === 0) {
+			end = m.index;
+			break;
+		}
+	}
+	return [...text.slice(start.index + start[0].length, end).matchAll(/<dict>([\s\S]*?)<\/dict>/g)].map(([, entry]) => {
+		const value = (key) => new RegExp(`<key>${key}</key>\\s*<string>([^<]*)</string>`).exec(entry)?.[1];
+		return {
+			identifier: value("LibraryIdentifier"),
+			path: value("LibraryPath"),
+			platform: value("SupportedPlatform"),
+			variant: value("SupportedPlatformVariant")
+		};
+	});
+}
+//#endregion
+//#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, native) {
+	const binaries = native?.binaries ?? packageBinaries(root);
+	const pods = podsSearchPaths(path.join(root, "ios"));
+	const frameworkPaths = [...new Set(binaries.ios.map(frameworkSearchPath).filter((dir) => dir !== void 0))];
+	const ios = pods || frameworkPaths.length ? pods ?? {} : void 0;
+	return {
+		android: {
+			classpath: path.join(root, ".lucent/android-classpath.json"),
+			...binaries.android.length ? { libraries: binaries.android } : {}
+		},
+		...ios ? { ios: {
+			...ios,
+			frameworkPaths: [...ios.frameworkPaths ?? [], ...frameworkPaths]
+		} } : {}
+	};
+}
+function packageBinaries(root) {
+	const hashes = projectHashes(root);
+	try {
+		const { binaries } = resolveNative(lucentPackages(root), { hashes });
+		hashes.save();
+		return binaries;
+	} catch {
+		return {
+			ios: [],
+			android: []
+		};
+	}
+}
+const projectHashes = (root) => fileHashes(path.join(root, ".lucent/file-hashes.json"));
+function resolveAndroidDependencies(root, files, sdk, native, force) {
+	const gradlew = gradlewOf(root);
+	const android = path.dirname(gradlew);
+	if (!sdkImports(files).android.length || !fs.existsSync(gradlew)) return { status: "none" };
+	const stateFile = path.join(root, ".lucent/android-classpath.state.json");
+	const inputs = gradleInputsHash(root, native);
+	const record = (ok) => {
+		fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+		fs.writeFileSync(stateFile, JSON.stringify({
+			inputs,
+			ok
+		}) + "\n");
+	};
+	if (process.env.LUCENT_GRADLE_CLASSPATH) {
+		if (fs.existsSync(sdk.android.classpath)) record(true);
+		return { status: "cached" };
+	}
+	if (process.env.LUCENT_NO_GRADLE) return fs.existsSync(sdk.android.classpath) ? { status: "cached" } : { status: "deferred" };
+	const known = () => {
+		const state = fs.existsSync(stateFile) ? JSON.parse(fs.readFileSync(stateFile, "utf8")) : {};
+		if (force || state.inputs !== inputs) return void 0;
+		if (state.ok === false) return {
+			status: "failed",
+			detail: "Gradle could not resolve them for these build files before; lucent build --force retries"
+		};
+		return fs.existsSync(sdk.android.classpath) ? { status: "cached" } : void 0;
+	};
+	const before = known();
+	if (before) return before;
+	const lock = path.join(root, ".lucent/gradle.lock");
+	if (!acquire(lock)) {
+		waitFor(lock);
+		const after = known();
+		if (after) return after;
+		if (!acquire(lock)) throw new Error(`${lock}: another lucent build holds it`);
+	}
+	try {
+		const script = packageFile("gradle/lucent-classpath.init.gradle");
+		const r = spawnSync(gradlew, [
+			"-q",
+			"--init-script",
+			script,
+			":app:lucentClasspath"
+		], {
+			cwd: android,
+			encoding: "utf8",
+			env: {
+				...process.env,
+				LUCENT_GRADLE_CLASSPATH: "1"
+			}
+		});
+		record(r.status === 0);
+		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")}`
+		};
+	} finally {
+		fs.rmSync(lock, { force: true });
+	}
+}
+function acquire(lock) {
+	fs.mkdirSync(path.dirname(lock), { recursive: true });
+	for (;;) try {
+		fs.writeFileSync(lock, `${os.hostname()}\n${process.pid}`, { flag: "wx" });
+		return true;
+	} catch {
+		if (holderAlive(lock)) return false;
+		fs.rmSync(lock, { force: true });
+	}
+}
+function holderAlive(lock) {
+	let text;
+	try {
+		text = fs.readFileSync(lock, "utf8");
+	} catch {
+		return false;
+	}
+	const [host, pid] = text.split("\n");
+	if (host !== os.hostname()) return true;
+	try {
+		process.kill(Number(pid), 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function waitFor(lock, timeoutMs = 6e5) {
+	const sleeper = new Int32Array(new SharedArrayBuffer(4));
+	for (const start = Date.now(); fs.existsSync(lock) && holderAlive(lock);) {
+		if (Date.now() - start > timeoutMs) return;
+		Atomics.wait(sleeper, 0, 0, 50);
+	}
+}
+function writeLinkedPackage(root, out, native) {
+	const templates = path.join(runtimeDir(), "native");
+	const created = !fs.existsSync(path.join(out, "react-native.config.js"));
+	for (const file of listFiles(templates)) {
+		const to = path.join(out, path.relative(templates, file));
+		if (fs.existsSync(to)) continue;
+		fs.mkdirSync(path.dirname(to), { recursive: true });
+		fs.copyFileSync(file, to);
+	}
+	writeGradleDependencies(out, native);
+	if (created) staleAutolinking(root);
+	return created;
+}
+function staleAutolinking(root) {
+	const dir = path.join(root, "android/build/generated/autolinking");
+	if (!fs.existsSync(dir)) return;
+	for (const f of fs.readdirSync(dir)) if (f.endsWith(".sha")) fs.rmSync(path.join(dir, f));
+}
+function listFiles(dir) {
+	return fs.readdirSync(dir, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? listFiles(path.join(dir, e.name)) : [path.join(dir, e.name)]);
+}
+function writeGradleDependencies(out, native) {
+	const file = path.join(out, "android/build.gradle");
+	const kotlin = (dir) => {
+		const at = path.join(out, "android/src/main/java/dev/lucent", dir);
+		return fs.existsSync(at) ? fs.readdirSync(at).filter((f) => f.endsWith(".kt")).map((f) => fs.readFileSync(path.join(at, f), "utf8")) : [];
+	};
+	const text = libraryBuildGradle(fs.readFileSync(path.join(runtimeDir(), "native/android/build.gradle"), "utf8"), native, kotlin("shims").length > 0, kotlin("compose"));
+	if (fs.existsSync(file) && fs.readFileSync(file, "utf8") === text) return;
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	fs.writeFileSync(file, text);
+}
+const APP_PLISTS = [{
+	entries: (n) => n.ios.infoPlist,
+	files: (dir) => ["Info.plist"].filter((f) => fs.existsSync(path.join(dir, f))),
+	none: "the app has no Info.plist"
+}, {
+	entries: (n) => n.ios.entitlements,
+	files: (dir) => fs.readdirSync(dir).filter((f) => f.endsWith(".entitlements")),
+	none: "the app's target has no .entitlements file"
+}];
+function missingAppEntries(root, native) {
+	const ios = path.join(root, "ios");
+	const targets = fs.existsSync(ios) ? fs.readdirSync(ios, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => path.join(ios, e.name)) : [];
+	const out = [];
+	const warn = (text) => out.push({
+		level: "warn",
+		text: `${text} (the Expo config plugin adds it)`
+	});
+	const who = (from) => `${from.join(" and ")} ${from.length === 1 ? "needs" : "need"}`;
+	for (const { entries, files, none } of APP_PLISTS) {
+		const keys = Object.entries(entries(native));
+		const found = targets.flatMap((dir) => files(dir).map((f) => path.join(dir, f)));
+		if (!keys.length || !targets.length) continue;
+		if (!found.length) for (const [key, { from }] of keys) warn(`${who(from)} ${key}, but ${none}`);
+		for (const file of found) {
+			const app = plistEntries(fs.readFileSync(file, "utf8"));
+			const where = path.relative(root, file);
+			for (const [key, { value, from }] of keys) {
+				const has = app.get(key);
+				if (has === void 0) warn(`${who(from)} ${key} in ${where}`);
+				else if (Array.isArray(value)) for (const v of value.filter((v) => !(Array.isArray(has) && has.includes(v)))) warn(`${who(from)} ${JSON.stringify(v)} in ${key} in ${where}`);
+			}
+		}
+	}
+	return out;
+}
+function plistEntries(text) {
+	const out = /* @__PURE__ */ new Map();
+	for (const m of text.matchAll(/<key>([^<]*)<\/key>\s*(?:<string>([^<]*)<\/string>|<(true|false)\/>|<array>([\s\S]*?)<\/array>|<array\/>)?/g)) {
+		const [, key, string, boolean, array] = m;
+		out.set(key, string !== void 0 ? string : boolean !== void 0 ? boolean === "true" : array !== void 0 || m[0].endsWith("<array/>") ? [...(array ?? "").matchAll(/<string>([^<]*)<\/string>/g)].map((s) => s[1]) : null);
+	}
+	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.android.dependencies));
+	return h.digest("hex").slice(0, 16);
+}
+const gradlewOf = (root) => path.join(root, "android", process.platform === "win32" ? "gradlew.bat" : "gradlew");
+function pendingAndroidModules(root, files, sdk) {
+	const imports = sdkImports(files).android;
+	const resolved = sdk.android?.classpath && fs.existsSync(sdk.android.classpath);
+	if (!imports.length || resolved || fs.existsSync(gradlewOf(root))) return [];
+	const available = sdkModules("android", sdk);
+	if (!Array.isArray(available)) return [];
+	const declared = new Set(available);
+	return imports.filter((m) => !declared.has(m));
+}
+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 prefetchJobs(imports, platforms, slots) {
+	const jobs = platforms.flatMap((p) => imports[p].map((m) => [p, m]));
+	const count = Math.min(jobs.length, slots);
+	return Array.from({ length: count }, (_, i) => {
+		const mine = jobs.filter((_, j) => j % count === i);
+		return platforms.flatMap((p) => {
+			const modules = mine.filter(([q]) => q === p).map(([, m]) => m);
+			return modules.length ? [`--${p}`, modules.join(",")] : [];
+		});
+	});
+}
+function backgroundPrefetch(root, files, platforms) {
+	const slots = Math.max(1, os.availableParallelism() - 1);
+	for (const args of prefetchJobs(sdkImports(files), platforms, slots)) spawn(process.execPath, [
+		process.argv[1],
+		"sdk",
+		"prefetch",
+		...args,
+		"--root",
+		root
+	], {
+		detached: true,
+		stdio: "ignore"
+	}).unref();
+}
+//#endregion
+export { projectHashes as a, sdkImports as c, pendingAndroidModules as i, staleAutolinking as l, mapLucentPaths as n, projectSdk as o, missingAppEntries as r, resolveAndroidDependencies as s, backgroundPrefetch as t, writeLinkedPackage as u };

package/dist/sdk-coverage-iiv3JqMp.js

@@ -0,0 +1,113 @@
+import { N as projectFiles, R as coverage, U as symbolKey, c as sdkModules, et as sdkSourceModule, h as toolkitsFrom, s as sdkModule } from "./src-ChnmWLwn.js";
+import { c as sdkImports, o as projectSdk } from "./project-BKNoTEEp.js";
+import { i as table } from "./format-D9fnIMEx.js";
+import { n as USAGE_FILE, o as readUsage } from "./sdk-usage-0ZFMAYg1.js";
+import fs from "node:fs";
+import path from "node:path";
+//#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)));
+	let evidence;
+	try {
+		evidence = readEvidence(root, typeof flags.exercised === "string" ? flags.exercised : "", (problem) => out.error(`${t.warn(t.symbols.warn)} ${problem}: generated is unknown until the next check or build`));
+	} catch (e) {
+		out.error(`${t.error(t.symbols.fail)} ${e.message}`);
+		return 1;
+	}
+	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, void 0, evidence));
+			for (const toolkit of toolkitsFrom(platform, m)) {
+				const source = sdkSourceModule(platform, m, sdk);
+				if ("missing" in source) {
+					out.error(`${t.error(t.symbols.fail)} ${toolkit}: ${source.missing}`);
+					return 1;
+				}
+				reports.push({
+					...coverage(source.schema, void 0, evidence),
+					module: toolkit
+				});
+			}
+		}
+	}
+	if (flags.json) out.data(flags.members ? reports : reports.map((c) => ({
+		...c,
+		members: void 0
+	})));
+	else {
+		const pct = (n, t) => `${t ? (100 * n / t).toFixed(1) : "0.0"}%`;
+		const known = (n) => n === null ? "-" : String(n);
+		const rows = reports.map((c) => [
+			c.module,
+			String(c.stages.discovered),
+			String(c.stages.representable),
+			`${c.unrepresentable} (${pct(c.unrepresentable, c.total)})`,
+			known(c.stages.generated),
+			known(c.stages.exercised)
+		]);
+		for (const line of table([[
+			"module",
+			"discovered",
+			"representable",
+			"unrepresentable",
+			"generated",
+			"exercised"
+		].map((h) => t.dim(h)), ...rows])) out.print(line);
+		if (flags.members) for (const c of reports) {
+			out.print("");
+			out.print(t.bold(c.module));
+			for (const line of table(c.members.map((m) => [
+				`  ${t.dim(m.stage)}`,
+				m.display,
+				m.reason ?? t.dim(m.key ?? "")
+			]))) out.print(line.trimEnd());
+		}
+	}
+	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;
+}
+function readEvidence(root, exercisedFile, warn) {
+	const out = {};
+	try {
+		const usage = readUsage(path.join(root, USAGE_FILE));
+		if (usage) out.generated = new Set(usage.symbols.map(symbolKey));
+	} catch (e) {
+		warn(e.message);
+	}
+	if (!exercisedFile) return out;
+	const value = JSON.parse(fs.readFileSync(path.resolve(root, exercisedFile), "utf8"));
+	if (!Array.isArray(value) || !value.every((k) => typeof k === "string")) throw new Error(`${exercisedFile}: expected a JSON array of symbol keys (lucent sdk coverage --members --json lists them)`);
+	out.exercised = new Set(value);
+	return out;
+}
+//#endregion
+export { run };

package/dist/sdk-diff-ByJ1Gw-F.js

@@ -0,0 +1,109 @@
+import { B as diffModule, H as displayName, K as cachedSchema, U as symbolKey, V as diffSymbols, s as sdkModule, z as compareArtifacts } from "./src-ChnmWLwn.js";
+import { o as projectSdk } from "./project-BKNoTEEp.js";
+import { i as table } from "./format-D9fnIMEx.js";
+import { o as readUsage, r as artifactText, s as sdkUnavailable, t as LOCK_FILE, u as usedModules } from "./sdk-usage-0ZFMAYg1.js";
+import path from "node:path";
+//#region src/cli/commands/sdk-diff.ts
+const entry = (c) => {
+	const s = c.after ?? c.before;
+	return {
+		change: c.change,
+		platform: s.platform,
+		module: s.module,
+		key: symbolKey(c.before ?? s),
+		display: displayName(c.before ?? s),
+		signature: s.signature,
+		details: c.details
+	};
+};
+function run({ root, flags, out }) {
+	const t = out.theme;
+	let lock;
+	try {
+		lock = readUsage(path.join(root, LOCK_FILE));
+	} catch (e) {
+		out.error(`${t.error(t.symbols.fail)} ${e.message}`);
+		return 1;
+	}
+	if (!lock) {
+		out.error(`${t.error(t.symbols.fail)} no ${LOCK_FILE}: lucent sdk lock records the SDKs to compare with`);
+		return 1;
+	}
+	const sdk = projectSdk(root);
+	const unavailable = lock.targets.flatMap((p) => {
+		const reason = sdkUnavailable(p, sdk);
+		return reason ? [{
+			platform: p,
+			reason
+		}] : [];
+	});
+	const available = (p) => !unavailable.some((u) => u.platform === p);
+	const schemaOf = (p, m) => {
+		const r = sdkModule(p, m, sdk);
+		return "schema" in r ? r.schema : r;
+	};
+	const used = diffSymbols(lock.symbols.filter((s) => available(s.platform)), schemaOf);
+	const lockedModules = Object.keys(lock.modules).filter((k) => available(k.split("/")[0]));
+	const artifacts = compareArtifacts(lock.modules, usedModules(lockedModules, sdk));
+	const others = [];
+	const uncached = [];
+	if (flags.all) {
+		const usedKeys = new Set(lock.symbols.map(symbolKey));
+		for (const key of lockedModules) {
+			const [p, m] = key.split("/");
+			const ref = lock.modules[key].schema;
+			const before = ref ? cachedSchema(p, m, ref, sdk) : void 0;
+			const after = schemaOf(p, m);
+			if (!before) uncached.push(key);
+			if (!before || "missing" in after) continue;
+			others.push(...diffModule(before, after).filter((c) => c.change !== "unchanged" && !usedKeys.has(symbolKey(c.before ?? c.after))));
+		}
+	}
+	const removed = used.filter((c) => c.change === "removed").length;
+	const changed = used.filter((c) => c.change === "changed").length;
+	const ok = !unavailable.length && !removed && !changed;
+	if (out.json) {
+		out.data({
+			ok,
+			unavailable,
+			artifacts,
+			used: used.map(entry),
+			...flags.all ? {
+				others: others.map(entry),
+				uncached
+			} : {}
+		});
+		return ok ? 0 : 1;
+	}
+	for (const u of unavailable) out.error(`${t.error(t.symbols.fail)} ${u.platform}: ${u.reason}`);
+	print(out, artifacts, [...used, ...others]);
+	for (const key of uncached) out.print(t.dim(`lucent:${key}: the locked schema is not in this machine's SDK cache: only its used symbols are compared`));
+	const total = used.length;
+	out.print(removed + changed ? `${removed + changed} of ${total} used symbols changed: ${removed} removed, ${changed} changed ${t.dim(`(lucent sdk lock records the installed SDKs once the code is updated)`)}` : `${t.success(t.symbols.ok)} none of the ${total} used symbols changed`);
+	return ok ? 0 : 1;
+}
+function print(out, artifacts, changes) {
+	const t = out.theme;
+	const byModule = /* @__PURE__ */ new Map();
+	const of = (key) => byModule.get(key) ?? byModule.set(key, { changes: [] }).get(key);
+	for (const a of artifacts) of(a.module).artifacts = a;
+	for (const c of changes) {
+		if (c.change === "unchanged") continue;
+		const s = c.before ?? c.after;
+		of(`${s.platform}/${s.module}`).changes.push(c);
+	}
+	for (const [key, m] of [...byModule].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+		const [platform] = key.split("/");
+		out.print(`${t.brand(platform)}  ${t.bold(`lucent:${key}`)}`);
+		if (m.artifacts) out.print(`  ${t.dim("artifacts")}  ${artifactText(m.artifacts)}`);
+		const rows = m.changes.map((c) => [
+			`  ${c.change === "added" ? t.dim(c.change) : c.change === "changed" ? t.warn(c.change) : t.error(c.change)}`,
+			displayName(c.before ?? c.after),
+			c.details.join("; ") || (c.after ?? c.before).signature
+		]);
+		for (const line of table(rows)) out.print(line.trimEnd());
+		out.print("");
+	}
+}
+//#endregion
+export { run };

package/dist/sdk-lock-BQn7IyRs.js

@@ -0,0 +1,38 @@
+import { r as plural, t as buildProject } from "./pipeline-BM_VM2X_.js";
+import { d as writeUsage, t as LOCK_FILE } from "./sdk-usage-0ZFMAYg1.js";
+import { t as plainSteps } from "./steps--_h-FFS7.js";
+import path from "node:path";
+//#region src/cli/commands/sdk-lock.ts
+async function run({ root, flags, out }) {
+	const t = out.theme;
+	const platforms = typeof flags.platforms === "string" && flags.platforms ? flags.platforms.split(",") : void 0;
+	const result = await buildProject(root, {
+		mode: "check",
+		force: true,
+		platforms
+	}, plainSteps(() => {}, t), (n) => out.error(`${n.level === "ok" ? t.symbols.ok : t.warn(t.symbols.warn)} ${n.text}`));
+	const others = result.usage?.targets.join(",");
+	const failure = result.fatal ?? (result.ok ? void 0 : `${plural(result.diagnostics.length, "error")} in the project: lucent check shows them; the lock records a project that checks`) ?? (result.skipped.length ? [...result.skipped.map((s) => `${s.platform}: ${s.reason}`), `the lock needs every platform the project has code for: install the SDK, or lock ${others} alone with --platforms ${others}`].join("\n") : void 0);
+	if (failure || !result.usage) {
+		if (out.json) out.data({
+			ok: false,
+			error: failure ?? "the check recorded no SDK usage"
+		});
+		else out.error(`${t.error(t.symbols.fail)} ${failure ?? "the check recorded no SDK usage"}`);
+		return 1;
+	}
+	const usage = result.usage;
+	writeUsage(path.join(root, LOCK_FILE), usage);
+	const summary = {
+		ok: true,
+		file: LOCK_FILE,
+		targets: usage.targets,
+		modules: Object.keys(usage.modules).length,
+		symbols: usage.symbols.length
+	};
+	if (out.json) out.data(summary);
+	else out.print(`${t.success(t.symbols.ok)} ${LOCK_FILE}  ${plural(summary.symbols, "symbol")} of ${plural(summary.modules, "module")}${usage.targets.length ? `, for ${usage.targets.join(" and ")}` : ""}`);
+	return 0;
+}
+//#endregion
+export { run };

package/dist/{sdk-prefetch-mo04JDZV.js → sdk-prefetch-Bv2pNega.js}

@@ -1,5 +1,5 @@
-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 { N as projectFiles, c as sdkModules, q as extractionCount, s as sdkModule } from "./src-ChnmWLwn.js";
+import { c as sdkImports, o as projectSdk } from "./project-BKNoTEEp.js";
 import { t as plainSteps } from "./steps--_h-FFS7.js";
 //#region src/cli/commands/sdk-prefetch.ts
 async function run({ root, flags, out }) {

package/dist/{sdk-search-Iv4K3-8a.js → sdk-search-CPGJm_Ne.js}

@@ -1,6 +1,6 @@
-import { D as sdkModule, E as sdkAvailable, S as cachedModules, g as projectFiles, k as sdkNames } from "./src-BD7f1_aZ.js";
+import { G as cachedModules, N as projectFiles, Q as sdkNames, X as sdkAvailable, s as sdkModule } from "./src-ChnmWLwn.js";
+import { c as sdkImports, o as projectSdk } from "./project-BKNoTEEp.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;

package/dist/{sdk-show-CkrdlqlP.js → sdk-show-BUkLqRnA.js}

@@ -1,5 +1,5 @@
-import { D as sdkModule, E as sdkAvailable, O as sdkModules, y as sdkDts } from "./src-BD7f1_aZ.js";
-import { i as projectSdk } from "./project-D8tEet0k.js";
+import { X as sdkAvailable, c as sdkModules, o as sdkDeclarations, s as sdkModule } from "./src-ChnmWLwn.js";
+import { o as projectSdk } from "./project-BKNoTEEp.js";
 //#region src/cli/commands/sdk-show.ts
 function run({ root, positionals, out }) {
 	const t = out.theme;
@@ -19,7 +19,7 @@ function run({ root, positionals, out }) {
 			const r = sdkModule(platform, module, sdk);
 			if ("missing" in r) continue;
 			const [type, member] = parts.slice(n);
-			const block = declaration(sdkDts(r.schema), type);
+			const block = declaration(sdkDeclarations(r.schema), type);
 			if (!block) {
 				out.error(`${t.error(t.symbols.fail)} no ${type} in lucent:${platform}/${module}: lucent sdk search ${type} finds similar names`);
 				return 1;
@@ -29,13 +29,14 @@ function run({ root, positionals, out }) {
 				out.error(`${t.error(t.symbols.fail)} ${type} has no member ${member}`);
 				return 1;
 			}
+			const from = r.schema.form === "source" ? "lucent:compose" : `lucent:${platform}/${module}`;
 			if (out.json) out.data({
 				platform,
 				module,
 				symbol,
 				declaration: shown
 			});
-			else out.print(`${t.dim(`// lucent:${platform}/${module}`)}\n${highlight(shown, t)}`);
+			else out.print(`${t.dim(`// ${from}`)}\n${highlight(shown, t)}`);
 			return 0;
 		}
 	}