@lucent-lang/lucent 0.0.4 → 0.1.1

package/dist/pipeline-BM_VM2X_.js

@@ -0,0 +1,700 @@
+import { C as bindExtensions, F as moduleNamespace, M as platformOf, N as projectFiles, P as usesPlatforms, S as inNativePackage, Z as sdkModuleArtifacts, d as isUpToDate, j as moduleNameOf, l as deferredLibraryGradle, n as compile, p as writeNativePackage, q as extractionCount, s as sdkModule, u as inputsKey, v as resolveNative } from "./src-ChnmWLwn.js";
+import { n as lucentPackages } from "./packages-CSmKeaAh.js";
+import { a as projectHashes, c as sdkImports, i as pendingAndroidModules, l as staleAutolinking, n as mapLucentPaths, o as projectSdk, r as missingAppEntries, s as resolveAndroidDependencies, t as backgroundPrefetch, u as writeLinkedPackage } from "./project-BKNoTEEp.js";
+import { a as lockProblems, c as sdkUsage, d as writeUsage, i as frozenFailure, l as usageReadable, n as USAGE_FILE, o as readUsage, s as sdkUnavailable, t as LOCK_FILE, u as usedModules } from "./sdk-usage-0ZFMAYg1.js";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+const ACTION_KINDS = [
+	"reinstall",
+	"relink",
+	"compile-native",
+	"repackage",
+	"reload-js"
+];
+function contentHash(data) {
+	return createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+function fileArtifact(root, file) {
+	return {
+		key: path.relative(root, path.resolve(file)).split(path.sep).join("/"),
+		hash: fs.existsSync(file) ? contentHash(fs.readFileSync(file)) : "missing"
+	};
+}
+function byKey(a, b) {
+	return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+}
+var BuildGraph = class {
+	nodes = /* @__PURE__ */ new Map();
+	timings = {};
+	startedAt = {};
+	started = Date.now();
+	mode;
+	constructor(mode) {
+		this.mode = mode;
+	}
+	record(id, kind, status, fields = {}) {
+		if (this.nodes.has(id)) throw new Error(`build graph: node ${id} recorded twice`);
+		const inputs = [...fields.inputs ?? []].sort(byKey);
+		const outputs = [...fields.outputs ?? []].sort(byKey);
+		const node = {
+			id,
+			kind,
+			status,
+			inputs,
+			outputs,
+			hash: contentHash(JSON.stringify({
+				kind,
+				inputs,
+				outputs
+			})),
+			...fields.detail !== void 0 ? { detail: fields.detail } : {},
+			...fields.log !== void 0 ? { log: fields.log } : {}
+		};
+		this.nodes.set(id, node);
+		if (fields.ms !== void 0) {
+			this.timings[id] = fields.ms;
+			this.startedAt[id] = Math.max(0, Date.now() - fields.ms - this.started);
+		}
+		return node;
+	}
+	get(id) {
+		return this.nodes.get(id);
+	}
+	toRecord(requiredAction, pendingActions = []) {
+		const nodes = [...this.nodes.values()];
+		return {
+			schemaVersion: 1,
+			mode: this.mode,
+			nodes,
+			requiredAction,
+			pendingActions,
+			timings: { ...this.timings },
+			startedAt: { ...this.startedAt }
+		};
+	}
+};
+function writeBuildRecord(file, record) {
+	fs.mkdirSync(path.dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	fs.writeFileSync(tmp, `${JSON.stringify(record, null, 2)}\n`);
+	fs.renameSync(tmp, file);
+}
+function requiredAction(next, targets, changedUnits) {
+	if (next.podInstall) return {
+		kind: "relink",
+		targets,
+		dependencyChanges: ["native files added or removed"]
+	};
+	if (next.rebuild) return {
+		kind: "compile-native",
+		targets,
+		changedUnits: [...changedUnits].sort()
+	};
+	if (next.reload) return { kind: "reload-js" };
+	return { kind: "none" };
+}
+//#endregion
+//#region src/cli/changes.ts
+const IGNORED = {
+	kind: void 0,
+	targets: []
+};
+const OUTPUT_ROLES = [
+	[/^manifest\.json$/, () => IGNORED],
+	[/^types\//, () => IGNORED],
+	[/^js\/_lucent\/identity\.js$/, () => IGNORED],
+	[/^js\//, () => ({
+		kind: "reload-js",
+		targets: "all"
+	})],
+	[/^cpp\/generated\/(ios|android|host)\//, (m) => ({
+		kind: "compile-native",
+		targets: [m[1]]
+	})],
+	[/^cpp\//, () => ({
+		kind: "compile-native",
+		targets: "all"
+	})],
+	[/^ios\//, () => ({
+		kind: "compile-native",
+		targets: ["ios"]
+	})],
+	[/^android\/src\/main\/java\//, () => ({
+		kind: "compile-native",
+		targets: ["android"]
+	})],
+	[/^android\/src\/main\/AndroidManifest\.xml$/, () => ({
+		kind: "reinstall",
+		targets: ["android"]
+	})],
+	[/^LucentNative\.podspec$/, () => ({
+		kind: "relink",
+		targets: ["ios"]
+	})],
+	[/^android\//, () => ({
+		kind: "relink",
+		targets: ["android"]
+	})]
+];
+const FIELD_ACTIONS = {
+	ios: {
+		nativeSources: "compile-native",
+		resources: "repackage",
+		resourceBundles: "repackage",
+		vendoredFrameworks: "relink"
+	},
+	android: {
+		nativeSources: "compile-native",
+		resources: "repackage",
+		assets: "repackage",
+		libraries: "relink",
+		nativeLibraries: "relink"
+	}
+};
+const APP_CONFIGURATION = ["infoPlist", "entitlements"];
+function packageRoles(file, manifests) {
+	const roles = [];
+	for (const manifest of manifests) for (const platform of ["ios", "android"]) for (const [field, kind] of Object.entries(FIELD_ACTIONS[platform])) {
+		const listed = manifest[platform][field];
+		if ((Array.isArray(listed) ? listed : Object.values(listed).flat()).some((p) => file === inNativePackage(p) || file.startsWith(`${inNativePackage(p)}/`))) roles.push({
+			kind,
+			targets: [platform]
+		});
+	}
+	return roles;
+}
+function rolesOf(file, change) {
+	if (file.startsWith("packages/")) {
+		const roles = packageRoles(file, [change.manifest, ...change.previous ? [change.previous] : []]);
+		return roles.length ? roles : [{
+			kind: "relink",
+			targets: "all"
+		}];
+	}
+	for (const [pattern, role] of OUTPUT_ROLES) {
+		const m = pattern.exec(file);
+		if (m) return [role(m)];
+	}
+	return [{
+		kind: "relink",
+		targets: "all"
+	}];
+}
+const canonical = (v) => JSON.stringify(v, (_, x) => x && typeof x === "object" && !Array.isArray(x) ? Object.fromEntries(Object.entries(x).sort(([a], [b]) => a < b ? -1 : 1)) : x);
+function classifyChanges(change) {
+	const actions = /* @__PURE__ */ new Map();
+	const need = (kind, targets, file) => {
+		const on = (targets === "all" ? change.targets : targets).filter((t) => change.targets.includes(t));
+		if (!on.length) return;
+		const action = actions.get(kind) ?? {
+			targets: /* @__PURE__ */ new Set(),
+			files: /* @__PURE__ */ new Set()
+		};
+		for (const t of on) action.targets.add(t);
+		action.files.add(file);
+		actions.set(kind, action);
+	};
+	for (const file of [...change.written, ...change.removed]) {
+		if (file === "resolved.json") {
+			for (const key of APP_CONFIGURATION) if (canonical(change.manifest.ios[key]) !== canonical(change.previous?.ios[key] ?? {})) need("reinstall", ["ios"], `resolved.json#ios.${key}`);
+			continue;
+		}
+		for (const role of rolesOf(file, change)) if (role.kind) need(role.kind, role.targets, file);
+	}
+	for (const file of [...change.added, ...change.removed]) for (const role of rolesOf(file, change)) if (role.kind && role.kind !== "reload-js") need("relink", role.targets === "all" ? ["ios"] : role.targets.filter((t) => t === "ios"), file);
+	return ACTION_KINDS.filter((kind) => actions.has(kind)).map((kind) => {
+		const { targets, files } = actions.get(kind);
+		return {
+			kind,
+			targets: change.targets.filter((t) => targets.has(t)),
+			files: [...files].sort()
+		};
+	});
+}
+const ACTION_TEXT = {
+	reinstall: "reinstall the app",
+	relink: "relink native dependencies",
+	"compile-native": "recompile native code",
+	repackage: "repackage resources",
+	"reload-js": "reload JavaScript"
+};
+function filesText(files, shown = 2) {
+	const more = files.length - shown;
+	return `${files.slice(0, shown).join(", ")}${more > 0 ? ` +${more} more` : ""}`;
+}
+//#endregion
+//#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;
+	let nativeInputs = [];
+	const graph = new BuildGraph(options.mode);
+	let targets = [];
+	let changedUnits = [];
+	const skipped = [];
+	const outcome = (o) => {
+		const next = o.next ?? NONE;
+		const actions = o.actions ?? [];
+		const record = graph.toRecord(requiredAction(next, targets, changedUnits), actions);
+		writeBuildRecord(path.join(root, ".lucent/build-record.json"), record);
+		return {
+			ok: false,
+			upToDate: false,
+			files,
+			modules: moduleSummary(files, void 0),
+			diagnostics: [],
+			warnings: [],
+			next,
+			actions,
+			nativeInputs,
+			record,
+			skipped,
+			ms: Date.now() - t0,
+			...o
+		};
+	};
+	const tResolve = Date.now();
+	try {
+		files = projectFiles(root);
+		const hashes = projectHashes(root);
+		native = resolveNative(lucentPackages(root), { hashes });
+		hashes.save();
+		nativeInputs = native.read;
+	} catch (e) {
+		graph.record("resolve", "resolve", "failed", {
+			detail: e.message,
+			ms: Date.now() - tResolve
+		});
+		return outcome({ fatal: e.message });
+	}
+	const superseded = (step) => {
+		graph.record(step, step === "generate" ? "generate" : "check", "skipped", { detail: "superseded by a newer change" });
+		return outcome({ superseded: true });
+	};
+	graph.record("resolve", "resolve", "ok", {
+		inputs: [{
+			key: "native-dependencies",
+			hash: contentHash(JSON.stringify(native.manifest))
+		}, ...packageInputs(native)],
+		ms: Date.now() - tResolve
+	});
+	if (options.signal?.aborted) return superseded("check");
+	let extensions = [];
+	if (native.extensions.length) {
+		const t = Date.now();
+		const inputs = native.extensions.map((e) => ({
+			key: `ext/${e.name}`,
+			hash: e.hash
+		}));
+		try {
+			extensions = bindExtensions(native.extensions);
+		} catch (e) {
+			graph.record("extract:extensions", "extract", "failed", {
+				inputs,
+				detail: e.message,
+				ms: Date.now() - t
+			});
+			return outcome({ fatal: e.message });
+		}
+		graph.record("extract:extensions", "extract", "ok", {
+			inputs,
+			ms: Date.now() - t
+		});
+	}
+	const sdk = projectSdk(root, native);
+	const outDir = path.resolve(root, options.out ?? ".lucent/native");
+	let lock;
+	const lockProblem = (detail) => {
+		graph.record("resolve:lock", "resolve", "failed", { detail });
+		return outcome({ fatal: detail });
+	};
+	if (options.frozen) {
+		try {
+			lock = readUsage(path.join(root, LOCK_FILE));
+		} catch (e) {
+			return lockProblem(e.message);
+		}
+		if (!lock) return lockProblem(`--frozen needs ${LOCK_FILE}: run lucent sdk lock and commit it`);
+		for (const p of lock.targets) {
+			if (options.platforms && !options.platforms.includes(p)) continue;
+			const why = sdkUnavailable(p, sdk);
+			if (why) return lockProblem(`the SDK lock requires ${p}, whose SDK is unavailable: ${why}`);
+		}
+	}
+	const libraryGradle = path.join(outDir, "android/build.gradle");
+	const configured = fs.existsSync(libraryGradle) ? fs.readFileSync(libraryGradle, "utf8") : void 0;
+	let platforms = options.platforms;
+	let deferAndroid = false;
+	let deferReason = "its dependencies are resolved by the Gradle build";
+	if (build && (!platforms || platforms.includes("android"))) {
+		if (writeLinkedPackage(root, outDir, native) && process.env.LUCENT_GRADLE_CLASSPATH) {
+			const detail = `this Gradle build read the app's autolinking config before ${path.relative(root, outDir)} existed, so the app would not link Lucent: build again`;
+			graph.record("resolve:android", "resolve", "failed", { detail });
+			return outcome({ fatal: detail });
+		}
+		steps.start("android-dependencies", "Android dependencies");
+		await steps.flush();
+		const t = Date.now();
+		const deps = resolveAndroidDependencies(root, files, sdk, native.manifest, !!options.force);
+		const label = "Android dependencies";
+		graph.record("resolve:android", "resolve", deps.status === "resolved" ? "ok" : deps.status === "deferred" ? "skipped" : deps.status === "failed" ? "failed" : "cached", {
+			...deps.status === "failed" ? { detail: deps.detail } : {},
+			ms: Date.now() - t
+		});
+		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 (!deferAndroid && !platforms?.includes("android")) {
+		const pending = pendingAndroidModules(root, files, sdk).map((m) => `lucent:android/${m}`);
+		if (pending.length) {
+			deferAndroid = true;
+			deferReason = "the app has no Android project yet";
+			notify({
+				level: "warn",
+				text: `${pending.join(", ")} ${pending.length === 1 ? "is" : "are"} untyped: the app has no Android project to resolve ${pending.length === 1 ? "it" : "them"} yet. Checked after expo prebuild, or once android/ exists${platforms ? "" : "; skipped Android here"}`
+			});
+		}
+	}
+	if (!platforms && files.some((f) => platformOf(f) || usesPlatforms(f))) {
+		for (const p of ["ios", "android"]) {
+			const why = sdkUnavailable(p, sdk);
+			if (why) {
+				skipped.push({
+					platform: p,
+					reason: why
+				});
+				notify({
+					level: "warn",
+					text: `${why}; skipped ${p === "ios" ? "iOS" : "Android"} (build it with --platforms ${p} once the SDK is installed)`
+				});
+			} else if (p === "android" && deferAndroid) skipped.push({
+				platform: p,
+				reason: deferReason
+			});
+		}
+		const installed = ["ios", "android"].filter((p) => !skipped.some((s) => s.platform === p));
+		if (!installed.length) {
+			const detail = deferAndroid ? `no platform to build here: ${skipped.map((s) => `${s.platform}: ${s.reason}`).join("; ")}` : "no platform SDK is installed";
+			graph.record("resolve:platforms", "resolve", "failed", { detail });
+			return outcome({ fatal: detail });
+		}
+		platforms = installed;
+		if (build && options.prefetch) backgroundPrefetch(root, files, installed);
+	}
+	for (const { platform, reason } of skipped) if (lock?.targets.includes(platform)) return lockProblem(`the SDK lock requires ${platform}, which this build skips: ${reason}`);
+	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;
+	targets = [...platforms ?? ["ios", "android"]];
+	const built = (platforms ?? []).filter((p) => p !== "host");
+	const checkInputs = [...files.map((f) => fileArtifact(root, f)), {
+		key: "targets",
+		hash: contentHash(targets.join(","))
+	}];
+	const key = inputsKey(files, outDir) + (platforms ? `:${platforms.join(",")}` : "") + `:${createHash("sha256").update(JSON.stringify(native.manifest)).digest("hex").slice(0, 12)}`;
+	const checked = path.join(root, ".lucent/check.json");
+	const cacheable = !options.force && !lock && usageReadable(path.join(root, ".lucent/sdk-usage.json"));
+	if (!build && cacheable) {
+		if ((fs.existsSync(checked) ? JSON.parse(fs.readFileSync(checked, "utf8")) : {}).inputs === key) {
+			graph.record("check", "check", "cached", { inputs: checkInputs });
+			return outcome({
+				ok: true,
+				upToDate: true,
+				modules
+			});
+		}
+	}
+	if (build && cacheable && isUpToDate(outDir, key)) {
+		graph.record("check", "check", "cached", { inputs: checkInputs });
+		graph.record("generate", "generate", "cached", { outputs: packageArtifacts(root, outDir) });
+		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;
+		const read = wanted.map(([p, m]) => ({
+			key: `${p}/${m}`,
+			artifacts: sdkModuleArtifacts(p, m, sdk)
+		}));
+		const artifacts = new Map(read.flatMap((r) => r.artifacts).map((a) => [a.id, a]));
+		const identity = (a) => `${a.id}#${a.contentHash}`;
+		graph.record("extract", "extract", extracted ? "ok" : "cached", {
+			inputs: [...read.map((r) => ({
+				key: r.key,
+				hash: contentHash(r.artifacts.map(identity).join("\n"))
+			})), ...[...artifacts.values()].map((a) => ({
+				key: a.id,
+				hash: a.contentHash
+			}))],
+			detail: listed,
+			ms: Date.now() - t
+		});
+		steps.finish({
+			name: "sdk",
+			label: "SDK bindings",
+			status: extracted ? "ok" : "cached",
+			detail: listed,
+			ms: extracted ? Date.now() - t : void 0
+		});
+	}
+	if (lock) {
+		const locked = Object.keys(lock.modules).filter((k) => built.includes(k.split("/")[0]));
+		const problems = lockProblems(lock, usedModules([...wanted.map(([p, m]) => `${p}/${m}`), ...locked], sdk));
+		if (problems.length) {
+			graph.record("extract:lock", "extract", "failed", { detail: problems.join("\n") });
+			return outcome({ fatal: frozenFailure(problems) });
+		}
+	}
+	steps.start("check", `Checking ${plural(moduleCount, "module")}`);
+	await steps.flush();
+	const tCheck = Date.now();
+	const deferred = deferAndroid && !platforms?.includes("android") ? ["android"] : [];
+	const result = compile(files, {
+		platforms,
+		sdk,
+		extensions,
+		deferred
+	});
+	const relative = (d) => ({
+		...d,
+		file: d.file && path.relative(root, d.file)
+	});
+	const diagnostics = result.diagnostics.map(relative);
+	const warnings = (result.warnings ?? []).map(relative);
+	if (!result.ok) {
+		graph.record("check", "check", "failed", {
+			inputs: checkInputs,
+			detail: plural(diagnostics.length, "error"),
+			ms: Date.now() - tCheck
+		});
+		steps.finish({
+			name: "check",
+			label: `Checked ${plural(moduleCount, "module")}`,
+			status: "failed",
+			detail: plural(diagnostics.length, "error"),
+			ms: Date.now() - tCheck
+		});
+		return outcome({
+			modules,
+			diagnostics,
+			warnings
+		});
+	}
+	const names = [...result.proxies.keys()];
+	const usage = sdkUsage(result.sdkUses ?? [], built, wanted.map(([p, m]) => `${p}/${m}`), sdk);
+	writeUsage(path.join(root, USAGE_FILE), usage);
+	const unlocked = lock ? lockProblems(lock, usage.modules, usage.symbols) : [];
+	if (unlocked.length) {
+		graph.record("check", "check", "failed", {
+			inputs: checkInputs,
+			detail: unlocked.join("\n"),
+			ms: Date.now() - tCheck
+		});
+		steps.finish({
+			name: "check",
+			label: `Checked ${plural(moduleCount, "module")}`,
+			status: "failed",
+			detail: `not the SDK symbols ${LOCK_FILE} records`,
+			ms: Date.now() - tCheck
+		});
+		return outcome({
+			modules,
+			warnings,
+			usage,
+			fatal: frozenFailure(unlocked)
+		});
+	}
+	graph.record("check", "check", "ok", {
+		inputs: checkInputs,
+		ms: Date.now() - tCheck
+	});
+	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,
+			warnings,
+			usage
+		});
+	}
+	if (options.signal?.aborted) return superseded("generate");
+	const resolvedFile = path.join(outDir, "resolved.json");
+	const previous = fs.existsSync(resolvedFile) ? JSON.parse(fs.readFileSync(resolvedFile, "utf8")) : void 0;
+	const tWrite = Date.now();
+	const w = writeNativePackage(result, outDir, {
+		inputsKey: key,
+		native,
+		androidDeferred: deferred.includes("android")
+	});
+	const inPackage = (f) => path.relative(outDir, f).split(path.sep).join("/");
+	const written = new Set(w.written.map(inPackage));
+	if (written.has("react-native.config.js")) staleAutolinking(root);
+	if (process.env.LUCENT_GRADLE_CLASSPATH && configured !== void 0 && fs.readFileSync(libraryGradle, "utf8") !== configured && configured !== deferredLibraryGradle(native)) {
+		const detail = `this Gradle build configured the Lucent Android library before its build.gradle changed (${path.relative(root, libraryGradle)}: Kotlin shims, packages' Android needs), so it would build it as it was: build again`;
+		graph.record("generate", "generate", "failed", {
+			detail,
+			ms: Date.now() - tWrite
+		});
+		return outcome({ fatal: detail });
+	}
+	graph.record("generate", "generate", "ok", {
+		outputs: packageArtifacts(root, outDir),
+		detail: `${written.size} written, ${w.removed.length} removed`,
+		ms: Date.now() - tWrite
+	});
+	changedUnits = [...written].filter((f) => f.startsWith("cpp/"));
+	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 missingAppEntries(root, native.manifest)) notify(n);
+	const nativeChanged = w.removed.length > 0 || [...written].some((f) => !f.startsWith("js/") && f !== "manifest.json");
+	return outcome({
+		ok: true,
+		modules,
+		warnings,
+		usage,
+		actions: classifyChanges({
+			written: [...written],
+			added: w.added.map(inPackage),
+			removed: w.removed.map(inPackage),
+			manifest: native.manifest,
+			previous,
+			targets
+		}),
+		next: {
+			rebuild: nativeChanged,
+			podInstall: w.structureChanged,
+			reload: !nativeChanged && [...written].some((f) => f.startsWith("js/"))
+		}
+	});
+}
+function packageInputs(native) {
+	const { ios, android } = native.manifest;
+	const listed = [
+		...ios.nativeSources,
+		...ios.resources,
+		...Object.values(ios.resourceBundles).flat(),
+		...ios.vendoredFrameworks,
+		...android.nativeSources,
+		...android.resources,
+		...android.assets,
+		...android.libraries,
+		...android.nativeLibraries
+	];
+	return [...new Map(listed.map((p) => [inNativePackage(p), p.hash])).entries()].map(([key, hash]) => ({
+		key,
+		hash
+	}));
+}
+function packageArtifacts(root, outDir) {
+	const out = [];
+	const walk = (dir) => {
+		for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+			const full = path.join(dir, e.name);
+			if (e.isDirectory()) walk(full);
+			else if (full !== path.join(outDir, "manifest.json")) out.push(fileArtifact(root, full));
+		}
+	};
+	if (fs.existsSync(outDir)) walk(outDir);
+	return out;
+}
+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 { filesText as a, ACTION_TEXT as i, nextText as n, plural as r, buildProject as t };