fundus 0.0.4 → 0.2.0

package/build/client/_app/version.json

@@ -1 +1 @@
-{"version":"1783982340628"}
+{"version":"1784103096725"}

package/build/client/favicon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+	<rect width="64" height="64" rx="14" fill="#1e1e1e" />
+	<path d="M32 7 57 32 32 57 7 32Z" fill="#0d99ff" />
+</svg>

package/build/handler.js

@@ -2,9 +2,9 @@ import './shims.js';
 import 'node:fs';
 import 'node:path';
 import 'node:process';
-export { h as handler } from './server/chunks/handler-DnbS2t1B.js';
-import './server/chunks/index.js-g77q3Boj.js';
-import './server/chunks/manifest.js-qmEXbstS.js';
+export { h as handler } from './server/chunks/handler-DZ2Sps4a.js';
+import './server/chunks/index.js-CdmTWQz8.js';
+import './server/chunks/manifest.js-GhfNr35x.js';
 import './env.js';
 import 'node:buffer';
 import 'node:crypto';
@@ -12,11 +12,11 @@ import 'node:http';
 import 'node:timers';
 import 'node:querystring';
 import 'node:stream';
-import './server/chunks/chunks/shared.js-B1gC9MiJ.js';
-import './server/chunks/chunks/internal.js-DGo2jPcg.js';
-import './server/chunks/chunks/utils.js-DnEJ3UjO.js';
+import './server/chunks/chunks/shared.js-Dob0TlTu.js';
+import './server/chunks/chunks/internal.js-Dn37LrAW.js';
+import './server/chunks/chunks/utils.js-B4YimMxv.js';
 import 'node:url';
 import './server/chunks/chunks/internal2.js-BlXt2rfE.js';
-import './server/chunks/chunks/exports.js-C0rwMMtk.js';
+import './server/chunks/chunks/exports.js-DvhE7Ffd.js';
 import './server/chunks/chunks/routing.js-y-tryuip.js';
 //# sourceMappingURL=handler.js.map

package/build/index.js

@@ -1,7 +1,7 @@
 import http from 'node:http';
 import fs__default from 'node:fs';
 import process from 'node:process';
-import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-DnbS2t1B.js';
+import { p as polka, h as handler, f as format_listening_address } from './server/chunks/handler-DZ2Sps4a.js';
 import { env, timeout_env } from './env.js';
 import { rm } from 'node:fs/promises';
 import './shims.js';
@@ -11,14 +11,14 @@ import 'node:path';
 import 'node:timers';
 import 'node:querystring';
 import 'node:stream';
-import './server/chunks/chunks/shared.js-B1gC9MiJ.js';
-import './server/chunks/chunks/internal.js-DGo2jPcg.js';
-import './server/chunks/chunks/utils.js-DnEJ3UjO.js';
-import './server/chunks/index.js-g77q3Boj.js';
+import './server/chunks/chunks/shared.js-Dob0TlTu.js';
+import './server/chunks/chunks/internal.js-Dn37LrAW.js';
+import './server/chunks/chunks/utils.js-B4YimMxv.js';
+import './server/chunks/index.js-CdmTWQz8.js';
 import './server/chunks/chunks/internal2.js-BlXt2rfE.js';
-import './server/chunks/chunks/exports.js-C0rwMMtk.js';
+import './server/chunks/chunks/exports.js-DvhE7Ffd.js';
 import './server/chunks/chunks/routing.js-y-tryuip.js';
-import './server/chunks/manifest.js-qmEXbstS.js';
+import './server/chunks/manifest.js-GhfNr35x.js';
 import 'node:url';
 
 const path = env('SOCKET_PATH', false);

package/build/server/chunks/chunks/{context.js-BUZqFfWG.js → context.js-B77ZAVLi.js}

