fundus 0.0.2

package/dist/operations-DYM-5KVl.js

@@ -0,0 +1,1797 @@
+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
+/**
+* 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.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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.`);
+	return value;
+}
+function resolvePath(projectRoot, value) {
+	return isAbsolute(value) ? value : resolve(projectRoot, value);
+}
+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;
+}
+/** `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) }
+		}
+	};
+}
+/** 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)}`);
+	}
+	return resolveConfig(root, isRecord(module) && "default" in module ? module.default : module);
+}
+//#endregion
+//#region src/processing/ffmpeg.ts
+/**
+* The ffmpeg/ffprobe toolchain layer: binary resolution (bundled `-static`
+* packages by default, with host-config overrides) and a spawn helper.
+* Since proxies are committed, this toolchain is only needed where
+* assets are authored/processed — host builds and CI never invoke it.
+*/
+function ffmpegBinaryPath(config) {
+	if (config.plugins.video.ffmpegPath) return config.plugins.video.ffmpegPath;
+	if (!ffmpegStaticPath) throw new Error("ffmpeg-static provides no binary for this platform — set \"plugins.video.ffmpegPath\" in fundus.config.ts.");
+	return ffmpegStaticPath;
+}
+function ffprobeBinaryPath(config) {
+	if (config.plugins.video.ffprobePath) return config.plugins.video.ffprobePath;
+	if (!path) throw new Error("ffprobe-static provides no binary for this platform — set \"plugins.video.ffprobePath\" in fundus.config.ts.");
+	return path;
+}
+/**
+* Run a toolchain binary with an argument array (never a shell string) and
+* return its stdout. A non-zero exit throws with the stderr tail — ffmpeg
+* writes its diagnostics there.
+*/
+async function runToolchainBinary(binaryPath, commandArguments) {
+	try {
+		const { stdout } = await promisify(execFile)(binaryPath, commandArguments, {
+			encoding: "utf8",
+			maxBuffer: 16 * 1024 * 1024
+		});
+		return stdout;
+	} catch (cause) {
+		const failure = cause;
+		const diagnostics = (failure.stderr ?? failure.message).trim().split("\n").slice(-12).join("\n");
+		throw new Error(`${basename(binaryPath)} exited with code ${failure.code ?? "unknown"}:\n${diagnostics}`);
+	}
+}
+//#endregion
+//#region src/processing/media-probe.ts
+/** Parse ffprobe's JSON output (pure, testable without a binary). */
+function parseProbeOutput(json, filePath) {
+	const output = JSON.parse(json);
+	const videoStream = output.streams?.find((stream) => stream.codec_type === "video" && stream.width && stream.height);
+	const durationSeconds = Number(output.format?.duration ?? output.streams?.find((stream) => stream.duration)?.duration);
+	if (!Number.isFinite(durationSeconds)) throw new Error(`Could not read the media duration of ${filePath}.`);
+	return {
+		...videoStream ? {
+			width: videoStream.width,
+			height: videoStream.height
+		} : {},
+		durationMs: Math.round(durationSeconds * 1e3)
+	};
+}
+async function probeMedia(filePath, config) {
+	return parseProbeOutput(await runToolchainBinary(ffprobeBinaryPath(config), [
+		"-v",
+		"error",
+		"-show_entries",
+		"stream=codec_type,width,height,duration:format=duration",
+		"-of",
+		"json",
+		filePath
+	]), filePath);
+}
+//#endregion
+//#region src/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 = {
+	opus: "libopus",
+	aac: "aac"
+};
+/** The full ffmpeg argument list for one audio transcode (pure, testable). */
+function buildAudioTranscodeArguments(options) {
+	return [
+		"-hide_banner",
+		"-loglevel",
+		"error",
+		"-y",
+		"-i",
+		options.sourcePath,
+		"-vn",
+		"-c:a",
+		ENCODER_BY_CODEC[options.preset.codec],
+		"-b:a",
+		`${options.preset.bitrateKbps}k`,
+		"-map_metadata",
+		"-1",
+		"-fflags",
+		"+bitexact",
+		"-flags:a",
+		"+bitexact",
+		options.targetPath
+	];
+}
+async function processAudioFile(options) {
+	await mkdir(dirname(options.targetPath), { recursive: true });
+	await runToolchainBinary(ffmpegBinaryPath(options.config), buildAudioTranscodeArguments({
+		sourcePath: options.sourcePath,
+		targetPath: options.targetPath,
+		preset: options.preset
+	}));
+	return { durationMs: (await probeMedia(options.targetPath, options.config)).durationMs };
+}
+//#endregion
+//#region src/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];
+	if (!preset) throw new Error(`Unknown ${label} preset "${presetName}" (known: ${Object.keys(presets).sort().join(", ")}).`);
+	return preset;
+}
+/** A proxy-info field a given entry kind cannot do without. */
+function requireProxyField(proxy, field) {
+	const value = proxy[field];
+	if (value === void 0) throw new Error(`Proxy info of "${proxy.assetId}" is missing "${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
+/**
+* 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.
+*/
+/**
+* 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).
+*/
+function videoScaleWidth(sourceWidth, sourceHeight, maxWidth) {
+	const cappedWidth = maxWidth !== void 0 ? 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).
+*/
+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 !== void 0 ? ["-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
+	];
+}
+async function processVideoFile(options) {
+	await mkdir(dirname(options.targetPath), { recursive: true });
+	const source = await probeMedia(options.sourcePath, options.config);
+	if (source.width === void 0 || source.height === void 0) 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
+	}));
+	const output = await probeMedia(options.targetPath, options.config);
+	if (output.width === void 0 || output.height === void 0) throw new Error(`Transcoding ${options.sourcePath} produced no video stream.`);
+	return {
+		width: output.width,
+		height: output.height,
+		durationMs: output.durationMs
+	};
+}
+//#endregion
+//#region src/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 = {
+	descriptor: chromaKeyVideoPlugin,
+	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: ({ parameters, src, proxy }) => ({
+		kind: "chroma-key-video",
+		src,
+		width: requireProxyField(proxy, "width"),
+		height: requireProxyField(proxy, "height"),
+		durationMs: requireProxyField(proxy, "durationMs"),
+		chromaKey: parameters.chromaKey,
+		...parameters.mask ? { mask: parameters.mask } : {},
+		...parameters.fallback ? { fallback: parameters.fallback } : {}
+	})
+};
+//#endregion
+//#region src/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
+* the delivered (post-resize) dimensions.
+*/
+async function processImageFile(options) {
+	await mkdir(dirname(options.targetPath), { recursive: true });
+	let pipeline = sharp(options.sourcePath);
+	if (options.targetWidth !== void 0) pipeline = pipeline.resize({ width: options.targetWidth });
+	pipeline = pipeline.toFormat(options.preset.format, options.preset.quality !== void 0 ? { quality: options.preset.quality } : {});
+	const info = await pipeline.toFile(options.targetPath);
+	return {
+		width: info.width,
+		height: info.height
+	};
+}
+/** Pixel dimensions of an existing image file (for already-fresh proxies). */
+async function readImageDimensions(filePath) {
+	const metadata = await sharp(filePath).metadata();
+	if (typeof metadata.width !== "number" || typeof metadata.height !== "number") throw new Error(`Could not read image dimensions of ${filePath}.`);
+	return {
+		width: metadata.width,
+		height: metadata.height
+	};
+}
+//#endregion
+//#region src/plugins/image.ts
+/**
+* Image plugin (server part): sharp scale + convert per preset.
+*/
+/** The delivered file extension of an image-preset format. */
+function extensionForImageFormat(format) {
+	return format === "jpeg" ? "jpg" : format;
+}
+const imageServerPlugin = {
+	descriptor: imagePlugin,
+	pluginConfig: (config) => config.plugins.image,
+	presets: (config) => config.plugins.image.presets,
+	resolvePreset: (parameters, config) => resolveNamedPreset("image", parameters.preset, config.plugins.image.presets),
+	proxyExtension: (preset) => extensionForImageFormat(preset.format),
+	process: (job) => processImageFile({
+		sourcePath: job.sourcePath,
+		targetPath: job.targetPath,
+		preset: job.preset,
+		targetWidth: job.parameters.targetWidth
+	}),
+	readProxyInfo: (proxyPath) => readImageDimensions(proxyPath),
+	buildManifestEntry: ({ src, proxy }) => ({
+		kind: "image",
+		src,
+		width: requireProxyField(proxy, "width"),
+		height: requireProxyField(proxy, "height")
+	})
+};
+//#endregion
+//#region src/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.
+*/
+function hasAnySide(insets) {
+	if (!insets) return false;
+	return insets.top > 0 || insets.right > 0 || insets.bottom > 0 || insets.left > 0;
+}
+/**
+* Best-effort guess of the asset's export scale from a `@2x` / `@3x` suffix in
+* the file name (also tolerates `-`/`_` separators, e.g. `dialog-3x.png`).
+* Falls back to 1.
+*/
+function detectPixelRatio(fileName) {
+	const match = fileName.match(/(?:@|[-_])(\d)x(?=\.[^.]*$|$)/i);
+	const ratio = match ? Number(match[1]) : 1;
+	return ratio >= 1 ? ratio : 1;
+}
+const sliceServerPlugin = {
+	descriptor: slicePlugin,
+	pluginConfig: (config) => config.plugins.slice,
+	presets: (config) => config.plugins.slice.presets,
+	resolvePreset: (parameters, config) => resolveNamedPreset("slice", parameters.preset, config.plugins.slice.presets),
+	proxyExtension: (preset) => extensionForImageFormat(preset.format),
+	seedIngestParameters: async ({ rawPath, rawFileName, parameters }) => {
+		const dimensions = await readImageDimensions(rawPath);
+		return {
+			...parameters,
+			insets: defaultInsetsForSize(dimensions.width, dimensions.height),
+			pixelRatio: detectPixelRatio(rawFileName)
+		};
+	},
+	process: (job) => processImageFile({
+		sourcePath: job.sourcePath,
+		targetPath: job.targetPath,
+		preset: job.preset
+	}),
+	readProxyInfo: (proxyPath) => readImageDimensions(proxyPath),
+	buildManifestEntry: ({ parameters, src, proxy }) => {
+		return {
+			kind: "slice",
+			src,
+			slicing: {
+				mode: parameters.mode,
+				insets: parameters.insets,
+				pixelRatio: parameters.pixelRatio,
+				...hasAnySide(parameters.overdraw) ? { overdraw: parameters.overdraw } : {}
+			},
+			sourceWidth: requireProxyField(proxy, "width"),
+			sourceHeight: requireProxyField(proxy, "height")
+		};
+	}
+};
+//#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 = {
+	[imageServerPlugin.descriptor.type]: imageServerPlugin,
+	[sliceServerPlugin.descriptor.type]: sliceServerPlugin,
+	[videoServerPlugin.descriptor.type]: videoServerPlugin,
+	[chromaKeyVideoServerPlugin.descriptor.type]: chromaKeyVideoServerPlugin,
+	[audioServerPlugin.descriptor.type]: audioServerPlugin
+};
+function serverPluginForType(type, registry = serverPluginsByType) {
+	const plugin = registry[type];
+	if (!plugin) throw new Error(`Unknown asset type "${type}" (known: ${Object.keys(registry).sort().join(", ")}).`);
+	return plugin;
+}
+/** The core-descriptor view of a registry — what core's reference/graph helpers consume. */
+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);
+/**
+* The job-hash parameter input for an asset: the plugin-declared
+* processing-relevant subset when the plugin distinguishes one (chroma-key-
+* video: keying + references are entry-only), else the full parameter value.
+*/
+function processingParametersOf(plugin, parameters) {
+	return plugin.processingParameters ? plugin.processingParameters(parameters) : parameters;
+}
+//#endregion
+//#region src/codegen.ts
+/**
+* Manifest module codegen: one `<manifest-name-kebab>.generated.ts`
+* per manifest in the configured manifests directory, containing data only —
+* entries constructed through the runtime's `createManifest`. Deterministic:
+* 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";
+/** `mainCatalog` → `main-catalog`. */
+function kebabCaseFromCamel(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+/** Generated module file name for a manifest. */
+function manifestModuleFileName(manifestName) {
+	return `${kebabCaseFromCamel(manifestName)}.generated.ts`;
+}
+/**
+* Build the entry data codegen emits for one asset — delegated to
+* the owning server plugin's `buildManifestEntry`. Reference fields
+* (chroma-key-video's mask/fallback) stay `{ $asset }` markers here — the
+* generic `inlineAssetReferences` walk resolves them.
+*/
+function manifestEntryForAsset(record, proxy, config, registry = serverPluginsByType) {
+	const plugin = serverPluginForType(record.type, registry);
+	return plugin.buildManifestEntry({
+		assetId: proxy.assetId,
+		parameters: plugin.descriptor.validateParameters(record.parameters),
+		src: `${config.proxyBasePath}${proxy.relativePath.split("/").map(encodeURIComponent).join("/")}`,
+		proxy
+	});
+}
+/**
+* Replace every `{ $asset }` marker in a built entry with the referenced
+* asset's own (already inlined) entry data. Codegen inlines the
+* resolved reference, so the runtime never resolves ids. Generic deep walk;
+* plugin entry builders stay reference-unaware.
+*/
+function inlineAssetReferences(value, resolveEntry) {
+	return inlineValue(value, resolveEntry);
+}
+function inlineValue(value, resolveEntry) {
+	if (isAssetReference(value)) return resolveEntry(value.$asset);
+	if (Array.isArray(value)) return value.map((element) => inlineValue(element, resolveEntry));
+	if (typeof value === "object" && value !== null) {
+		const inlined = {};
+		for (const [key, nested] of Object.entries(value)) inlined[key] = inlineValue(nested, resolveEntry);
+		return inlined;
+	}
+	return value;
+}
+/**
+* Build the entries for one manifest from its membership picture: the whole
+* delivery set (explicit ∪ passive members — the shared membership
+* computation) in dependency order (the closure is a DAG — a
+* cycle throws), each entry's markers inlined from the already-built entries.
+* Only the explicit members appear top-level — they are the manifest's API
+* surface; passive members exist solely inlined.
+*/
+function buildManifestEntries(options) {
+	const buildEntry = options.entryBuilder ?? ((assetId, record, proxy, config) => manifestEntryForAsset(record, proxy, config, options.registry));
+	const buildOrder = topologicalReferenceOrder(options.membership.deliveredAssetIds, options.referencesByAsset);
+	const builtEntries = {};
+	const resolveEntry = (assetId) => {
+		if (!Object.hasOwn(builtEntries, assetId)) throw new Error(`Cannot inline reference to "${assetId}" — no entry was built for it.`);
+		return builtEntries[assetId];
+	};
+	for (const assetId of buildOrder) {
+		if (!Object.hasOwn(options.library.assets, assetId)) throw new Error(`Cannot build an entry for unknown asset "${assetId}".`);
+		const proxy = options.proxies[assetId];
+		if (!proxy) throw new Error(`No proxy info for asset "${assetId}". Run processing before codegen.`);
+		builtEntries[assetId] = inlineAssetReferences(buildEntry(assetId, options.library.assets[assetId], proxy, options.config), resolveEntry);
+	}
+	const memberEntries = {};
+	for (const assetId of options.membership.explicitMemberIds) memberEntries[assetId] = builtEntries[assetId];
+	return memberEntries;
+}
+/** Render one generated manifest module. */
+function renderManifestModule(manifestName, entries) {
+	const assetIds = Object.keys(entries).sort(compareCodeUnits);
+	return `${GENERATED_HEADER}import { createManifest } from 'fundus';\n\n${assetIds.length === 0 ? `export const ${manifestName} = createManifest({});` : `export const ${manifestName} = createManifest({\n` + assetIds.map((assetId) => {
+		return `\t${assetId}: ${JSON.stringify(entries[assetId], null, "	").replace(/\n/g, "\n	")}`;
+	}).join(",\n") + `\n});`}\n`;
+}
+/** Fundus-owned generated modules not present in the expected file-name set. */
+async function strayGeneratedModuleNames(manifestsDir, expectedFileNames) {
+	let fileNames;
+	try {
+		fileNames = await readdir(manifestsDir);
+	} catch (cause) {
+		if (cause.code === "ENOENT") return [];
+		throw cause;
+	}
+	const strayNames = [];
+	for (const fileName of fileNames) {
+		if (!fileName.endsWith(".generated.ts") || expectedFileNames.has(fileName)) continue;
+		if ((await readFile(join(manifestsDir, fileName), "utf8")).startsWith("// generated by fundus — do not edit\n")) strayNames.push(fileName);
+	}
+	return strayNames.sort(compareCodeUnits);
+}
+/**
+* Write one module per manifest and remove generated modules whose manifest is
+* gone. Only files starting with the fundus header are ever removed, so other
+* generated files co-located in the directory stay untouched.
+*/
+async function generateManifestModules(config, library, proxies, registry = serverPluginsByType) {
+	await mkdir(config.manifestsDir, { recursive: true });
+	const report = {
+		written: [],
+		removed: []
+	};
+	const expectedFileNames = /* @__PURE__ */ new Set();
+	const namesByFileName = /* @__PURE__ */ new Map();
+	for (const manifestName of Object.keys(library.manifests)) {
+		const fileName = manifestModuleFileName(manifestName);
+		namesByFileName.set(fileName, [...namesByFileName.get(fileName) ?? [], manifestName]);
+	}
+	for (const [fileName, manifestNames] of namesByFileName) if (manifestNames.length > 1) throw new Error(`Manifests ${manifestNames.map((name) => `"${name}"`).join(" and ")} would both generate "${fileName}" — rename one so the kebab-case module names stay distinct.`);
+	const referencesByAsset = collectAllReferences(library, descriptorsByType(registry));
+	const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
+	const renderedModules = [];
+	for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
+		const entries = buildManifestEntries({
+			membership: membershipByManifest[manifestName],
+			library,
+			proxies,
+			config,
+			referencesByAsset,
+			registry
+		});
+		const fileName = manifestModuleFileName(manifestName);
+		expectedFileNames.add(fileName);
+		renderedModules.push({
+			fileName,
+			content: renderManifestModule(manifestName, entries)
+		});
+	}
+	for (const { fileName, content } of renderedModules) {
+		await writeFile(join(config.manifestsDir, fileName), content);
+		report.written.push(fileName);
+	}
+	for (const fileName of await strayGeneratedModuleNames(config.manifestsDir, expectedFileNames)) {
+		await unlink(join(config.manifestsDir, fileName));
+		report.removed.push(fileName);
+	}
+	return report;
+}
+/**
+* First 8 hex chars of sha256 over rawHash + canonical parameters + pipeline
+* version — the `<jobHash>` segment of a proxy file name.
+*/
+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
+async function ensureManagedFolder(root, folder) {
+	const directory = join(root, folder);
+	await mkdir(directory, { recursive: true });
+	if (folder === "") return;
+	const sentinel = join(directory, FOLDER_SENTINEL);
+	if (!existsSync(sentinel)) await writeFile(sentinel, "");
+}
+async function syncManagedFolders(config, library) {
+	await Promise.all(library.folders.flatMap((folder) => [ensureManagedFolder(config.rawDir, folder), ensureManagedFolder(config.proxyDir, folder)]));
+}
+/** Recursively list files as POSIX-style paths relative to `root`. */
+async function listRelativeFiles(root, folder = "") {
+	const directory = join(root, folder);
+	if (!existsSync(directory)) return [];
+	const result = [];
+	for (const entry of await readdir(directory, { withFileTypes: true })) {
+		const relativePath = folder === "" ? entry.name : `${folder}/${entry.name}`;
+		if (entry.isDirectory()) result.push(...await listRelativeFiles(root, relativePath));
+		else if (entry.isFile()) result.push(relativePath);
+	}
+	return result;
+}
+function encodeRelativePathForUrl(path) {
+	return path.split("/").map(encodeURIComponent).join("/");
+}
+//#endregion
+//#region src/processing/processor.ts
+/**
+* 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.
+*/
+/** 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. */
+function isProxyFileName(fileName) {
+	return PROXY_FILE_PATTERN.test(fileName);
+}
+/** Whether a shaped proxy file belongs to one specific asset id. */
+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.
+*/
+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);
+	return `${assetId}.${jobHash(record.rawHash, {
+		parameters: processingParametersOf(plugin.descriptor, parameters),
+		presetSettings: preset
+	})}.${plugin.proxyExtension(preset)}`;
+}
+/** Expected proxy path relative to proxyDir, mirroring the raw asset folder. */
+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.
+*/
+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. */
+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.
+*/
+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.
+*/
+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 = /* @__PURE__ */ 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;
+	}
+	for (const relativePath of await listRelativeFiles(config.proxyDir)) {
+		if (!isProxyFileName(rawFileNameOfPath(relativePath))) continue;
+		if (expectedRelativePaths.has(relativePath)) continue;
+		await unlink(join(config.proxyDir, relativePath));
+		report.pruned.push(relativePath);
+	}
+	report.pruned.sort();
+	return report;
+}
+//#endregion
+//#region src/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
+* is always the current truth. Proxy files are the pipeline's business — this
+* 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._-]*$/;
+function assertSafeFileName(fileName) {
+	if (!SAFE_SEGMENT.test(fileName) || fileName.includes("/") || fileName.includes("\\")) throw new Error(`Unsafe file name "${fileName}".`);
+}
+/** Validate a persisted/served file path without allowing traversal outside its root. */
+function assertSafeRelativeFilePath(filePath) {
+	if (filePath.startsWith("/") || filePath.endsWith("/") || filePath.includes("\\")) throw new Error(`Unsafe file path "${filePath}".`);
+	const segments = filePath.split("/");
+	if (segments.length === 0) throw new Error(`Unsafe file path "${filePath}".`);
+	assertSafeFileName(segments.at(-1) ?? "");
+	const folder = segments.slice(0, -1).join("/");
+	if (folder !== "") {
+		const problem = folderPathError(folder);
+		if (problem) throw new Error(problem);
+	}
+}
+/**
+* Turn an arbitrary uploaded file name (spaces, umlauts, parentheses, nested
+* paths) into a safe single segment: strip the directory, transliterate to
+* ASCII-ish, replace runs of disallowed characters with `-`, and lower-case
+* the extension. Never throws for a normal image name.
+*/
+function sanitizeFileName(original) {
+	const base = original.split(/[\\/]/).pop() ?? original;
+	const dot = base.lastIndexOf(".");
+	const rawStem = dot > 0 ? base.slice(0, dot) : base;
+	const rawExtension = dot > 0 ? base.slice(dot + 1) : "";
+	let stem = rawStem.normalize("NFKD").replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-{2,}/g, "-").replace(/^[-.]+|[-.]+$/g, "");
+	if (!stem) stem = "asset";
+	if (!/^[a-zA-Z0-9]/.test(stem)) stem = `raw-${stem}`;
+	const extension = rawExtension.toLowerCase().replace(/[^a-z0-9]/g, "");
+	return extension ? `${stem}.${extension}` : stem;
+}
+function sha256Hex(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+var LibraryStore = class {
+	#config;
+	#registry;
+	#queue = Promise.resolve();
+	constructor(config, registry = serverPluginsByType) {
+		this.#config = config;
+		this.#registry = registry;
+	}
+	get config() {
+		return this.#config;
+	}
+	/** Run a mutation after every previously enqueued one has settled. */
+	#enqueue(operation) {
+		const run = this.#queue.then(operation, operation);
+		this.#queue = run.then(() => {}, () => {});
+		return run;
+	}
+	/** Read + parse the library file; a missing file is an empty library. */
+	async read() {
+		if (!existsSync(this.#config.library)) return createEmptyLibrary();
+		return parseLibrary(await readFile(this.#config.library, "utf8"));
+	}
+	/** Deterministically serialize + write the library file. */
+	async write(library) {
+		await mkdir(join(this.#config.library, ".."), { recursive: true });
+		const temporaryPath = `${this.#config.library}.tmp`;
+		await writeFile(temporaryPath, serializeLibrary(library));
+		await rename(temporaryPath, this.#config.library);
+	}
+	/**
+	* Ingest a new asset: write the raw file into `rawDir` (under a sanitized,
+	* non-colliding name), hash its content, and create the library record with
+	* the owning plugin's default parameters. Returns the updated library.
+	*/
+	async ingest(options) {
+		return this.#enqueue(() => this.#ingest(options));
+	}
+	async #ingest(options) {
+		const idProblem = assetIdError(options.id);
+		if (idProblem) throw new Error(idProblem);
+		const plugin = serverPluginForType(options.type, this.#registry);
+		const extension = extname(sanitizeFileName(options.fileName)).slice(1).toLowerCase();
+		if (!plugin.descriptor.accepts.includes(extension)) throw new Error(`The ${options.type} type does not accept ".${extension}" files (accepts: ${plugin.descriptor.accepts.join(", ")}).`);
+		const library = await this.read();
+		if (Object.hasOwn(library.assets, options.id)) throw new Error(`An asset with id "${options.id}" already exists.`);
+		const folder = options.folder === void 0 ? "" : normalizeFolderPath(options.folder);
+		this.#requireFolder(library, folder);
+		await mkdir(join(this.#config.rawDir, folder), { recursive: true });
+		const storedName = this.#uniqueRawName(sanitizeFileName(options.fileName), folder);
+		const storedPath = folder === "" ? storedName : `${folder}/${storedName}`;
+		await writeFile(join(this.#config.rawDir, storedPath), options.bytes);
+		const record = {
+			type: options.type,
+			raw: storedPath,
+			rawHash: sha256Hex(options.bytes),
+			parameters: plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)),
+			manifests: []
+		};
+		library.assets[options.id] = record;
+		await this.write(library);
+		return library;
+	}
+	/** Replace an asset's parameters (validated by the owning plugin). */
+	async updateParameters(id, parameters) {
+		return this.#enqueue(() => this.#updateParameters(id, parameters));
+	}
+	async #updateParameters(id, parameters) {
+		const library = await this.read();
+		const record = this.#requireAsset(library, id);
+		record.parameters = serverPluginForType(record.type, this.#registry).descriptor.validateParameters(parameters);
+		await this.write(library);
+		return library;
+	}
+	/** Replace an asset's manifest membership (every name must exist). */
+	async setManifests(id, manifests) {
+		return this.#enqueue(() => this.#setManifests(id, manifests));
+	}
+	async #setManifests(id, manifests) {
+		const library = await this.read();
+		const record = this.#requireAsset(library, id);
+		const unique = [...new Set(manifests)];
+		for (const name of unique) if (!Object.hasOwn(library.manifests, name)) throw new Error(`Unknown manifest "${name}".`);
+		record.manifests = unique.sort();
+		await this.write(library);
+		return library;
+	}
+	/** Rename an asset id (the raw file keeps its name — ids are the stable key). */
+	async renameAsset(id, newId) {
+		return this.#enqueue(() => this.#renameAsset(id, newId));
+	}
+	async #renameAsset(id, newId) {
+		const idProblem = assetIdError(newId);
+		if (idProblem) throw new Error(idProblem);
+		const library = await this.read();
+		const record = this.#requireAsset(library, id);
+		if (newId === id) return library;
+		if (Object.hasOwn(library.assets, newId)) throw new Error(`An asset with id "${newId}" already exists.`);
+		delete library.assets[id];
+		library.assets[newId] = record;
+		await this.write(library);
+		await this.#deleteProxiesOf(id);
+		return library;
+	}
+	/** Move an asset's raw file and current proxies without changing its stable id. */
+	async moveAsset(id, folder) {
+		return this.#enqueue(() => this.#moveAsset(id, folder));
+	}
+	async #moveAsset(id, requestedFolder) {
+		const folder = normalizeFolderPath(requestedFolder);
+		const library = await this.read();
+		const record = this.#requireAsset(library, id);
+		this.#requireFolder(library, folder);
+		const currentFolder = folderOfRawPath(record.raw);
+		if (folder === currentFolder) return library;
+		const fileName = rawFileNameOfPath(record.raw);
+		const nextRaw = folder === "" ? fileName : `${folder}/${fileName}`;
+		const nextRawPath = join(this.#config.rawDir, nextRaw);
+		if (existsSync(nextRawPath)) throw new Error(`Raw file "${nextRaw}" already exists.`);
+		await ensureManagedFolder(this.#config.rawDir, folder);
+		await ensureManagedFolder(this.#config.proxyDir, folder);
+		const movedProxies = [];
+		let rawMoved = false;
+		try {
+			await rename(join(this.#config.rawDir, record.raw), nextRawPath);
+			rawMoved = true;
+			for (const relativePath of await listRelativeFiles(this.#config.proxyDir, currentFolder)) {
+				if (folderOfRawPath(relativePath) !== currentFolder) continue;
+				const proxyFileName = rawFileNameOfPath(relativePath);
+				if (!isProxyFileNameFor(id, proxyFileName)) continue;
+				const nextRelativePath = folder === "" ? proxyFileName : `${folder}/${proxyFileName}`;
+				await rename(join(this.#config.proxyDir, relativePath), join(this.#config.proxyDir, nextRelativePath));
+				movedProxies.push({
+					from: relativePath,
+					to: nextRelativePath
+				});
+			}
+			record.raw = nextRaw;
+			await this.write(library);
+		} catch (cause) {
+			record.raw = currentFolder === "" ? fileName : `${currentFolder}/${fileName}`;
+			for (const proxy of movedProxies.reverse()) await rename(join(this.#config.proxyDir, proxy.to), join(this.#config.proxyDir, proxy.from));
+			if (rawMoved) await rename(nextRawPath, join(this.#config.rawDir, record.raw));
+			throw cause;
+		}
+		return library;
+	}
+	async createFolder(path) {
+		return this.#enqueue(() => this.#createFolder(path));
+	}
+	async #createFolder(requestedPath) {
+		const path = normalizeFolderPath(requestedPath);
+		const problem = folderPathError(path);
+		if (problem) throw new Error(problem);
+		const library = await this.read();
+		const parent = parentFolderPath(path);
+		this.#requireFolder(library, parent);
+		this.#assertFolderAvailable(library, path);
+		library.folders.push(path);
+		library.folders.sort();
+		await Promise.all([ensureManagedFolder(this.#config.rawDir, path), ensureManagedFolder(this.#config.proxyDir, path)]);
+		await this.write(library);
+		return library;
+	}
+	async renameFolder(path, newName) {
+		return this.#enqueue(() => this.#renameFolder(path, newName));
+	}
+	async #renameFolder(requestedPath, requestedName) {
+		const path = normalizeFolderPath(requestedPath);
+		const newName = requestedName.normalize("NFC");
+		const nameProblem = folderNameError(newName);
+		if (nameProblem) throw new Error(nameProblem);
+		const nextPath = joinFolderPath(parentFolderPath(path), newName);
+		return this.#relocateFolder(path, nextPath);
+	}
+	/** Move a complete folder subtree below another folder (or the implicit root). */
+	async moveFolder(path, parent) {
+		return this.#enqueue(() => this.#moveFolder(path, parent));
+	}
+	async #moveFolder(requestedPath, requestedParent) {
+		const path = normalizeFolderPath(requestedPath);
+		const nextPath = joinFolderPath(normalizeFolderPath(requestedParent), folderNameOf(path));
+		return this.#relocateFolder(path, nextPath);
+	}
+	async #relocateFolder(path, nextPath) {
+		const library = await this.read();
+		this.#requireFolder(library, path, false);
+		const nextParent = parentFolderPath(nextPath);
+		this.#requireFolder(library, nextParent);
+		if (isFolderOrDescendant(nextParent, path)) throw new Error(`Folder "${path}" cannot be moved into itself or one of its descendants.`);
+		if (nextPath === path) return library;
+		this.#assertFolderAvailable(library, nextPath, path);
+		const renamedFolders = library.folders.map((folder) => isFolderOrDescendant(folder, path) ? replaceFolderPrefix(folder, path, nextPath) : folder);
+		const renamedKeys = /* @__PURE__ */ new Set();
+		for (const folder of renamedFolders) {
+			const key = portableFolderPathKey(folder);
+			if (renamedKeys.has(key)) throw new Error(`Folder rename would collide at "${folder}".`);
+			renamedKeys.add(key);
+		}
+		const rawFrom = join(this.#config.rawDir, path);
+		const rawTo = join(this.#config.rawDir, nextPath);
+		const proxyFrom = join(this.#config.proxyDir, path);
+		const proxyTo = join(this.#config.proxyDir, nextPath);
+		await mkdir(join(rawTo, ".."), { recursive: true });
+		await mkdir(join(proxyTo, ".."), { recursive: true });
+		const caseOnly = portableFolderPathKey(path) === portableFolderPathKey(nextPath);
+		const rawTemporary = caseOnly ? `${rawFrom}.fundus-${crypto.randomUUID()}` : rawFrom;
+		const proxyTemporary = caseOnly ? `${proxyFrom}.fundus-${crypto.randomUUID()}` : proxyFrom;
+		if (caseOnly) {
+			await rename(rawFrom, rawTemporary);
+			try {
+				await rename(proxyFrom, proxyTemporary);
+			} catch (cause) {
+				await rename(rawTemporary, rawFrom);
+				throw cause;
+			}
+		}
+		try {
+			await rename(rawTemporary, rawTo);
+			try {
+				await rename(proxyTemporary, proxyTo);
+			} catch (cause) {
+				if (caseOnly) {
+					await rename(rawTo, rawTemporary);
+					await rename(rawTemporary, rawFrom);
+					await rename(proxyTemporary, proxyFrom);
+				} else await rename(rawTo, rawFrom);
+				throw cause;
+			}
+		} catch (cause) {
+			if (caseOnly) {
+				if (existsSync(rawTemporary)) await rename(rawTemporary, rawFrom);
+				if (existsSync(proxyTemporary)) await rename(proxyTemporary, proxyFrom);
+			}
+			throw cause;
+		}
+		library.folders = renamedFolders.sort();
+		for (const record of Object.values(library.assets)) {
+			const assetFolder = folderOfRawPath(record.raw);
+			if (!isFolderOrDescendant(assetFolder, path)) continue;
+			record.raw = `${replaceFolderPrefix(assetFolder, path, nextPath)}/${rawFileNameOfPath(record.raw)}`;
+		}
+		try {
+			await this.write(library);
+		} catch (cause) {
+			if (caseOnly) {
+				await rename(rawTo, rawTemporary);
+				await rename(proxyTo, proxyTemporary);
+				await rename(rawTemporary, rawFrom);
+				await rename(proxyTemporary, proxyFrom);
+			} else {
+				await rename(rawTo, rawFrom);
+				await rename(proxyTo, proxyFrom);
+			}
+			throw cause;
+		}
+		return library;
+	}
+	/** Recursively delete a folder and every asset stored below it. */
+	async deleteFolder(path) {
+		return this.#enqueue(() => this.#deleteFolder(path));
+	}
+	async #deleteFolder(requestedPath) {
+		const path = normalizeFolderPath(requestedPath);
+		const library = await this.read();
+		this.#requireFolder(library, path, false);
+		const deletedAssetIds = Object.entries(library.assets).filter(([, record]) => isFolderOrDescendant(folderOfRawPath(record.raw), path)).map(([id]) => id).sort();
+		for (const id of deletedAssetIds) delete library.assets[id];
+		library.folders = library.folders.filter((folder) => !isFolderOrDescendant(folder, path));
+		const token = crypto.randomUUID();
+		const rawPath = join(this.#config.rawDir, path);
+		const proxyPath = join(this.#config.proxyDir, path);
+		const rawTemporary = join(this.#config.rawDir, `.fundus-delete-${token}`);
+		const proxyTemporary = join(this.#config.proxyDir, `.fundus-delete-${token}`);
+		await rename(rawPath, rawTemporary);
+		try {
+			await rename(proxyPath, proxyTemporary);
+		} catch (cause) {
+			await rename(rawTemporary, rawPath);
+			throw cause;
+		}
+		try {
+			await this.write(library);
+		} catch (cause) {
+			await rename(rawTemporary, rawPath);
+			await rename(proxyTemporary, proxyPath);
+			throw cause;
+		}
+		await Promise.all([rm(rawTemporary, {
+			recursive: true,
+			force: true
+		}), rm(proxyTemporary, {
+			recursive: true,
+			force: true
+		})]);
+		return {
+			library,
+			deletedAssetIds
+		};
+	}
+	/** Delete an asset: remove the record, its raw file, and its proxies. */
+	async deleteAsset(id) {
+		return this.#enqueue(() => this.#deleteAsset(id));
+	}
+	async #deleteAsset(id) {
+		return this.#deleteAssets([id]);
+	}
+	/** Delete several assets as one library/file transaction. */
+	async deleteAssets(ids) {
+		return this.#enqueue(() => this.#deleteAssets(ids));
+	}
+	async #deleteAssets(ids) {
+		const uniqueIds = [...new Set(ids)];
+		if (uniqueIds.length === 0) throw new Error("At least one asset id is required.");
+		const library = await this.read();
+		const records = uniqueIds.map((id) => ({
+			id,
+			record: this.#requireAsset(library, id)
+		}));
+		const deletedIds = new Set(uniqueIds);
+		const token = crypto.randomUUID();
+		const rawTemporaryRoot = join(this.#config.rawDir, `.fundus-delete-assets-${token}`);
+		const proxyTemporaryRoot = join(this.#config.proxyDir, `.fundus-delete-assets-${token}`);
+		const movedRawPaths = [];
+		const movedProxyPaths = [];
+		const stageFile = async (root, temporaryRoot, relativePath) => {
+			const source = join(root, relativePath);
+			if (!existsSync(source)) return;
+			const target = join(temporaryRoot, relativePath);
+			await mkdir(dirname(target), { recursive: true });
+			await rename(source, target);
+		};
+		const restoreFiles = async (root, temporaryRoot, relativePaths) => {
+			for (const relativePath of [...relativePaths].reverse()) {
+				const source = join(temporaryRoot, relativePath);
+				if (!existsSync(source)) continue;
+				const target = join(root, relativePath);
+				await mkdir(dirname(target), { recursive: true });
+				await rename(source, target);
+			}
+		};
+		try {
+			for (const { record } of records) {
+				await stageFile(this.#config.rawDir, rawTemporaryRoot, record.raw);
+				movedRawPaths.push(record.raw);
+			}
+			if (existsSync(this.#config.proxyDir)) {
+				for (const relativePath of await listRelativeFiles(this.#config.proxyDir)) if ([...deletedIds].some((id) => isProxyFileNameFor(id, rawFileNameOfPath(relativePath)))) {
+					await stageFile(this.#config.proxyDir, proxyTemporaryRoot, relativePath);
+					movedProxyPaths.push(relativePath);
+				}
+			}
+			for (const id of uniqueIds) delete library.assets[id];
+			await this.write(library);
+		} catch (cause) {
+			await restoreFiles(this.#config.proxyDir, proxyTemporaryRoot, movedProxyPaths);
+			await restoreFiles(this.#config.rawDir, rawTemporaryRoot, movedRawPaths);
+			await Promise.all([rm(rawTemporaryRoot, {
+				recursive: true,
+				force: true
+			}), rm(proxyTemporaryRoot, {
+				recursive: true,
+				force: true
+			})]);
+			throw cause;
+		}
+		await Promise.all([rm(rawTemporaryRoot, {
+			recursive: true,
+			force: true
+		}), rm(proxyTemporaryRoot, {
+			recursive: true,
+			force: true
+		})]);
+		return library;
+	}
+	async createManifest(name) {
+		return this.#enqueue(() => this.#createManifest(name));
+	}
+	async #createManifest(name) {
+		const nameProblem = manifestNameError(name);
+		if (nameProblem) throw new Error(nameProblem);
+		const library = await this.read();
+		if (Object.hasOwn(library.manifests, name)) throw new Error(`A manifest named "${name}" already exists.`);
+		const fileName = manifestModuleFileName(name);
+		for (const existingName of Object.keys(library.manifests)) if (manifestModuleFileName(existingName) === fileName) throw new Error(`Manifest "${name}" would generate the same module ("${fileName}") as the existing manifest "${existingName}" — pick a name with a distinct kebab-case form.`);
+		library.manifests[name] = {};
+		await this.write(library);
+		return library;
+	}
+	/**
+	* Set (or clear) a manifest's editor appearance — its color and/or emoji.
+	* An `undefined` field is left unchanged; a `null` field clears it. Values
+	* are validated against the fixed palettes.
+	*/
+	async setManifestAppearance(name, appearance) {
+		return this.#enqueue(() => this.#setManifestAppearance(name, appearance));
+	}
+	async #setManifestAppearance(name, appearance) {
+		const library = await this.read();
+		if (!Object.hasOwn(library.manifests, name)) throw new Error(`Unknown manifest "${name}".`);
+		const record = library.manifests[name];
+		if (appearance.color !== void 0) if (appearance.color === null) delete record.color;
+		else {
+			const problem = manifestColorError(appearance.color);
+			if (problem) throw new Error(problem);
+			record.color = appearance.color;
+		}
+		if (appearance.emoji !== void 0) if (appearance.emoji === null) delete record.emoji;
+		else {
+			const problem = manifestEmojiError(appearance.emoji);
+			if (problem) throw new Error(problem);
+			record.emoji = appearance.emoji;
+		}
+		await this.write(library);
+		return library;
+	}
+	/** Rename a manifest and rewrite every asset's membership to the new name. */
+	async renameManifest(name, newName) {
+		return this.#enqueue(() => this.#renameManifest(name, newName));
+	}
+	async #renameManifest(name, newName) {
+		const nameProblem = manifestNameError(newName);
+		if (nameProblem) throw new Error(nameProblem);
+		const library = await this.read();
+		if (!Object.hasOwn(library.manifests, name)) throw new Error(`Unknown manifest "${name}".`);
+		if (newName === name) return library;
+		if (Object.hasOwn(library.manifests, newName)) throw new Error(`A manifest named "${newName}" already exists.`);
+		const fileName = manifestModuleFileName(newName);
+		for (const existingName of Object.keys(library.manifests)) if (existingName !== name && manifestModuleFileName(existingName) === fileName) throw new Error(`Manifest "${newName}" would generate the same module ("${fileName}") as the existing manifest "${existingName}" — pick a name with a distinct kebab-case form.`);
+		const record = library.manifests[name];
+		delete library.manifests[name];
+		library.manifests[newName] = record;
+		for (const assetRecord of Object.values(library.assets)) if (assetRecord.manifests.includes(name)) assetRecord.manifests = assetRecord.manifests.map((manifest) => manifest === name ? newName : manifest).sort();
+		await this.write(library);
+		return library;
+	}
+	/** Delete a manifest and strip it from every asset's membership. */
+	async deleteManifest(name) {
+		return this.#enqueue(() => this.#deleteManifest(name));
+	}
+	async #deleteManifest(name) {
+		const library = await this.read();
+		if (!Object.hasOwn(library.manifests, name)) throw new Error(`Unknown manifest "${name}".`);
+		delete library.manifests[name];
+		for (const record of Object.values(library.assets)) record.manifests = record.manifests.filter((manifest) => manifest !== name);
+		await this.write(library);
+		return library;
+	}
+	/**
+	* Structural + referential validation, listed per asset: invalid id, unknown
+	* type, dangling raw pointer, invalid parameters, unknown manifest names,
+	* and reference errors (dangling target, type mismatch, cycles).
+	*/
+	async validate(library) {
+		const issues = [];
+		const folderKeys = /* @__PURE__ */ new Map();
+		for (const folder of library.folders) {
+			const problem = folderPathError(folder);
+			if (problem) issues.push({ message: problem });
+			if (folder !== normalizeFolderPath(folder)) issues.push({ message: `Folder path "${folder}" is not Unicode-normalized.` });
+			const key = portableFolderPathKey(folder);
+			const collision = folderKeys.get(key);
+			if (collision !== void 0) issues.push({ message: `Folders "${collision}" and "${folder}" collide on disk.` });
+			else folderKeys.set(key, folder);
+			const parent = parentFolderPath(folder);
+			if (parent !== "" && !library.folders.includes(parent)) issues.push({ message: `Folder "${folder}" has missing parent "${parent}".` });
+			for (const root of [this.#config.rawDir, this.#config.proxyDir]) if (!existsSync(join(root, folder, ".gitkeep"))) issues.push({ message: `Folder "${folder}" is not mirrored with a .gitkeep in ${root}.` });
+		}
+		for (const [name, record] of Object.entries(library.manifests)) {
+			const nameProblem = manifestNameError(name);
+			if (nameProblem) issues.push({ message: nameProblem });
+			if (record.color !== void 0) {
+				const colorProblem = manifestColorError(record.color);
+				if (colorProblem) issues.push({ message: `Manifest "${name}": ${colorProblem}` });
+			}
+			if (record.emoji !== void 0) {
+				const emojiProblem = manifestEmojiError(record.emoji);
+				if (emojiProblem) issues.push({ message: `Manifest "${name}": ${emojiProblem}` });
+			}
+		}
+		const namesByModuleFile = /* @__PURE__ */ new Map();
+		for (const name of Object.keys(library.manifests)) {
+			const fileName = manifestModuleFileName(name);
+			const existingName = namesByModuleFile.get(fileName);
+			if (existingName !== void 0) issues.push({ message: `Manifests "${existingName}" and "${name}" would both generate "${fileName}".` });
+			else namesByModuleFile.set(fileName, name);
+		}
+		for (const [assetId, record] of Object.entries(library.assets)) {
+			const idProblem = assetIdError(assetId);
+			if (idProblem) issues.push({
+				assetId,
+				message: idProblem
+			});
+			const plugin = this.#registry[record.type];
+			if (!plugin) issues.push({
+				assetId,
+				message: `Unknown asset type "${record.type}".`
+			});
+			else try {
+				plugin.descriptor.validateParameters(record.parameters);
+			} catch (cause) {
+				issues.push({
+					assetId,
+					message: `Invalid parameters: ${cause instanceof Error ? cause.message : String(cause)}`
+				});
+			}
+			try {
+				assertSafeRelativeFilePath(record.raw);
+			} catch (cause) {
+				issues.push({
+					assetId,
+					message: cause instanceof Error ? cause.message : String(cause)
+				});
+			}
+			const assetFolder = folderOfRawPath(record.raw);
+			if (assetFolder !== "" && !library.folders.includes(assetFolder)) issues.push({
+				assetId,
+				message: `Unknown asset folder "${assetFolder}".`
+			});
+			if (!existsSync(join(this.#config.rawDir, record.raw))) issues.push({
+				assetId,
+				message: `Raw file "${record.raw}" is missing from the raw directory.`
+			});
+			for (const manifest of record.manifests) if (!library.manifests[manifest]) issues.push({
+				assetId,
+				message: `Unknown manifest "${manifest}".`
+			});
+		}
+		issues.push(...referenceErrors(library, collectAllReferences(library, descriptorsByType(this.#registry))));
+		return issues;
+	}
+	async #deleteProxiesOf(assetId) {
+		if (!existsSync(this.#config.proxyDir)) return;
+		for (const relativePath of await listRelativeFiles(this.#config.proxyDir)) if (isProxyFileNameFor(assetId, rawFileNameOfPath(relativePath))) await unlink(join(this.#config.proxyDir, relativePath));
+	}
+	async syncFolders(library) {
+		await syncManagedFolders(this.#config, library);
+	}
+	#requireAsset(library, id) {
+		if (!Object.hasOwn(library.assets, id)) throw new Error(`Unknown asset "${id}".`);
+		return library.assets[id];
+	}
+	/** Resolve a non-colliding raw file name, appending `-1`, `-2`, … before the extension. */
+	#uniqueRawName(fileName, folder) {
+		if (!existsSync(join(this.#config.rawDir, folder, fileName))) return fileName;
+		const extension = extname(fileName);
+		const stem = fileName.slice(0, fileName.length - extension.length);
+		for (let index = 1;; index++) {
+			const candidate = `${stem}-${index}${extension}`;
+			if (!existsSync(join(this.#config.rawDir, folder, candidate))) return candidate;
+		}
+	}
+	#requireFolder(library, folder, allowRoot = true) {
+		if (folder === "" && allowRoot) return;
+		if (!library.folders.includes(folder)) throw new Error(`Unknown folder "${folder}".`);
+	}
+	#assertFolderAvailable(library, path, except) {
+		const key = portableFolderPathKey(path);
+		const collision = library.folders.find((folder) => folder !== except && portableFolderPathKey(folder) === key);
+		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 };