@lucent-lang/lucent 0.0.4 → 0.1.0

package/schemas/sdk-lock.schema.json

@@ -0,0 +1,67 @@
+{
+  "$id": "https://lucent-lang.dev/schemas/sdk-lock.schema.json",
+  "title": "lucent-sdk.lock.json, and .lucent/sdk-usage.json",
+  "description": "The SDKs a project's modules were read from and the SDK symbols its code uses. No machine paths.",
+  "type": "object",
+  "required": ["format", "targets", "modules", "symbols"],
+  "additionalProperties": false,
+  "properties": {
+    "format": { "const": 1 },
+    "targets": {
+      "type": "array",
+      "description": "The targets platform code was compiled for: a --frozen build needs each one's SDK",
+      "items": { "enum": ["ios", "android"] }
+    },
+    "modules": {
+      "type": "object",
+      "description": "<platform>/<module> → how the build read it",
+      "additionalProperties": {
+        "type": "object",
+        "required": ["artifacts"],
+        "additionalProperties": false,
+        "properties": {
+          "artifacts": {
+            "type": "array",
+            "description": "The artifacts its schema was read from: <id>#<content hash>",
+            "items": { "type": "string", "pattern": "^[^#]+#\\w+$" }
+          },
+          "schema": {
+            "type": "string",
+            "description": "Where the SDK cache keeps that schema: <scope>/<entry>"
+          }
+        }
+      }
+    },
+    "symbols": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["platform", "module", "kind", "name", "signature"],
+        "additionalProperties": false,
+        "properties": {
+          "platform": { "enum": ["ios", "android"] },
+          "module": { "type": "string" },
+          "owner": { "type": "string", "description": "The declaring type's Lucent name" },
+          "kind": { "enum": ["type", "constructor", "method", "property", "function", "constant"] },
+          "name": {
+            "type": "string",
+            "description": "The Lucent name; constructor for constructors"
+          },
+          "static": { "const": true },
+          "symbol": {
+            "type": "string",
+            "description": "The native identity: swift:, objc:, c: or jvm:"
+          },
+          "signature": { "type": "string" },
+          "since": { "type": ["number", "string"] },
+          "deprecated": { "const": true },
+          "cases": { "type": "array", "items": { "type": "string" } },
+          "roles": {
+            "type": "array",
+            "items": { "enum": ["call", "new", "get", "set", "implement"] }
+          }
+        }
+      }
+    }
+  }
+}

package/ts-plugin/index.js

@@ -1,7 +1,7 @@
 "use strict";
 // TypeScript language-service plugin: adds Lucent diagnostics to *.lucent.ts
-// (index.js, not .cjs: tsserver resolves plugin paths without "exports").
-// files. tsserver loads plugins with require() and its own `typescript`,
+// files, and types platform Lucent files' JSX with their toolkit (index.js,
+// not .cjs: tsserver resolves plugin paths without "exports"). tsserver loads plugins with require() and its own `typescript`,
 // while the compiler is an ES module that walks ASTs from its own
 // `typescript`; so the plugin imports the compiler asynchronously and hands
 // it file paths and unsaved text, never the editor's AST.
@@ -9,9 +9,74 @@
 const LUCENT_FILE = /\.lucent\.tsx?$/;
 const TYPESCRIPT_PASSTHROUGH = "LUCENT9001";
 