@@ -1,6 +1,5 @@
-import './core.js-xfrkaQpS.js';
-import { r as rawFileNameOfPath, f as folderOfRawPath } from './folder-path.js-ytx9ucgg.js';
-import { s as serverPluginsByType, i as isRecord, L as LibraryStore, a as serverPluginForType, p as processAssets, g as generateManifestModules, c as collectAllReferences, d as descriptorsByType, b as computeLibraryMembership, e as allDeliveredAssetIds, f as compareCodeUnits, r as readCurrentProxy, h as encodeRelativePathForUrl } from './library-store.js-ZLudCJlT.js';
+import { f as folderOfRawPath, r as rawFileNameOfPath, C as typesForFileName, D as proposeAssetId, e as parentFolderPath, m as portableFolderPathKey, b as assetIdError } from './core.js-EA_ysb1J.js';
+import { s as serverPluginsByType, i as isRecord, L as LibraryStore, a as serverPluginForType, v as verifyStableRawFile, p as processAssets, g as generateManifestModules, c as collectAllReferences, d as descriptorsByType, b as computeLibraryMembership, e as allDeliveredAssetIds, f as compareCodeUnits, r as readCurrentProxy, h as encodeRelativePathForUrl, j as classifyRawDirectory } from './library-store.js-DJ-JRE-g.js';
 import { isAbsolute, resolve, join } from 'node:path';
 import { existsSync } from 'node:fs';
 import { createJiti } from 'jiti';
@@ -63,6 +62,60 @@ async function loadConfig(projectRoot) {
 	return resolveConfig(root, isRecord(module) && "default" in module ? module.default : module);
 }
 //#endregion
