fundus 0.0.4 → 0.2.0

package/build/server/chunks/chunks/internal2.js-BlXt2rfE.js.map

@@ -1 +1 @@
-{"version":3,"file":"internal2.js-BlXt2rfE.js","sources":["../../../../.svelte-kit/output/server/chunks/internal2.js"],"sourcesContent":["//#region node_modules/@sveltejs/kit/src/runtime/app/paths/internal/server.js\nvar base = \"\";\nvar assets = base;\nvar app_dir = \"_app\";\nvar initial = {\n\tbase,\n\tassets\n};\n/**\n* `base` could be overridden during rendering to be relative;\n* this one's the original non-relative base path\n*/\nvar initial_base = initial.base;\n/**\n* @param {{ base: string, assets: string }} paths\n*/\nfunction override(paths) {\n\tbase = paths.base;\n\tassets = paths.assets;\n}\nfunction reset() {\n\tbase = initial.base;\n\tassets = initial.assets;\n}\n/** @param {string} path */\nfunction set_assets(path) {\n\tassets = initial.assets = path;\n}\n//#endregion\n//#region node_modules/@sveltejs/kit/src/runtime/app/env/internal.js\nvar version = \"1783982340628\";\nvar prerendering = false;\nfunction set_building() {}\nfunction set_prerendering() {\n\tprerendering = true;\n}\n//#endregion\nexport { app_dir as a, initial_base as c, set_assets as d, version as i, override as l, set_building as n, assets as o, set_prerendering as r, base as s, prerendering as t, reset as u };\n"],"names":[],"mappings":"AAAA;AACG,IAAC,IAAI,GAAG;AACR,IAAC,MAAM,GAAG;AACV,IAAC,OAAO,GAAG;AACd,IAAI,OAAO,GAAG;AACd,CAAC,IAAI;AACL,CAAC;AACD,CAAC;AAMD;AACA;AACA;AACA,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI;AAClB,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM;AACtB;AACA,SAAS,KAAK,GAAG;AACjB,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI;AACpB,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM;AACxB;;;;"}
+{"version":3,"file":"internal2.js-BlXt2rfE.js","sources":["../../../../.svelte-kit/output/server/chunks/internal2.js"],"sourcesContent":["//#region node_modules/@sveltejs/kit/src/runtime/app/paths/internal/server.js\nvar base = \"\";\nvar assets = base;\nvar app_dir = \"_app\";\nvar initial = {\n\tbase,\n\tassets\n};\n/**\n* `base` could be overridden during rendering to be relative;\n* this one's the original non-relative base path\n*/\nvar initial_base = initial.base;\n/**\n* @param {{ base: string, assets: string }} paths\n*/\nfunction override(paths) {\n\tbase = paths.base;\n\tassets = paths.assets;\n}\nfunction reset() {\n\tbase = initial.base;\n\tassets = initial.assets;\n}\n/** @param {string} path */\nfunction set_assets(path) {\n\tassets = initial.assets = path;\n}\n//#endregion\n//#region node_modules/@sveltejs/kit/src/runtime/app/env/internal.js\nvar version = \"1784103096725\";\nvar prerendering = false;\nfunction set_building() {}\nfunction set_prerendering() {\n\tprerendering = true;\n}\n//#endregion\nexport { app_dir as a, initial_base as c, set_assets as d, version as i, override as l, set_building as n, assets as o, set_prerendering as r, base as s, prerendering as t, reset as u };\n"],"names":[],"mappings":"AAAA;AACG,IAAC,IAAI,GAAG;AACR,IAAC,MAAM,GAAG;AACV,IAAC,OAAO,GAAG;AACd,IAAI,OAAO,GAAG;AACd,CAAC,IAAI;AACL,CAAC;AACD,CAAC;AAMD;AACA;AACA;AACA,SAAS,QAAQ,CAAC,KAAK,EAAE;AACzB,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI;AAClB,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM;AACtB;AACA,SAAS,KAAK,GAAG;AACjB,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI;AACpB,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM;AACxB;;;;"}

package/build/server/chunks/chunks/{library-store.js-ZLudCJlT.js → library-store.js-DJ-JRE-g.js}

