fundus 0.0.2 → 0.0.3

package/dist/server/processing/processor.js

@@ -0,0 +1,158 @@
+/**
+ * The processing pipeline: every delivered asset gets exactly one
+ * proxy named `<assetId>.<jobHash>.<extension>`. Delivered = explicit or
+ * passive member of ≥ 1 manifest (codegen inlines referenced
+ * entries, so a passive member's proxy must exist even when the asset is in
+ * no manifest itself). Because the name is computable without running the job,
+ * staleness is a name check: expected name exists → up to date, else →
+ * process. Afterwards, files in the proxy directory that no asset expects are
+ * pruned.
+ *
+ * Type-agnostic: every per-type decision (preset resolution, extension, the
+ * sharp/ffmpeg step, proxy probing) lives on the server plugins; this module
+ * only consults the registry — which it takes as a parameter, so tests can
+ * drive the pipeline with fixture asset types.
+ */
+import { existsSync } from 'node:fs';
+import { mkdir, rename, stat, unlink } from 'node:fs/promises';
+import { basename, dirname, extname, join } from 'node:path';
+import { allDeliveredAssetIds, collectAllReferences, computeLibraryMembership, folderOfRawPath, rawFileNameOfPath } from '../../core/index.js';
+import { jobHash } from '../job-hash.js';
+import { descriptorsByType, processingParametersOf, serverPluginForType, serverPluginsByType } from '../plugins.js';
+import { ensureManagedFolder, listRelativeFiles } from '../folder-filesystem.js';
+/** Proxy file name shape; its id segment is pinned to core's asset-id grammar. */
+const PROXY_FILE_PATTERN = /^[a-z][A-Za-z0-9]*\.[0-9a-f]{8}\.[a-z0-9]+$/;
+/** Whether a file name in the proxy directory is (shaped like) a fundus proxy. */
+export function isProxyFileName(fileName) {
+    return PROXY_FILE_PATTERN.test(fileName);
+}
+/** Whether a shaped proxy file belongs to one specific asset id. */
+export function isProxyFileNameFor(assetId, fileName) {
+    return isProxyFileName(fileName) && fileName.startsWith(`${assetId}.`);
+}
+/**
+ * The proxy file name an asset's current raw content + parameters demand.
+ * Throws when the parameters are invalid or reference an unknown preset.
+ *
+ * The hash input is the *effective* processing input: the asset's
+ * processing-relevant parameters (the plugin-declared subset — entry-only data
+ * like chroma-key tuning and references must not rename the proxy)
+ * plus the preset's **resolved settings** — parameters only carry the preset
+ * *name*, so hashing them alone would keep serving stale proxy bytes after a
+ * preset's quality/format is edited in the host config.
+ */
+export function expectedProxyFileName(assetId, record, config, registry = serverPluginsByType) {
+    const plugin = serverPluginForType(record.type, registry);
+    const parameters = plugin.descriptor.validateParameters(record.parameters);
+    const preset = plugin.resolvePreset(parameters, config);
+    const hash = jobHash(record.rawHash, {
+        parameters: processingParametersOf(plugin.descriptor, parameters),
+        presetSettings: preset
+    });
+    return `${assetId}.${hash}.${plugin.proxyExtension(preset)}`;
+}
+/** Expected proxy path relative to proxyDir, mirroring the raw asset folder. */
+export function expectedProxyRelativePath(assetId, record, config, registry = serverPluginsByType) {
+    const fileName = expectedProxyFileName(assetId, record, config, registry);
+    const folder = folderOfRawPath(record.raw);
+    return folder === '' ? fileName : `${folder}/${fileName}`;
+}
+/**
+ * Output metadata of an existing proxy file, probed per the owning plugin's
+ * strategy: image-backed proxies via sharp, media proxies via ffprobe.
+ */
+export async function readProxyOutputInfo(type, proxyPath, config, registry = serverPluginsByType) {
+    return serverPluginForType(type, registry).readProxyInfo(proxyPath, config);
+}
+/** Read one asset's current proxy projection, or null when its expected file is absent. */
+export async function readCurrentProxy(assetId, record, config, registry = serverPluginsByType) {
+    const fileName = expectedProxyFileName(assetId, record, config, registry);
+    const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
+    const proxyPath = join(config.proxyDir, relativePath);
+    if (!existsSync(proxyPath))
+        return null;
+    const [outputInfo, proxyStat] = await Promise.all([
+        readProxyOutputInfo(record.type, proxyPath, config, registry),
+        stat(proxyPath)
+    ]);
+    return { assetId, fileName, relativePath, ...outputInfo, fileSize: proxyStat.size };
+}
+/**
+ * The delivered set: every explicit or passive member of ≥ 1 manifest —
+ * derived by the shared membership computation. Assets outside
+ * it are inert.
+ */
+export function deliveredAssetIds(library, registry = serverPluginsByType) {
+    return allDeliveredAssetIds(computeLibraryMembership(library, collectAllReferences(library, descriptorsByType(registry))));
+}
+/** Run the owning plugin's processing job for one stale/missing proxy. */
+async function processAssetFile(record, rawPath, proxyPath, config, registry) {
+    const plugin = serverPluginForType(record.type, registry);
+    const parameters = plugin.descriptor.validateParameters(record.parameters);
+    const extension = extname(proxyPath);
+    const stem = basename(proxyPath, extension);
+    const temporaryPath = join(dirname(proxyPath), `.${stem}.${crypto.randomUUID()}.tmp${extension}`);
+    try {
+        const output = await plugin.process({
+            sourcePath: rawPath,
+            targetPath: temporaryPath,
+            parameters,
+            preset: plugin.resolvePreset(parameters, config),
+            config
+        });
+        await rename(temporaryPath, proxyPath);
+        return output;
+    }
+    catch (cause) {
+        await unlink(temporaryPath).catch(() => { });
+        throw cause;
+    }
+}
+/**
+ * Ensure every delivered asset's proxy exists (processing stale/missing ones)
+ * and prune orphans. Assets outside the delivered set are skipped entirely.
+ */
+export async function processAssets(config, library, registry = serverPluginsByType) {
+    const report = { processed: [], reused: [], pruned: [], proxies: {} };
+    await mkdir(config.proxyDir, { recursive: true });
+    await Promise.all(library.folders.map((folder) => ensureManagedFolder(config.proxyDir, folder)));
+    const delivered = deliveredAssetIds(library, registry);
+    const expectedRelativePaths = new Set();
+    for (const [assetId, record] of Object.entries(library.assets)) {
+        if (!delivered.has(assetId))
+            continue;
+        const fileName = expectedProxyFileName(assetId, record, config, registry);
+        const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
+        expectedRelativePaths.add(relativePath);
+        const proxyPath = join(config.proxyDir, relativePath);
+        const rawPath = join(config.rawDir, record.raw);
+        await mkdir(dirname(proxyPath), { recursive: true });
+        let proxy = await readCurrentProxy(assetId, record, config, registry);
+        if (proxy) {
+            report.reused.push(assetId);
+        }
+        else {
+            if (!existsSync(rawPath)) {
+                throw new Error(`Cannot process "${assetId}": raw file "${record.raw}" is missing.`);
+            }
+            const outputInfo = await processAssetFile(record, rawPath, proxyPath, config, registry);
+            report.processed.push(assetId);
+            const proxyStat = await stat(proxyPath);
+            proxy = { assetId, fileName, relativePath, ...outputInfo, fileSize: proxyStat.size };
+        }
+        report.proxies[assetId] = proxy;
+    }
+    // Prune orphans: only files matching the proxy naming pattern are touched,
+    // so a stray non-fundus file in the directory is left alone.
+    for (const relativePath of await listRelativeFiles(config.proxyDir)) {
+        const fileName = rawFileNameOfPath(relativePath);
+        if (!isProxyFileName(fileName))
+            continue;
+        if (expectedRelativePaths.has(relativePath))
+            continue;
+        await unlink(join(config.proxyDir, relativePath));
+        report.pruned.push(relativePath);
+    }
+    report.pruned.sort();
+    return report;
+}

