@lucent-lang/lucent 0.0.4

package/app.plugin.js

@@ -0,0 +1,92 @@
+"use strict";
+// Expo config plugin. During `expo prebuild` it runs `lucent build` (so the
+// native package exists before `pod install` / Gradle) and makes sure the app's
+// react-native.config.js links it.
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+let built = false;
+
+function buildOnce(projectRoot) {
+  if (built) return;
+  built = true;
+  const cli = path.join(__dirname, "bin/lucent.cjs");
+  // No Gradle during prebuild: android/ is half-written, and a Gradle run would cache it so
+  // (autolinking with the template's package). The Gradle task this plugin applies resolves
+  // the classpath and builds Android when the app is built.
+  const r = spawnSync(process.execPath, [cli, "build", "--root", projectRoot], {
+    stdio: "inherit",
+    env: { ...process.env, LUCENT_NO_GRADLE: "1" },
+  });
+  if (r.status !== 0)
+    throw new Error("lucent build failed; fix the errors above and run prebuild again");
+  const rnConfig = path.join(projectRoot, "react-native.config.js");
+  const entry = `"lucent": { root: require("path").join(__dirname, ".lucent", "native") }`;
+  const text = fs.existsSync(rnConfig) ? fs.readFileSync(rnConfig, "utf8") : undefined;
+  if (text === undefined) {
+    fs.writeFileSync(rnConfig, `module.exports = {\n  dependencies: {\n    ${entry},\n  },\n};\n`);
+  } else if (text.includes('"lucent-native"')) {
+    // Earlier versions named the dependency lucent-native.
+    fs.writeFileSync(rnConfig, text.replace('"lucent-native"', '"lucent"'));
+  } else if (!/["']lucent["']\s*:/.test(text)) {
+    throw new Error(`Add ${entry} to the "dependencies" of react-native.config.js`);
+  }
+}
+
+/** The line that applies Lucent's Gradle task (gradle/lucent.gradle) in android/app/build.gradle. */
+const GRADLE_LINE = `apply from: new File(new File(["node", "--print", "require.resolve('@lucent-lang/lucent/package.json')"].execute(null, rootDir).text.trim()).parentFile, "gradle/lucent.gradle")`;
+
+/**
+ * android/app/build.gradle with the Gradle task applied after React
+ * Native's plugin (or the last `apply plugin`, or at the top), or
+ * undefined when it is applied already.
+ */
+function applyGradleTask(text) {
+  if (text.includes("gradle/lucent.gradle")) return undefined;
+  const lines = text.split("\n");
+  const react = lines.findIndex((l) => /^apply plugin: ["']com\.facebook\.react["']/.test(l));
+  const lastApply = lines.reduce((at, l, i) => (l.startsWith("apply plugin:") ? i : at), -1);
+  const after = react >= 0 ? react : lastApply;
+  lines.splice(after + 1, 0, GRADLE_LINE);
+  return lines.join("\n");
+}
+
+/** Info.plist entries Lucent packages need (their lucent.json), as the last build recorded them. */
+function packagesInfoPlist(projectRoot) {
+  const manifest = path.join(projectRoot, ".lucent", "native", "manifest.json");
+  if (!fs.existsSync(manifest)) return {};
+  return JSON.parse(fs.readFileSync(manifest, "utf8")).infoPlist || {};
+}
+
+function withLucent(config) {
+  const { withAppBuildGradle, withDangerousMod, withInfoPlist } = require("expo/config-plugins");
+  // Gradle builds run lucent build first, like `lucent init` sets up in bare apps.
+  config = withAppBuildGradle(config, (c) => {
+    if (c.modResults.language === "groovy")
+      c.modResults.contents = applyGradleTask(c.modResults.contents) ?? c.modResults.contents;
+    return c;
+  });
+  // Keys the app sets itself win.
+  config = withInfoPlist(config, (c) => {
+    buildOnce(c.modRequest.projectRoot);
+    for (const [key, { value }] of Object.entries(packagesInfoPlist(c.modRequest.projectRoot))) {
+      if (c.modResults[key] === undefined) c.modResults[key] = value;
+    }
+    return c;
+  });
+  for (const platform of ["ios", "android"]) {
+    config = withDangerousMod(config, [
+      platform,
+      async (c) => {
+        buildOnce(c.modRequest.projectRoot);
+        return c;
+      },
+    ]);
+  }
+  return config;
+}
+
+module.exports = withLucent;
+module.exports.GRADLE_LINE = GRADLE_LINE;
+module.exports.applyGradleTask = applyGradleTask;

package/bin/lucent.cjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+"use strict";
+// Runs the bundled CLI, both when installed and in this repository, where
+// `pnpm build` (or the watching `dev` task) keeps dist/ current.
+const fs = require("node:fs");
+const path = require("node:path");
+const { pathToFileURL } = require("node:url");
+
+const dist = path.join(__dirname, "../dist/cli.js");
+if (!fs.existsSync(dist)) {
+  process.stderr.write(
+    "lucent: dist/cli.js is missing; run `pnpm build` in the repository first\n",
+  );
+  process.exit(1);
+}
+import(pathToFileURL(dist).href);

package/core/index.cjs

@@ -0,0 +1,11 @@
+"use strict";
+// lucent:core's JavaScript implementation, for tests that run Lucent modules
+// as plain TypeScript: point Jest's moduleNameMapper or Vitest's alias for
+// `lucent:core` here. Installed packages ship it as lib/core.cjs (copied by
+// the package build, vite.config.ts); in this repository it is the
+// compiler's source.
+const fs = require("node:fs");
+const path = require("node:path");
+
+const inRepository = fs.existsSync(path.join(__dirname, "../src"));
+module.exports = require(inRepository ? "../../compiler/lib/core.cjs" : "../lib/core.cjs");

package/dist/bench-CR3E7e2e.js

@@ -0,0 +1,304 @@
+import { d as coreJsPath, g as projectFiles, m as moduleNameOf, n as compile, s as runtimeDir } from "./src-BD7f1_aZ.js";
+import { i as table } from "./format-D9fnIMEx.js";
+import { t as renderDiagnostic } from "./diagnostic-BM9sXmwl.js";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import ts from "typescript";
+import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+//#region ../runtime/test/sources.ts
+function runtimeSources(cppDir) {
+	const list = (dir, ext) => fs.readdirSync(path.join(cppDir, dir)).filter((f) => f.endsWith(ext)).map((f) => path.join(cppDir, dir, f));
+	return {
+		cxx: [...list("lucent", ".cpp"), ...list("lucent/jsi", ".cpp")],
+		c: list("third_party/quickjs", ".c")
+	};
+}
+const cFlags = [
+	"-std=c11",
+	"-O2",
+	"-w"
+];
+const hostLibs = process.platform === "darwin" ? ["-framework", "CoreFoundation"] : [];
+//#endregion
+//#region src/cli/commands/bench.ts
+const HERMES_FIX = "lucent bench runs your modules in a desktop Hermes: build one (git clone https://github.com/facebook/hermes ~/hermes && cmake -S ~/hermes -B ~/hermes/build -G Ninja -DCMAKE_BUILD_TYPE=Release && ninja -C ~/hermes/build hermesvm jsi), or point HERMES_DIR at a build";
+async function run({ root, out }) {
+	const t = out.theme;
+	const fail = (message) => {
+		if (out.json) out.data({
+			ok: false,
+			error: message
+		});
+		else out.error(`${t.error(t.symbols.fail)} ${message}`);
+		return 1;
+	};
+	const benches = findBenches(root);
+	if (!benches.length) return fail("no *.bench.ts file: next to a module, export default { name: () => call(), … }");
+	const hermes = process.env.HERMES_DIR || path.join(os.homedir(), "hermes");
+	if (!fs.existsSync(path.join(hermes, "build/lib")) || !fs.existsSync(path.join(hermes, "API/jsi"))) return fail(`no Hermes build at ${hermes}. ${HERMES_FIX}`);
+	const files = projectFiles(root);
+	const result = compile(files, { platforms: ["host"] });
+	if (!result.ok) {
+		for (const d of result.diagnostics) out.error(renderDiagnostic({
+			...d,
+			file: d.file && path.relative(root, d.file)
+		}, d.file && fs.existsSync(d.file) ? fs.readFileSync(d.file, "utf8") : void 0, t));
+		return 1;
+	}
+	const work = path.join(root, ".lucent/bench");
+	const generated = path.join(work, "generated");
+	fs.rmSync(generated, {
+		recursive: true,
+		force: true
+	});
+	for (const [name, content] of result.files) {
+		const file = path.join(generated, name.replace(/^host\//, ""));
+		fs.mkdirSync(path.dirname(file), { recursive: true });
+		fs.writeFileSync(file, content);
+	}
+	if (!out.json) out.print(t.dim("building the native host (the first run compiles the runtime)…"));
+	const exe = await buildHost(work, generated, hermes);
+	const script = path.join(work, "bench.js");
+	fs.writeFileSync(script, benchScript(root, files, benches, result.proxies));
+	const r = spawnSync(exe, [script], {
+		encoding: "utf8",
+		timeout: 6e5,
+		maxBuffer: 64 << 20
+	});
+	if (r.status !== 0) return fail(`the benchmark failed:\n${r.stderr || r.stdout}`);
+	const cases = r.stdout.trim().split("\n").filter((l) => l.startsWith("{")).map((l) => {
+		const c = JSON.parse(l);
+		return {
+			...c,
+			speedup: c.error ? 0 : c.js / c.native
+		};
+	});
+	if (out.json) {
+		out.data({
+			ok: cases.every((c) => c.same && !c.error),
+			cases
+		});
+		return cases.every((c) => c.same && !c.error) ? 0 : 1;
+	}
+	const time = (ms) => ms < 1 ? `${(ms * 1e3).toFixed(1)} µs` : `${ms.toFixed(ms < 10 ? 2 : 1)} ms`;
+	const row = (c) => c.error ? [
+		c.name,
+		t.error(c.error),
+		"",
+		""
+	] : [
+		c.name,
+		time(c.js),
+		time(c.native),
+		`${c.speedup >= 1 ? t.success(`${c.speedup.toFixed(1)}x`) : t.warn(`${c.speedup.toFixed(1)}x`)}${c.same ? "" : t.error("  results differ")}`
+	];
+	const lines = table([[
+		"CASE",
+		"JS",
+		"LUCENT",
+		"SPEEDUP"
+	].map((h) => t.dim(h)), ...cases.map(row)], 3);
+	out.print(`\n${lines[0]}`);
+	cases.forEach((c, i) => {
+		if (c.file !== cases[i - 1]?.file) out.print(t.bold(c.file));
+		out.print(`${lines[i + 1]}`);
+	});
+	out.print(t.dim("\nper call, best of 5 rounds; desktop Hermes, so devices differ"));
+	return cases.every((c) => c.same && !c.error) ? 0 : 1;
+}
+function findBenches(root) {
+	const out = [];
+	const walk = (dir) => {
+		for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+			if (e.name === "node_modules" || e.name.startsWith(".") || e.name === "ios" || e.name === "android") continue;
+			const full = path.join(dir, e.name);
+			if (e.isDirectory()) walk(full);
+			else if (e.name.endsWith(".bench.ts")) out.push(full);
+		}
+	};
+	walk(root);
+	return out.sort();
+}
+async function objects(work, sources) {
+	const dir = path.join(work, "obj");
+	fs.mkdirSync(dir, { recursive: true });
+	const jobs = sources.map((s) => {
+		const key = createHash("sha256").update(s.cc).update(s.flags.join(" ")).update(s.file).update(fs.readFileSync(s.file)).digest("hex").slice(0, 16);
+		return {
+			...s,
+			obj: path.join(dir, `${path.basename(s.file).replace(/\.\w+$/, "")}-${key}.o`)
+		};
+	});
+	const todo = jobs.filter((j) => !fs.existsSync(j.obj));
+	let next = 0;
+	const worker = async () => {
+		while (next < todo.length) {
+			const j = todo[next++];
+			await new Promise((resolve, reject) => {
+				const child = spawn(j.cc, [
+					...j.flags,
+					"-c",
+					j.file,
+					"-o",
+					`${j.obj}.tmp`
+				], { stdio: [
+					"ignore",
+					"ignore",
+					"pipe"
+				] });
+				let err = "";
+				child.stderr.on("data", (d) => err += d.toString());
+				child.on("error", reject);
+				child.on("close", (code) => code === 0 ? (fs.renameSync(`${j.obj}.tmp`, j.obj), resolve()) : reject(/* @__PURE__ */ new Error(`${j.cc} failed on ${j.file}:\n${err}`)));
+			});
+		}
+	};
+	await Promise.all(Array.from({ length: Math.max(1, os.availableParallelism() - 1) }, worker));
+	return jobs.map((j) => j.obj);
+}
+async function buildHost(work, generated, hermes) {
+	const cpp = path.join(runtimeDir(), "cpp");
+	const cxx = process.env.CXX ?? "clang++";
+	const flags = [
+		"-std=c++20",
+		"-ffp-contract=off",
+		"-O2",
+		"-DNDEBUG",
+		"-w",
+		`-I${cpp}`,
+		`-I${generated}`,
+		`-I${hermes}/API`,
+		`-I${hermes}/API/jsi`,
+		`-I${hermes}/public`
+	];
+	const rs = runtimeSources(cpp);
+	const objs = await objects(work, [
+		...fs.readdirSync(generated).filter((f) => f.endsWith(".cpp")).map((f) => ({
+			file: path.join(generated, f),
+			cc: cxx,
+			flags
+		})),
+		...rs.cxx.map((file) => ({
+			file,
+			cc: cxx,
+			flags
+		})),
+		...rs.c.map((file) => ({
+			file,
+			cc: process.env.CC ?? "clang",
+			flags: cFlags
+		})),
+		{
+			file: path.join(runtimeDir(), "test/jsi/harness.cpp"),
+			cc: cxx,
+			flags
+		}
+	]);
+	const exe = path.join(work, "bench-host");
+	const r = spawnSync(cxx, [
+		...objs,
+		`-L${hermes}/build/lib`,
+		`-L${hermes}/build/jsi`,
+		"-lhermesvm",
+		"-ljsi",
+		"-lpthread",
+		...hostLibs,
+		`-Wl,-rpath,${hermes}/build/lib`,
+		`-Wl,-rpath,${hermes}/build/jsi`,
+		"-o",
+		exe
+	], { encoding: "utf8" });
+	if (r.status !== 0) throw new Error(`linking the benchmark host failed:\n${r.stderr}`);
+	return exe;
+}
+function benchScript(root, files, benches, proxies) {
+	const defs = {};
+	const jsDeps = {};
+	const nativeDeps = {};
+	const transpile = (source) => ts.transpileModule(source, { compilerOptions: {
+		module: ts.ModuleKind.CommonJS,
+		target: ts.ScriptTarget.ES2019,
+		esModuleInterop: false
+	} }).outputText;
+	const loader = fs.readFileSync(path.join(runtimeDir(), "js/index.js"), "utf8");
+	defs.core = fs.readFileSync(coreJsPath(), "utf8");
+	defs.loader = loader;
+	defs["react-native"] = "module.exports = { TurboModuleRegistry: { get: function () { return undefined; } } };";
+	const resolve = (from, spec) => {
+		if (spec === "lucent:core") return "core";
+		if (!spec.startsWith(".")) return void 0;
+		const base = path.resolve(path.dirname(from), spec);
+		return [
+			`${base}.ts`,
+			base,
+			`${base}.tsx`
+		].find((f) => files.includes(f) || benches.includes(f));
+	};
+	const specs = (source) => [...source.matchAll(/(?:from|import)\s+["']([^"']+)["']/g)].map((m) => m[1]);
+	for (const file of [...files, ...benches]) {
+		const source = fs.readFileSync(file, "utf8");
+		defs[file] = transpile(source);
+		jsDeps[file] = {};
+		nativeDeps[file] = {};
+		for (const spec of specs(source)) {
+			const target = resolve(file, spec);
+			if (!target) continue;
+			jsDeps[file][spec] = target;
+			nativeDeps[file][spec] = files.includes(target) ? `proxy:${moduleNameOf(target)}` : target;
+		}
+	}
+	for (const [name, proxy] of proxies) {
+		defs[`proxy:${name}`] = proxy;
+		nativeDeps[`proxy:${name}`] = {
+			[`${"../".repeat(name.split("/").length - 1) || "./"}_lucent/runtime.js`]: "loader",
+			"react-native": "react-native"
+		};
+	}
+	nativeDeps.loader = {};
+	return `var defs = {
+${Object.entries(defs).map(([id, code]) => `${JSON.stringify(id)}: function (module, exports, require) {\n${code}\n}`).join(",\n")}
+};
+var deps = { js: ${JSON.stringify(jsDeps)}, native: ${JSON.stringify(nativeDeps)} };
+var loaded = { js: {}, native: {} };
+function load(world, id) {
+  var cache = loaded[world];
+  if (cache[id]) return cache[id].exports;
+  var module = { exports: {} };
+  cache[id] = module;
+  defs[id](module, module.exports, function (spec) {
+    var target = (deps[world][id] || {})[spec];
+    if (target === undefined) throw new Error("cannot resolve " + spec + " from " + id);
+    return load(world, target);
+  });
+  return module.exports;
+}
+// Milliseconds per call: the best of 5 rounds, each repeating the call for
+// at least 30 ms, so fast cases are measured beyond the clock's resolution.
+function best(f) {
+  var min = Infinity;
+  for (var r = 0; r < 5; r++) {
+    var start = Date.now(), calls = 0, elapsed;
+    do { f(); calls++; elapsed = Date.now() - start; } while (elapsed < 30);
+    min = Math.min(min, elapsed / calls);
+  }
+  return min;
+}
+var benches = ${JSON.stringify(benches.map((b) => [b, path.relative(root, b)]))};
+for (var i = 0; i < benches.length; i++) {
+  var id = benches[i][0], file = benches[i][1];
+  var js = load("js", id).default, native = load("native", id).default;
+  for (var name in js) {
+    try {
+      var same = JSON.stringify(js[name]()) === JSON.stringify(native[name]());
+      print(JSON.stringify({ file: file, name: name, js: best(js[name]), native: best(native[name]), same: same }));
+    } catch (e) {
+      print(JSON.stringify({ file: file, name: name, js: 0, native: 0, same: false, error: String(e && e.message || e) }));
+    }
+  }
+}
+`;
+}
+//#endregion
+export { run };

package/dist/build-CAIrRSYA.js

@@ -0,0 +1,7 @@
+import { t as buildOrCheck } from "./build-check-QozuNJm5.js";
+//#region src/cli/commands/build.ts
+function run(invocation) {
+	return buildOrCheck("build", invocation);
+}
+//#endregion
+export { run };

package/dist/build-check-QozuNJm5.js

@@ -0,0 +1,92 @@
+import { n as version } from "./version-bqpIO5sP.js";
+import { i as table, n as duration } from "./format-D9fnIMEx.js";
+import { t as renderDiagnostic } from "./diagnostic-BM9sXmwl.js";
+import { n as nextText, r as plural, t as buildProject } from "./pipeline-CH7-2cxu.js";
+import { t as plainSteps } from "./steps--_h-FFS7.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/cli/commands/build-check.ts
+async function buildOrCheck(command, { root, flags, out }) {
+	const theme = out.theme;
+	const notices = [];
+	const notify = (n) => {
+		notices.push(n);
+		out.print(`${n.level === "ok" ? theme.success(theme.symbols.ok) : theme.warn(theme.symbols.warn)} ${n.text}`);
+	};
+	if (command === "build") out.print(`${theme.brand(theme.symbols.brand)} ${theme.bold("lucent")} ${theme.dim(version())}\n`);
+	const steps = command === "check" || out.json ? plainSteps(() => {}, theme) : out.terminal.interactive ? (await import("./live-steps-BGcWFM9M.js")).liveSteps(theme) : plainSteps((l) => out.print(l), theme);
+	let result;
+	try {
+		result = await buildProject(root, {
+			mode: command,
+			force: !!flags.force,
+			platforms: typeof flags.platforms === "string" && flags.platforms ? flags.platforms.split(",") : void 0,
+			out: typeof flags.out === "string" ? flags.out : void 0,
+			prefetch: true
+		}, steps, notify);
+	} finally {
+		await steps.close();
+	}
+	if (out.json) {
+		if (result.fatal) out.data({
+			ok: false,
+			error: result.fatal
+		});
+		else if (command === "check") out.data({
+			ok: result.ok,
+			modules: result.modules.map((m) => m.name),
+			diagnostics: result.diagnostics,
+			errors: result.diagnostics.length,
+			ms: result.ms
+		});
+		else out.data({
+			ok: result.ok,
+			upToDate: result.upToDate,
+			out: path.resolve(root, typeof flags.out === "string" ? flags.out : ".lucent/native"),
+			modules: result.modules,
+			steps: steps.results,
+			diagnostics: result.diagnostics,
+			notices,
+			next: result.next,
+			ms: result.ms
+		});
+		return result.ok ? 0 : 1;
+	}
+	if (result.fatal) {
+		out.error(`${theme.error(theme.symbols.fail)} ${result.fatal}`);
+		return 1;
+	}
+	if (!result.ok) {
+		problems(result.diagnostics, result.modules.length, result.ms, command === "build");
+		return 1;
+	}
+	if (command === "check") {
+		out.print(`${theme.success(theme.symbols.ok)} ${plural(result.modules.length, "module")}, no problems  ${theme.dim(result.upToDate ? `${duration(result.ms)} (unchanged since the last check)` : duration(result.ms))}`);
+		return 0;
+	}
+	if (result.upToDate) return 0;
+	out.print("");
+	for (const line of table(result.modules.map((m, i) => [
+		i ? "" : theme.dim("modules"),
+		m.name,
+		m.platforms.join(" ")
+	]))) out.print(line);
+	out.print(`${theme.dim("next")}     ${nextText(result.next)}`);
+	return 0;
+	function problems(diagnostics, modules, ms, build) {
+		const sources = /* @__PURE__ */ new Map();
+		const source = (file) => {
+			if (!sources.has(file)) {
+				const abs = path.resolve(root, file);
+				sources.set(file, fs.existsSync(abs) ? fs.readFileSync(abs, "utf8") : void 0);
+			}
+			return sources.get(file);
+		};
+		out.error("");
+		for (const d of diagnostics) out.error(`${renderDiagnostic(d, d.file ? source(d.file) : void 0, theme)}\n`);
+		const summary = `${plural(diagnostics.length, "error")} ${theme.dim("·")} ${plural(modules, "module")} ${theme.dim("·")} ${duration(ms)}`;
+		out.error(`  ${theme.error(summary)}${build ? theme.dim("  nothing was written") : ""}`);
+	}
+}
+//#endregion
+export { buildOrCheck as t };

package/dist/check-1SCmYlqA.js

@@ -0,0 +1,7 @@
+import { t as buildOrCheck } from "./build-check-QozuNJm5.js";
+//#region src/cli/commands/check.ts
+function run(invocation) {
+	return buildOrCheck("check", invocation);
+}
+//#endregion
+export { run };

package/dist/clean-BVwpbJ5K.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+//#region src/cli/commands/clean.ts
+function size(dir) {
+	if (!fs.existsSync(dir)) return 0;
+	const stat = fs.statSync(dir);
+	if (!stat.isDirectory()) return stat.size;
+	return fs.readdirSync(dir).reduce((n, e) => n + size(path.join(dir, e)), 0);
+}
+const mb = (bytes) => `${(bytes / 1e6).toFixed(1)} MB`;
+function run({ root, flags, out }) {
+	const t = out.theme;
+	const generated = path.join(root, ".lucent");
+	if (fs.existsSync(generated)) {
+		const freed = size(generated);
+		fs.rmSync(generated, {
+			recursive: true,
+			force: true
+		});
+		out.print(`${t.success(t.symbols.ok)} removed .lucent  ${t.dim(mb(freed))}`);
+	} else out.print(`${t.dim(t.symbols.off)} nothing to remove in the project`);
+	if (flags.cache) {
+		const cache = path.join(process.env.LUCENT_CACHE_DIR || path.join(process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache"), "lucent"), "sdk");
+		const freed = size(cache);
+		fs.rmSync(cache, {
+			recursive: true,
+			force: true
+		});
+		out.print(`${t.success(t.symbols.ok)} removed the SDK cache  ${t.dim(`${mb(freed)}, ${cache.replace(os.homedir(), "~")}; SDK modules are extracted again on first use`)}`);
+	}
+	return 0;
+}
+//#endregion
+export { run };