fundus 0.2.0 → 0.4.0

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

@@ -1,8 +1,10 @@
-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 { a as plugins, b as audioPlugin, c as chromaKeyVideoPlugin, v as videoPlugin, s as slicePlugin, d as imagePlugin, n as normalizeFolderPath, e as folderOfRawPath, g as rawFileNameOfPath, f as folderPathError, h as parentFolderPath, j as folderNameError, k as joinFolderPath, l as folderNameOf, m as isFolderOrDescendant, o as replaceFolderPrefix, q as portableFolderPathKey, t as defaultInsetsForSize, F as FOLDER_SENTINEL, r as rawFilePathError, u as isAssetReference, w as validateVideoPreset, V as VIDEO_BUILT_IN_PRESETS, x as validateAudioPreset, A as AUDIO_BUILT_IN_PRESETS, y as validateImagePreset, I as IMAGE_BUILT_IN_PRESETS, S as SLICE_BUILT_IN_PRESETS } from './core.js-Clg1CHb6.js';
+import { a as assetIdError, m as manifestNameError } from './asset-id.js-CFsW8jeL.js';
 import { m as manifestColorError, a as manifestEmojiError } from './manifest-appearance.js-DTk355LQ.js';
+import { c as canonicalizeParameters, a as compareCodeUnits, v as verifyStableRawFile } from './raw-reconciliation.js-DOFtjkgu.js';
 import { join, extname, dirname, basename, isAbsolute, resolve } from 'node:path';