package/dist/server/processing/video-processing.d.ts

@@ -0,0 +1,35 @@
+import type { VideoPreset } from '../../core/index.js';
+import type { ResolvedFundusConfig } from '../config-loader.js';
+/**
+ * The delivered width the scale filter must produce, or null when no filter is
+ * needed. `maxWidth` is a downscale-only cap; yuv420p demands even dimensions,
+ * so an odd (capped or source) width rounds down and an odd source height
+ * forces a filter even without a cap (the `-2` idiom rounds it).
+ */
+export declare function videoScaleWidth(sourceWidth: number, sourceHeight: number, maxWidth?: number): number | null;
+/**
+ * The full ffmpeg argument list for one video transcode (pure, testable
+ * without a binary). `-map_metadata -1` + bitexact flags keep the output
+ * byte-stable across runs (no embedded timestamps or encoder version tags);
+ * a source audio track is kept (re-encoded as AAC — a UI video may carry
+ * sound; nothing is stripped silently).
+ */
+export declare function buildVideoTranscodeArguments(options: {
+    sourcePath: string;
+    targetPath: string;
+    preset: VideoPreset;
+    /** From `videoScaleWidth`; null = no scaling. */
+    scaleWidth: number | null;
+}): string[];
+export interface VideoProcessingOutput {
+    width: number;
+    height: number;
+    durationMs: number;
+}
+export declare function processVideoFile(options: {
+    sourcePath: string;
+    targetPath: string;
+    preset: VideoPreset;
+    maxWidth?: number;
+    config: ResolvedFundusConfig;
+}): Promise<VideoProcessingOutput>;

