fundus 0.0.2 → 0.0.4

package/{dist/operations-DYM-5KVl.js → build/server/chunks/chunks/library-store.js-ZLudCJlT.js}

@@ -1,87 +1,330 @@
-import { mkdir, readFile, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, extname, isAbsolute, join, resolve } from "node:path";
-import { AUDIO_BUILT_IN_PRESETS, FOLDER_SENTINEL, IMAGE_BUILT_IN_PRESETS, SLICE_BUILT_IN_PRESETS, VIDEO_BUILT_IN_PRESETS, allDeliveredAssetIds, assetIdError, audioPlugin, canonicalizeParameters, chromaKeyVideoPlugin, collectAllReferences, compareCodeUnits, computeLibraryMembership, createEmptyLibrary, defaultInsetsForSize, folderNameError, folderNameOf, folderOfRawPath, folderPathError, imagePlugin, isAssetReference, isFolderOrDescendant, joinFolderPath, manifestColorError, manifestEmojiError, manifestNameError, normalizeFolderPath, parentFolderPath, parseLibrary, portableFolderPathKey, rawFileNameOfPath, referenceErrors, replaceFolderPrefix, serializeLibrary, slicePlugin, topologicalReferenceOrder, validateAudioPreset, validateImagePreset, validateVideoPreset, videoPlugin } from "#fundus/core";
-import { existsSync } from "node:fs";
-import { createJiti } from "jiti";
-import { createHash } from "node:crypto";
-import ffmpegStaticPath from "ffmpeg-static";
-import { path } from "ffprobe-static";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import sharp from "sharp";
-//#region src/config-loader.ts
+import { p as plugins, a as audioPlugin, c as chromaKeyVideoPlugin, v as videoPlugin, s as slicePlugin, i as imagePlugin, b as assetIdError, d as defaultInsetsForSize, m as manifestNameError, e as isAssetReference, f as validateVideoPreset, V as VIDEO_BUILT_IN_PRESETS, g as validateAudioPreset, A as AUDIO_BUILT_IN_PRESETS, h as validateImagePreset, I as IMAGE_BUILT_IN_PRESETS, S as SLICE_BUILT_IN_PRESETS } from './core.js-xfrkaQpS.js';
+import { n as normalizeFolderPath, f as folderOfRawPath, r as rawFileNameOfPath, a as folderPathError, p as parentFolderPath, b as folderNameError, j as joinFolderPath, c as folderNameOf, i as isFolderOrDescendant, d as replaceFolderPrefix, e as portableFolderPathKey, F as FOLDER_SENTINEL } from './folder-path.js-ytx9ucgg.js';
+import { m as manifestColorError, a as manifestEmojiError } from './manifest-appearance.js-DTk355LQ.js';
+import { join, extname, dirname, basename, isAbsolute, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { readFile, mkdir, writeFile, rename, rm, unlink, stat, readdir } from 'node:fs/promises';
+import ffmpegStaticPath from 'ffmpeg-static';
+import { path } from 'ffprobe-static';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import sharp from 'sharp';
+import { createHash } from 'node:crypto';
+
+//#region src/lib/core/library.ts
+/** A fresh, empty library. */
+function createEmptyLibrary() {
+	return {
+		version: 1,
+		folders: [],
+		assets: {},
+		manifests: {}
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /**
-* Loads and resolves the host's `fundus.config.ts` through jiti, validates
-* the shape, resolves all paths to
-* absolute, and merges the built-in plugin preset defaults under the host's.
+* Keys that are prototype-pollution hazards as record keys: assigning
+* `assets["__proto__"] = …` on a plain object replaces its prototype instead
+* of adding an entry. Rejected outright at parse time — id *validity* beyond
+* this is a validator concern (reported as issues, not parse failures).
 */
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+var DANGEROUS_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+function assertSafeKey(kind, key) {
+	if (DANGEROUS_KEYS.includes(key)) throw new Error(`Library ${kind} key "${key}" is not allowed.`);
+}
+function parseAssetRecord(id, value) {
+	if (!isRecord$1(value)) throw new Error(`Library asset "${id}" must be an object.`);
+	if (typeof value.type !== "string" || value.type.length === 0) throw new Error(`Library asset "${id}" is missing a string "type".`);
+	if (typeof value.raw !== "string" || value.raw.length === 0) throw new Error(`Library asset "${id}" is missing a string "raw" file name.`);
+	if (typeof value.rawHash !== "string" || value.rawHash.length === 0) throw new Error(`Library asset "${id}" is missing a string "rawHash".`);
+	if (!("parameters" in value)) throw new Error(`Library asset "${id}" is missing "parameters".`);
+	if (!Array.isArray(value.manifests) || value.manifests.some((entry) => typeof entry !== "string")) throw new Error(`Library asset "${id}" must have a "manifests" array of strings.`);
+	return {
+		type: value.type,
+		raw: value.raw,
+		rawHash: value.rawHash,
+		parameters: value.parameters,
+		manifests: value.manifests
+	};
 }
-function requiredString(config, key) {
-	const value = config[key];
-	if (typeof value !== "string" || value.length === 0) throw new Error(`fundus.config: "${key}" must be a non-empty string.`);
+function parseManifestRecord(name, value) {
+	const record = {};
+	if ("color" in value && value.color !== void 0) {
+		if (typeof value.color !== "string") throw new Error(`Library manifest "${name}" has a non-string "color".`);
+		record.color = value.color;
+	}
+	if ("emoji" in value && value.emoji !== void 0) {
+		if (typeof value.emoji !== "string") throw new Error(`Library manifest "${name}" has a non-string "emoji".`);
+		record.emoji = value.emoji;
+	}
+	return record;
+}
+/**
+* Parse and structurally validate a library file's JSON text. Throws with a
+* clear message on any malformed part; plugin parameter validation is a
+* separate, plugin-owned step.
+*/
+function parseLibrary(json) {
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch (cause) {
+		throw new Error(`Library file is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	if (!isRecord$1(value)) throw new Error("Library file must contain a JSON object.");
+	if (value.version !== 1) throw new Error(`Unsupported library version ${JSON.stringify(value.version)} (expected 1).`);
+	if (!isRecord$1(value.assets)) throw new Error("Library \"assets\" must be an object.");
+	if (!isRecord$1(value.manifests)) throw new Error("Library \"manifests\" must be an object.");
+	if (value.folders !== void 0 && (!Array.isArray(value.folders) || value.folders.some((entry) => typeof entry !== "string"))) throw new Error("Library \"folders\" must be an array of strings.");
+	const folders = value.folders === void 0 ? [] : value.folders;
+	for (const folder of folders) {
+		const problem = folderPathError(folder);
+		if (problem) throw new Error(`Invalid library folder: ${problem}`);
+	}
+	const assets = {};
+	for (const [id, record] of Object.entries(value.assets)) {
+		assertSafeKey("asset", id);
+		assets[id] = parseAssetRecord(id, record);
+	}
+	const manifests = {};
+	for (const [name, record] of Object.entries(value.manifests)) {
+		assertSafeKey("manifest", name);
+		if (!isRecord$1(record)) throw new Error(`Library manifest "${name}" must be an object.`);
+		manifests[name] = parseManifestRecord(name, record);
+	}
+	return {
+		version: 1,
+		folders,
+		assets,
+		manifests
+	};
+}
+/** Recursively sort object keys so serialization is order-independent. */
+function sortValue(value) {
+	if (Array.isArray(value)) return value.map(sortValue);
+	if (typeof value === "object" && value !== null) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) {
+			const entry = value[key];
+			if (entry !== void 0) sorted[key] = sortValue(entry);
+		}
+		return sorted;
+	}
 	return value;
 }
-function resolvePath(projectRoot, value) {
-	return isAbsolute(value) ? value : resolve(projectRoot, value);
+/**
+* Serialize a library deterministically: recursively sorted keys, tab-indented,
+* trailing newline. Same library → byte-identical file, whatever the in-memory
+* insertion order was.
+*/
+function serializeLibrary(library) {
+	return `${JSON.stringify(sortValue({
+		...library,
+		folders: [...library.folders].sort()
+	}), null, "	")}\n`;
 }
-function mergePresets(label, builtIn, pluginConfig, validatePreset) {
-	const merged = { ...builtIn };
-	if (pluginConfig === void 0) return merged;
-	if (!isRecord(pluginConfig)) throw new Error(`fundus.config: "plugins.${label}" must be an object.`);
-	if (pluginConfig.presets === void 0) return merged;
-	if (!isRecord(pluginConfig.presets)) throw new Error(`fundus.config: "plugins.${label}.presets" must be an object.`);
-	for (const [name, preset] of Object.entries(pluginConfig.presets)) merged[name] = validatePreset(name, preset);
-	return merged;
+//#endregion
+//#region src/lib/core/canonicalize.ts
+/**
+* Stable JSON for hash inputs: recursively sorted keys, no whitespace,
+* `undefined` object values dropped. Two parameter objects that differ only in
+* key order (or in explicitly-undefined optionals) canonicalize identically,
+* so the derived job hash — and thus the proxy file name — stays stable.
+*/
+function canonicalizeParameters(parameters) {
+	return stringify(parameters);
 }
-/** `plugins.video.ffmpegPath` / `ffprobePath`: optional system-binary overrides. */
-function binaryPathOverride(projectRoot, pluginConfig, key) {
-	if (!isRecord(pluginConfig) || pluginConfig[key] === void 0) return null;
-	const value = pluginConfig[key];
-	if (typeof value !== "string" || value.length === 0) throw new Error(`fundus.config: "plugins.video.${key}" must be a non-empty string.`);
-	return resolvePath(projectRoot, value);
-}
-/** Pure resolution step (testable without a config file on disk). */
-function resolveConfig(projectRoot, value) {
-	if (!isRecord(value)) throw new Error("fundus.config must default-export a configuration object.");
-	const proxyBasePath = requiredString(value, "proxyBasePath");
-	if (!proxyBasePath.endsWith("/")) throw new Error("fundus.config: \"proxyBasePath\" must end with \"/\".");
-	const plugins = value.plugins === void 0 ? {} : value.plugins;
-	if (!isRecord(plugins)) throw new Error("fundus.config: \"plugins\" must be an object.");
-	return {
-		rawDir: resolvePath(projectRoot, requiredString(value, "rawDir")),
-		proxyDir: resolvePath(projectRoot, requiredString(value, "proxyDir")),
-		library: resolvePath(projectRoot, requiredString(value, "library")),
-		manifestsDir: resolvePath(projectRoot, requiredString(value, "manifestsDir")),
-		proxyBasePath,
-		plugins: {
-			image: { presets: mergePresets("image", IMAGE_BUILT_IN_PRESETS, plugins.image, validateImagePreset) },
-			slice: { presets: mergePresets("slice", SLICE_BUILT_IN_PRESETS, plugins.slice, validateImagePreset) },
-			video: {
-				presets: mergePresets("video", VIDEO_BUILT_IN_PRESETS, plugins.video, validateVideoPreset),
-				ffmpegPath: binaryPathOverride(projectRoot, plugins.video, "ffmpegPath"),
-				ffprobePath: binaryPathOverride(projectRoot, plugins.video, "ffprobePath")
-			},
-			audio: { presets: mergePresets("audio", AUDIO_BUILT_IN_PRESETS, plugins.audio, validateAudioPreset) }
+/** Deterministic UTF-16 code-unit ordering, independent of host locale. */
+function compareCodeUnits(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function stringify(value) {
+	if (value === void 0) return "null";
+	if (value === null || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+	if (typeof value === "string") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stringify).join(",")}]`;
+	if (typeof value === "object") {
+		const record = value;
+		const parts = [];
+		for (const key of Object.keys(record).sort()) {
+			if (record[key] === void 0) continue;
+			parts.push(`${JSON.stringify(key)}:${stringify(record[key])}`);
 		}
-	};
+		return `{${parts.join(",")}}`;
+	}
+	throw new Error(`Cannot canonicalize a ${typeof value} value.`);
 }
-/** Load `fundus.config.ts` from the host project root. */
-async function loadConfig(projectRoot) {
-	const root = resolve(projectRoot);
-	const configPath = resolve(root, "fundus.config.ts");
-	if (!existsSync(configPath)) throw new Error(`No fundus.config.ts found in ${root}.`);
-	let module;
-	try {
-		module = await createJiti(import.meta.url, { interopDefault: false }).import(configPath);
-	} catch (cause) {
-		throw new Error(`Cannot load fundus.config.ts: ${cause instanceof Error ? cause.message : String(cause)}`);
+//#endregion
+//#region src/lib/core/reference-graph.ts
+/**
+* Ask each asset's owning plugin for the references in its parameters. Assets
+* whose type is unknown or whose parameters do not validate contribute no
+* references — those problems are reported by the regular validation pass.
+*/
+function collectAllReferences(library, plugins) {
+	const referencesByAsset = {};
+	for (const [assetId, record] of Object.entries(library.assets)) {
+		referencesByAsset[assetId] = [];
+		const plugin = plugins[record.type];
+		if (!plugin?.collectReferences) continue;
+		try {
+			referencesByAsset[assetId] = plugin.collectReferences(plugin.validateParameters(record.parameters));
+		} catch {}
+	}
+	return referencesByAsset;
+}
+/**
+* Reference *errors* (they block build/codegen): a reference to an unknown
+* asset, a target whose type is not among the field's expected types, and
+* cycles (composition is acyclic by nature).
+*/
+function referenceErrors(library, referencesByAsset) {
+	const issues = [];
+	for (const [assetId, references] of Object.entries(referencesByAsset)) for (const reference of references) {
+		if (!Object.hasOwn(library.assets, reference.assetId)) {
+			issues.push({
+				assetId,
+				message: `Reference "${reference.field}" points at unknown asset "${reference.assetId}".`
+			});
+			continue;
+		}
+		const targetType = library.assets[reference.assetId].type;
+		if (reference.expectedTypes.length > 0 && !reference.expectedTypes.includes(targetType)) issues.push({
+			assetId,
+			message: `Reference "${reference.field}" points at "${reference.assetId}" of type "${targetType}" — expected ${reference.expectedTypes.map((type) => `"${type}"`).join(" or ")}.`
+		});
+	}
+	issues.push(...cycleErrors(referencesByAsset));
+	return issues;
+}
+/** DFS cycle detection with an explicit stack path; each cycle reported once. */
+function cycleErrors(referencesByAsset) {
+	const issues = [];
+	const finished = /* @__PURE__ */ new Set();
+	const reportedCycles = /* @__PURE__ */ new Set();
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	function visit(assetId) {
+		if (finished.has(assetId)) return;
+		if (onStack.has(assetId)) {
+			const cyclePath = [...stack.slice(stack.indexOf(assetId)), assetId];
+			const cycleKey = [...new Set(cyclePath)].sort().join("\0");
+			if (!reportedCycles.has(cycleKey)) {
+				reportedCycles.add(cycleKey);
+				issues.push({
+					assetId: cyclePath[0],
+					message: `Reference cycle: ${cyclePath.map((id) => `"${id}"`).join(" → ")} — references express composition and must stay acyclic.`
+				});
+			}
+			return;
+		}
+		stack.push(assetId);
+		onStack.add(assetId);
+		for (const reference of referencesByAsset[assetId] ?? []) if (Object.hasOwn(referencesByAsset, reference.assetId)) visit(reference.assetId);
+		stack.pop();
+		onStack.delete(assetId);
+		finished.add(assetId);
+	}
+	for (const assetId of Object.keys(referencesByAsset)) visit(assetId);
+	return issues;
+}
+/**
+* The transitive reference closure of a set of assets, including the starting
+* set — the assets that must be delivered so the starting set renders as
+* authored. Tolerates cycles and ignores dangling targets (both are reported
+* as errors by `referenceErrors`).
+*/
+function referenceClosure(assetIds, referencesByAsset) {
+	const closure = /* @__PURE__ */ new Set();
+	const pending = [...assetIds];
+	while (pending.length > 0) {
+		const assetId = pending.pop();
+		if (closure.has(assetId) || !Object.hasOwn(referencesByAsset, assetId)) continue;
+		closure.add(assetId);
+		for (const reference of referencesByAsset[assetId]) pending.push(reference.assetId);
+	}
+	return closure;
+}
+/**
+* A dependencies-first order over `assetIds` and everything they transitively
+* reference — the build order that lets each entry inline its references from
+* already-built entries. Throws on a cycle (with the cycle path).
+*/
+function topologicalReferenceOrder(assetIds, referencesByAsset) {
+	const order = [];
+	const finished = /* @__PURE__ */ new Set();
+	const stack = [];
+	const onStack = /* @__PURE__ */ new Set();
+	function visit(assetId) {
+		if (finished.has(assetId) || !Object.hasOwn(referencesByAsset, assetId)) return;
+		if (onStack.has(assetId)) {
+			const cyclePath = [...stack.slice(stack.indexOf(assetId)), assetId];
+			throw new Error(`Reference cycle: ${cyclePath.map((id) => `"${id}"`).join(" → ")} — cannot order entries.`);
+		}
+		stack.push(assetId);
+		onStack.add(assetId);
+		for (const reference of referencesByAsset[assetId]) visit(reference.assetId);
+		stack.pop();
+		onStack.delete(assetId);
+		finished.add(assetId);
+		order.push(assetId);
+	}
+	for (const assetId of assetIds) visit(assetId);
+	return order;
+}
+//#endregion
+//#region src/lib/core/manifest-membership.ts
+/**
+* Compute the full membership picture from a library and its collected
+* references: for each manifest the explicit members, the passive members
+* (`referenceClosure(explicit) − explicit`) with their via-attribution, and
+* the resulting delivery set.
+*/
+function computeLibraryMembership(library, referencesByAsset) {
+	const manifestNames = new Set(Object.keys(library.manifests));
+	for (const record of Object.values(library.assets)) for (const manifestName of record.manifests) manifestNames.add(manifestName);
+	const membership = {};
+	for (const manifestName of [...manifestNames].sort(compareCodeUnits)) {
+		const explicitMemberIds = Object.entries(library.assets).filter(([, record]) => record.manifests.includes(manifestName)).map(([assetId]) => assetId).sort(compareCodeUnits);
+		const explicitMemberSet = new Set(explicitMemberIds);
+		const deliveredAssetIds = new Set(explicitMemberIds);
+		const viaByPassiveAssetId = /* @__PURE__ */ new Map();
+		for (const explicitMemberId of explicitMemberIds) for (const reachedAssetId of referenceClosure([explicitMemberId], referencesByAsset)) {
+			deliveredAssetIds.add(reachedAssetId);
+			if (explicitMemberSet.has(reachedAssetId)) continue;
+			const via = viaByPassiveAssetId.get(reachedAssetId) ?? [];
+			via.push(explicitMemberId);
+			viaByPassiveAssetId.set(reachedAssetId, via);
+		}
+		membership[manifestName] = {
+			explicitMemberIds,
+			passiveMembers: [...viaByPassiveAssetId.entries()].map(([assetId, via]) => ({
+				assetId,
+				via
+			})).sort((a, b) => compareCodeUnits(a.assetId, b.assetId)),
+			deliveredAssetIds
+		};
 	}
-	return resolveConfig(root, isRecord(module) && "default" in module ? module.default : module);
+	return membership;
+}
+/**
+* Every asset delivered by at least one manifest, explicitly or passively —
+* the processing set (assets outside it are inert). An asset is
+* *unreachable* (nothing delivers it) exactly when it is missing here.
+*/
+function allDeliveredAssetIds(membership) {
+	const delivered = /* @__PURE__ */ new Set();
+	for (const manifestMembership of Object.values(membership)) for (const assetId of manifestMembership.deliveredAssetIds) delivered.add(assetId);
+	return delivered;
 }
 //#endregion
-//#region src/processing/ffmpeg.ts
+//#region src/lib/server/processing/ffmpeg.ts
 /**
 * The ffmpeg/ffprobe toolchain layer: binary resolution (bundled `-static`
 * packages by default, with host-config overrides) and a spawn helper.
@@ -117,7 +360,7 @@ async function runToolchainBinary(binaryPath, commandArguments) {
 	}
 }
 //#endregion
-//#region src/processing/media-probe.ts
+//#region src/lib/server/processing/media-probe.ts
 /** Parse ffprobe's JSON output (pure, testable without a binary). */
 function parseProbeOutput(json, filePath) {
 	const output = JSON.parse(json);
@@ -144,13 +387,13 @@ async function probeMedia(filePath, config) {
 	]), filePath);
 }
 //#endregion
-//#region src/processing/audio-processing.ts
+//#region src/lib/server/processing/audio-processing.ts
 /**
 * The ffmpeg transcode step of the audio plugin: one audio-only proxy per
 * preset (opus/webm or aac/m4a). Deterministic like the video step:
 * metadata stripped, bitexact muxing.
 */
-const ENCODER_BY_CODEC = {
+var ENCODER_BY_CODEC = {
 	opus: "libopus",
 	aac: "aac"
 };
@@ -187,7 +430,29 @@ async function processAudioFile(options) {
 	return { durationMs: (await probeMedia(options.targetPath, options.config)).durationMs };
 }
 //#endregion
-//#region src/plugins/contract.ts
+//#region src/lib/server/plugins/config.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergePresets(options) {
+	const { label, builtIn, pluginConfig, validatePreset } = options;
+	const merged = { ...builtIn };
+	if (pluginConfig === void 0) return merged;
+	if (!isRecord(pluginConfig)) throw new Error(`fundus.config: "plugins.${label}" must be an object.`);
+	if (pluginConfig.presets === void 0) return merged;
+	if (!isRecord(pluginConfig.presets)) throw new Error(`fundus.config: "plugins.${label}.presets" must be an object.`);
+	for (const [name, preset] of Object.entries(pluginConfig.presets)) merged[name] = validatePreset(name, preset);
+	return merged;
+}
+function binaryPathOverride(options) {
+	const { projectRoot, pluginConfig, label, key } = options;
+	if (!isRecord(pluginConfig) || pluginConfig[key] === void 0) return null;
+	const value = pluginConfig[key];
+	if (typeof value !== "string" || value.length === 0) throw new Error(`fundus.config: "plugins.${label}.${key}" must be a non-empty string.`);
+	return isAbsolute(value) ? value : resolve(projectRoot, value);
+}
+//#endregion
+//#region src/lib/server/plugins/contract.ts
 /** Resolve a named preset out of a plugin's merged preset map, or throw listing the known names. */
 function resolveNamedPreset(label, presetName, presets) {
 	const preset = presets[presetName];
@@ -201,32 +466,7 @@ function requireProxyField(proxy, field) {
 	return value;
 }
 //#endregion
-//#region src/plugins/audio.ts
-/**
-* Audio plugin (server part): one ffmpeg transcode per preset.
-* No dimensions — the proxy's only output metadata is its duration.
-*/
-const audioServerPlugin = {
-	descriptor: audioPlugin,
-	pluginConfig: (config) => config.plugins.audio,
-	presets: (config) => config.plugins.audio.presets,
-	resolvePreset: (parameters, config) => resolveNamedPreset("audio", parameters.preset, config.plugins.audio.presets),
-	proxyExtension: (preset) => preset.container,
-	process: (job) => processAudioFile({
-		sourcePath: job.sourcePath,
-		targetPath: job.targetPath,
-		preset: job.preset,
-		config: job.config
-	}),
-	readProxyInfo: (proxyPath, config) => probeMedia(proxyPath, config),
-	buildManifestEntry: ({ src, proxy }) => ({
-		kind: "audio",
-		src,
-		durationMs: requireProxyField(proxy, "durationMs")
-	})
-};
-//#endregion
-//#region src/processing/video-processing.ts
+//#region src/lib/server/processing/video-processing.ts
 /**
 * 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
@@ -309,15 +549,95 @@ async function processVideoFile(options) {
 	};
 }
 //#endregion
-//#region src/plugins/chroma-key-video.ts
+//#region src/lib/server/plugins/video.ts
+/**
+* Video plugin (server part): one ffmpeg transcode per preset.
+*/
+var videoConfigDefinition = {
+	namespace: "video",
+	resolve: ({ projectRoot, value }) => ({
+		presets: mergePresets({
+			label: "video",
+			builtIn: VIDEO_BUILT_IN_PRESETS,
+			pluginConfig: value,
+			validatePreset: validateVideoPreset
+		}),
+		ffmpegPath: binaryPathOverride({
+			projectRoot,
+			pluginConfig: value,
+			label: "video",
+			key: "ffmpegPath"
+		}),
+		ffprobePath: binaryPathOverride({
+			projectRoot,
+			pluginConfig: value,
+			label: "video",
+			key: "ffprobePath"
+		})
+	})
+};
+var videoServerPlugin = {
+	descriptor: videoPlugin,
+	configDefinitions: [videoConfigDefinition],
+	pluginConfig: (config) => config.plugins.video,
+	presets: (config) => config.plugins.video.presets,
+	resolvePreset: (parameters, config) => resolveNamedPreset("video", parameters.preset, config.plugins.video.presets),
+	proxyExtension: (preset) => preset.container,
+	process: (job) => processVideoFile({
+		sourcePath: job.sourcePath,
+		targetPath: job.targetPath,
+		preset: job.preset,
+		maxWidth: job.parameters.maxWidth,
+		config: job.config
+	}),
+	readProxyInfo: (proxyPath, config) => probeMedia(proxyPath, config),
+	buildManifestEntry: ({ src, proxy }) => ({
+		kind: "video",
+		src,
+		width: requireProxyField(proxy, "width"),
+		height: requireProxyField(proxy, "height"),
+		durationMs: requireProxyField(proxy, "durationMs")
+	})
+};
+var audioServerPlugin = {
+	descriptor: audioPlugin,
+	configDefinitions: [{
+		namespace: "audio",
+		resolve: ({ value }) => ({ presets: mergePresets({
+			label: "audio",
+			builtIn: AUDIO_BUILT_IN_PRESETS,
+			pluginConfig: value,
+			validatePreset: validateAudioPreset
+		}) })
+	}, videoConfigDefinition],
+	pluginConfig: (config) => config.plugins.audio,
+	presets: (config) => config.plugins.audio.presets,
+	resolvePreset: (parameters, config) => resolveNamedPreset("audio", parameters.preset, config.plugins.audio.presets),
+	proxyExtension: (preset) => preset.container,
+	process: (job) => processAudioFile({
+		sourcePath: job.sourcePath,
+		targetPath: job.targetPath,
+		preset: job.preset,
+		config: job.config
+	}),
+	readProxyInfo: (proxyPath, config) => probeMedia(proxyPath, config),
+	buildManifestEntry: ({ src, proxy }) => ({
+		kind: "audio",
+		src,
+		durationMs: requireProxyField(proxy, "durationMs")
+	})
+};
+//#endregion
+//#region src/lib/server/plugins/chroma-key-video.ts
 /**
 * Chroma-key-video plugin (server part): shares the video plugin's transcode
 * pipeline and preset namespace — the keying parameters and the
 * mask/fallback references never reach ffmpeg, they are entry-only data
 * (the descriptor's `processingParameters` keeps them out of the job hash).
 */
-const chromaKeyVideoServerPlugin = {
+var chromaKeyVideoServerPlugin = {
 	descriptor: chromaKeyVideoPlugin,
+	configDefinitions: [videoConfigDefinition],
 	pluginConfig: (config) => config.plugins.video,
 	presets: (config) => config.plugins.video.presets,
 	resolvePreset: (parameters, config) => resolveNamedPreset("video", parameters.preset, config.plugins.video.presets),
@@ -342,7 +662,7 @@ const chromaKeyVideoServerPlugin = {
 	})
 };
 //#endregion
-//#region src/processing/image-processing.ts
+//#region src/lib/server/processing/image-processing.ts
 /**
 * The sharp step shared by the image and slice plugins: optional resize to a
 * target width, format conversion per preset, write the proxy file. Returns
@@ -369,16 +689,26 @@ async function readImageDimensions(filePath) {
 	};
 }
 //#endregion
-//#region src/plugins/image.ts
+//#region src/lib/server/plugins/image.ts
 /**
 * Image plugin (server part): sharp scale + convert per preset.
 */
+var imageConfigDefinition = {
+	namespace: "image",
+	resolve: ({ value }) => ({ presets: mergePresets({
+		label: "image",
+		builtIn: IMAGE_BUILT_IN_PRESETS,
+		pluginConfig: value,
+		validatePreset: validateImagePreset
+	}) })
+};
 /** The delivered file extension of an image-preset format. */
 function extensionForImageFormat(format) {
 	return format === "jpeg" ? "jpg" : format;
 }
-const imageServerPlugin = {
+var imageServerPlugin = {
 	descriptor: imagePlugin,
+	configDefinitions: [imageConfigDefinition],
 	pluginConfig: (config) => config.plugins.image,
 	presets: (config) => config.plugins.image.presets,
 	resolvePreset: (parameters, config) => resolveNamedPreset("image", parameters.preset, config.plugins.image.presets),
@@ -398,12 +728,21 @@ const imageServerPlugin = {
 	})
 };
 //#endregion
-//#region src/plugins/slice.ts
+//#region src/lib/server/plugins/slice.ts
 /**
 * Slice plugin (server part): the same sharp conversion as the image plugin,
 * never resized — insets are authored in source pixels, so the delivered proxy
 * keeps the source dimensions. The slicing data is entry-only.
 */
+var sliceConfigDefinition = {
+	namespace: "slice",
+	resolve: ({ value }) => ({ presets: mergePresets({
+		label: "slice",
+		builtIn: SLICE_BUILT_IN_PRESETS,
+		pluginConfig: value,
+		validatePreset: validateImagePreset
+	}) })
+};
 function hasAnySide(insets) {
 	if (!insets) return false;
 	return insets.top > 0 || insets.right > 0 || insets.bottom > 0 || insets.left > 0;
@@ -418,8 +757,9 @@ function detectPixelRatio(fileName) {
 	const ratio = match ? Number(match[1]) : 1;
 	return ratio >= 1 ? ratio : 1;
 }
-const sliceServerPlugin = {
+var sliceServerPlugin = {
 	descriptor: slicePlugin,
+	configDefinitions: [sliceConfigDefinition],
 	pluginConfig: (config) => config.plugins.slice,
 	presets: (config) => config.plugins.slice.presets,
 	resolvePreset: (parameters, config) => resolveNamedPreset("slice", parameters.preset, config.plugins.slice.presets),
@@ -454,41 +794,15 @@ const sliceServerPlugin = {
 	}
 };
 //#endregion
-//#region src/plugins/video.ts
-/**
-* Video plugin (server part): one ffmpeg transcode per preset.
-*/
-const videoServerPlugin = {
-	descriptor: videoPlugin,
-	pluginConfig: (config) => config.plugins.video,
-	presets: (config) => config.plugins.video.presets,
-	resolvePreset: (parameters, config) => resolveNamedPreset("video", parameters.preset, config.plugins.video.presets),
-	proxyExtension: (preset) => preset.container,
-	process: (job) => processVideoFile({
-		sourcePath: job.sourcePath,
-		targetPath: job.targetPath,
-		preset: job.preset,
-		maxWidth: job.parameters.maxWidth,
-		config: job.config
-	}),
-	readProxyInfo: (proxyPath, config) => probeMedia(proxyPath, config),
-	buildManifestEntry: ({ src, proxy }) => ({
-		kind: "video",
-		src,
-		width: requireProxyField(proxy, "width"),
-		height: requireProxyField(proxy, "height"),
-		durationMs: requireProxyField(proxy, "durationMs")
-	})
-};
-//#endregion
-//#region src/plugins.ts
-const serverPluginsByType = {
+//#region src/lib/server/plugins.ts
+var serverPluginCatalogue = {
 	[imageServerPlugin.descriptor.type]: imageServerPlugin,
 	[sliceServerPlugin.descriptor.type]: sliceServerPlugin,
 	[videoServerPlugin.descriptor.type]: videoServerPlugin,
 	[chromaKeyVideoServerPlugin.descriptor.type]: chromaKeyVideoServerPlugin,
 	[audioServerPlugin.descriptor.type]: audioServerPlugin
 };
+var serverPluginsByType = plugins.project(serverPluginCatalogue, "server implementation");
 function serverPluginForType(type, registry = serverPluginsByType) {
 	const plugin = registry[type];
 	if (!plugin) throw new Error(`Unknown asset type "${type}" (known: ${Object.keys(registry).sort().join(", ")}).`);
@@ -498,8 +812,7 @@ function serverPluginForType(type, registry = serverPluginsByType) {
 function descriptorsByType(registry) {
 	return Object.fromEntries(Object.entries(registry).map(([type, plugin]) => [type, plugin.descriptor]));
 }
-/** The built-in registry's descriptor map (the common case; registry-aware code derives its own). */
-const pluginsByType = descriptorsByType(serverPluginsByType);
+descriptorsByType(serverPluginsByType);
 /**
 * The job-hash parameter input for an asset: the plugin-declared
 * processing-relevant subset when the plugin distinguishes one (chroma-key-
@@ -509,7 +822,7 @@ function processingParametersOf(plugin, parameters) {
 	return plugin.processingParameters ? plugin.processingParameters(parameters) : parameters;
 }
 //#endregion
-//#region src/codegen.ts
+//#region src/lib/server/codegen.ts
 /**
 * Manifest module codegen: one `<manifest-name-kebab>.generated.ts`
 * per manifest in the configured manifests directory, containing data only —
@@ -517,7 +830,7 @@ function processingParametersOf(plugin, parameters) {
 * sorted asset ids, fixed property order, tab indentation. Generated modules
 * for deleted manifests are removed (only files carrying the fundus header).
 */
-const GENERATED_HEADER = "// generated by fundus — do not edit\n";
+var GENERATED_HEADER = "// generated by fundus — do not edit\n";
 /** `mainCatalog` → `main-catalog`. */
 function kebabCaseFromCamel(name) {
 	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
@@ -664,7 +977,7 @@ function jobHash(rawHash, parameters, pipelineVersion = 1) {
 	return createHash("sha256").update(rawHash + canonicalizeParameters(parameters) + String(pipelineVersion)).digest("hex").slice(0, 8);
 }
 //#endregion
-//#region src/folder-filesystem.ts
+//#region src/lib/server/folder-filesystem.ts
 async function ensureManagedFolder(root, folder) {
 	const directory = join(root, folder);
 	await mkdir(directory, { recursive: true });
@@ -691,7 +1004,7 @@ function encodeRelativePathForUrl(path) {
 	return path.split("/").map(encodeURIComponent).join("/");
 }
 //#endregion
-//#region src/processing/processor.ts
+//#region src/lib/server/processing/processor.ts
 /**
 * The processing pipeline: every delivered asset gets exactly one
 * proxy named `<assetId>.<jobHash>.<extension>`. Delivered = explicit or
@@ -708,7 +1021,7 @@ function encodeRelativePathForUrl(path) {
 * drive the pipeline with fixture asset types.
 */
 /** 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]+$/;
+var 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. */
 function isProxyFileName(fileName) {
 	return PROXY_FILE_PATTERN.test(fileName);
@@ -845,7 +1158,7 @@ async function processAssets(config, library, registry = serverPluginsByType) {
 	return report;
 }
 //#endregion
-//#region src/library-store.ts
+//#region src/lib/server/library-store.ts
 /**
 * The fs-backed store over the library file (SSOT) and the raw directory.
 * Every mutation is load → modify → deterministic write, so the file on disk
@@ -853,7 +1166,7 @@ async function processAssets(config, library, registry = serverPluginsByType) {
 * store only removes them on asset deletion (the pipeline also prunes orphans).
 */
 /** A single path segment with no traversal — guards against `../` escapes. */
-const SAFE_SEGMENT = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var SAFE_SEGMENT = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 function assertSafeFileName(fileName) {
 	if (!SAFE_SEGMENT.test(fileName) || fileName.includes("/") || fileName.includes("\\")) throw new Error(`Unsafe file name "${fileName}".`);
 }
@@ -1450,348 +1763,6 @@ var LibraryStore = class {
 		if (collision !== void 0) throw new Error(`Folder "${path}" collides with existing folder "${collision}".`);
 	}
 };
-//#endregion
-//#region src/operations.ts
-/**
-* The one operations layer: builds the state payload and runs
-* every mutation through the autosave chain — write library → process affected
-* assets → regenerate codegen → return fresh state. Both the REST server
-* and the CLI consume this class, so every
-* operation has exactly one implementation and there is no other save path.
-*/
-/**
-* The CLI's `--parameters` merge semantics (M7): a SHALLOW merge at the top
-* level onto the current parameters — a nested object value replaces the whole
-* current object under that key, a top-level `null` clears an optional field,
-* and an asset reference is set with the normal `{"$asset": "<id>"}` marker.
-* The merged result still passes the owning plugin's full validation.
-*/
-function mergeParameterPatch(currentParameters, patch) {
-	if (typeof patch !== "object" || patch === null || Array.isArray(patch)) throw new Error("The parameter patch must be a JSON object, e.g. {\"preset\": \"default\"}.");
-	const merged = typeof currentParameters === "object" && currentParameters !== null && !Array.isArray(currentParameters) ? { ...currentParameters } : {};
-	for (const [key, value] of Object.entries(patch)) if (value === null) delete merged[key];
-	else merged[key] = value;
-	return merged;
-}
-var FundusOperations = class {
-	#config;
-	#registry;
-	#store;
-	constructor(config, registry = serverPluginsByType) {
-		this.#config = config;
-		this.#registry = registry;
-		this.#store = new LibraryStore(config, registry);
-	}
-	get config() {
-		return this.#config;
-	}
-	get store() {
-		return this.#store;
-	}
-	/** Read-only state snapshot (no processing). */
-	async state() {
-		return this.#buildState(await this.#store.read(), []);
-	}
-	/**
-	* Ingest an upload: store the raw file + record, then let the owning
-	* plugin's optional `seedIngestParameters` derive better starting
-	* parameters from the stored raw file (slices: insets from the image
-	* dimensions, pixel ratio from the file name — the schema default can't
-	* know either). The CLI additionally applies a parameter patch and/or an
-	* explicit membership set in the same operation; a failing application
-	* rolls the whole ingest back, so a failed ingest leaves nothing behind.
-	*/
-	async ingest(options) {
-		let library = await this.#store.ingest(options);
-		try {
-			const plugin = serverPluginForType(options.type, this.#registry);
-			if (plugin.seedIngestParameters) {
-				const record = library.assets[options.id];
-				const seeded = await plugin.seedIngestParameters({
-					rawPath: join(this.#config.rawDir, record.raw),
-					rawFileName: rawFileNameOfPath(record.raw),
-					parameters: plugin.descriptor.validateParameters(record.parameters),
-					config: this.#config
-				});
-				if (seeded !== void 0) library = await this.#store.updateParameters(options.id, seeded);
-			}
-			if (options.parametersPatch !== void 0 || options.manifests !== void 0) library = await this.#applyAssetChanges(library, options.id, {
-				parametersPatch: options.parametersPatch,
-				manifests: options.manifests
-			});
-		} catch (cause) {
-			await this.#store.deleteAsset(options.id);
-			throw cause;
-		}
-		return this.#afterMutation(library);
-	}
-	/** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
-	async patchAsset(id, body) {
-		let library = await this.#store.read();
-		this.#requireAsset(library, id);
-		if (body.parameters !== void 0) library = await this.#store.updateParameters(id, body.parameters);
-		if (body.manifests !== void 0) {
-			if (!Array.isArray(body.manifests) || body.manifests.some((name) => typeof name !== "string")) throw new Error("\"manifests\" must be an array of manifest names.");
-			library = await this.#store.setManifests(id, body.manifests);
-		}
-		if (body.renameTo !== void 0) {
-			if (typeof body.renameTo !== "string") throw new Error("\"renameTo\" must be a string.");
-			library = await this.#store.renameAsset(id, body.renameTo);
-		}
-		if (body.folder !== void 0) {
-			if (typeof body.folder !== "string") throw new Error("\"folder\" must be a string.");
-			library = await this.#store.moveAsset(body.renameTo ?? id, body.folder);
-		}
-		return this.#afterMutation(library);
-	}
-	async moveAsset(id, folder) {
-		return this.#afterMutation(await this.#store.moveAsset(id, folder));
-	}
-	/** Move a selected asset set as one editor action and roll back on any failure. */
-	async moveAssets(assetIds, folder) {
-		const uniqueIds = [...new Set(assetIds)];
-		if (uniqueIds.length === 0) throw new Error("At least one asset id is required.");
-		const originalFolders = /* @__PURE__ */ new Map();
-		const library = await this.#store.read();
-		for (const id of uniqueIds) {
-			this.#requireAsset(library, id);
-			originalFolders.set(id, folderOfRawPath(library.assets[id].raw));
-		}
-		const movedIds = [];
-		try {
-			let updated = library;
-			for (const id of uniqueIds) {
-				if (originalFolders.get(id) === folder) continue;
-				updated = await this.#store.moveAsset(id, folder);
-				movedIds.push(id);
-			}
-			return this.#afterMutation(updated);
-		} catch (cause) {
-			for (const id of movedIds.reverse()) await this.#store.moveAsset(id, originalFolders.get(id) ?? "");
-			throw cause;
-		}
-	}
-	async createFolder(path) {
-		return this.#afterMutation(await this.#store.createFolder(path));
-	}
-	async renameFolder(path, newName) {
-		return this.#afterMutation(await this.#store.renameFolder(path, newName));
-	}
-	async moveFolder(path, parent) {
-		return this.#afterMutation(await this.#store.moveFolder(path, parent));
-	}
-	async deleteFolder(path) {
-		const result = await this.#store.deleteFolder(path);
-		return this.#afterMutation(result.library);
-	}
-	/**
-	* CLI-facing asset update (M7): shallow-merge a parameter patch and/or
-	* replace the explicit manifest membership — validating the *result* before
-	* anything is persisted, so a change that would leave the library invalid
-	* (dangling or cyclic reference, unknown manifest, invalid parameters) is
-	* rejected with nothing written. The REST `patchAsset` keeps the editor's
-	* lenient replace semantics.
-	*/
-	async setAsset(id, changes) {
-		const library = await this.#store.read();
-		this.#requireAsset(library, id);
-		return this.#afterMutation(await this.#applyAssetChanges(library, id, changes));
-	}
-	/**
-	* CLI-facing rename (M7): rejects a rename that would break references —
-	* a referrer keeps pointing at the old id, so renaming a referenced asset
-	* introduces dangling-reference errors. Update the referrers first.
-	*/
-	async renameAsset(id, newId) {
-		const library = await this.#store.read();
-		this.#requireAsset(library, id);
-		if (newId !== id && !Object.hasOwn(library.assets, newId)) {
-			const candidate = structuredClone(library);
-			candidate.assets[newId] = candidate.assets[id];
-			delete candidate.assets[id];
-			await this.#assertNoIntroducedIssues(library, candidate);
-		}
-		return this.#afterMutation(await this.#store.renameAsset(id, newId));
-	}
-	/**
-	* Delete an asset: the record, its raw file, and its proxies. With
-	* `failOnIntroducedIssues` (the CLI), a delete that would break references
-	* (the asset is a reference target) is rejected before anything —
-	* including the raw file — is removed; the REST route stays lenient.
-	*/
-	async deleteAsset(id, options) {
-		if (options?.failOnIntroducedIssues) {
-			const library = await this.#store.read();
-			this.#requireAsset(library, id);
-			const candidate = structuredClone(library);
-			delete candidate.assets[id];
-			await this.#assertNoIntroducedIssues(library, candidate);
-		}
-		return this.#afterMutation(await this.#store.deleteAsset(id));
-	}
-	/** Delete a selected asset set as one lenient editor mutation. */
-	async deleteAssets(assetIds) {
-		const uniqueIds = [...new Set(assetIds)];
-		if (uniqueIds.length === 0) throw new Error("At least one asset id is required.");
-		return this.#afterMutation(await this.#store.deleteAssets(uniqueIds));
-	}
-	async createManifest(name) {
-		return this.#afterMutation(await this.#store.createManifest(name));
-	}
-	async setManifestAppearance(name, appearance) {
-		return this.#afterMutation(await this.#store.setManifestAppearance(name, appearance));
-	}
-	/** Apply a PATCH body: appearance fields and/or a rename — in that order. */
-	async patchManifest(name, body) {
-		let library = await this.#store.setManifestAppearance(name, {
-			color: body.color,
-			emoji: body.emoji
-		});
-		if (body.renameTo !== void 0) {
-			if (typeof body.renameTo !== "string") throw new Error("\"renameTo\" must be a string.");
-			library = await this.#store.renameManifest(name, body.renameTo);
-		}
-		return this.#afterMutation(library);
-	}
-	/**
-	* Rename a manifest: rewrites every asset's membership and replaces the
-	* generated module (the old one is pruned as a stray). Host code importing
-	* the module must be updated by hand — both the file name and the exported
-	* const change with the manifest name.
-	*/
-	async renameManifest(name, newName) {
-		return this.#afterMutation(await this.#store.renameManifest(name, newName));
-	}
-	async deleteManifest(name) {
-		return this.#afterMutation(await this.#store.deleteManifest(name));
-	}
-	/** The autosave chain tail: process + regenerate, then report fresh state. */
-	async #afterMutation(library) {
-		const pipelineIssues = [];
-		const issues = await this.#store.validate(library);
-		if (issues.length === 0) try {
-			const report = await processAssets(this.#config, library, this.#registry);
-			await generateManifestModules(this.#config, library, report.proxies, this.#registry);
-		} catch (cause) {
-			pipelineIssues.push({ message: `Processing failed: ${cause instanceof Error ? cause.message : String(cause)}` });
-		}
-		return this.#buildState(library, pipelineIssues, issues);
-	}
-	async #buildState(library, extraIssues, precomputedIssues) {
-		const issues = [...precomputedIssues ?? await this.#store.validate(library), ...extraIssues];
-		const referencesByAsset = collectAllReferences(library, descriptorsByType(this.#registry));
-		const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
-		const delivered = allDeliveredAssetIds(membershipByManifest);
-		const passiveManifestsByAsset = /* @__PURE__ */ new Map();
-		for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) for (const passiveMember of membershipByManifest[manifestName].passiveMembers) {
-			const passiveManifests = passiveManifestsByAsset.get(passiveMember.assetId) ?? [];
-			passiveManifests.push({
-				manifest: manifestName,
-				via: passiveMember.via
-			});
-			passiveManifestsByAsset.set(passiveMember.assetId, passiveManifests);
-		}
-		const incomingByAsset = /* @__PURE__ */ new Map();
-		for (const [referrerId, references] of Object.entries(referencesByAsset)) for (const reference of references) {
-			const incoming = incomingByAsset.get(reference.assetId) ?? [];
-			incoming.push({
-				field: reference.field,
-				assetId: referrerId
-			});
-			incomingByAsset.set(reference.assetId, incoming);
-		}
-		const assets = [];
-		for (const assetId of Object.keys(library.assets).sort(compareCodeUnits)) {
-			const record = library.assets[assetId];
-			const warnings = [];
-			for (const issue of issues) if (issue.assetId === assetId) warnings.push(issue.message);
-			if (record.manifests.length === 0 && !delivered.has(assetId)) warnings.push("In no manifest and not referenced by any delivered asset — nothing is processed or generated for it.");
-			let proxy = null;
-			if (delivered.has(assetId)) try {
-				const currentProxy = await readCurrentProxy(assetId, record, this.#config, this.#registry);
-				if (currentProxy) proxy = {
-					url: `/files/proxy/${encodeRelativePathForUrl(currentProxy.relativePath)}`,
-					upToDate: true,
-					...currentProxy
-				};
-				else warnings.push("Proxy is stale or missing — it will be (re)processed on the next save.");
-			} catch (cause) {
-				warnings.push(cause instanceof Error ? cause.message : String(cause));
-			}
-			assets.push({
-				id: assetId,
-				type: record.type,
-				raw: record.raw,
-				folder: folderOfRawPath(record.raw),
-				rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}`,
-				rawHash: record.rawHash,
-				parameters: record.parameters,
-				manifests: record.manifests,
-				passiveManifests: passiveManifestsByAsset.get(assetId) ?? [],
-				proxy,
-				warnings,
-				references: {
-					outgoing: referencesByAsset[assetId].map((reference) => ({
-						field: reference.field,
-						assetId: reference.assetId
-					})),
-					incoming: incomingByAsset.get(assetId) ?? []
-				}
-			});
-		}
-		const proxySizeByAssetId = new Map(assets.filter((asset) => asset.proxy).map((asset) => [asset.id, asset.proxy?.fileSize ?? 0]));
-		const manifestMemberships = {};
-		const manifestDeliveredBytes = {};
-		for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
-			const membership = membershipByManifest[manifestName];
-			manifestMemberships[manifestName] = {
-				explicitMemberIds: membership.explicitMemberIds,
-				passiveMembers: membership.passiveMembers
-			};
-			let deliveredBytes = 0;
-			for (const deliveredAssetId of membership.deliveredAssetIds) deliveredBytes += proxySizeByAssetId.get(deliveredAssetId) ?? 0;
-			manifestDeliveredBytes[manifestName] = deliveredBytes;
-		}
-		const presetNames = {};
-		for (const [type, plugin] of Object.entries(this.#registry)) presetNames[type] = Object.keys(plugin.presets(this.#config)).sort();
-		return {
-			library,
-			assets,
-			issues,
-			presetNames,
-			manifestMemberships,
-			manifestDeliveredBytes
-		};
-	}
-	#requireAsset(library, id) {
-		if (!Object.hasOwn(library.assets, id)) throw new Error(`Unknown asset "${id}".`);
-	}
-	/**
-	* Apply a CLI asset change to the store, validating the resulting library
-	* on an in-memory candidate first — nothing is persisted when the change
-	* would introduce validation issues. Pre-existing issues never block an
-	* unrelated mutation (only *introduced* issues are rejected).
-	*/
-	async #applyAssetChanges(library, id, changes) {
-		const candidate = structuredClone(library);
-		const candidateRecord = candidate.assets[id];
-		if (changes.parametersPatch !== void 0) candidateRecord.parameters = serverPluginForType(candidateRecord.type, this.#registry).descriptor.validateParameters(mergeParameterPatch(candidateRecord.parameters, changes.parametersPatch));
-		if (changes.manifests !== void 0) candidateRecord.manifests = [...new Set(changes.manifests)].sort();
-		await this.#assertNoIntroducedIssues(library, candidate);
-		let updated = library;
-		if (changes.parametersPatch !== void 0) updated = await this.#store.updateParameters(id, candidateRecord.parameters);
-		if (changes.manifests !== void 0) updated = await this.#store.setManifests(id, changes.manifests);
-		return updated;
-	}
-	/** Reject a candidate library that has validation issues the current one lacks. */
-	async #assertNoIntroducedIssues(library, candidate) {
-		const existingIssueKeys = new Set((await this.#store.validate(library)).map((issue) => `${issue.assetId ?? ""}|${issue.message}`));
-		const introduced = (await this.#store.validate(candidate)).filter((issue) => !existingIssueKeys.has(`${issue.assetId ?? ""}|${issue.message}`));
-		if (introduced.length > 0) {
-			const lines = introduced.map((issue) => `  - ${issue.assetId ? `[${issue.assetId}] ` : ""}${issue.message}`);
-			throw new Error(`Rejected — the change would leave the library invalid (nothing was written):\n${lines.join("\n")}`);
-		}
-	}
-};
-//#endregion
-export { runToolchainBinary as C, ffmpegBinaryPath as S, resolveConfig as T, strayGeneratedModuleNames as _, deliveredAssetIds as a, serverPluginForType as b, isProxyFileName as c, readProxyOutputInfo as d, listRelativeFiles as f, renderManifestModule as g, manifestModuleFileName as h, sha256Hex as i, processAssets as l, generateManifestModules as m, LibraryStore as n, expectedProxyFileName as o, buildManifestEntries as p, assertSafeRelativeFilePath as r, expectedProxyRelativePath as s, FundusOperations as t, readCurrentProxy as u, descriptorsByType as v, loadConfig as w, serverPluginsByType as x, pluginsByType as y };
+
+export { LibraryStore as L, serverPluginForType as a, computeLibraryMembership as b, collectAllReferences as c, descriptorsByType as d, allDeliveredAssetIds as e, compareCodeUnits as f, generateManifestModules as g, encodeRelativePathForUrl as h, isRecord as i, assertSafeRelativeFilePath as j, processAssets as p, readCurrentProxy as r, serverPluginsByType as s };
+//# sourceMappingURL=library-store.js-ZLudCJlT.js.map