fundus 0.4.0 → 0.6.0

package/build/server/chunks/chunks/{contract.js-sHny3b-s.js → contract.js-DGMufT2e.js}

@@ -1,15 +1,16 @@
-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 { a as plugins, b as audioPlugin, d as chromaKeyVideoPlugin, v as videoPlugin, s as slicePlugin, e as imagePlugin, n as normalizeFolderPath, g as folderOfRawPath, h as rawFileNameOfPath, j as canonicalizeParameters, f as folderPathError, k as parentFolderPath, l as folderNameError, m as joinFolderPath, o as folderNameOf, q as isFolderOrDescendant, t as replaceFolderPrefix, u as portableFolderPathKey, c as compareCodeUnits, w as processedSliceInsets, x as defaultInsetsForSize, F as FOLDER_SENTINEL, r as rawFilePathError, y as slicedAxesFor, z as isAssetReference, A as validateVideoPreset, V as VIDEO_BUILT_IN_PRESETS, B as validateAudioPreset, C as AUDIO_BUILT_IN_PRESETS, D as validateImagePreset, I as IMAGE_BUILT_IN_PRESETS, S as SLICE_BUILT_IN_PRESETS } from './core.js-DNIuZ9y-.js';
+import { a as assetIdError, r as referenceErrors, c as collectAllReferences, b as computeLibraryMembership, m as manifestNameError, d as allDeliveredAssetIds, t as topologicalReferenceOrder } from './manifest-membership.js-CJnQXrL4.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 { v as verifyStableRawFile } from './raw-reconciliation2.js-C2No1QIL.js';
 import { join, extname, dirname, basename, isAbsolute, resolve } from 'node:path';
 import { existsSync } from 'node:fs';
-import { readFile, mkdir, writeFile, rename, unlink, rm, stat, readdir } from 'node:fs/promises';
+import { readFile, mkdir, writeFile, rename, unlink, rm, stat, readdir, mkdtemp } from 'node:fs/promises';
 import ffmpegStaticPath from 'ffmpeg-static';
 import { path } from 'ffprobe-static';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import sharp from 'sharp';
+import { tmpdir } from 'node:os';
 import { createHash } from 'node:crypto';
 
 //#region src/lib/core/library.ts