+// A platform's Lucent files write JSX with its toolkit (the compiler's TOOLKITS,
+// ui/toolkits.ts; a test keeps them equal): their implicit JSX runtime import
+// resolves to lucent:<toolkit>, whose module declares the JSX namespace.
+const TOOLKIT_JSX = { ios: "swiftui", android: "compose" };
+const PLATFORM_FILE = /\.(ios|android)\.lucent\.tsx$/;
+const JSX_RUNTIME = /\/jsx-(dev-)?runtime$/;
+
+/**
+ * Types each platform Lucent file's JSX with its toolkit, the app's other
+ * files' JSX as they are: TypeScript imports a JSX runtime implicitly, per
+ * file, and the host resolves that import. An app whose JSX has no runtime
+ * import (React Native's `jsx: react-native`) gets React's as its import
+ * source, which types React's JSX alike (react/jsx-runtime's JSX is
+ * React.JSX), once it has platform Lucent files.
+ */
+function withToolkitJsx(ts, host) {
+  const settings = host.getCompilationSettings.bind(host);
+  host.getCompilationSettings = () => {
+    const options = settings();
+    const imported =
+      options.jsx === ts.JsxEmit.ReactJSX ||
+      options.jsx === ts.JsxEmit.ReactJSXDev ||
+      options.jsx === ts.JsxEmit.React ||
+      options.jsxImportSource;
+    if (imported || !host.getScriptFileNames().some((f) => PLATFORM_FILE.test(f))) return options;
+    return { ...options, jsxImportSource: "react" };
+  };
+
+  const resolve = host.resolveModuleNameLiterals
+    ? host.resolveModuleNameLiterals.bind(host)
+    : defaultResolution(ts, host);
+  host.resolveModuleNameLiterals = (literals, containing, redirected, options, sf, reused) => {
+    const platform = PLATFORM_FILE.exec(containing);
+    const toolkit = platform && TOOLKIT_JSX[platform[1]];
+    // The implicit import is synthesized: it has no place in the file's text.
+    const runtime = (l) => toolkit && l.pos < 0 && JSX_RUNTIME.test(l.text);
+    const own = literals.map((l) =>
+      runtime(l) ? Object.create(l, { text: { value: `lucent:${toolkit}` } }) : l,
+    );
+    return resolve(own, containing, redirected, options, sf, reused);
+  };
+}
+
+/** Module resolution as the language service does it, for a host that leaves it to it. */
+function defaultResolution(ts, host) {
+  const cache = ts.createModuleResolutionCache(
+    host.getCurrentDirectory(),
+    (f) => f,
+    host.getCompilationSettings(),
+  );
+  return (literals, containing, redirected, options, sf) =>
+    literals.map((l) =>
+      ts.resolveModuleName(
+        l.text,
+        containing,
+        options,
+        host,
+        cache,
+        redirected,
+        ts.getModeForUsageLocation(sf, l, options),
+      ),
+    );
+}
+
 function createPlugin(loadCompiler) {
   return function init({ typescript: ts }) {
     function create(info) {
+      withToolkitJsx(ts, info.languageServiceHost);
       const log = (msg) => info.project.projectService.logger.info(`[lucent] ${msg}`);
       let compiler;
       loadCompiler().then(
@@ -37,7 +102,11 @@ function createPlugin(loadCompiler) {
               : undefined;
             return snap ? snap.getText(0, snap.getLength()) : undefined;
           };
-          for (const d of compiler.checkSources(files, readSource)) {
+          // Bound again each check: headers (and packages) change too; unchanged ones are read once.
+          const extensions = compiler.projectExtensions(
+            info.languageServiceHost.getCurrentDirectory(),
+          );
+          for (const d of compiler.checkSources(files, readSource, { extensions })) {
             if (d.code === TYPESCRIPT_PASSTHROUGH || !d.file) continue;
             const list = byFile.get(d.file) || [];
             list.push(d);
@@ -70,7 +139,10 @@ function createPlugin(loadCompiler) {
             ]
               .filter(Boolean)
               .join("\n"),
-            category: ts.DiagnosticCategory.Error,
+            category:
+              d.severity === "warning"
+                ? ts.DiagnosticCategory.Warning
+                : ts.DiagnosticCategory.Error,
             code: Number(d.code.replace(/^LUCENT/, "")),
             source: "lucent",
           }));
@@ -97,3 +169,4 @@ const compiler = fs.existsSync(path.join(__dirname, "../src"))
 
 module.exports = createPlugin(() => import(compiler));
 module.exports.createPlugin = createPlugin;
+module.exports.TOOLKIT_JSX = TOOLKIT_JSX;

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

@@ -1,232 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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 };