@@ -1,9 +1,8 @@
-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 { p as plugins, a as audioPlugin, c as chromaKeyVideoPlugin, v as videoPlugin, s as slicePlugin, i as imagePlugin, b as assetIdError, n as normalizeFolderPath, f as folderOfRawPath, r as rawFileNameOfPath, d as folderPathError, e as parentFolderPath, g as folderNameError, j as joinFolderPath, h as folderNameOf, k as isFolderOrDescendant, l as replaceFolderPrefix, m as portableFolderPathKey, o as defaultInsetsForSize, q as manifestNameError, F as FOLDER_SENTINEL, t as rawFilePathError, u as portableRawPathKey, w as isFundusTransactionName, x as isAssetReference, y as validateVideoPreset, V as VIDEO_BUILT_IN_PRESETS, z as validateAudioPreset, A as AUDIO_BUILT_IN_PRESETS, B as validateImagePreset, I as IMAGE_BUILT_IN_PRESETS, S as SLICE_BUILT_IN_PRESETS } from './core.js-EA_ysb1J.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 { existsSync, constants } from 'node:fs';
+import { readFile, mkdir, writeFile, rename, unlink, rm, stat, readdir, open, lstat } from 'node:fs/promises';
 import ffmpegStaticPath from 'ffmpeg-static';
 import { path } from 'ffprobe-static';
 import { execFile } from 'node:child_process';
@@ -1004,6 +1003,310 @@ function encodeRelativePathForUrl(path) {
 	return path.split("/").map(encodeURIComponent).join("/");
 }
 //#endregion