package/dist/server/processing/video-processing.js

@@ -0,0 +1,87 @@
+/**
+ * The ffmpeg transcode step shared by the video and chroma-key-video plugins
+ * (chroma-key-video builds on video's processing; its keying data is
+ * entry-only and never reaches ffmpeg). Deterministic output: all
+ * metadata is stripped and bitexact muxing is forced, so re-running a job
+ * yields byte-identical proxy files.
+ */
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { ffmpegBinaryPath, runToolchainBinary } from './ffmpeg.js';
+import { probeMedia } from './media-probe.js';
+/**
+ * The delivered width the scale filter must produce, or null when no filter is
+ * needed. `maxWidth` is a downscale-only cap; yuv420p demands even dimensions,
+ * so an odd (capped or source) width rounds down and an odd source height
+ * forces a filter even without a cap (the `-2` idiom rounds it).
+ */
+export function videoScaleWidth(sourceWidth, sourceHeight, maxWidth) {
+    const cappedWidth = maxWidth !== undefined ? Math.min(maxWidth, sourceWidth) : sourceWidth;
+    const evenWidth = Math.max(2, cappedWidth - (cappedWidth % 2));
+    if (evenWidth === sourceWidth && sourceHeight % 2 === 0)
+        return null;
+    return evenWidth;
+}
+/**
+ * The full ffmpeg argument list for one video transcode (pure, testable
+ * without a binary). `-map_metadata -1` + bitexact flags keep the output
+ * byte-stable across runs (no embedded timestamps or encoder version tags);
+ * a source audio track is kept (re-encoded as AAC — a UI video may carry
+ * sound; nothing is stripped silently).
+ */
+export function buildVideoTranscodeArguments(options) {
+    const { sourcePath, targetPath, preset, scaleWidth } = options;
+    return [
+        '-hide_banner',
+        '-loglevel',
+        'error',
+        '-y',
+        '-i',
+        sourcePath,
+        ...(scaleWidth !== null ? ['-vf', `scale=${scaleWidth}:-2`] : []),
+        '-c:v',
+        'libx264',
+        '-preset',
+        preset.encoderPreset,
+        ...(preset.tune !== undefined ? ['-tune', preset.tune] : []),
+        '-crf',
+        String(preset.crf),
+        '-pix_fmt',
+        preset.pixelFormat,
+        '-c:a',
+        'aac',
+        '-b:a',
+        '128k',
+        '-map_metadata',
+        '-1',
+        '-fflags',
+        '+bitexact',
+        '-flags:v',
+        '+bitexact',
+        '-flags:a',
+        '+bitexact',
+        '-movflags',
+        '+faststart',
+        targetPath
+    ];
+}
+export async function processVideoFile(options) {
+    await mkdir(dirname(options.targetPath), { recursive: true });
+    const source = await probeMedia(options.sourcePath, options.config);
+    if (source.width === undefined || source.height === undefined) {
+        throw new Error(`${options.sourcePath} has no video stream.`);
+    }
+    const scaleWidth = videoScaleWidth(source.width, source.height, options.maxWidth);
+    await runToolchainBinary(ffmpegBinaryPath(options.config), buildVideoTranscodeArguments({
+        sourcePath: options.sourcePath,
+        targetPath: options.targetPath,
+        preset: options.preset,
+        scaleWidth
+    }));
+    // Probe the output — the delivered dimensions/duration are what the entry carries.
+    const output = await probeMedia(options.targetPath, options.config);
+    if (output.width === undefined || output.height === undefined) {
+        throw new Error(`Transcoding ${options.sourcePath} produced no video stream.`);
+    }
+    return { width: output.width, height: output.height, durationMs: output.durationMs };
+}