+//#region src/lib/server/raw-safety.ts
+function rawSafetyIssueKey(issue) {
+	return `${issue.kind}|${issue.assetId ?? ""}|${issue.path}`;
+}
+/** Managed-source safety gate shared by editor operations and `fundus build`. */
+function rawSafetyIssues(library, classification, compatibleTypes) {
+	const issues = [];
+	if (!classification.complete) for (const diagnostic of classification.diagnostics) issues.push({
+		kind: "incomplete",
+		path: diagnostic.path,
+		message: diagnostic.reason
+	});
+	for (const blocker of classification.blockers) {
+		const affected = blocker.assetId ? [blocker.assetId] : Object.entries(library.assets).filter(([, record]) => record.raw === blocker.path || record.raw.startsWith(`${blocker.path}/`)).map(([assetId]) => assetId);
+		for (const assetId of affected) issues.push({
+			kind: "blocker",
+			path: blocker.path,
+			assetId,
+			message: `Raw source "${blocker.path}" is unsafe: ${blocker.reason}`
+		});
+	}
+	for (const missing of classification.deletions) issues.push({
+		kind: "missing",
+		path: missing.path,
+		assetId: missing.assetId,
+		message: `Raw file "${missing.path}" is missing from the raw directory.`
+	});
+	for (const move of classification.moves) issues.push({
+		kind: "missing",
+		path: move.from,
+		assetId: move.assetId,
+		message: `Raw file "${move.from}" is missing from the raw directory.`
+	});
+	for (const edited of classification.edited) issues.push({
+		kind: "edited",
+		path: edited.path,
+		assetId: edited.assetId,
+		message: `Raw file "${edited.path}" changed outside Fundus.`
+	});
+	for (const [assetId, record] of Object.entries(library.assets)) if (!compatibleTypes(record.raw).includes(record.type)) issues.push({
+		kind: "type-incompatible",
+		path: record.raw,
+		assetId,
+		message: `Raw file "${record.raw}" is not compatible with its current ${record.type} type.`
+	});
+	const seen = /* @__PURE__ */ new Set();
+	return issues.filter((issue) => {
+		const key = rawSafetyIssueKey(issue);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+//#endregion
 //#region src/lib/server/operations.ts
 /**
 * The one operations layer: builds the state payload and runs
@@ -89,6 +142,8 @@ var FundusOperations = class {
 	#config;
 	#registry;
 	#store;
+	#operationQueue = Promise.resolve();
+	#pipelineQueue = Promise.resolve();
 	constructor(config, registry = serverPluginsByType) {
 		this.#config = config;
 		this.#registry = registry;
@@ -100,9 +155,146 @@ var FundusOperations = class {
 	get store() {
 		return this.#store;
 	}
-	/** Read-only state snapshot (no processing). */
-	async state() {
-		return this.#buildState(await this.#store.read(), []);
+	#enqueueOperation(operation) {
+		const run = this.#operationQueue.then(operation, operation);
+		this.#operationQueue = run.then(() => {}, () => {});
+		return run;
+	}
+	/** Read-only state snapshot, serialized with mutations but never processing or writing. */
+	state() {
+		return this.#enqueueOperation(() => this.#state());
+	}
+	async #state() {
+		await this.#pipelineQueue;
+		const library = await this.#store.read();
+		const classification = await this.#classifyRawDirectory(library);
+		return this.#snapshotState(library, classification);
+	}
+	/** Reconcile only changes that are safe without a user decision: unique moves and deletions. */
+	reconcileRawState() {
+		return this.#enqueueOperation(async () => {
+			let library = await this.#store.read();
+			let classification = await this.#classifyRawDirectory(library);
+			if (!this.#canAutoReconcile(classification)) return this.#snapshotState(library, classification);
+			for (let pass = 0; pass < 2; pass++) {
+				const result = await this.#store.transactCandidate(async (candidate, current) => {
+					const fresh = await this.#classifyRawDirectory(current);
+					const affectedIds = [];
+					if (!this.#canAutoReconcile(fresh)) return {
+						classification: fresh,
+						affectedIds
+					};
+					for (const move of fresh.moves) {
+						candidate.assets[move.assetId].raw = move.path;
+						this.#registerFolderAncestors(candidate, folderOfRawPath(move.path));
+						affectedIds.push(move.assetId);
+					}
+					for (const deletion of fresh.deletions) {
+						delete candidate.assets[deletion.assetId];
+						affectedIds.push(deletion.assetId);
+					}
+					return {
+						classification: fresh,
+						affectedIds
+					};
+				});
+				library = result.library;
+				classification = result.value.classification;
+				if (!result.changed) return this.#snapshotState(library, classification);
+				await this.#store.syncFolders(library);
+				for (const id of result.value.affectedIds) await this.#store.deleteProxiesOf(id);
+				const snapshot = await this.#afterMutationSnapshot(library);
+				library = snapshot.library;
+				classification = snapshot.classification;
+				if (classification.moves.length === 0 && classification.deletions.length === 0) return snapshot.state;
+				if (!this.#canAutoReconcile(classification, true)) return snapshot.state;
+			}
+			return this.#snapshotState(library, classification, [{ message: "Raw directory kept changing during reconciliation; refresh again after external file operations settle." }]);
+		});
+	}
+	/** Adopt an already-existing raw file without copying, renaming, or deleting it. */
+	adoptRawFile(token, id, type, manifests = []) {
+		return this.#enqueueOperation(async () => {
+			const result = await this.#store.transactCandidate(async (candidate, current) => {
+				const file = (await this.#classifyRawDirectory(current)).unmanaged.find((entry) => this.#newToken(entry.path, entry.hash) === token);
+				if (!file) throw new Error("This ingestion item is stale; refresh the editor and try again.");
+				const idProblem = assetIdError(id);
+				if (idProblem) throw new Error(idProblem);
+				if (Object.hasOwn(candidate.assets, id)) throw new Error(`An asset with id "${id}" already exists.`);
+				if (!this.#compatibleTypes(file.path).includes(type)) throw new Error(`The ${type} type does not accept "${file.path}".`);
+				const uniqueManifests = [...new Set(manifests)];
+				for (const name of uniqueManifests) if (!Object.hasOwn(candidate.manifests, name)) throw new Error(`Unknown manifest "${name}".`);
+				const plugin = serverPluginForType(type, this.#registry);
+				let parameters = plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config));
+				parameters = plugin.descriptor.validateParameters(parameters);
+				if (plugin.seedIngestParameters) {
+					const seeded = await plugin.seedIngestParameters({
+						rawPath: join(this.#config.rawDir, file.path),
+						rawFileName: rawFileNameOfPath(file.path),
+						parameters,
+						config: this.#config
+					});
+					if (seeded !== void 0) parameters = plugin.descriptor.validateParameters(seeded);
+				}
+				await verifyStableRawFile(join(this.#config.rawDir, file.path), file.hash);
+				this.#registerFolderAncestors(candidate, folderOfRawPath(file.path));
+				candidate.assets[id] = {
+					type,
+					raw: file.path,
+					rawHash: file.hash,
+					parameters,
+					manifests: uniqueManifests.sort()
+				};
+			});
+			await this.#store.syncFolders(result.library);
+			return this.#afterMutation(result.library);
+		});
+	}
+	/** Reset/reseed edited bytes, optionally changing to another compatible type. */
+	acceptEditedRawFile(token, type) {
+		return this.#enqueueOperation(async () => {
+			const result = await this.#store.transactCandidate(async (candidate, current) => {
+				const classification = await this.#classifyRawDirectory(current);
+				const edited = this.#editedRawFiles(classification, current).find((entry) => this.#editedToken(entry.assetId, entry.path, entry.hash) === token);
+				if (!edited) throw new Error("This edited item is stale; refresh the editor and try again.");
+				if (!this.#compatibleTypes(edited.path).includes(type)) throw new Error(`The ${type} type does not accept "${edited.path}".`);
+				const plugin = serverPluginForType(type, this.#registry);
+				let parameters = plugin.descriptor.validateParameters(plugin.descriptor.defaultParameters(plugin.pluginConfig(this.#config)));
+				if (plugin.seedIngestParameters) {
+					const seeded = await plugin.seedIngestParameters({
+						rawPath: join(this.#config.rawDir, edited.path),
+						rawFileName: rawFileNameOfPath(edited.path),
+						parameters,
+						config: this.#config
+					});
+					if (seeded !== void 0) parameters = plugin.descriptor.validateParameters(seeded);
+				}
+				await verifyStableRawFile(join(this.#config.rawDir, edited.path), edited.hash);
+				const record = candidate.assets[edited.assetId];
+				record.type = type;
+				record.rawHash = edited.hash;
+				record.parameters = parameters;
+				return edited.assetId;
+			});
+			await this.#store.deleteProxiesOf(result.value);
+			return this.#afterMutation(result.library);
+		});
+	}
+	/** Accept edited bytes while preserving type, parameters, path and memberships. */
+	dismissEditedRawFile(token) {
+		return this.#enqueueOperation(async () => {
+			const result = await this.#store.transactCandidate(async (candidate, current) => {
+				const classification = await this.#classifyRawDirectory(current);
+				const edited = this.#editedRawFiles(classification, current).find((entry) => this.#editedToken(entry.assetId, entry.path, entry.hash) === token);
+				if (!edited) throw new Error("This edited item is stale; refresh the editor and try again.");
+				const record = current.assets[edited.assetId];
+				if (!this.#compatibleTypes(edited.path).includes(record.type)) throw new Error(`The moved file "${edited.path}" is not compatible with its current ${record.type} type; choose a compatible type and process it.`);
+				candidate.assets[edited.assetId].rawHash = edited.hash;
+				return edited.assetId;
+			});
+			await this.#store.deleteProxiesOf(result.value);
+			return this.#afterMutation(result.library);
+		});
 	}
 	/**
 	* Ingest an upload: store the raw file + record, then let the owning
@@ -113,7 +305,10 @@ var FundusOperations = class {
 	* 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) {
+	ingest(options) {
+		return this.#enqueueOperation(() => this.#ingest(options));
+	}
+	async #ingest(options) {
 		let library = await this.#store.ingest(options);
 		try {
 			const plugin = serverPluginForType(options.type, this.#registry);
@@ -138,7 +333,10 @@ var FundusOperations = class {
 		return this.#afterMutation(library);
 	}
 	/** Apply a PATCH body: parameters and/or manifests and/or a rename — in that order. */
-	async patchAsset(id, body) {
+	patchAsset(id, body) {
+		return this.#enqueueOperation(() => this.#patchAsset(id, body));
+	}
+	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);
@@ -156,11 +354,24 @@ var FundusOperations = class {
 		}
 		return this.#afterMutation(library);
 	}