@@ -147,169 +148,6 @@ function serializeLibrary(library) {
 	}), null, "	")}\n`;
 }
 //#endregion
-//#region src/lib/core/reference-graph.ts
-/**
-* Ask each asset's owning plugin for the references in its parameters. Assets
-* whose type is unknown or whose parameters do not validate contribute no
-* references — those problems are reported by the regular validation pass.
-*/
-function collectAllReferences(library, plugins) {
-	const referencesByAsset = {};
-	for (const [assetId, record] of Object.entries(library.assets)) {
-		referencesByAsset[assetId] = [];
-		const plugin = plugins[record.type];
-		if (!plugin?.collectReferences) continue;
-		try {
-			referencesByAsset[assetId] = plugin.collectReferences(plugin.validateParameters(record.parameters));
-		} catch {}
-	}
-	return referencesByAsset;
-}
-/**
-* Reference *errors* (they block build/codegen): a reference to an unknown
-* asset, a target whose type is not among the field's expected types, and
-* cycles (composition is acyclic by nature).
-*/
-function referenceErrors(library, referencesByAsset) {
-	const issues = [];
-	for (const [assetId, references] of Object.entries(referencesByAsset)) for (const reference of references) {
-		if (!Object.hasOwn(library.assets, reference.assetId)) {
-			issues.push({
-				assetId,
-				message: `Reference "${reference.field}" points at unknown asset "${reference.assetId}".`
-			});
-			continue;
-		}
-		const targetType = library.assets[reference.assetId].type;
-		if (reference.expectedTypes.length > 0 && !reference.expectedTypes.includes(targetType)) issues.push({
-			assetId,
-			message: `Reference "${reference.field}" points at "${reference.assetId}" of type "${targetType}" — expected ${reference.expectedTypes.map((type) => `"${type}"`).join(" or ")}.`
-		});
-	}
-	issues.push(...cycleErrors(referencesByAsset));
-	return issues;
-}
-/** DFS cycle detection with an explicit stack path; each cycle reported once. */
-function cycleErrors(referencesByAsset) {
-	const issues = [];
-	const finished = /* @__PURE__ */ new Set();
-	const reportedCycles = /* @__PURE__ */ new Set();
-	const stack = [];
-	const onStack = /* @__PURE__ */ new Set();
-	function visit(assetId) {
-		if (finished.has(assetId)) return;
-		if (onStack.has(assetId)) {
-			const cyclePath = [...stack.slice(stack.indexOf(assetId)), assetId];
-			const cycleKey = [...new Set(cyclePath)].sort().join("\0");
-			if (!reportedCycles.has(cycleKey)) {
-				reportedCycles.add(cycleKey);
-				issues.push({
-					assetId: cyclePath[0],
-					message: `Reference cycle: ${cyclePath.map((id) => `"${id}"`).join(" → ")} — references express composition and must stay acyclic.`
-				});
-			}
-			return;
-		}
-		stack.push(assetId);
-		onStack.add(assetId);
-		for (const reference of referencesByAsset[assetId] ?? []) if (Object.hasOwn(referencesByAsset, reference.assetId)) visit(reference.assetId);
-		stack.pop();
-		onStack.delete(assetId);
-		finished.add(assetId);
-	}
-	for (const assetId of Object.keys(referencesByAsset)) visit(assetId);
-	return issues;
-}
-/**
-* The transitive reference closure of a set of assets, including the starting
-* set — the assets that must be delivered so the starting set renders as
-* authored. Tolerates cycles and ignores dangling targets (both are reported
-* as errors by `referenceErrors`).
-*/
-function referenceClosure(assetIds, referencesByAsset) {
-	const closure = /* @__PURE__ */ new Set();
-	const pending = [...assetIds];
-	while (pending.length > 0) {
-		const assetId = pending.pop();
-		if (closure.has(assetId) || !Object.hasOwn(referencesByAsset, assetId)) continue;
-		closure.add(assetId);
-		for (const reference of referencesByAsset[assetId]) pending.push(reference.assetId);
-	}
-	return closure;
-}
-/**
-* A dependencies-first order over `assetIds` and everything they transitively
-* reference — the build order that lets each entry inline its references from
-* already-built entries. Throws on a cycle (with the cycle path).
-*/
-function topologicalReferenceOrder(assetIds, referencesByAsset) {
-	const order = [];
-	const finished = /* @__PURE__ */ new Set();
-	const stack = [];
-	const onStack = /* @__PURE__ */ new Set();
-	function visit(assetId) {
-		if (finished.has(assetId) || !Object.hasOwn(referencesByAsset, assetId)) return;
-		if (onStack.has(assetId)) {
-			const cyclePath = [...stack.slice(stack.indexOf(assetId)), assetId];
-			throw new Error(`Reference cycle: ${cyclePath.map((id) => `"${id}"`).join(" → ")} — cannot order entries.`);
-		}
-		stack.push(assetId);
-		onStack.add(assetId);
-		for (const reference of referencesByAsset[assetId]) visit(reference.assetId);
-		stack.pop();
-		onStack.delete(assetId);
-		finished.add(assetId);
-		order.push(assetId);
-	}
-	for (const assetId of assetIds) visit(assetId);
-	return order;
-}
-//#endregion
-//#region src/lib/core/manifest-membership.ts
-/**
-* Compute the full membership picture from a library and its collected
-* references: for each manifest the explicit members, the passive members
-* (`referenceClosure(explicit) − explicit`) with their via-attribution, and
-* the resulting delivery set.
-*/
-function computeLibraryMembership(library, referencesByAsset) {
-	const manifestNames = new Set(Object.keys(library.manifests));
-	for (const record of Object.values(library.assets)) for (const manifestName of record.manifests) manifestNames.add(manifestName);
-	const membership = {};
-	for (const manifestName of [...manifestNames].sort(compareCodeUnits)) {
-		const explicitMemberIds = Object.entries(library.assets).filter(([, record]) => record.manifests.includes(manifestName)).map(([assetId]) => assetId).sort(compareCodeUnits);
-		const explicitMemberSet = new Set(explicitMemberIds);
-		const deliveredAssetIds = new Set(explicitMemberIds);
-		const viaByPassiveAssetId = /* @__PURE__ */ new Map();
-		for (const explicitMemberId of explicitMemberIds) for (const reachedAssetId of referenceClosure([explicitMemberId], referencesByAsset)) {
-			deliveredAssetIds.add(reachedAssetId);
-			if (explicitMemberSet.has(reachedAssetId)) continue;
-			const via = viaByPassiveAssetId.get(reachedAssetId) ?? [];
-			via.push(explicitMemberId);
-			viaByPassiveAssetId.set(reachedAssetId, via);
-		}
-		membership[manifestName] = {
-			explicitMemberIds,
-			passiveMembers: [...viaByPassiveAssetId.entries()].map(([assetId, via]) => ({
-				assetId,
-				via
-			})).sort((a, b) => compareCodeUnits(a.assetId, b.assetId)),
-			deliveredAssetIds
-		};
-	}
-	return membership;
-}
-/**
-* Every asset delivered by at least one manifest, explicitly or passively —
-* the processing set (assets outside it are inert). An asset is
-* *unreachable* (nothing delivers it) exactly when it is missing here.
-*/
-function allDeliveredAssetIds(membership) {
-	const delivered = /* @__PURE__ */ new Set();
-	for (const manifestMembership of Object.values(membership)) for (const assetId of manifestMembership.deliveredAssetIds) delivered.add(assetId);
-	return delivered;
-}
-//#endregion
 //#region src/lib/server/processing/ffmpeg.ts
 /**
 * The ffmpeg/ffprobe toolchain layer: binary resolution (bundled `-static`
@@ -714,11 +552,173 @@ var imageServerPlugin = {
 	})
 };
 //#endregion
+//#region src/lib/server/processing/slice-processing.ts
+/**
+* Slice-specific image processing. Fixed caps are copied pixel-for-pixel; only
+* the source region that will be stretched is scaled down. Bands are extracted
+* and recomposed through temporary PNGs so large assets are not held in several
+* full-size raw buffers at once.
+*/
+var MAX_COMPRESSION_PIXELS = 32e6;
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+/** The length after percentage-based compression, with one stretch pixel kept. */
+function compressedStretchSize(size, compression) {
+	if (size <= 0) return 0;
+	return Math.max(1, Math.round(size * (1 - clamp(compression, 0, 100) / 100)));
+}
+function assertSliceCompressionDimensions(width, height) {
+	if (width * height > MAX_COMPRESSION_PIXELS) throw new Error(`Slice compression supports images up to ${MAX_COMPRESSION_PIXELS.toLocaleString("en-US")} pixels.`);
+}
+function fixedBands(size, startInset, endInset) {
+	const start = clamp(startInset, 0, size);
+	const end = clamp(endInset, 0, size - start);
+	return {
+		start,
+		center: size - start - end,
+		end
+	};
+}
+function axisBands(start, center, end, targetCenter) {
+	return [
+		{
+			start: 0,
+			size: start,
+			targetSize: start
+		},
+		{
+			start,
+			size: center,
+			targetSize: targetCenter
+		},
+		{
+			start: start + center,
+			size: end,
+			targetSize: end
+		}
+	].filter((band) => band.size > 0 && band.targetSize > 0);
+}
+async function compressAxisToPng(options) {
+	const horizontal = options.axis === "x";
+	const width = horizontal ? options.start + options.targetCenter + options.end : options.dimensions.width;
+	const height = horizontal ? options.dimensions.height : options.start + options.targetCenter + options.end;
+	const composites = [];
+	let destinationOffset = 0;
+	let bandIndex = 0;
+	for (const band of axisBands(options.start, options.center, options.end, options.targetCenter)) {
+		const bandPath = join(options.temporaryDirectory, `${options.prefix}-${bandIndex}.png`);
+		const extracted = sharp(options.sourcePath).extract({
+			left: horizontal ? band.start : 0,
+			top: horizontal ? 0 : band.start,
+			width: horizontal ? band.size : options.dimensions.width,
+			height: horizontal ? options.dimensions.height : band.size
+		});
+		if (band.targetSize !== band.size) extracted.resize({
+			width: horizontal ? band.targetSize : options.dimensions.width,
+			height: horizontal ? options.dimensions.height : band.targetSize,
+			fit: "fill"
+		});
+		await extracted.png().toFile(bandPath);
+		composites.push({
+			input: bandPath,
+			left: horizontal ? destinationOffset : 0,
+			top: horizontal ? 0 : destinationOffset
+		});
+		destinationOffset += band.targetSize;
+		bandIndex += 1;
+	}
+	await sharp({ create: {
+		width,
+		height,
+		channels: 4,
+		background: {
+			r: 0,
+			g: 0,
+			b: 0,
+			alpha: 0
+		}
+	} }).composite(composites).png().toFile(options.targetPath);
+	return {
+		width,
+		height
+	};
+}
+async function processSliceImageFile(options) {
+	const axes = slicedAxesFor(options.mode);
+	const compressionX = axes.horizontal ? options.compression?.x ?? 0 : 0;
+	const compressionY = axes.vertical ? options.compression?.y ?? 0 : 0;
+	if (compressionX === 0 && compressionY === 0) return processImageFile(options);
+	const metadata = await sharp(options.sourcePath).metadata();
+	if (metadata.width === void 0 || metadata.height === void 0) throw new Error(`Could not read image dimensions of ${options.sourcePath}.`);
+	assertSliceCompressionDimensions(metadata.width, metadata.height);
+	let dimensions = {
+		width: metadata.width,
+		height: metadata.height
+	};
+	const processedInsets = processedSliceInsets({
+		...options,
+		width: metadata.width,
+		height: metadata.height
+	});
+	let currentPath = options.sourcePath;
+	const temporaryDirectory = await mkdtemp(join(tmpdir(), "fundus-slice-compression-"));
+	try {
+		if (compressionX > 0) {
+			const bands = fixedBands(dimensions.width, processedInsets.left, processedInsets.right);
+			const targetCenter = compressedStretchSize(bands.center, compressionX);
+			if (targetCenter > 0 && targetCenter < bands.center) {
+				currentPath = join(temporaryDirectory, "compressed-x.png");
+				dimensions = await compressAxisToPng({
+					sourcePath: options.sourcePath,
+					targetPath: currentPath,
+					temporaryDirectory,
+					prefix: "x-band",
+					dimensions,
+					axis: "x",
+					...bands,
+					targetCenter
+				});
+			}
+		}
+		if (compressionY > 0) {
+			const bands = fixedBands(dimensions.height, processedInsets.top, processedInsets.bottom);
+			const targetCenter = compressedStretchSize(bands.center, compressionY);
+			if (targetCenter > 0 && targetCenter < bands.center) {
+				const nextPath = join(temporaryDirectory, "compressed-y.png");
+				dimensions = await compressAxisToPng({
+					sourcePath: currentPath,
+					targetPath: nextPath,
+					temporaryDirectory,
+					prefix: "y-band",
+					dimensions,
+					axis: "y",
+					...bands,
+					targetCenter
+				});
+				currentPath = nextPath;
+			}
+		}
+		await mkdir(dirname(options.targetPath), { recursive: true });
+		const info = await sharp(currentPath).toFormat(options.preset.format, options.preset.quality !== void 0 ? { quality: options.preset.quality } : {}).toFile(options.targetPath);
+		return {
+			width: info.width,
+			height: info.height
+		};
+	} finally {
+		await rm(temporaryDirectory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
 //#region src/lib/server/plugins/slice.ts
 /**
 * Slice plugin (server part): the same sharp conversion as the image plugin,
-* never resized — insets are authored in source pixels, so the delivered proxy
-* keeps the source dimensions. The slicing data is entry-only.
+* fixed caps keep their source-pixel size, while optional compression removes
+* redundant pixels from the stretchable regions. The slicing data itself is
+* entry-only.
 */
 var sliceConfigDefinition = {
 	namespace: "slice",
@@ -758,24 +758,34 @@ var sliceServerPlugin = {
 			pixelRatio: detectPixelRatio(rawFileName)
 		};
 	},
-	process: (job) => processImageFile({
+	process: (job) => processSliceImageFile({
 		sourcePath: job.sourcePath,
 		targetPath: job.targetPath,
-		preset: job.preset
+		preset: job.preset,
+		mode: job.parameters.mode,
+		insets: job.parameters.insets,
+		overdraw: job.parameters.overdraw,
+		compression: job.parameters.compression
 	}),
 	readProxyInfo: (proxyPath) => readImageDimensions(proxyPath),
 	buildManifestEntry: ({ parameters, src, proxy }) => {
+		const sourceWidth = requireProxyField(proxy, "width");
+		const sourceHeight = requireProxyField(proxy, "height");
 		return {
 			kind: "slice",
 			src,
 			slicing: {
 				mode: parameters.mode,
-				insets: parameters.insets,
+				insets: processedSliceInsets({
+					...parameters,
+					width: sourceWidth,
+					height: sourceHeight
+				}),
 				pixelRatio: parameters.pixelRatio,
 				...hasAnySide(parameters.overdraw) ? { overdraw: parameters.overdraw } : {}
 			},
-			sourceWidth: requireProxyField(proxy, "width"),
-			sourceHeight: requireProxyField(proxy, "height")
+			sourceWidth,
+			sourceHeight
 		};
 	}
 };
@@ -1351,13 +1361,13 @@ var LibraryStore = class {
 		return library;
 	}
 	/** CAS-protected replacement used only by a repeatable import source. */
-	async replaceRawFromImportSource(id, bytes, expected, nextSource) {
+	async replaceRawFromImportSource(id, bytes, expected, nextSource, updateParameters) {
 		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');
+			const { verifyStableRawFile } = await import('./raw-reconciliation.js-_D9lZ_sc.js');
 			try {
 				await verifyStableRawFile(absolutePath, expected.rawHash);
 			} catch {
@@ -1368,6 +1378,7 @@ var LibraryStore = class {
 			const backupPath = `${absolutePath}.fundus-reimport-${token}`;
 			const previousHash = record.rawHash;
 			const previousSource = structuredClone(record.importSource);
+			const previousParameters = structuredClone(record.parameters);
 			let staged = false;
 			let installed = false;
 			try {
@@ -1378,10 +1389,12 @@ var LibraryStore = class {
 				installed = true;
 				record.rawHash = sha256Hex(bytes);
 				if (nextSource) record.importSource = structuredClone(nextSource);
+				if (updateParameters) record.parameters = updateParameters(record.parameters);
 				await this.write(library);
 			} catch (cause) {
 				record.rawHash = previousHash;
 				record.importSource = previousSource;
+				record.parameters = previousParameters;
 				if (installed) await unlink(absolutePath).catch(() => {});
 				if (staged) await rename(backupPath, absolutePath);
 				await unlink(temporaryPath).catch(() => {});
@@ -1906,5 +1919,5 @@ function invalidInput(message) {
 	throw new SourceImportError("invalid-input", message);
 }
 
-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
+export { LibraryStore as L, SourceImportError as S, serverPluginForType as a, invalidInput as b, assertSafeRelativeFilePath as c, descriptorsByType as d, encodeRelativePathForUrl as e, generateManifestModules as g, isRecord as i, processAssets as p, readCurrentProxy as r, serverPluginsByType as s };
+//# sourceMappingURL=contract.js-DGMufT2e.js.map