fundus 0.0.2 → 0.0.4

package/build/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/build/index.js

@@ -0,0 +1,145 @@
+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 { env, timeout_env } from './env.js';
+import { rm } from 'node:fs/promises';
+import './shims.js';
+import 'node:buffer';
+import 'node:crypto';
+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/internal2.js-BlXt2rfE.js';
+import './server/chunks/chunks/exports.js-C0rwMMtk.js';
+import './server/chunks/chunks/routing.js-y-tryuip.js';
+import './server/chunks/manifest.js-qmEXbstS.js';
+import 'node:url';
+
+const path = env('SOCKET_PATH', false);
+const host = env('HOST', '0.0.0.0');
+const port = env('PORT', !path && '3000');
+
+const shutdown_timeout = parseInt(env('SHUTDOWN_TIMEOUT', '30'));
+const idle_timeout = parseInt(env('IDLE_TIMEOUT', '0'));
+const listen_pid = parseInt(env('LISTEN_PID', '0'));
+const listen_fds = parseInt(env('LISTEN_FDS', '0'));
+// https://www.freedesktop.org/software/systemd/man/latest/sd_listen_fds.html
+const SD_LISTEN_FDS_START = 3;
+
+if (listen_pid !== 0 && listen_pid !== process.pid) {
+	throw new Error(`received LISTEN_PID ${listen_pid} but current process id is ${process.pid}`);
+}
+if (listen_fds > 1) {
+	throw new Error(
+		`only one socket is allowed for socket activation, but LISTEN_FDS was set to ${listen_fds}`
+	);
+}
+
+const socket_activation = listen_pid === process.pid && listen_fds === 1;
+
+let requests = 0;
+/** @type {NodeJS.Timeout | void} */
+let shutdown_timeout_id;
+/** @type {NodeJS.Timeout | void} */
+let idle_timeout_id;
+
+// Initialize the HTTP server here so that we can set properties before starting to listen.
+// Otherwise, polka delays creating the server until listen() is called. Settings these
+// properties after the server has started listening could lead to race conditions.
+const httpServer = http.createServer();
+
+const keep_alive_timeout = timeout_env('KEEP_ALIVE_TIMEOUT');
+if (keep_alive_timeout !== undefined) {
+	// Convert the keep-alive timeout from seconds to milliseconds (the unit Node.js expects).
+	httpServer.keepAliveTimeout = keep_alive_timeout * 1000;
+}
+
+const headers_timeout = timeout_env('HEADERS_TIMEOUT');
+if (headers_timeout !== undefined) {
+	// Convert the headers timeout from seconds to milliseconds (the unit Node.js expects).
+	httpServer.headersTimeout = headers_timeout * 1000;
+}
+
+const server = polka({ server: httpServer }).use(handler);
+
+if (socket_activation) {
+	server.listen({ fd: SD_LISTEN_FDS_START }, () => {
+		console.log(`Listening on file descriptor ${SD_LISTEN_FDS_START}`);
+	});
+} else {
+	if (path) {
+		try {
+			if (fs__default.statSync(path).size === 0) {
+				await rm(path);
+			}
+		} catch {
+			// ignore
+		}
+	}
+
+	server.listen({ path, host, port }, () => {
+		console.log(`Listening on ${format_listening_address(path, host, port, httpServer.address())}`);
+	});
+}
+
+/** @param {'SIGINT' | 'SIGTERM' | 'IDLE'} reason */
+function graceful_shutdown(reason) {
+	if (shutdown_timeout_id) return;
+
+	// If a connection was opened with a keep-alive header close() will wait for the connection to
+	// time out rather than close it even if it is not handling any requests, so call this first
+	httpServer.closeIdleConnections();
+
+	httpServer.close((error) => {
+		// occurs if the server is already closed
+		if (error) return;
+
+		if (shutdown_timeout_id) {
+			clearTimeout(shutdown_timeout_id);
+		}
+		if (idle_timeout_id) {
+			clearTimeout(idle_timeout_id);
+		}
+
+		// @ts-expect-error custom events cannot be typed
+		process.emit('sveltekit:shutdown', reason);
+	});
+
+	shutdown_timeout_id = setTimeout(() => httpServer.closeAllConnections(), shutdown_timeout * 1000);
+}
+
+httpServer.on(
+	'request',
+	/** @param {import('node:http').IncomingMessage} req */
+	(req) => {
+		requests++;
+
+		if (socket_activation && idle_timeout_id) {
+			idle_timeout_id = clearTimeout(idle_timeout_id);
+		}
+
+		req.on('close', () => {
+			requests--;
+
+			if (shutdown_timeout_id) {
+				// close connections as soon as they become idle, so they don't accept new requests
+				httpServer.closeIdleConnections();
+			}
+			if (requests === 0 && socket_activation && idle_timeout) {
+				idle_timeout_id = setTimeout(() => graceful_shutdown('IDLE'), idle_timeout * 1000);
+			}
+		});
+	}
+);
+
+process.on('SIGTERM', graceful_shutdown);
+process.on('SIGINT', graceful_shutdown);
+
+export { host, path, port, server };
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../.svelte-kit/adapter-node/entries/index.js"],"sourcesContent":["import http from 'node:http';\nimport fs__default from 'node:fs';\nimport process from 'node:process';\nimport { handler } from './handler.js';\nimport { env, timeout_env } from './env.js';\nimport { p as polka } from './chunks/vendor.js';\nimport { rm } from 'node:fs/promises';\nimport { format_listening_address } from './utils.js';\n\nconst path = env('SOCKET_PATH', false);\nconst host = env('HOST', '0.0.0.0');\nconst port = env('PORT', !path && '3000');\n\nconst shutdown_timeout = parseInt(env('SHUTDOWN_TIMEOUT', '30'));\nconst idle_timeout = parseInt(env('IDLE_TIMEOUT', '0'));\nconst listen_pid = parseInt(env('LISTEN_PID', '0'));\nconst listen_fds = parseInt(env('LISTEN_FDS', '0'));\n// https://www.freedesktop.org/software/systemd/man/latest/sd_listen_fds.html\nconst SD_LISTEN_FDS_START = 3;\n\nif (listen_pid !== 0 && listen_pid !== process.pid) {\n\tthrow new Error(`received LISTEN_PID ${listen_pid} but current process id is ${process.pid}`);\n}\nif (listen_fds > 1) {\n\tthrow new Error(\n\t\t`only one socket is allowed for socket activation, but LISTEN_FDS was set to ${listen_fds}`\n\t);\n}\n\nconst socket_activation = listen_pid === process.pid && listen_fds === 1;\n\nlet requests = 0;\n/** @type {NodeJS.Timeout | void} */\nlet shutdown_timeout_id;\n/** @type {NodeJS.Timeout | void} */\nlet idle_timeout_id;\n\n// Initialize the HTTP server here so that we can set properties before starting to listen.\n// Otherwise, polka delays creating the server until listen() is called. Settings these\n// properties after the server has started listening could lead to race conditions.\nconst httpServer = http.createServer();\n\nconst keep_alive_timeout = timeout_env('KEEP_ALIVE_TIMEOUT');\nif (keep_alive_timeout !== undefined) {\n\t// Convert the keep-alive timeout from seconds to milliseconds (the unit Node.js expects).\n\thttpServer.keepAliveTimeout = keep_alive_timeout * 1000;\n}\n\nconst headers_timeout = timeout_env('HEADERS_TIMEOUT');\nif (headers_timeout !== undefined) {\n\t// Convert the headers timeout from seconds to milliseconds (the unit Node.js expects).\n\thttpServer.headersTimeout = headers_timeout * 1000;\n}\n\nconst server = polka({ server: httpServer }).use(handler);\n\nif (socket_activation) {\n\tserver.listen({ fd: SD_LISTEN_FDS_START }, () => {\n\t\tconsole.log(`Listening on file descriptor ${SD_LISTEN_FDS_START}`);\n\t});\n} else {\n\tif (path) {\n\t\ttry {\n\t\t\tif (fs__default.statSync(path).size === 0) {\n\t\t\t\tawait rm(path);\n\t\t\t}\n\t\t} catch {\n\t\t\t// ignore\n\t\t}\n\t}\n\n\tserver.listen({ path, host, port }, () => {\n\t\tconsole.log(`Listening on ${format_listening_address(path, host, port, httpServer.address())}`);\n\t});\n}\n\n/** @param {'SIGINT' | 'SIGTERM' | 'IDLE'} reason */\nfunction graceful_shutdown(reason) {\n\tif (shutdown_timeout_id) return;\n\n\t// If a connection was opened with a keep-alive header close() will wait for the connection to\n\t// time out rather than close it even if it is not handling any requests, so call this first\n\thttpServer.closeIdleConnections();\n\n\thttpServer.close((error) => {\n\t\t// occurs if the server is already closed\n\t\tif (error) return;\n\n\t\tif (shutdown_timeout_id) {\n\t\t\tclearTimeout(shutdown_timeout_id);\n\t\t}\n\t\tif (idle_timeout_id) {\n\t\t\tclearTimeout(idle_timeout_id);\n\t\t}\n\n\t\t// @ts-expect-error custom events cannot be typed\n\t\tprocess.emit('sveltekit:shutdown', reason);\n\t});\n\n\tshutdown_timeout_id = setTimeout(() => httpServer.closeAllConnections(), shutdown_timeout * 1000);\n}\n\nhttpServer.on(\n\t'request',\n\t/** @param {import('node:http').IncomingMessage} req */\n\t(req) => {\n\t\trequests++;\n\n\t\tif (socket_activation && idle_timeout_id) {\n\t\t\tidle_timeout_id = clearTimeout(idle_timeout_id);\n\t\t}\n\n\t\treq.on('close', () => {\n\t\t\trequests--;\n\n\t\t\tif (shutdown_timeout_id) {\n\t\t\t\t// close connections as soon as they become idle, so they don't accept new requests\n\t\t\t\thttpServer.closeIdleConnections();\n\t\t\t}\n\t\t\tif (requests === 0 && socket_activation && idle_timeout) {\n\t\t\t\tidle_timeout_id = setTimeout(() => graceful_shutdown('IDLE'), idle_timeout * 1000);\n\t\t\t}\n\t\t});\n\t}\n);\n\nprocess.on('SIGTERM', graceful_shutdown);\nprocess.on('SIGINT', graceful_shutdown);\n\nexport { host, path, port, server };\n"],"names":[],"mappings":"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"}