-	async moveAsset(id, folder) {
+	moveAsset(id, folder) {
+		return this.#enqueueOperation(() => this.#moveAsset(id, folder));
+	}
+	async #moveAsset(id, folder) {
 		return this.#afterMutation(await this.#store.moveAsset(id, folder));
 	}
+	/** Replace the raw bytes/name and run the normal processing + codegen tail. */
+	replaceRawFile(id, options) {
+		return this.#enqueueOperation(() => this.#replaceRawFile(id, options));
+	}
+	async #replaceRawFile(id, options) {
+		return this.#afterMutation(await this.#store.replaceRawFile(id, options));
+	}
 	/** Move a selected asset set as one editor action and roll back on any failure. */
-	async moveAssets(assetIds, folder) {
+	moveAssets(assetIds, folder) {
+		return this.#enqueueOperation(() => this.#moveAssets(assetIds, folder));
+	}
+	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();
@@ -183,16 +394,28 @@ var FundusOperations = class {
 			throw cause;
 		}
 	}
-	async createFolder(path) {
+	createFolder(path) {
+		return this.#enqueueOperation(() => this.#createFolder(path));
+	}
+	async #createFolder(path) {
 		return this.#afterMutation(await this.#store.createFolder(path));
 	}
-	async renameFolder(path, newName) {
+	renameFolder(path, newName) {
+		return this.#enqueueOperation(() => this.#renameFolder(path, newName));
+	}
+	async #renameFolder(path, newName) {
 		return this.#afterMutation(await this.#store.renameFolder(path, newName));
 	}
