fundus 0.0.2

package/dist/build-CZYFLLvl.js

@@ -0,0 +1,191 @@
+import { _ as strayGeneratedModuleNames, a as deliveredAssetIds, c as isProxyFileName, f as listRelativeFiles, g as renderManifestModule, h as manifestModuleFileName, i as sha256Hex, l as processAssets, m as generateManifestModules, n as LibraryStore, p as buildManifestEntries, s as expectedProxyRelativePath, u as readCurrentProxy, v as descriptorsByType, w as loadConfig, x as serverPluginsByType } from "./operations-DYM-5KVl.js";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { collectAllReferences, compareCodeUnits, computeLibraryMembership, rawFileNameOfPath } from "#fundus/core";
+import { existsSync } from "node:fs";
+//#region src/check.ts
+/**
+* `fundus check` — the verify-only CI gate: no writes, ever. It
+* fails when the library does not validate, when a committed proxy is stale,
+* missing, or orphaned, or when a generated manifest module differs from an
+* in-memory regeneration. Warnings (unreachable asset, raw-hash drift) are
+* treated as errors unless `--allow-warnings` downgrades them — errors are
+* never downgradable.
+*/
+/** The human rendering of a finding — `[assetId] message`, as `fundus check` prints it. */
+function formatCheckFinding(finding) {
+	return `${finding.assetId ? `[${finding.assetId}] ` : ""}${finding.message}`;
+}
+async function runCheck(projectRoot, registry = serverPluginsByType) {
+	const config = await loadConfig(projectRoot);
+	const store = new LibraryStore(config, registry);
+	const library = await store.read();
+	const report = {
+		errors: [],
+		warnings: [],
+		assetCount: Object.keys(library.assets).length,
+		manifestCount: Object.keys(library.manifests).length
+	};
+	const issues = await store.validate(library);
+	for (const issue of issues) report.errors.push({
+		kind: "validation",
+		message: issue.message,
+		...issue.assetId !== void 0 ? { assetId: issue.assetId } : {}
+	});
+	const delivered = deliveredAssetIds(library, registry);
+	const expectedProxyPaths = /* @__PURE__ */ new Set();
+	const proxies = {};
+	let proxiesComplete = true;
+	for (const assetId of [...delivered].sort(compareCodeUnits)) {
+		const record = library.assets[assetId];
+		let proxy;
+		try {
+			proxy = await readCurrentProxy(assetId, record, config, registry);
+		} catch (cause) {
+			if (!issues.some((issue) => issue.assetId === assetId)) report.errors.push({
+				kind: "proxy-unresolvable",
+				message: cause instanceof Error ? cause.message : String(cause),
+				assetId
+			});
+			proxiesComplete = false;
+			continue;
+		}
+		if (!proxy) {
+			const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
+			expectedProxyPaths.add(relativePath);
+			report.errors.push({
+				kind: "proxy-missing",
+				message: `Proxy "${relativePath}" is missing or stale — run \`fundus build\` and commit the result.`,
+				assetId,
+				fileName: relativePath
+			});
+			proxiesComplete = false;
+			continue;
+		}
+		expectedProxyPaths.add(proxy.relativePath);
+		proxies[assetId] = proxy;
+	}
+	if (existsSync(config.proxyDir)) for (const relativePath of (await listRelativeFiles(config.proxyDir)).sort()) {
+		if (!isProxyFileName(rawFileNameOfPath(relativePath)) || expectedProxyPaths.has(relativePath)) continue;
+		report.errors.push({
+			kind: "proxy-orphaned",
+			message: `Orphaned proxy "${relativePath}" — no asset expects it; run \`fundus build\` and commit the result.`,
+			fileName: relativePath
+		});
+	}
+	if (issues.length === 0 && proxiesComplete) {
+		await checkGeneratedModules(report, library, config, proxies, registry);
+		await checkStrayModules(report, library, config);
+	}
+	collectUnreachableAssets(report, library, delivered);
+	await collectRawHashDrift(report, library, config);
+	return report;
+}
+async function checkGeneratedModules(report, library, config, proxies, registry) {
+	const referencesByAsset = collectAllReferences(library, descriptorsByType(registry));
+	const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
+	for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
+		const fileName = manifestModuleFileName(manifestName);
+		const modulePath = join(config.manifestsDir, fileName);
+		let expectedContent;
+		try {
+			expectedContent = renderManifestModule(manifestName, buildManifestEntries({
+				membership: membershipByManifest[manifestName],
+				library,
+				proxies,
+				config,
+				referencesByAsset,
+				registry
+			}));
+		} catch (cause) {
+			report.errors.push({
+				kind: "module-regeneration-failed",
+				message: `Cannot regenerate module "${fileName}": ${cause instanceof Error ? cause.message : String(cause)}`,
+				manifest: manifestName,
+				fileName
+			});
+			continue;
+		}
+		if (!existsSync(modulePath)) {
+			report.errors.push({
+				kind: "module-missing",
+				message: `Generated module "${fileName}" is missing — run \`fundus build\` and commit the result.`,
+				manifest: manifestName,
+				fileName
+			});
+			continue;
+		}
+		if (await readFile(modulePath, "utf8") !== expectedContent) report.errors.push({
+			kind: "module-out-of-sync",
+			message: `Generated module "${fileName}" is out of sync with the library — run \`fundus build\` and commit the result.`,
+			manifest: manifestName,
+			fileName
+		});
+	}
+}
+async function checkStrayModules(report, library, config) {
+	const expectedFileNames = new Set(Object.keys(library.manifests).map((manifestName) => manifestModuleFileName(manifestName)));
+	for (const fileName of await strayGeneratedModuleNames(config.manifestsDir, expectedFileNames)) report.errors.push({
+		kind: "module-stray",
+		message: `Stray generated module "${fileName}" — its manifest no longer exists; run \`fundus build\`.`,
+		fileName
+	});
+}
+/**
+* The unreachable-asset warning: fires only when nothing delivers the asset —
+* no explicit membership AND no passive membership in any manifest. An asset
+* that is only passively delivered (referenced by a delivered asset) is fine.
+*/
+function collectUnreachableAssets(report, library, delivered) {
+	for (const [assetId, record] of Object.entries(library.assets)) if (record.manifests.length === 0 && !delivered.has(assetId)) report.warnings.push({
+		kind: "unreachable-asset",
+		message: "In no manifest and not referenced by any delivered asset — nothing is processed or generated for it.",
+		assetId
+	});
+}
+/**
+* Raw-hash drift: a raw file replaced on disk while the library still pins the
+* old content hash. The proxy name derives from the *recorded* hash, so the
+* name check alone would keep passing while the delivered pixels are outdated.
+*/
+async function collectRawHashDrift(report, library, config) {
+	for (const [assetId, record] of Object.entries(library.assets)) {
+		const rawPath = join(config.rawDir, record.raw);
+		if (!existsSync(rawPath)) continue;
+		if (sha256Hex(new Uint8Array(await readFile(rawPath))) !== record.rawHash) report.warnings.push({
+			kind: "raw-hash-drift",
+			message: `Raw file "${record.raw}" changed since it was ingested (hash drift) — re-ingest or update it through the editor, then run \`fundus build\`.`,
+			assetId,
+			fileName: record.raw
+		});
+	}
+}
+//#endregion
+//#region src/build.ts
+/**
+* `fundus build` — headless pipeline run: validate the library, process all
+* stale/missing proxies, prune orphans, regenerate every manifest module.
+* Throws on validation errors (the CLI exits non-zero).
+*/
+async function runBuild(projectRoot, registry = serverPluginsByType) {
+	const config = await loadConfig(projectRoot);
+	const store = new LibraryStore(config, registry);
+	const library = await store.read();
+	await store.syncFolders(library);
+	const issues = await store.validate(library);
+	if (issues.length > 0) {
+		const lines = issues.map((issue) => `  - ${formatCheckFinding({
+			kind: "validation",
+			assetId: issue.assetId,
+			message: issue.message
+		})}`);
+		throw new Error(`Library validation failed:\n${lines.join("\n")}`);
+	}
+	const processing = await processAssets(config, library, registry);
+	return {
+		processing,
+		codegen: await generateManifestModules(config, library, processing.proxies, registry)
+	};
+}
+//#endregion
+export { formatCheckFinding as n, runCheck as r, runBuild as t };

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export { };