package/dist/server/server.d.ts

@@ -0,0 +1,13 @@
+import { type IncomingMessage, type ServerResponse } from 'node:http';
+export { parseByteRange } from './http.js';
+export type FundusHandler = (request: IncomingMessage, response: ServerResponse, next: (error?: unknown) => void) => void;
+export interface FundusServerOptions {
+    handler: FundusHandler;
+    port: number;
+    forceCloseAfterMs?: number;
+}
+export interface FundusServer {
+    port: number;
+    stop(): Promise<void>;
+}
+export declare function startServer(options: FundusServerOptions): Promise<FundusServer>;

package/dist/server/server.js

@@ -0,0 +1,57 @@
+import { createServer } from 'node:http';
+export { parseByteRange } from './http.js';
+export async function startServer(options) {
+    const server = createServer((request, response) => {
+        // adapter-node otherwise assumes HTTPS when a custom server does not
+        // provide protocol metadata, which makes same-origin multipart uploads
+        // fail SvelteKit's CSRF check on this intentionally HTTP-only local server.
+        request.headers['x-fundus-proto'] = 'http';
+        options.handler(request, response, (cause) => {
+            if (response.writableEnded)
+                return;
+            response.statusCode = 500;
+            response.setHeader('Content-Type', 'application/json; charset=utf-8');
+            response.end(JSON.stringify({
+                error: {
+                    message: cause instanceof Error ? cause.message : 'Fundus handler declined the request.'
+                }
+            }));
+        });
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (cause) => {
+            server.off('listening', onListening);
+            reject(cause);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(options.port, '127.0.0.1');
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Fundus server did not expose a TCP listening address.');
+    }
+    let stopping;
+    return {
+        port: address.port,
+        stop() {
+            stopping ??= new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => server.closeAllConnections(), options.forceCloseAfterMs ?? 1000);
+                timeout.unref();
+                server.closeIdleConnections();
+                server.close((cause) => {
+                    clearTimeout(timeout);
+                    if (cause)
+                        reject(cause);
+                    else
+                        resolve();
+                });
+            });
+            return stopping;
+        }
+    };
+}

package/dist/server/start.d.ts

@@ -0,0 +1 @@
+export declare function runStart(projectRoot: string): Promise<void>;

package/dist/server/start.js