package/build/server/chunks/chunks/context.js-BUZqFfWG.js

@@ -0,0 +1,429 @@
+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 { isAbsolute, resolve, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createJiti } from 'jiti';
+
+//#region src/lib/server/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 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 resolve(projectRoot, value);
+}
+function configDefinitionsFor(registry) {
+	const byNamespace = /* @__PURE__ */ new Map();
+	for (const plugin of Object.values(registry)) for (const definition of plugin.configDefinitions) {
+		const existing = byNamespace.get(definition.namespace);
+		if (existing && existing !== definition) throw new Error(`Plugins provide conflicting config definitions for "plugins.${definition.namespace}".`);
+		byNamespace.set(definition.namespace, definition);
+	}
+	return [...byNamespace.values()];
+}
+/** Pure resolution step (testable without a config file on disk). */
+function resolveConfig(projectRoot, value, registry = serverPluginsByType) {
+	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.");
+	const resolvedPlugins = {};
+	for (const definition of configDefinitionsFor(registry)) resolvedPlugins[definition.namespace] = definition.resolve({
+		projectRoot,
+		value: plugins[definition.namespace]
+	});
+	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: resolvedPlugins
+	};
+}
+/** 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/lib/server/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
+//#region src/lib/server/context.ts
+var context;
+function initializeFundusContext() {
+	context ??= createFundusContext();
+	return context;
+}
+function getFundusContext() {
+	return initializeFundusContext();
+}
+async function createFundusContext() {
+	const projectRoot = process.env.FUNDUS_PROJECT_ROOT;
+	if (!projectRoot || !isAbsolute(projectRoot)) throw new Error("FUNDUS_PROJECT_ROOT must be set to an absolute host project directory.");
+	const config = await loadConfig(projectRoot);
+	return {
+		config,
+		operations: new FundusOperations(config)
+	};
+}
+
+export { getFundusContext as g, initializeFundusContext as i };
+//# sourceMappingURL=context.js-BUZqFfWG.js.map