-import { existsSync, constants } from 'node:fs';
-import { readFile, mkdir, writeFile, rename, unlink, rm, stat, readdir, open, lstat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { readFile, mkdir, writeFile, rename, unlink, rm, stat, readdir } from 'node:fs/promises';
 import ffmpegStaticPath from 'ffmpeg-static';
 import { path } from 'ffprobe-static';
 import { execFile } from 'node:child_process';
@@ -37,20 +39,32 @@ var DANGEROUS_KEYS = [
 function assertSafeKey(kind, key) {
 	if (DANGEROUS_KEYS.includes(key)) throw new Error(`Library ${kind} key "${key}" is not allowed.`);
 }
-function parseAssetRecord(id, value) {
+function parseImportSource(id, value) {
+	if (!isRecord$1(value)) throw new Error(`Library asset "${id}" has a non-object "importSource".`);
+	if (typeof value.importer !== "string" || value.importer.length === 0) throw new Error(`Library asset "${id}" has an invalid import source "importer".`);
+	if (!("parameters" in value)) throw new Error(`Library asset "${id}" import source is missing "parameters".`);
+	return {
+		importer: value.importer,
+		parameters: value.parameters
+	};
+}
+function parseAssetRecord(id, value, version) {
 	if (!isRecord$1(value)) throw new Error(`Library asset "${id}" must be an object.`);
 	if (typeof value.type !== "string" || value.type.length === 0) throw new Error(`Library asset "${id}" is missing a string "type".`);
 	if (typeof value.raw !== "string" || value.raw.length === 0) throw new Error(`Library asset "${id}" is missing a string "raw" file name.`);
 	if (typeof value.rawHash !== "string" || value.rawHash.length === 0) throw new Error(`Library asset "${id}" is missing a string "rawHash".`);
 	if (!("parameters" in value)) throw new Error(`Library asset "${id}" is missing "parameters".`);
 	if (!Array.isArray(value.manifests) || value.manifests.some((entry) => typeof entry !== "string")) throw new Error(`Library asset "${id}" must have a "manifests" array of strings.`);
-	return {
+	if (version === 1 && value.importSource !== void 0) throw new Error(`Library asset "${id}" uses "importSource", which requires library version 2.`);
+	const record = {
 		type: value.type,
 		raw: value.raw,
 		rawHash: value.rawHash,
 		parameters: value.parameters,
 		manifests: value.manifests
 	};
+	if (value.importSource !== void 0) record.importSource = parseImportSource(id, value.importSource);
+	return record;
 }
 function parseManifestRecord(name, value) {
 	const record = {};
@@ -77,7 +91,7 @@ function parseLibrary(json) {
 		throw new Error(`Library file is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
 	}
 	if (!isRecord$1(value)) throw new Error("Library file must contain a JSON object.");
-	if (value.version !== 1) throw new Error(`Unsupported library version ${JSON.stringify(value.version)} (expected 1).`);
+	if (value.version !== 1 && value.version !== 2) throw new Error(`Unsupported library version ${JSON.stringify(value.version)} (expected 1 or 2).`);
 	if (!isRecord$1(value.assets)) throw new Error("Library \"assets\" must be an object.");
 	if (!isRecord$1(value.manifests)) throw new Error("Library \"manifests\" must be an object.");
 	if (value.folders !== void 0 && (!Array.isArray(value.folders) || value.folders.some((entry) => typeof entry !== "string"))) throw new Error("Library \"folders\" must be an array of strings.");
@@ -89,7 +103,7 @@ function parseLibrary(json) {
 	const assets = {};
 	for (const [id, record] of Object.entries(value.assets)) {
 		assertSafeKey("asset", id);
-		assets[id] = parseAssetRecord(id, record);
+		assets[id] = parseAssetRecord(id, record, value.version);
 	}
 	const manifests = {};
 	for (const [name, record] of Object.entries(value.manifests)) {
@@ -98,7 +112,7 @@ function parseLibrary(json) {
 		manifests[name] = parseManifestRecord(name, record);
 	}
 	return {
-		version: 1,
+		version: value.version,
 		folders,
 		assets,
 		manifests
@@ -123,43 +137,16 @@ function sortValue(value) {
 * insertion order was.
 */
 function serializeLibrary(library) {
+	if (library.version === 1) {
+		const sourced = Object.entries(library.assets).find(([, record]) => record.importSource);
+		if (sourced) throw new Error(`Library asset "${sourced[0]}" uses "importSource", which requires library version 2.`);
+	}
 	return `${JSON.stringify(sortValue({
 		...library,
 		folders: [...library.folders].sort()
 	}), null, "	")}\n`;
 }
 //#endregion
-//#region src/lib/core/canonicalize.ts
-/**
-* Stable JSON for hash inputs: recursively sorted keys, no whitespace,
-* `undefined` object values dropped. Two parameter objects that differ only in
-* key order (or in explicitly-undefined optionals) canonicalize identically,
-* so the derived job hash — and thus the proxy file name — stays stable.
-*/
-function canonicalizeParameters(parameters) {
-	return stringify(parameters);
-}
-/** Deterministic UTF-16 code-unit ordering, independent of host locale. */
-function compareCodeUnits(left, right) {
-	return left < right ? -1 : left > right ? 1 : 0;
-}
-function stringify(value) {
-	if (value === void 0) return "null";
-	if (value === null || typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
-	if (typeof value === "string") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(stringify).join(",")}]`;
-	if (typeof value === "object") {
-		const record = value;
-		const parts = [];
-		for (const key of Object.keys(record).sort()) {
-			if (record[key] === void 0) continue;
-			parts.push(`${JSON.stringify(key)}:${stringify(record[key])}`);
-		}
-		return `{${parts.join(",")}}`;
-	}
-	throw new Error(`Cannot canonicalize a ${typeof value} value.`);
-}
-//#endregion
 //#region src/lib/core/reference-graph.ts
 /**
 * Ask each asset's owning plugin for the references in its parameters. Assets
@@ -1003,310 +990,6 @@ 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
@@ -1554,9 +1237,12 @@ var LibraryStore = class {
 	* the owning plugin's default parameters. Returns the updated library.
 	*/
 	async ingest(options) {
-		return this.#enqueue(() => this.#ingest(options));
+		return this.createAsset(options);
 	}
-	async #ingest(options) {
+	async createAsset(options, prepareParameters) {
+		return this.#enqueue(() => this.#createAsset(options, prepareParameters));
+	}
+	async #createAsset(options, prepareParameters) {
 		const idProblem = assetIdError(options.id);
 		if (idProblem) throw new Error(idProblem);
 		const plugin = serverPluginForType(options.type, this.#registry);
@@ -1566,20 +1252,49 @@ var LibraryStore = class {
 		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 manifests = [...new Set(options.manifests ?? [])].sort();
+		for (const manifest of manifests) if (!Object.hasOwn(library.manifests, manifest)) throw new Error(`Unknown manifest "${manifest}".`);
+		const rawDirectory = join(this.#config.rawDir, folder);
+		await mkdir(rawDirectory, { 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;
+		const finalPath = join(this.#config.rawDir, storedPath);
+		const temporaryPath = join(rawDirectory, `.fundus-create-${crypto.randomUUID()}.tmp`);
+		let installed = false;
+		try {
+			await writeFile(temporaryPath, options.bytes);
+			let parameters = plugin.descriptor.validateParameters(plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)));
+			if (prepareParameters) parameters = plugin.descriptor.validateParameters(await prepareParameters({
+				rawPath: temporaryPath,
+				rawFileName: storedName,
+				parameters
+			}));
+			const record = {
+				type: options.type,
+				raw: storedPath,
+				rawHash: sha256Hex(options.bytes),
+				parameters,
+				manifests
+			};
+			if (options.importSource) {
+				record.importSource = structuredClone(options.importSource);
+				library.version = 2;
+			}
+			library.assets[options.id] = record;
+			parseLibrary(serializeLibrary(library));
+			await rename(temporaryPath, finalPath);
+			installed = true;
+			await this.write(library);
+			return library;
+		} catch (cause) {
+			const cleanupErrors = [];
+			if (installed) await unlink(finalPath).catch((error) => cleanupErrors.push(error));
+			await unlink(temporaryPath).catch((error) => {
+				if (error.code !== "ENOENT") cleanupErrors.push(error);
+			});
+			if (cleanupErrors.length > 0) throw new AggregateError([cause, ...cleanupErrors], "Asset creation failed and cleanup was incomplete.");
+			throw cause;
+		}
 	}
 	/**
 	* Replace one asset's raw file while preserving its identity and authored
@@ -1598,6 +1313,7 @@ var LibraryStore = class {
 		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 previousSource = record.importSource;
 		const folder = folderOfRawPath(previousRaw);
 		const previousName = rawFileNameOfPath(previousRaw);
 		const storedName = sanitizedName === previousName ? previousName : this.#uniqueRawName(sanitizedName, folder);
@@ -1620,10 +1336,12 @@ var LibraryStore = class {
 			replacementInstalled = true;
 			record.raw = nextRaw;
 			record.rawHash = sha256Hex(options.bytes);
+			delete record.importSource;
 			await this.write(library);
 		} catch (cause) {
 			record.raw = previousRaw;
 			record.rawHash = previousHash;
+			if (previousSource) record.importSource = previousSource;
 			if (replacementInstalled) await unlink(nextPath).catch(() => {});
 			if (previousStaged) await rename(backupPath, previousPath);
 			await unlink(temporaryPath).catch(() => {});
@@ -1632,6 +1350,47 @@ var LibraryStore = class {
 		if (previousStaged) await unlink(backupPath).catch(() => {});
 		return library;
 	}
+	/** CAS-protected replacement used only by a repeatable import source. */
+	async replaceRawFromImportSource(id, bytes, expected, nextSource) {
+		return this.#enqueue(async () => {
+			const library = await this.read();
+			const record = this.#requireAsset(library, id);
+			if (record.raw !== expected.raw || record.rawHash !== expected.rawHash || record.type !== expected.type || !record.importSource || canonicalizeParameters(record.importSource) !== expected.canonicalSource) throw new Error("stale-import");
+			const absolutePath = join(this.#config.rawDir, record.raw);
+			const { verifyStableRawFile } = await import('./raw-reconciliation2.js-DFwky2ou.js');
+			try {
+				await verifyStableRawFile(absolutePath, expected.rawHash);
+			} catch {
+				throw new Error("stale-import");
+			}
+			const token = crypto.randomUUID();
+			const temporaryPath = `${absolutePath}.fundus-reimport-${token}.tmp`;
+			const backupPath = `${absolutePath}.fundus-reimport-${token}`;
+			const previousHash = record.rawHash;
+			const previousSource = structuredClone(record.importSource);
+			let staged = false;
+			let installed = false;
+			try {
+				await writeFile(temporaryPath, bytes);
+				await rename(absolutePath, backupPath);
+				staged = true;
+				await rename(temporaryPath, absolutePath);
+				installed = true;
+				record.rawHash = sha256Hex(bytes);
+				if (nextSource) record.importSource = structuredClone(nextSource);
+				await this.write(library);
+			} catch (cause) {
+				record.rawHash = previousHash;
+				record.importSource = previousSource;
+				if (installed) await unlink(absolutePath).catch(() => {});
+				if (staged) await rename(backupPath, absolutePath);
+				await unlink(temporaryPath).catch(() => {});
+				throw cause;
+			}
+			if (staged) 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));
@@ -2131,6 +1890,21 @@ var LibraryStore = class {
 		if (collision !== void 0) throw new Error(`Folder "${path}" collides with existing folder "${collision}".`);
 	}
 };
+//#endregion
+//#region src/lib/server/importers/contract.ts
+var SourceImportError = class extends Error {
+	code;
+	retryAfterSeconds;
+	constructor(code, message, retryAfterSeconds) {
+		super(message);
+		this.name = "SourceImportError";
+		this.code = code;
+		this.retryAfterSeconds = retryAfterSeconds;
+	}
+};
+function invalidInput(message) {
+	throw new SourceImportError("invalid-input", message);
+}
 
-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
+export { LibraryStore as L, SourceImportError as S, serverPluginForType as a, computeLibraryMembership as b, collectAllReferences as c, descriptorsByType as d, allDeliveredAssetIds as e, encodeRelativePathForUrl as f, generateManifestModules as g, invalidInput as h, isRecord as i, assertSafeRelativeFilePath as j, processAssets as p, readCurrentProxy as r, serverPluginsByType as s };
+//# sourceMappingURL=contract.js-sHny3b-s.js.map