@@ -0,0 +1,33 @@
+/** Start the packaged SvelteKit Node editor and API for one host project. */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { startServer } from './server.js';
+export async function runStart(projectRoot) {
+    process.env.FUNDUS_PROJECT_ROOT = resolve(projectRoot);
+    process.env.FUNDUS_BODY_SIZE_LIMIT ??= 'Infinity';
+    process.env.FUNDUS_ADAPTER_BODY_SIZE_LIMIT = process.env.FUNDUS_BODY_SIZE_LIMIT;
+    process.env.FUNDUS_ADAPTER_PROTOCOL_HEADER = 'x-fundus-proto';
+    const handlerUrl = new URL('../../build/handler.js', import.meta.url);
+    if (!existsSync(handlerUrl)) {
+        throw new Error(`The packaged Fundus SvelteKit handler is missing from ${fileURLToPath(handlerUrl)}. Reinstall the fundus package or report a packaging error.`);
+    }
+    const module = (await import(handlerUrl.href));
+    if (typeof module.handler !== 'function') {
+        throw new Error(`The packaged Fundus handler at ${fileURLToPath(handlerUrl)} is invalid.`);
+    }
+    const configuredPort = Number(process.env.FUNDUS_API_PORT ?? 5176);
+    const server = await startServer({ handler: module.handler, port: configuredPort });
+    console.log(`fundus editor: http://127.0.0.1:${server.port}  (project: ${process.env.FUNDUS_PROJECT_ROOT})`);
+    let signalStop;
+    const stopForSignal = () => {
+        signalStop ??= server.stop().then(() => {
+            process.exitCode = 0;
+        }, (cause) => {
+            console.error(cause);
+            process.exitCode = 1;
+        });
+    };
+    process.once('SIGINT', stopForSignal);
+    process.once('SIGTERM', stopForSignal);
+}

package/package.json

@@ -1,17 +1,11 @@
 {
 	"name": "fundus",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"type": "module",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/grischaerbe/fundus.git"
 	},
-	"imports": {
-		"#fundus/core": {
-			"types": "./dist/core/index.d.ts",
-			"default": "./dist/core/index.js"
-		}
-	},
 	"bin": {
 		"fundus": "./dist/cli.js"
 	},
@@ -23,8 +17,8 @@
 			"default": "./dist/runtime/index.js"
 		},
 		"./server": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
+			"types": "./dist/server/index.d.ts",
+			"default": "./dist/server/index.js"
 		},
 		"./config": {
 			"types": "./dist/config.d.ts",
@@ -32,18 +26,26 @@
 		}
 	},
 	"files": [
-		"dist"
+		"dist",
+		"build"
 	],
 	"engines": {
 		"node": ">=20.19.0"
 	},
 	"scripts": {
-		"build": "tsdown",
-		"prepack": "npm run build --workspace=@fundus/core && npm run build --workspace=@fundus/runtime && npm run build --workspace=@fundus/editor && npm run build",
+		"dev": "vite dev",
+		"build:package": "svelte-package --input src/lib --output dist && node scripts/postbuild-package.mjs && publint",
+		"build:app": "vite build",
+		"build": "npm run build:package && npm run build:app",
 		"test": "npm run build && vitest run",
-		"check": "npm run build && tsc --noEmit",
+		"smoke:pack": "node scripts/smoke-packed.mjs",
+		"check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json && tsc --noEmit",
 		"lint": "prettier --check .",
-		"format": "prettier --write ."
+		"format": "prettier --write .",
+		"prepack": "npm run build",
+		"changeset": "changeset",
+		"version-packages": "changeset version",
+		"release": "changeset publish"
 	},
 	"dependencies": {
 		"ffmpeg-static": "^5.3.0",
@@ -55,11 +57,22 @@
 		"svelte": "^5.0.0"
 	},
 	"devDependencies": {
+		"@changesets/changelog-github": "^0.7.0",
+		"@changesets/cli": "^2.31.0",
+		"@sveltejs/adapter-node": "^5.5.7",
+		"@sveltejs/kit": "^2.69.2",
+		"@sveltejs/package": "^2.5.8",
+		"@sveltejs/vite-plugin-svelte": "^7.1.2",
 		"@types/ffprobe-static": "^2.0.3",
-		"@types/node": "^24.0.10",
+		"@types/node": "^24.13.3",
+		"fuse.js": "^7.4.2",
+		"prettier": "^3.8.3",
+		"prettier-plugin-svelte": "^4.1.0",
+		"publint": "^0.3.21",
 		"svelte": "^5.56.1",
-		"tsdown": "^0.21.10",
+		"svelte-check": "^4.6.0",
 		"typescript": "^6.0.3",
+		"vite": "^8.0.16",
 		"vitest": "^3.2.4"
 	}
 }

package/dist/build-CZYFLLvl.js

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