+//#region src/lib/server/raw-reconciliation.ts
+function objectIdentity(value) {
+	return `${value.dev}:${value.ino}:${value.mode}`;
+}
+function fileIdentity(value) {
+	return `${objectIdentity(value)}:${value.size}:${value.mtimeNs}:${value.ctimeNs}`;
+}
+function pathMatchesHandle(pathStat, handleStat) {
+	return pathStat.isFile() && objectIdentity(pathStat) === objectIdentity(handleStat);
+}
+/** Hash one regular file without following its final path component. */
+async function stableRawFileHash(path) {
+	let lastProblem;
+	for (let attempt = 0; attempt < 3; attempt++) try {
+		const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+		try {
+			const before = await handle.stat({ bigint: true });
+			const pathBefore = await lstat(path, { bigint: true });
+			if (!before.isFile() || !pathMatchesHandle(pathBefore, before)) throw new Error("path is not the opened regular file");
+			const hash = createHash("sha256");
+			for await (const chunk of handle.createReadStream({ autoClose: false })) hash.update(chunk);
+			const after = await handle.stat({ bigint: true });
+			const pathAfter = await lstat(path, { bigint: true });
+			if (fileIdentity(before) === fileIdentity(after) && pathMatchesHandle(pathAfter, after)) return hash.digest("hex");
+			lastProblem = /* @__PURE__ */ new Error("changed while it was being hashed");
+		} finally {
+			await handle.close().catch(() => {});
+		}
+	} catch (cause) {
+		lastProblem = cause;
+	}
+	throw lastProblem instanceof Error ? lastProblem : new Error(String(lastProblem));
+}
+async function verifyStableRawFile(path, expectedHash) {
+	const actualHash = await stableRawFileHash(path);
+	if (actualHash !== expectedHash) throw new Error(`Raw source changed (expected ${expectedHash}, found ${actualHash}).`);
+}
+/** Enumerate without following symlinks and retain structural scan completeness. */
+async function scanRawDirectory(rawDir, includeFile = () => true) {
+	const files = [];
+	const blockers = [];
+	const diagnostics = [];
+	const occupiedPaths = /* @__PURE__ */ new Set();
+	const entryKinds = /* @__PURE__ */ new Map();
+	const ignoredRegularPaths = [];
+	let complete = true;
+	function markIncomplete(path, reason) {
+		complete = false;
+		diagnostics.push({
+			path,
+			reason
+		});
+	}
+	async function visit(folder) {
+		const absolutePath = join(rawDir, folder);
+		let before;
+		try {
+			before = await lstat(absolutePath, { bigint: true });
+		} catch (cause) {
+			markIncomplete(folder, `${folder === "" ? "Raw directory" : `Directory "${folder}"`} cannot be read: ${cause instanceof Error ? cause.message : String(cause)}`);
+			return;
+		}
+		if (!before.isDirectory() || before.isSymbolicLink()) {
+			markIncomplete(folder, `${folder === "" ? "Raw directory" : `Directory "${folder}"`} is not a regular directory.`);
+			return;
+		}
+		let entries;
+		try {
+			entries = await readdir(absolutePath, { withFileTypes: true });
+		} catch (cause) {
+			markIncomplete(folder, `${folder === "" ? "Raw directory" : `Directory "${folder}"`} cannot be traversed: ${cause instanceof Error ? cause.message : String(cause)}`);
+			return;
+		}
+		for (const entry of entries.sort((a, b) => compareCodeUnits(a.name, b.name))) {
+			const path = folder === "" ? entry.name : `${folder}/${entry.name}`;
+			if (entry.name === ".gitkeep" || isFundusTransactionName(entry.name)) continue;
+			if (entry.isDirectory()) {
+				occupiedPaths.add(path);
+				entryKinds.set(path, "directory");
+				const problem = folderPathError(path);
+				if (problem) blockers.push({
+					path,
+					reason: problem
+				});
+				else await visit(path);
+				continue;
+			}
+			if (entry.isFile()) {
+				if (!includeFile(path)) {
+					ignoredRegularPaths.push(path);
+					continue;
+				}
+				occupiedPaths.add(path);
+				entryKinds.set(path, "file");
+				const problem = rawFilePathError(path);
+				if (problem) {
+					blockers.push({
+						path,
+						reason: problem
+					});
+					continue;
+				}
+				try {
+					files.push({
+						path,
+						hash: await stableRawFileHash(join(rawDir, path))
+					});
+				} catch (cause) {
+					blockers.push({
+						path,
+						reason: `Could not obtain a stable file hash: ${cause instanceof Error ? cause.message : String(cause)}`
+					});
+				}
+				continue;
+			}
+			const kind = entry.isSymbolicLink() ? "symlink" : "special";
+			occupiedPaths.add(path);
+			entryKinds.set(path, kind);
+			blockers.push({
+				path,
+				reason: "Symlinks and special files are not supported."
+			});
+		}
+		try {
+			const after = await lstat(absolutePath, { bigint: true });
+			if (!after.isDirectory() || objectIdentity(before) !== objectIdentity(after)) markIncomplete(folder, `${folder === "" ? "Raw directory" : `Directory "${folder}"`} changed during traversal.`);
+		} catch (cause) {
+			markIncomplete(folder, `${folder === "" ? "Raw directory" : `Directory "${folder}"`} changed during traversal: ${cause instanceof Error ? cause.message : String(cause)}`);
+		}
+	}
+	await visit("");
+	const collisions = /* @__PURE__ */ new Map();
+	for (const path of [...occupiedPaths].sort(compareCodeUnits)) {
+		const key = portableRawPathKey(path);
+		const previous = collisions.get(key);
+		if (previous !== void 0 && previous !== path) {
+			const reason = `Raw paths "${previous}" and "${path}" collide portably.`;
+			blockers.push({
+				path: previous,
+				reason
+			});
+			blockers.push({
+				path,
+				reason
+			});
+		} else collisions.set(key, path);
+	}
+	const blockersByPath = /* @__PURE__ */ new Map();
+	for (const blocker of blockers) if (!blockersByPath.has(blocker.path)) blockersByPath.set(blocker.path, blocker);
+	const sortedBlockers = [...blockersByPath.values()].sort((a, b) => compareCodeUnits(a.path, b.path));
+	const blocked = new Set(sortedBlockers.map((entry) => entry.path));
+	return {
+		complete,
+		diagnostics: diagnostics.sort((a, b) => compareCodeUnits(a.path, b.path)),
+		files: files.filter((entry) => !blocked.has(entry.path)).sort((a, b) => compareCodeUnits(a.path, b.path)),
+		blockers: sortedBlockers,
+		occupiedPaths,
+		entryKinds,
+		ignoredRegularPaths: ignoredRegularPaths.sort(compareCodeUnits)
+	};
+}
+/** Pure deterministic matching: exact path first, then only 1:1 hash groups. */
+function classifyRawFiles(library, scan) {
+	const filesByPath = new Map(scan.files.map((file) => [file.path, file]));
+	const remainingFiles = new Map(filesByPath);
+	const remainingRecords = /* @__PURE__ */ new Map();
+	const unchangedAssetIds = [];
+	const edited = [];
+	const blockers = [...scan.blockers];
+	const excludedPrefixes = [];
+	for (const assetId of Object.keys(library.assets).sort(compareCodeUnits)) {
+		const record = library.assets[assetId];
+		const kind = scan.entryKinds.get(record.raw);
+		if (kind !== void 0 && kind !== "file") {
+			const existing = blockers.find((blocker) => blocker.path === record.raw);
+			if (existing) existing.assetId = assetId;
+			else blockers.push({
+				assetId,
+				path: record.raw,
+				reason: `Managed raw path is occupied by a ${kind}.`
+			});
+			excludedPrefixes.push(record.raw);
+			continue;
+		}
+		const exact = filesByPath.get(record.raw);
+		if (exact) {
+			remainingFiles.delete(record.raw);
+			if (exact.hash === record.rawHash) unchangedAssetIds.push(assetId);
+			else edited.push({
+				assetId,
+				...exact
+			});
+		} else if (scan.complete && !scan.occupiedPaths.has(record.raw) && !scan.blockers.some((blocker) => record.raw === blocker.path || record.raw.startsWith(`${blocker.path}/`))) remainingRecords.set(assetId, {
+			path: record.raw,
+			hash: record.rawHash
+		});
+	}
+	for (const path of remainingFiles.keys()) if (excludedPrefixes.some((prefix) => path.startsWith(`${prefix}/`))) remainingFiles.delete(path);
+	const recordsByHash = /* @__PURE__ */ new Map();
+	for (const [assetId, record] of remainingRecords) recordsByHash.set(record.hash, [...recordsByHash.get(record.hash) ?? [], assetId]);
+	const filesByHash = /* @__PURE__ */ new Map();
+	for (const file of remainingFiles.values()) filesByHash.set(file.hash, [...filesByHash.get(file.hash) ?? [], file]);
+	const moves = [];
+	if (scan.complete) for (const [hash, assetIds] of recordsByHash) {
+		const candidates = filesByHash.get(hash) ?? [];
+		if (assetIds.length !== 1 || candidates.length !== 1) continue;
+		const assetId = assetIds[0];
+		const file = candidates[0];
+		moves.push({
+			assetId,
+			from: remainingRecords.get(assetId)?.path ?? "",
+			...file
+		});
+		remainingRecords.delete(assetId);
+		remainingFiles.delete(file.path);
+	}
+	const blockerKeys = /* @__PURE__ */ new Set();
+	const uniqueBlockers = blockers.filter((blocker) => {
+		const key = `${blocker.assetId ?? ""}|${blocker.path}`;
+		if (blockerKeys.has(key)) return false;
+		blockerKeys.add(key);
+		return true;
+	});
+	return {
+		complete: scan.complete,
+		diagnostics: scan.diagnostics,
+		unchangedAssetIds,
+		edited: edited.sort((a, b) => compareCodeUnits(a.path, b.path)),
+		moves: scan.complete ? moves.sort((a, b) => compareCodeUnits(a.path, b.path)) : [],
+		deletions: scan.complete ? [...remainingRecords].map(([assetId, record]) => ({
+			assetId,
+			path: record.path
+		})) : [],
+		unmanaged: [...remainingFiles.values()].sort((a, b) => compareCodeUnits(a.path, b.path)),
+		blockers: uniqueBlockers.sort((a, b) => compareCodeUnits(a.path, b.path))
+	};
+}
+async function classifyRawDirectory(rawDir, library, includeExternalFile = () => true) {
+	const managedPaths = new Set(Object.values(library.assets).map((record) => record.raw));
+	const scan = await scanRawDirectory(rawDir, (path) => managedPaths.has(path) || includeExternalFile(path));
+	const classification = classifyRawFiles(library, scan);
+	if (!classification.complete || classification.deletions.length === 0) return classification;
+	const ignoredByHash = /* @__PURE__ */ new Map();
+	for (const path of scan.ignoredRegularPaths) try {
+		const hash = await stableRawFileHash(join(rawDir, path));
+		ignoredByHash.set(hash, [...ignoredByHash.get(hash) ?? [], path]);
+	} catch (cause) {
+		return {
+			...classification,
+			complete: false,
+			diagnostics: [...classification.diagnostics, {
+				path,
+				reason: `Could not safely check ignored raw file "${path}" while managed files were missing: ${cause instanceof Error ? cause.message : String(cause)}`
+			}].sort((a, b) => compareCodeUnits(a.path, b.path)),
+			moves: [],
+			deletions: []
+		};
+	}
+	const missingByHash = /* @__PURE__ */ new Map();
+	for (const deletion of classification.deletions) {
+		const hash = library.assets[deletion.assetId].rawHash;
+		missingByHash.set(hash, [...missingByHash.get(hash) ?? [], deletion]);
+	}
+	const supportedByHash = /* @__PURE__ */ new Map();
+	for (const file of classification.unmanaged) supportedByHash.set(file.hash, [...supportedByHash.get(file.hash) ?? [], file.path]);
+	const protectedAssetIds = /* @__PURE__ */ new Set();
+	const unsupportedBlockers = [];
+	const ambiguityDiagnostics = [];
+	for (const [hash, ignoredPaths] of ignoredByHash) {
+		const missing = missingByHash.get(hash) ?? [];
+		if (missing.length === 0) continue;
+		const candidatePaths = [...supportedByHash.get(hash) ?? [], ...ignoredPaths].sort(compareCodeUnits);
+		const sortedMissing = [...missing].sort((a, b) => compareCodeUnits(a.assetId, b.assetId));
+		if (sortedMissing.length === 1 && ignoredPaths.length === 1 && candidatePaths.length === 1) {
+			const [{ assetId, path: oldPath }] = sortedMissing;
+			const [destination] = ignoredPaths;
+			protectedAssetIds.add(assetId);
+			unsupportedBlockers.push({
+				assetId,
+				path: destination,
+				reason: `Asset "${assetId}" was moved from "${oldPath}" to unsupported path "${destination}". Rename it externally to a supported extension.`
+			});
+			continue;
+		}
+		ambiguityDiagnostics.push({
+			path: candidatePaths[0] ?? "",
+			reason: `Ignored raw files ambiguously match missing assets [${sortedMissing.map((entry) => entry.assetId).join(", ")}] and candidate paths [${candidatePaths.join(", ")}]. Restore or reduce the external files until the match is unique.`
+		});
+	}
+	if (ambiguityDiagnostics.length > 0) return {
+		...classification,
+		complete: false,
+		diagnostics: [...classification.diagnostics, ...ambiguityDiagnostics].sort((a, b) => compareCodeUnits(`${a.path}|${a.reason}`, `${b.path}|${b.reason}`)),
+		moves: [],
+		deletions: [],
+		blockers: [...classification.blockers, ...unsupportedBlockers].sort((a, b) => compareCodeUnits(a.path, b.path))
+	};
+	return {
+		...classification,
+		deletions: classification.deletions.filter((deletion) => !protectedAssetIds.has(deletion.assetId)),
+		blockers: [...classification.blockers, ...unsupportedBlockers].sort((a, b) => compareCodeUnits(a.path, b.path))
+	};
+}
+//#endregion
 //#region src/lib/server/processing/processor.ts
 /**
 * The processing pipeline: every delivered asset gets exactly one
@@ -1094,6 +1397,7 @@ async function processAssetFile(record, rawPath, proxyPath, config, registry) {
 	const stem = basename(proxyPath, extension);
 	const temporaryPath = join(dirname(proxyPath), `.${stem}.${crypto.randomUUID()}.tmp${extension}`);
 	try {
+		await verifyStableRawFile(rawPath, record.rawHash);
 		const output = await plugin.process({
 			sourcePath: rawPath,
 			targetPath: temporaryPath,
@@ -1101,6 +1405,7 @@ async function processAssetFile(record, rawPath, proxyPath, config, registry) {
 			preset: plugin.resolvePreset(parameters, config),
 			config
 		});
+		await verifyStableRawFile(rawPath, record.rawHash);
 		await rename(temporaryPath, proxyPath);
 		return output;
 	} catch (cause) {
@@ -1165,22 +1470,10 @@ async function processAssets(config, library, registry = serverPluginsByType) {
 * 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. */