-	async moveFolder(path, parent) {
+	moveFolder(path, parent) {
+		return this.#enqueueOperation(() => this.#moveFolder(path, parent));
+	}
+	async #moveFolder(path, parent) {
 		return this.#afterMutation(await this.#store.moveFolder(path, parent));
 	}
-	async deleteFolder(path) {
+	deleteFolder(path) {
+		return this.#enqueueOperation(() => this.#deleteFolder(path));
+	}
+	async #deleteFolder(path) {
 		const result = await this.#store.deleteFolder(path);
 		return this.#afterMutation(result.library);
 	}
@@ -204,7 +427,10 @@ var FundusOperations = class {
 	* rejected with nothing written. The REST `patchAsset` keeps the editor's
 	* lenient replace semantics.
 	*/
-	async setAsset(id, changes) {
+	setAsset(id, changes) {
+		return this.#enqueueOperation(() => this.#setAsset(id, changes));
+	}
+	async #setAsset(id, changes) {
 		const library = await this.#store.read();
 		this.#requireAsset(library, id);
 		return this.#afterMutation(await this.#applyAssetChanges(library, id, changes));
@@ -214,7 +440,10 @@ var FundusOperations = class {
 	* 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) {
+	renameAsset(id, newId) {
+		return this.#enqueueOperation(() => this.#renameAsset(id, newId));
+	}
+	async #renameAsset(id, newId) {
 		const library = await this.#store.read();
 		this.#requireAsset(library, id);
 		if (newId !== id && !Object.hasOwn(library.assets, newId)) {
@@ -231,7 +460,10 @@ var FundusOperations = class {
 	* (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) {
+	deleteAsset(id, options) {
+		return this.#enqueueOperation(() => this.#deleteAsset(id, options));
+	}
+	async #deleteAsset(id, options) {
 		if (options?.failOnIntroducedIssues) {
 			const library = await this.#store.read();
 			this.#requireAsset(library, id);
@@ -242,19 +474,31 @@ var FundusOperations = class {
 		return this.#afterMutation(await this.#store.deleteAsset(id));
 	}
 	/** Delete a selected asset set as one lenient editor mutation. */
-	async deleteAssets(assetIds) {
+	deleteAssets(assetIds) {
+		return this.#enqueueOperation(() => this.#deleteAssets(assetIds));
+	}
+	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) {
+	createManifest(name) {
+		return this.#enqueueOperation(() => this.#createManifest(name));
+	}
+	async #createManifest(name) {
 		return this.#afterMutation(await this.#store.createManifest(name));
 	}
-	async setManifestAppearance(name, appearance) {
+	setManifestAppearance(name, appearance) {
+		return this.#enqueueOperation(() => this.#setManifestAppearance(name, appearance));
+	}
+	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) {
+	patchManifest(name, body) {
+		return this.#enqueueOperation(() => this.#patchManifest(name, body));
+	}
+	async #patchManifest(name, body) {
 		let library = await this.#store.setManifestAppearance(name, {
 			color: body.color,
 			emoji: body.emoji
@@ -271,26 +515,47 @@ var FundusOperations = class {
 	* the module must be updated by hand — both the file name and the exported
 	* const change with the manifest name.
 	*/
-	async renameManifest(name, newName) {
+	renameManifest(name, newName) {
+		return this.#enqueueOperation(() => this.#renameManifest(name, newName));
+	}
+	async #renameManifest(name, newName) {
 		return this.#afterMutation(await this.#store.renameManifest(name, newName));
 	}
-	async deleteManifest(name) {
+	deleteManifest(name) {
+		return this.#enqueueOperation(() => this.#deleteManifest(name));
+	}
+	async #deleteManifest(name) {
 		return this.#afterMutation(await this.#store.deleteManifest(name));
 	}
 	/** The autosave chain tail: process + regenerate, then report fresh state. */
 	async #afterMutation(library) {
+		return (await this.#afterMutationSnapshot(library)).state;
+	}
+	async #afterMutationSnapshot(library) {
+		const run = this.#pipelineQueue.then(() => this.#runAfterMutation(library), () => this.#runAfterMutation(library));
+		this.#pipelineQueue = run.then(() => {}, () => {});
+		return run;
+	}
+	async #runAfterMutation(library) {
 		const pipelineIssues = [];
-		const issues = await this.#store.validate(library);
-		if (issues.length === 0) try {
+		const classification = await this.#classifyRawDirectory(library);
+		const ordinaryIssues = await this.#store.validate(library);
+		const safetyIssues = this.#rawSafetyIssues(library, classification);
+		if (ordinaryIssues.length === 0 && safetyIssues.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);
+		const latestLibrary = await this.#store.read();
+		const latestClassification = await this.#classifyRawDirectory(latestLibrary);
+		return {
+			library: latestLibrary,
+			classification: latestClassification,
+			state: await this.#snapshotState(latestLibrary, latestClassification, pipelineIssues)
+		};
 	}
-	async #buildState(library, extraIssues, precomputedIssues) {
-		const issues = [...precomputedIssues ?? await this.#store.validate(library), ...extraIssues];
+	async #buildState(library, issues, classification) {
 		const referencesByAsset = collectAllReferences(library, descriptorsByType(this.#registry));
 		const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
 		const delivered = allDeliveredAssetIds(membershipByManifest);
@@ -335,7 +600,7 @@ var FundusOperations = class {
 				type: record.type,
 				raw: record.raw,
 				folder: folderOfRawPath(record.raw),
-				rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}`,
+				rawUrl: `/files/raw/${encodeRelativePathForUrl(record.raw)}?v=${record.rawHash.slice(0, 12)}`,
 				rawHash: record.rawHash,
 				parameters: record.parameters,
 				manifests: record.manifests,
@@ -372,9 +637,118 @@ var FundusOperations = class {
 			issues,
 			presetNames,
 			manifestMemberships,
-			manifestDeliveredBytes
+			manifestDeliveredBytes,
+			rawIngestionQueue: this.#buildRawIngestionQueue(library, classification)
 		};
 	}
+	#compatibleTypes(path) {
+		return typesForFileName(path, Object.values(this.#registry).map((plugin) => plugin.descriptor)).sort(compareCodeUnits);
+	}
+	#classifyRawDirectory(library) {
+		return classifyRawDirectory(this.#config.rawDir, library, (path) => this.#compatibleTypes(path).length > 0);
+	}
+	#rawSafetyIssues(library, classification) {
+		return rawSafetyIssues(library, classification, (path) => this.#compatibleTypes(path));
+	}
+	async #snapshotState(library, classification, extraIssues = []) {
+		const issues = [
+			...await this.#store.validate(library),
+			...this.#rawSafetyIssues(library, classification),
+			...extraIssues
+		];
+		const seen = /* @__PURE__ */ new Set();
+		const uniqueIssues = issues.filter((issue) => {
+			const key = `${issue.assetId ?? ""}|${issue.message}`;
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		return this.#buildState(library, uniqueIssues, classification);
+	}
+	#canAutoReconcile(classification, retry = false) {
+		return classification.complete && classification.blockers.length === 0 && classification.moves.length + classification.deletions.length > 0 && (!retry || classification.edited.length === 0 && classification.unmanaged.length === 0);
+	}
+	#newToken(path, hash) {
+		return `new:${path}:${hash}`;
+	}
+	#editedToken(assetId, path, hash) {
+		return `edited:${assetId}:${path}:${hash}`;
+	}
+	#proposedId(path, reservedIds) {
+		const base = proposeAssetId(rawFileNameOfPath(path));
+		if (!reservedIds.has(base)) return base;
+		for (let index = 2;; index++) {
+			const candidate = `${base}${index}`;
+			if (!reservedIds.has(candidate)) return candidate;
+		}
+	}
+	#buildRawIngestionQueue(library, classification) {
+		const queue = [];
+		const reservedIds = new Set(Object.keys(library.assets));
+		for (const file of classification.unmanaged) {
+			const compatibleTypes = this.#compatibleTypes(file.path);
+			const proposedId = this.#proposedId(file.path, reservedIds);
+			reservedIds.add(proposedId);
+			queue.push({
+				kind: "new",
+				token: this.#newToken(file.path, file.hash),
+				path: file.path,
+				hash: file.hash,
+				compatibleTypes,
+				proposedId
+			});
+		}
+		for (const edited of this.#editedRawFiles(classification, library)) {
+			const currentType = library.assets[edited.assetId].type;
+			queue.push({
+				kind: "edited",
+				token: this.#editedToken(edited.assetId, edited.path, edited.hash),
+				path: edited.path,
+				hash: edited.hash,
+				assetId: edited.assetId,
+				currentType,
+				compatibleTypes: this.#compatibleTypes(edited.path)
+			});
+		}
+		for (const blocker of classification.blockers) queue.push({
+			kind: "unsupported",
+			token: `unsupported:${blocker.path}:${blocker.reason}`,
+			path: blocker.path,
+			reason: blocker.reason
+		});
+		for (const diagnostic of classification.diagnostics) queue.push({
+			kind: "unsupported",
+			token: `unsupported:raw-directory:${diagnostic.reason}`,
+			path: diagnostic.path || "Raw directory",
+			reason: diagnostic.reason
+		});
+		return queue.sort((a, b) => compareCodeUnits(a.path, b.path));
+	}
+	#editedRawFiles(classification, library) {
+		const edited = new Map(classification.edited.map((entry) => [entry.assetId, entry]));
+		for (const assetId of classification.unchangedAssetIds) {
+			const record = library.assets[assetId];
+			if (!this.#compatibleTypes(record.raw).includes(record.type)) edited.set(assetId, {
+				assetId,
+				path: record.raw,
+				hash: record.rawHash
+			});
+		}
+		return [...edited.values()].sort((a, b) => compareCodeUnits(a.path, b.path));
+	}
+	#registerFolderAncestors(library, folder) {
+		if (folder === "") return;
+		const missing = [];
+		for (let current = folder; current !== ""; current = parentFolderPath(current)) if (!library.folders.includes(current)) missing.push(current);
+		const keys = new Map(library.folders.map((path) => [portableFolderPathKey(path), path]));
+		for (const path of missing.reverse()) {
+			const collision = keys.get(portableFolderPathKey(path));
+			if (collision !== void 0 && collision !== path) throw new Error(`Folder "${path}" collides with existing folder "${collision}".`);
+			library.folders.push(path);
+			keys.set(portableFolderPathKey(path), path);
+		}
+		library.folders.sort(compareCodeUnits);
+	}
 	#requireAsset(library, id) {
 		if (!Object.hasOwn(library.assets, id)) throw new Error(`Unknown asset "${id}".`);
 	}
@@ -426,4 +800,4 @@ async function createFundusContext() {
 }
 
 export { getFundusContext as g, initializeFundusContext as i };
-//# sourceMappingURL=context.js-BUZqFfWG.js.map
+//# sourceMappingURL=context.js-B77ZAVLi.js.map