fundus 0.0.2

package/dist/core/index.js

@@ -0,0 +1,962 @@
+import { a as isAssetReference, i as validateImagePreset, n as RASTER_IMAGE_EXTENSIONS, r as imagePlugin, t as IMAGE_BUILT_IN_PRESETS } from "./image-Dqmz8FXS.js";
+//#region src/folder-path.ts
+/** The implicit raw/proxy root. Explicit folders are always non-empty paths. */
+const ROOT_FOLDER = "";
+/** Fundus-owned file that preserves explicit empty folders in source control. */
+const FOLDER_SENTINEL = ".gitkeep";
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+const WINDOWS_FORBIDDEN_CHARACTERS = /[<>:"|?*]/;
+const WINDOWS_RESERVED_NAME = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/i;
+/** Validate one human-facing folder name (a single path segment). */
+function folderNameError(name) {
+	if (name.length === 0) return "Folder names must not be empty.";
+	if (name !== name.trim()) return "Folder names must not start or end with whitespace.";
+	if (name === "." || name === "..") return `"${name}" is not a valid folder name.`;
+	if (name.includes("/") || name.includes("\\")) return "Folder names must not contain path separators.";
+	if (CONTROL_CHARACTERS.test(name)) return "Folder names must not contain control characters.";
+	if (WINDOWS_FORBIDDEN_CHARACTERS.test(name)) return "Folder names must not contain Windows-reserved characters (: * ? \" < > |).";
+	if (name.endsWith(".")) return "Folder names must not end with a dot.";
+	if (name.toLocaleLowerCase("en-US") === "root") return `"${name}" is reserved for the implicit Fundus root folder.`;
+	if (name.toLocaleLowerCase("en-US") === ".gitkeep") return `"${name}" is reserved for Fundus folder management.`;
+	if (WINDOWS_RESERVED_NAME.test(name)) return `"${name}" is a reserved filesystem name.`;
+	return null;
+}
+/** Normalize a validated, portable relative folder path to NFC + POSIX separators. */
+function normalizeFolderPath(path) {
+	return path.split("/").map((segment) => segment.normalize("NFC")).join("/");
+}
+/** Validate a non-root, POSIX-relative folder path. */
+function folderPathError(path) {
+	if (path.length === 0) return "The root is implicit and cannot be registered as a folder.";
+	if (path.startsWith("/") || path.endsWith("/")) return "Folder paths must be relative and must not start or end with a slash.";
+	for (const segment of path.split("/")) {
+		const problem = folderNameError(segment);
+		if (problem) return `Invalid folder path "${path}": ${problem}`;
+	}
+	return null;
+}
+/** Case-insensitive, Unicode-normalized key used to prevent portable path collisions. */
+function portableFolderPathKey(path) {
+	return normalizeFolderPath(path).toLocaleLowerCase("en-US");
+}
+function parentFolderPath(path) {
+	const separator = path.lastIndexOf("/");
+	return separator === -1 ? "" : path.slice(0, separator);
+}
+function folderNameOf(path) {
+	const separator = path.lastIndexOf("/");
+	return separator === -1 ? path : path.slice(separator + 1);
+}
+function joinFolderPath(parent, name) {
+	return parent === "" ? name : `${parent}/${name}`;
+}
+function folderOfRawPath(rawPath) {
+	return parentFolderPath(rawPath);
+}
+function rawFileNameOfPath(rawPath) {
+	return folderNameOf(rawPath);
+}
+function isFolderOrDescendant(path, ancestor) {
+	return path === ancestor || path.startsWith(`${ancestor}/`);
+}
+function replaceFolderPrefix(path, from, to) {
+	if (path === from) return to;
+	return `${to}${path.slice(from.length)}`;
+}
+//#endregion
+//#region src/library.ts
+/** A fresh, empty library. */
+function createEmptyLibrary() {
+	return {
+		version: 1,
+		folders: [],
+		assets: {},
+		manifests: {}
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Keys that are prototype-pollution hazards as record keys: assigning
+* `assets["__proto__"] = …` on a plain object replaces its prototype instead
+* of adding an entry. Rejected outright at parse time — id *validity* beyond
+* this is a validator concern (reported as issues, not parse failures).
+*/
+const DANGEROUS_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+function assertSafeKey(kind, key) {
+	if (DANGEROUS_KEYS.includes(key)) throw new Error(`Library ${kind} key "${key}" is not allowed.`);
+}
+function parseAssetRecord(id, value) {
+	if (!isRecord(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 {
+		type: value.type,
+		raw: value.raw,
+		rawHash: value.rawHash,
+		parameters: value.parameters,
+		manifests: value.manifests
+	};
+}
+function parseManifestRecord(name, value) {
+	const record = {};
+	if ("color" in value && value.color !== void 0) {
+		if (typeof value.color !== "string") throw new Error(`Library manifest "${name}" has a non-string "color".`);
+		record.color = value.color;
+	}
+	if ("emoji" in value && value.emoji !== void 0) {
+		if (typeof value.emoji !== "string") throw new Error(`Library manifest "${name}" has a non-string "emoji".`);
+		record.emoji = value.emoji;
+	}
+	return record;
+}
+/**
+* Parse and structurally validate a library file's JSON text. Throws with a
+* clear message on any malformed part; plugin parameter validation is a
+* separate, plugin-owned step.
+*/
+function parseLibrary(json) {
+	let value;
+	try {
+		value = JSON.parse(json);
+	} catch (cause) {
+		throw new Error(`Library file is not valid JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+	}
+	if (!isRecord(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 (!isRecord(value.assets)) throw new Error("Library \"assets\" must be an object.");
+	if (!isRecord(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.");
+	const folders = value.folders === void 0 ? [] : value.folders;
+	for (const folder of folders) {
+		const problem = folderPathError(folder);
+		if (problem) throw new Error(`Invalid library folder: ${problem}`);
+	}
+	const assets = {};
+	for (const [id, record] of Object.entries(value.assets)) {
+		assertSafeKey("asset", id);
+		assets[id] = parseAssetRecord(id, record);
+	}
+	const manifests = {};
+	for (const [name, record] of Object.entries(value.manifests)) {
+		assertSafeKey("manifest", name);
+		if (!isRecord(record)) throw new Error(`Library manifest "${name}" must be an object.`);
+		manifests[name] = parseManifestRecord(name, record);
+	}
+	return {
+		version: 1,
+		folders,
+		assets,
+		manifests
+	};
+}
+/** Recursively sort object keys so serialization is order-independent. */
+function sortValue(value) {
+	if (Array.isArray(value)) return value.map(sortValue);
+	if (typeof value === "object" && value !== null) {
+		const sorted = {};
+		for (const key of Object.keys(value).sort()) {
+			const entry = value[key];
+			if (entry !== void 0) sorted[key] = sortValue(entry);
+		}
+		return sorted;
+	}
+	return value;
+}
+/**
+* Serialize a library deterministically: recursively sorted keys, tab-indented,
+* trailing newline. Same library → byte-identical file, whatever the in-memory
+* insertion order was.
+*/
+function serializeLibrary(library) {
+	return `${JSON.stringify(sortValue({
+		...library,
+		folders: [...library.folders].sort()
+	}), null, "	")}\n`;
+}
+//#endregion
+//#region src/asset-id.ts
+/**
+* Asset ids are the SSOT keys and the generated property names on manifests
+* are stable, human-readable camelCase slugs that must be valid JS
+* identifiers and must not collide with `Manifest` class members.
+*/
+/**
+* Names an asset id may never take: current and future members of the runtime
+* `Manifest` class (entries become direct properties on it), plus inherited
+* `Object.prototype` members that would shadow-collide, plus keys that are
+* prototype-pollution hazards when used as record keys (`prototype`;
+* `__proto__` already fails the camelCase pattern).
+*/
+const RESERVED_ASSET_IDS = [
+	"preload",
+	"release",
+	"entries",
+	"constructor",
+	"prototype",
+	"hasOwnProperty",
+	"isPrototypeOf",
+	"propertyIsEnumerable",
+	"toLocaleString",
+	"toString",
+	"valueOf"
+];
+const ASSET_ID_PATTERN = /^[a-z][A-Za-z0-9]*$/;
+/**
+* Whether `id` is a valid asset id: a camelCase JS identifier (lowercase
+* letter, then letters/digits) that is not a reserved `Manifest` member name.
+*/
+function isValidAssetId(id) {
+	return ASSET_ID_PATTERN.test(id) && !RESERVED_ASSET_IDS.includes(id);
+}
+/**
+* Why an id is invalid, as a human-readable message — or `null` when valid.
+* Lets the editor and the validator surface the precise reason.
+*/
+function assetIdError(id) {
+	if (!ASSET_ID_PATTERN.test(id)) return `"${id}" is not a valid asset id — use a camelCase identifier starting with a lowercase letter (e.g. "navigationPanel").`;
+	if (RESERVED_ASSET_IDS.includes(id)) return `"${id}" is reserved (it collides with a Manifest member name).`;
+	return null;
+}
+/**
+* Manifest names deliberately share the asset-id grammar because each name
+* becomes a generated JavaScript module export.
+*/
+function manifestNameError(name) {
+	if (!ASSET_ID_PATTERN.test(name)) return `"${name}" is not a valid manifest name — use a camelCase identifier starting with a lowercase letter (e.g. "mainCatalog").`;
+	if (RESERVED_ASSET_IDS.includes(name)) return `"${name}" is reserved (it collides with a Manifest member name).`;
+	return null;
+}
+//#endregion
+//#region src/manifest-appearance.ts
+/**
+* The fixed color palette. Values are the SSOT stored in the library; names are
+* an ergonomic CLI alias. A Figma-like spread of distinct, saturated hues.
+*/
+const MANIFEST_COLORS = [
+	{
+		name: "slate",
+		value: "#64748b"
+	},
+	{
+		name: "red",
+		value: "#ef4444"
+	},
+	{
+		name: "orange",
+		value: "#f97316"
+	},
+	{
+		name: "amber",
+		value: "#f59e0b"
+	},
+	{
+		name: "yellow",
+		value: "#eab308"
+	},
+	{
+		name: "lime",
+		value: "#84cc16"
+	},
+	{
+		name: "green",
+		value: "#22c55e"
+	},
+	{
+		name: "teal",
+		value: "#14b8a6"
+	},
+	{
+		name: "cyan",
+		value: "#06b6d4"
+	},
+	{
+		name: "blue",
+		value: "#3b82f6"
+	},
+	{
+		name: "indigo",
+		value: "#6366f1"
+	},
+	{
+		name: "violet",
+		value: "#8b5cf6"
+	},
+	{
+		name: "pink",
+		value: "#ec4899"
+	}
+];
+/** The fixed emoji set — 63 visually distinct choices (an 8×8 picker grid with a clear cell). */
+const MANIFEST_EMOJIS = [
+	"🗂️",
+	"🏠",
+	"🎯",
+	"⭐",
+	"🔥",
+	"💎",
+	"🎨",
+	"🧩",
+	"🚀",
+	"🎵",
+	"🏆",
+	"⚡",
+	"🌟",
+	"🍀",
+	"🎁",
+	"📦",
+	"🗺️",
+	"🔑",
+	"🛒",
+	"❤️",
+	"🐙",
+	"🎲",
+	"🌈",
+	"🧪",
+	"🎪",
+	"🎭",
+	"🎬",
+	"🎤",
+	"🎧",
+	"🎸",
+	"🥁",
+	"🔔",
+	"💡",
+	"🔮",
+	"🧭",
+	"⏰",
+	"📸",
+	"🖼️",
+	"📚",
+	"✏️",
+	"🖌️",
+	"🧲",
+	"⚙️",
+	"🛠️",
+	"🔧",
+	"🧰",
+	"🔌",
+	"🔋",
+	"🌍",
+	"🌙",
+	"☀️",
+	"❄️",
+	"🌊",
+	"🍄",
+	"🌵",
+	"🌸",
+	"🍎",
+	"🍕",
+	"🍩",
+	"☕",
+	"🐳",
+	"🦄",
+	"🐝"
+];
+/** Whether `value` is one of the fixed color values (`#rrggbb`, lowercased). */
+function isManifestColor(value) {
+	return MANIFEST_COLORS.some((color) => color.value === value);
+}
+/** Whether `emoji` is one of the fixed emojis. */
+function isManifestEmoji(emoji) {
+	return MANIFEST_EMOJIS.includes(emoji);
+}
+/**
+* Resolve a CLI-supplied color token (either a palette name like `blue` or a
+* hex value like `#3b82f6`, case-insensitively) to its stored hex value, or
+* `null` when it matches no palette entry.
+*/
+function resolveManifestColor(token) {
+	const normalized = token.trim().toLowerCase();
+	const match = MANIFEST_COLORS.find((color) => color.value === normalized || color.name === normalized);
+	return match ? match.value : null;
+}
+/** Why a color value is invalid, as a human-readable message — or `null` when valid. */
+function manifestColorError(value) {
+	if (isManifestColor(value)) return null;
+	return `"${value}" is not a selectable manifest color — choose one of: ${MANIFEST_COLORS.map((color) => `${color.name} (${color.value})`).join(", ")}.`;
+}
+/** Why an emoji is invalid, as a human-readable message — or `null` when valid. */
+function manifestEmojiError(emoji) {
+	if (isManifestEmoji(emoji)) return null;
+	return `"${emoji}" is not a selectable manifest emoji — choose one of: ${MANIFEST_EMOJIS.join(" ")}.`;
+}
+//#endregion
+//#region src/plugins/audio.ts
+/** Built-in presets, always available; host config merges over them. */
+const AUDIO_BUILT_IN_PRESETS = { default: {
+	codec: "opus",
+	bitrateKbps: 96,
+	container: "webm"
+} };
+/** Each codec's muxable container — a mismatch is a config error, not an ffmpeg one. */
+const CONTAINER_BY_CODEC = {
+	opus: "webm",
+	aac: "m4a"
+};
+function validateAudioPreset(name, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Audio preset "${name}" must be an object.`);
+	const record = value;
+	if (record.codec !== "opus" && record.codec !== "aac") throw new Error(`Audio preset "${name}" needs a "codec" of 'opus' | 'aac'.`);
+	if (typeof record.bitrateKbps !== "number" || !Number.isInteger(record.bitrateKbps) || record.bitrateKbps <= 0) throw new Error(`Audio preset "${name}" needs a positive integer "bitrateKbps".`);
+	const expectedContainer = CONTAINER_BY_CODEC[record.codec];
+	if (record.container !== expectedContainer) throw new Error(`Audio preset "${name}": codec '${record.codec}' requires container '${expectedContainer}'.`);
+	return {
+		codec: record.codec,
+		bitrateKbps: record.bitrateKbps,
+		container: expectedContainer
+	};
+}
+const AUDIO_EXTENSIONS = [
+	"mp3",
+	"wav",
+	"m4a",
+	"ogg",
+	"flac"
+];
+const audioPlugin = {
+	type: "audio",
+	accepts: [...AUDIO_EXTENSIONS],
+	defaultParameters: () => ({ preset: "default" }),
+	validateParameters(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Audio parameters must be an object.");
+		const record = value;
+		if (typeof record.preset !== "string" || record.preset.length === 0) throw new Error("Audio parameters need a non-empty string \"preset\".");
+		return { preset: record.preset };
+	}
+};
+//#endregion
+//#region src/chroma-key.ts
+/** The upstream shader's property defaults — a freshly ingested asset starts here. */
+const DEFAULT_CHROMA_KEY_PARAMETERS = {
+	keyColor: [
+		0,
+		1,
+		0
+	],
+	colorCutoff: .2,
+	colorFeathering: .33,
+	maskFeathering: 1,
+	sharpening: .5,
+	despill: 1,
+	despillLuminanceAdd: .2
+};
+const SCALAR_KEYS = [
+	"colorCutoff",
+	"colorFeathering",
+	"maskFeathering",
+	"sharpening",
+	"despill",
+	"despillLuminanceAdd"
+];
+function clampUnit(value) {
+	return Math.min(1, Math.max(0, value));
+}
+/**
+* Validate an unknown chroma-key blob: every field required, every channel and
+* scalar a finite number. Values are clamped into 0–1 (slider float artifacts
+* must not invalidate a library), non-numbers throw.
+*/
+function validateChromaKeyParameters(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("\"chromaKey\" must be an object.");
+	const record = value;
+	const keyColor = record.keyColor;
+	if (!Array.isArray(keyColor) || keyColor.length !== 3 || keyColor.some((channel) => typeof channel !== "number" || !Number.isFinite(channel))) throw new Error("\"chromaKey.keyColor\" must be an array of three numbers (RGB, 0–1 each).");
+	const result = { keyColor: [
+		clampUnit(keyColor[0]),
+		clampUnit(keyColor[1]),
+		clampUnit(keyColor[2])
+	] };
+	for (const key of SCALAR_KEYS) {
+		const scalar = record[key];
+		if (typeof scalar !== "number" || !Number.isFinite(scalar)) throw new Error(`"chromaKey.${key}" must be a number (0–1).`);
+		result[key] = clampUnit(scalar);
+	}
+	return result;
+}
+//#endregion
+//#region src/plugins/video.ts
+/**
+* Built-in presets, always available; host config merges over them. The
+* default is the proven committed-video formula: H.264, slow preset, animation
+* tune, CRF 28, yuv420p, faststart MP4.
+*/
+const VIDEO_BUILT_IN_PRESETS = { default: {
+	codec: "h264",
+	crf: 28,
+	encoderPreset: "slow",
+	tune: "animation",
+	pixelFormat: "yuv420p",
+	container: "mp4"
+} };
+function validateVideoPreset(name, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Video preset "${name}" must be an object.`);
+	const record = value;
+	if (record.codec !== "h264") throw new Error(`Video preset "${name}" needs a "codec" of 'h264'.`);
+	if (typeof record.crf !== "number" || !Number.isInteger(record.crf) || record.crf < 0) throw new Error(`Video preset "${name}" needs an integer "crf" ≥ 0.`);
+	if (typeof record.encoderPreset !== "string" || record.encoderPreset.length === 0) throw new Error(`Video preset "${name}" needs a non-empty string "encoderPreset".`);
+	if (record.tune !== void 0 && (typeof record.tune !== "string" || record.tune.length === 0)) throw new Error(`Video preset "${name}" has a non-string "tune".`);
+	if (typeof record.pixelFormat !== "string" || record.pixelFormat.length === 0) throw new Error(`Video preset "${name}" needs a non-empty string "pixelFormat".`);
+	if (record.container !== "mp4") throw new Error(`Video preset "${name}" needs a "container" of 'mp4'.`);
+	return {
+		codec: "h264",
+		crf: record.crf,
+		encoderPreset: record.encoderPreset,
+		...record.tune !== void 0 ? { tune: record.tune } : {},
+		pixelFormat: record.pixelFormat,
+		container: "mp4"
+	};
+}
+const VIDEO_EXTENSIONS = [
+	"mp4",
+	"mov",
+	"webm",
+	"m4v"
+];
+/** Shared by the video and chroma-key-video plugins (identical transcode inputs). */
+function validateVideoParameters(label, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`${label} parameters must be an object.`);
+	const record = value;
+	if (typeof record.preset !== "string" || record.preset.length === 0) throw new Error(`${label} parameters need a non-empty string "preset".`);
+	if (record.maxWidth !== void 0) {
+		if (typeof record.maxWidth !== "number" || !Number.isInteger(record.maxWidth) || record.maxWidth <= 0) throw new Error(`${label} "maxWidth" must be a positive integer when set.`);
+	}
+	return {
+		preset: record.preset,
+		...record.maxWidth !== void 0 ? { maxWidth: record.maxWidth } : {}
+	};
+}
+const videoPlugin = {
+	type: "video",
+	accepts: [...VIDEO_EXTENSIONS],
+	defaultParameters: () => ({ preset: "default" }),
+	validateParameters(value) {
+		return validateVideoParameters("Video", value);
+	}
+};
+//#endregion
+//#region src/plugins/chroma-key-video.ts
+/**
+* Chroma-key-video plugin (core part): a greenscreen video delivered through
+* the video plugin's transcode pipeline, plus the keying data the runtime's
+* WebGL renderer needs — chroma-key parameters and two optional image
+* references: a grayscale shape `mask` multiplied onto the keyed
+* alpha, and a static `fallback` image shown when WebGL2 is unavailable.
+*
+* The keying values and references are entry-only data: they travel into the
+* generated manifest entry but never touch the ffmpeg job, so
+* `processingParameters` narrows the job-hash input to the transcode inputs
+* (preset + maxWidth) — retuning a slider must not re-transcode the proxy.
+*/
+function validateOptionalReference(label, value) {
+	if (value === void 0) return void 0;
+	if (!isAssetReference(value)) throw new Error(`"${label}" must be an asset reference ({ "$asset": "<id>" }).`);
+	return { $asset: value.$asset };
+}
+const chromaKeyVideoPlugin = {
+	type: "chroma-key-video",
+	accepts: [...VIDEO_EXTENSIONS],
+	defaultParameters: () => ({
+		preset: "default",
+		chromaKey: {
+			...DEFAULT_CHROMA_KEY_PARAMETERS,
+			keyColor: [...DEFAULT_CHROMA_KEY_PARAMETERS.keyColor]
+		}
+	}),
+	validateParameters(value) {
+		const videoParameters = validateVideoParameters("Chroma-key-video", value);
+		const record = value;
+		const chromaKey = validateChromaKeyParameters(record.chromaKey);
+		const mask = validateOptionalReference("mask", record.mask);
+		const fallback = validateOptionalReference("fallback", record.fallback);
+		return {
+			...videoParameters,
+			chromaKey,
+			...mask !== void 0 ? { mask } : {},
+			...fallback !== void 0 ? { fallback } : {}
+		};
+	},
+	collectReferences(parameters) {
+		const references = [];
+		if (parameters.mask) references.push({
+			field: "mask",
+			assetId: parameters.mask.$asset,
+			expectedTypes: ["image"]
+		});
+		if (parameters.fallback) references.push({
+			field: "fallback",
+			assetId: parameters.fallback.$asset,
+			expectedTypes: ["image"]
+		});
+		return references;
+	},
+	processingParameters(parameters) {
+		return {
+			preset: parameters.preset,
+			...parameters.maxWidth !== void 0 ? { maxWidth: parameters.maxWidth } : {}
+		};
+	}
+};
+//#endregion
+//#region src/slice-data.ts
+/**
+* The slice data model keeps the source image separate from slicing metadata
+* (Fundus tracks raw files and
+* proxy dimensions separately), so there is no `SliceSource` here.
+*
+* The geometry is stored as **insets** (border thickness in source pixels), the
+* canonical, render-ready form — equivalent to CSS `border-image-slice`.
+* `slicedAxesFor` is the single source of truth for which axes each mode uses.
+*/
+const SLICE_MODES = [
+	"nine",
+	"three-horizontal",
+	"three-vertical",
+	"one"
+];
+/** All-zero insets — the "no overdraw" value. */
+function createZeroInsets() {
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+}
+/**
+* Default insets for a freshly ingested image: each border a quarter of the
+* corresponding dimension (at least 1px where the image is large enough),
+* always clamped so a center of at least one source pixel remains on each
+* axis. For an axis too small for insets + a 1px center (width/height ≤ 2)
+* the insets on that axis are 0 — structurally valid slicing for any size ≥ 1.
+*/
+function defaultInsetsForSize(width, height) {
+	const horizontal = Math.min(Math.max(1, Math.floor(width / 4)), Math.floor((width - 1) / 2));
+	const vertical = Math.min(Math.max(1, Math.floor(height / 4)), Math.floor((height - 1) / 2));
+	return {
+		top: vertical,
+		right: horizontal,
+		bottom: vertical,
+		left: horizontal
+	};
+}
+/** Which source-image axes are sliced for a mode. */
+function slicedAxesFor(mode) {
+	return {
+		horizontal: mode === "nine" || mode === "three-horizontal",
+		vertical: mode === "nine" || mode === "three-vertical"
+	};
+}
+/** Maximum inset on one side while preserving the opposite inset. */
+function maxInset(insets, side, width, height) {
+	if (side === "left") return width - insets.right;
+	if (side === "right") return width - insets.left;
+	if (side === "top") return height - insets.bottom;
+	return height - insets.top;
+}
+/** Maximum overdraw on one side while preserving at least one core source pixel. */
+function maxOverdraw(overdraw, side, width, height) {
+	return maxInset(overdraw, side, width, height) - 1;
+}
+//#endregion
+//#region src/plugins/slice.ts
+/** Built-in presets, always available; host config merges over them. */
+const SLICE_BUILT_IN_PRESETS = { default: {
+	format: "webp",
+	quality: 82
+} };
+function validateInsets(label, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Slice ${label} must be an object with top/right/bottom/left.`);
+	const record = value;
+	const sides = [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	];
+	const result = createZeroInsets();
+	for (const side of sides) {
+		const sideValue = record[side];
+		if (typeof sideValue !== "number" || !Number.isInteger(sideValue) || sideValue < 0) throw new Error(`Slice ${label}.${side} must be a non-negative integer.`);
+		result[side] = sideValue;
+	}
+	return result;
+}
+const slicePlugin = {
+	type: "slice",
+	accepts: [...RASTER_IMAGE_EXTENSIONS],
+	defaultParameters: () => ({
+		mode: "nine",
+		insets: createZeroInsets(),
+		pixelRatio: 1,
+		preset: "default"
+	}),
+	validateParameters(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Slice parameters must be an object.");
+		const record = value;
+		if (typeof record.mode !== "string" || !SLICE_MODES.includes(record.mode)) throw new Error(`Slice "mode" must be one of ${SLICE_MODES.map((mode) => `'${mode}'`).join(" | ")}.`);
+		const insets = validateInsets("insets", record.insets);
+		if (typeof record.pixelRatio !== "number" || !Number.isInteger(record.pixelRatio) || record.pixelRatio < 1) throw new Error("Slice \"pixelRatio\" must be an integer ≥ 1.");
+		const overdraw = record.overdraw === void 0 ? void 0 : validateInsets("overdraw", record.overdraw);
+		if (typeof record.preset !== "string" || record.preset.length === 0) throw new Error("Slice parameters need a non-empty string \"preset\".");
+		return {
+			mode: record.mode,
+			insets,
+			pixelRatio: record.pixelRatio,
+			...overdraw !== void 0 ? { overdraw } : {},
+			preset: record.preset
+		};
+	}
+};
+//#endregion
+//#region src/ingest.ts
+/**
+* Ingestion helpers shared by every ingest surface: the editor's
+* drag & drop dialog and the CLI's `asset ingest` command both resolve a
+* dropped file name to its candidate asset types and propose an asset id the
+* same way — one implementation, in core.
+*/
+/** The built-in descriptors, in registration order (image before slice, video before chroma-key-video). */
+const BUILT_IN_DESCRIPTORS = [
+	imagePlugin,
+	slicePlugin,
+	videoPlugin,
+	chromaKeyVideoPlugin,
+	audioPlugin
+];
+/** Unique HTML file-picker accept extensions derived from descriptor claims. */
+function acceptedExtensions(descriptors = BUILT_IN_DESCRIPTORS) {
+	return [...new Set(descriptors.flatMap((descriptor) => descriptor.accepts))].sort().map((extension) => `.${extension}`);
+}
+/**
+* Types an ingested file of this extension could become — derived from the
+* descriptors' `accepts` claims. Raster images and video containers are
+* ambiguous (image/slice, video/chroma-key-video) — the editor dialog prompts
+* once, the CLI requires `--type`; audio is unambiguous.
+*/
+function typesForFileName(fileName, descriptors = BUILT_IN_DESCRIPTORS) {
+	const extension = fileName.slice(fileName.lastIndexOf(".") + 1).toLowerCase();
+	return descriptors.filter((descriptor) => descriptor.accepts.includes(extension)).map((descriptor) => descriptor.type);
+}
+/**
+* Propose a camelCase asset id from a file name: split on non-alphanumeric
+* runs and case boundaries, drop a `@2x`-style scale suffix, lowercase the
+* first word, capitalize the rest, strip leading digits.
+*/
+function proposeAssetId(fileName) {
+	const words = fileName.replace(/\.[^.]+$/, "").replace(/(?:@|[-_])\dx$/i, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (words.length === 0) return "asset";
+	const withoutLeadingDigits = words.map((word, index) => index === 0 ? word.toLowerCase() : word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("").replace(/^[0-9]+/, "");
+	if (!withoutLeadingDigits) return "asset";
+	return withoutLeadingDigits.charAt(0).toLowerCase() + withoutLeadingDigits.slice(1);
+}
+//#endregion
+//#region src/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/config.ts
+/** Identity helper so the host config file gets full typing + completion. */
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+//#region src/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/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
+export { AUDIO_BUILT_IN_PRESETS, AUDIO_EXTENSIONS, DEFAULT_CHROMA_KEY_PARAMETERS, FOLDER_SENTINEL, IMAGE_BUILT_IN_PRESETS, MANIFEST_COLORS, MANIFEST_EMOJIS, RASTER_IMAGE_EXTENSIONS, RESERVED_ASSET_IDS, ROOT_FOLDER, SLICE_BUILT_IN_PRESETS, VIDEO_BUILT_IN_PRESETS, VIDEO_EXTENSIONS, acceptedExtensions, allDeliveredAssetIds, assetIdError, audioPlugin, canonicalizeParameters, chromaKeyVideoPlugin, collectAllReferences, compareCodeUnits, computeLibraryMembership, createEmptyLibrary, createZeroInsets, defaultInsetsForSize, defineConfig, folderNameError, folderNameOf, folderOfRawPath, folderPathError, imagePlugin, isAssetReference, isFolderOrDescendant, isManifestColor, isManifestEmoji, isValidAssetId, joinFolderPath, manifestColorError, manifestEmojiError, manifestNameError, maxInset, maxOverdraw, normalizeFolderPath, parentFolderPath, parseLibrary, portableFolderPathKey, proposeAssetId, rawFileNameOfPath, referenceClosure, referenceErrors, replaceFolderPrefix, resolveManifestColor, serializeLibrary, slicePlugin, slicedAxesFor, topologicalReferenceOrder, typesForFileName, validateAudioPreset, validateChromaKeyParameters, validateImagePreset, validateVideoParameters, validateVideoPreset, videoPlugin };