-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}".`);
-}
 /** 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);
-	}
+	const problem = rawFilePathError(filePath);
+	if (problem) throw new Error(problem);
 }
 /**
 * Turn an arbitrary uploaded file name (spaces, umlauts, parentheses, nested
@@ -1232,6 +1525,30 @@ var LibraryStore = class {
 		await rename(temporaryPath, this.#config.library);
 	}
 	/**
+	* Candidate-first source transaction used for externally-owned raw files.
+	* The callback runs after entering the store queue and may scan the raw tree;
+	* Fundus writes only the library candidate and never touches external bytes.
+	*/
+	async transactCandidate(change) {
+		return this.#enqueue(async () => {
+			const current = await this.read();
+			const before = serializeLibrary(current);
+			const candidate = structuredClone(current);
+			const value = await change(candidate, current);
+			const changed = serializeLibrary(candidate) !== before;
+			if (changed) await this.write(candidate);
+			return {
+				library: candidate,
+				value,
+				changed
+			};
+		});
+	}
+	/** Remove derived proxies after a source record was externally deleted/moved. */
+	async deleteProxiesOf(assetId) {
+		await this.#deleteProxiesOf(assetId);
+	}
+	/**
 	* 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.
@@ -1264,6 +1581,57 @@ var LibraryStore = class {
 		await this.write(library);
 		return library;
 	}
+	/**
+	* Replace one asset's raw file while preserving its identity and authored
+	* metadata. The replacement stays in the current folder, receives a safe
+	* non-colliding name, and must be accepted by the asset's existing type.
+	*/
+	async replaceRawFile(id, options) {
+		return this.#enqueue(() => this.#replaceRawFile(id, options));
+	}
+	async #replaceRawFile(id, options) {
+		const library = await this.read();
+		const record = this.#requireAsset(library, id);
+		const sanitizedName = sanitizeFileName(options.fileName);
+		const extension = extname(sanitizedName).slice(1).toLowerCase();
+		const plugin = serverPluginForType(record.type, this.#registry);
+		if (!plugin.descriptor.accepts.includes(extension)) throw new Error(`The ${record.type} type does not accept ".${extension}" files (accepts: ${plugin.descriptor.accepts.join(", ")}).`);
+		const previousRaw = record.raw;
+		const previousHash = record.rawHash;
+		const folder = folderOfRawPath(previousRaw);
+		const previousName = rawFileNameOfPath(previousRaw);
+		const storedName = sanitizedName === previousName ? previousName : this.#uniqueRawName(sanitizedName, folder);
+		const nextRaw = folder === "" ? storedName : `${folder}/${storedName}`;
+		const previousPath = join(this.#config.rawDir, previousRaw);
+		const nextPath = join(this.#config.rawDir, nextRaw);
+		const token = crypto.randomUUID();
+		const temporaryPath = join(this.#config.rawDir, folder, `.fundus-replace-${token}.tmp`);
+		const backupPath = `${previousPath}.fundus-replace-${token}`;
+		let previousStaged = false;
+		let replacementInstalled = false;
+		await mkdir(dirname(temporaryPath), { recursive: true });
+		try {
+			await writeFile(temporaryPath, options.bytes);
+			if (existsSync(previousPath)) {
+				await rename(previousPath, backupPath);
+				previousStaged = true;
+			}
+			await rename(temporaryPath, nextPath);
+			replacementInstalled = true;
+			record.raw = nextRaw;
+			record.rawHash = sha256Hex(options.bytes);
+			await this.write(library);
+		} catch (cause) {
+			record.raw = previousRaw;
+			record.rawHash = previousHash;
+			if (replacementInstalled) await unlink(nextPath).catch(() => {});
+			if (previousStaged) await rename(backupPath, previousPath);
+			await unlink(temporaryPath).catch(() => {});
+			throw cause;
+		}
+		if (previousStaged) await unlink(backupPath).catch(() => {});
+		return library;
+	}
 	/** Replace an asset's parameters (validated by the owning plugin). */
 	async updateParameters(id, parameters) {
 		return this.#enqueue(() => this.#updateParameters(id, parameters));
@@ -1764,5 +2132,5 @@ var LibraryStore = class {
 	}
 };
 
-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
+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, classifyRawDirectory as j, assertSafeRelativeFilePath as k, processAssets as p, readCurrentProxy as r, serverPluginsByType as s, verifyStableRawFile as v };
+//# sourceMappingURL=library-store.js-DJ-JRE-g.js.map