fundus 0.0.2

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import { FundusConfig, defineConfig } from "#fundus/core";
+export { type FundusConfig, defineConfig };

package/dist/config.js

@@ -0,0 +1,2 @@
+import { defineConfig } from "#fundus/core";
+export { defineConfig };

package/dist/core/image-Dqmz8FXS.js

@@ -0,0 +1,54 @@
+//#region src/asset-reference.ts
+/** Whether a value is a well-formed asset-reference marker. */
+function isAssetReference(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.$asset === "string" && value.$asset !== "";
+}
+//#endregion
+//#region src/plugins/image.ts
+const IMAGE_FORMATS = [
+	"webp",
+	"png",
+	"avif",
+	"jpeg"
+];
+/** Built-in presets, always available; host config merges over them. */
+const IMAGE_BUILT_IN_PRESETS = { default: {
+	format: "webp",
+	quality: 82
+} };
+function validateImagePreset(name, value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Image preset "${name}" must be an object.`);
+	const record = value;
+	if (typeof record.format !== "string" || !IMAGE_FORMATS.includes(record.format)) throw new Error(`Image preset "${name}" needs a "format" of ${IMAGE_FORMATS.map((format) => `'${format}'`).join(" | ")}.`);
+	if (record.quality !== void 0 && typeof record.quality !== "number") throw new Error(`Image preset "${name}" has a non-number "quality".`);
+	return {
+		format: record.format,
+		quality: record.quality
+	};
+}
+const RASTER_IMAGE_EXTENSIONS = [
+	"png",
+	"jpg",
+	"jpeg",
+	"webp",
+	"avif"
+];
+const imagePlugin = {
+	type: "image",
+	accepts: [...RASTER_IMAGE_EXTENSIONS],
+	defaultParameters: () => ({ preset: "default" }),
+	validateParameters(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error("Image parameters must be an object.");
+		const record = value;
+		if (typeof record.preset !== "string" || record.preset.length === 0) throw new Error("Image parameters need a non-empty string \"preset\".");
+		if (record.targetWidth !== void 0) {
+			if (typeof record.targetWidth !== "number" || !Number.isInteger(record.targetWidth) || record.targetWidth <= 0) throw new Error("Image \"targetWidth\" must be a positive integer when set.");
+		}
+		return {
+			preset: record.preset,
+			...record.targetWidth !== void 0 ? { targetWidth: record.targetWidth } : {}
+		};
+	}
+};
+//#endregion
+export { isAssetReference as a, validateImagePreset as i, RASTER_IMAGE_EXTENSIONS as n, imagePlugin as r, IMAGE_BUILT_IN_PRESETS as t };

package/dist/core/index.d.ts

@@ -0,0 +1,499 @@
+import { A as Library, C as ValidationIssueDto, D as isAssetReference, E as CollectedReference, F as serializeLibrary, M as ManifestRecord, N as createEmptyLibrary, O as AssetId, P as parseLibrary, S as ProxyStateDto, T as AssetReference, _ as PassiveManifestMembershipDto, a as referenceErrors, b as PatchFolderRequestDto, c as AssetReferenceLinkDto, d as CreateFolderRequestDto, f as CreateManifestRequestDto, g as MoveAssetsRequestDto, h as ManifestMembershipDto, i as referenceClosure, j as ManifestName, k as AssetRecord, l as AssetReferencesDto, m as FundusStateDto, n as ReferencesByAsset, o as topologicalReferenceOrder, p as DeleteAssetsRequestDto, r as collectAllReferences, s as ApiErrorDto, t as PluginDescriptorRegistry, u as AssetStateDto, v as PassiveMemberDto, w as AssetTypePluginDescriptor, x as PatchManifestRequestDto, y as PatchAssetRequestDto } from "./reference-graph-CjuHbLDw.js";
+
+//#region src/folder-path.d.ts
+/** The implicit raw/proxy root. Explicit folders are always non-empty paths. */
+declare const ROOT_FOLDER = "";
+/** Fundus-owned file that preserves explicit empty folders in source control. */
+declare const FOLDER_SENTINEL = ".gitkeep";
+/** Validate one human-facing folder name (a single path segment). */
+declare function folderNameError(name: string): string | null;
+/** Normalize a validated, portable relative folder path to NFC + POSIX separators. */
+declare function normalizeFolderPath(path: string): string;
+/** Validate a non-root, POSIX-relative folder path. */
+declare function folderPathError(path: string): string | null;
+/** Case-insensitive, Unicode-normalized key used to prevent portable path collisions. */
+declare function portableFolderPathKey(path: string): string;
+declare function parentFolderPath(path: string): string;
+declare function folderNameOf(path: string): string;
+declare function joinFolderPath(parent: string, name: string): string;
+declare function folderOfRawPath(rawPath: string): string;
+declare function rawFileNameOfPath(rawPath: string): string;
+declare function isFolderOrDescendant(path: string, ancestor: string): boolean;
+declare function replaceFolderPrefix(path: string, from: string, to: string): string;
+//#endregion
+//#region src/asset-id.d.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).
+ */
+declare const RESERVED_ASSET_IDS: readonly string[];
+/**
+ * Whether `id` is a valid asset id: a camelCase JS identifier (lowercase
+ * letter, then letters/digits) that is not a reserved `Manifest` member name.
+ */
+declare function isValidAssetId(id: string): boolean;
+/**
+ * Why an id is invalid, as a human-readable message — or `null` when valid.
+ * Lets the editor and the validator surface the precise reason.
+ */
+declare function assetIdError(id: string): string | null;
+/**
+ * Manifest names deliberately share the asset-id grammar because each name
+ * becomes a generated JavaScript module export.
+ */
+declare function manifestNameError(name: string): string | null;
+//#endregion
+//#region src/manifest-appearance.d.ts
+/**
+ * Manifest appearance: each manifest may carry a color and an emoji,
+ * chosen from these fixed sets, so the editor can tag its label everywhere and
+ * make asset↔manifest membership visually scannable. The sets are the closed
+ * palette both the editor pickers and the CLI validate against — storing a
+ * value outside them is rejected at every mutation entry point.
+ */
+/** One selectable manifest color: a stable display name and its hex value. */
+interface ManifestColor {
+  /** Human-readable palette name (used by the CLI's `--color <name|hex>`). */
+  name: string;
+  /** The stored value — a lowercase `#rrggbb` hex string. */
+  value: string;
+}
+/**
+ * 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.
+ */
+declare const MANIFEST_COLORS: readonly ManifestColor[];
+/** The fixed emoji set — 63 visually distinct choices (an 8×8 picker grid with a clear cell). */
+declare const MANIFEST_EMOJIS: readonly string[];
+/** Whether `value` is one of the fixed color values (`#rrggbb`, lowercased). */
+declare function isManifestColor(value: string): boolean;
+/** Whether `emoji` is one of the fixed emojis. */
+declare function isManifestEmoji(emoji: string): boolean;
+/**
+ * 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.
+ */
+declare function resolveManifestColor(token: string): string | null;
+/** Why a color value is invalid, as a human-readable message — or `null` when valid. */
+declare function manifestColorError(value: string): string | null;
+/** Why an emoji is invalid, as a human-readable message — or `null` when valid. */
+declare function manifestEmojiError(emoji: string): string | null;
+//#endregion
+//#region src/ingest.d.ts
+/** Unique HTML file-picker accept extensions derived from descriptor claims. */
+declare function acceptedExtensions(descriptors?: AssetTypePluginDescriptor<unknown, unknown>[]): string[];
+/**
+ * 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.
+ */
+declare function typesForFileName(fileName: string, descriptors?: AssetTypePluginDescriptor<unknown, unknown>[]): string[];
+/**
+ * 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.
+ */
+declare function proposeAssetId(fileName: string): string;
+//#endregion
+//#region src/canonicalize.d.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.
+ */
+declare function canonicalizeParameters(parameters: unknown): string;
+/** Deterministic UTF-16 code-unit ordering, independent of host locale. */
+declare function compareCodeUnits(left: string, right: string): number;
+//#endregion
+//#region src/plugins/audio.d.ts
+interface AudioPreset {
+  codec: 'opus' | 'aac';
+  /** Target bitrate in kilobits per second (`-b:a`). */
+  bitrateKbps: number;
+  container: 'webm' | 'm4a';
+}
+interface AudioPluginConfig {
+  /** Named presets; merged over the built-in defaults. */
+  presets?: Record<string, AudioPreset>;
+}
+interface AudioParameters {
+  /** Preset name, resolved against the audio plugin config's presets. */
+  preset: string;
+}
+/** Built-in presets, always available; host config merges over them. */
+declare const AUDIO_BUILT_IN_PRESETS: Record<string, AudioPreset>;
+declare function validateAudioPreset(name: string, value: unknown): AudioPreset;
+declare const AUDIO_EXTENSIONS: readonly string[];
+declare const audioPlugin: AssetTypePluginDescriptor<AudioParameters, AudioPluginConfig>;
+//#endregion
+//#region src/plugins/image.d.ts
+declare const IMAGE_FORMATS: readonly ["webp", "png", "avif", "jpeg"];
+type ImageFormat = (typeof IMAGE_FORMATS)[number];
+interface ImagePreset {
+  format: ImageFormat;
+  /** Encoder quality (format-dependent semantics); omitted = encoder default. */
+  quality?: number;
+}
+interface ImagePluginConfig {
+  /** Named presets; merged over the built-in defaults. */
+  presets?: Record<string, ImagePreset>;
+}
+interface ImageParameters {
+  /** Preset name, resolved against the plugin config's presets. */
+  preset: string;
+  /** Resize to this width (keeping aspect ratio); omitted = keep source size. */
+  targetWidth?: number;
+}
+/** Built-in presets, always available; host config merges over them. */
+declare const IMAGE_BUILT_IN_PRESETS: Record<string, ImagePreset>;
+declare function validateImagePreset(name: string, value: unknown): ImagePreset;
+declare const RASTER_IMAGE_EXTENSIONS: readonly string[];
+declare const imagePlugin: AssetTypePluginDescriptor<ImageParameters, ImagePluginConfig>;
+//#endregion
+//#region src/slice-data.d.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.
+ */
+declare const SLICE_MODES: readonly ["nine", "three-horizontal", "three-vertical", "one"];
+type SliceMode = (typeof SLICE_MODES)[number];
+/** Border thickness in source pixels. Always integers (pixel-precise). */
+interface SliceInsets {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+/**
+ * Full slicing description for an image, independent of which image it applies
+ * to. Stored in the library as (part of) the slice plugin's parameters and
+ * emitted into generated manifest entries.
+ */
+interface Slicing {
+  mode: SliceMode;
+  insets: SliceInsets;
+  /**
+   * Source pixels per CSS pixel — the scale the asset was exported at
+   * (`1` = @1x, `2` = @2x, `3` = @3x). All fixed slice dimensions (9-slice
+   * corners) are divided by this when rendering, so a high-resolution asset
+   * displays at its intended logical size.
+   */
+  pixelRatio: number;
+  /**
+   * Per-side thickness (in source pixels) of the image's baked-in overdraw — a
+   * drop shadow / glow painted around the actual element. The renderers treat
+   * the image **minus** the overdraw as the element: that core fills the layout
+   * box, and the overdraw band is painted outside it (like a CSS `box-shadow`).
+   * Optional: absent means no overdraw.
+   */
+  overdraw?: SliceInsets;
+}
+/** All-zero insets — the "no overdraw" value. */
+declare function createZeroInsets(): SliceInsets;
+/**
+ * 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.
+ */
+declare function defaultInsetsForSize(width: number, height: number): SliceInsets;
+/** Which source-image axes are sliced for a mode. */
+declare function slicedAxesFor(mode: SliceMode): {
+  horizontal: boolean;
+  vertical: boolean;
+};
+/** Maximum inset on one side while preserving the opposite inset. */
+declare function maxInset(insets: SliceInsets, side: keyof SliceInsets, width: number, height: number): number;
+/** Maximum overdraw on one side while preserving at least one core source pixel. */
+declare function maxOverdraw(overdraw: SliceInsets, side: keyof SliceInsets, width: number, height: number): number;
+//#endregion
+//#region src/plugins/slice.d.ts
+interface SliceParameters {
+  mode: SliceMode;
+  insets: SliceInsets;
+  pixelRatio: number;
+  overdraw?: SliceInsets;
+  /** Output format preset name, resolved against the slice plugin config's presets. */
+  preset: string;
+}
+/** Same shape as the image plugin's config: named output-format presets. */
+type SlicePluginConfig = ImagePluginConfig;
+/** Built-in presets, always available; host config merges over them. */
+declare const SLICE_BUILT_IN_PRESETS: Record<string, ImagePreset>;
+declare const slicePlugin: AssetTypePluginDescriptor<SliceParameters, SlicePluginConfig>;
+//#endregion
+//#region src/plugins/video.d.ts
+interface VideoPreset {
+  codec: 'h264';
+  /** x264 constant rate factor (quality; lower = better/larger). */
+  crf: number;
+  /** x264 speed/efficiency preset (`-preset`), e.g. 'slow'. */
+  encoderPreset: string;
+  /** x264 content tuning (`-tune`), e.g. 'animation'; omitted = none. */
+  tune?: string;
+  /** Output pixel format (`-pix_fmt`), e.g. 'yuv420p'. */
+  pixelFormat: string;
+  container: 'mp4';
+}
+interface VideoPluginConfig {
+  /** Named presets; merged over the built-in defaults. */
+  presets?: Record<string, VideoPreset>;
+  /** Absolute path of a system ffmpeg binary; omitted = the bundled `ffmpeg-static`. */
+  ffmpegPath?: string;
+  /** Absolute path of a system ffprobe binary; omitted = the bundled `ffprobe-static`. */
+  ffprobePath?: string;
+}
+interface VideoParameters {
+  /** Preset name, resolved against the video plugin config's presets. */
+  preset: string;
+  /** Downscale-only width cap (keeping aspect ratio); omitted = source resolution. */
+  maxWidth?: number;
+}
+/**
+ * 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.
+ */
+declare const VIDEO_BUILT_IN_PRESETS: Record<string, VideoPreset>;
+declare function validateVideoPreset(name: string, value: unknown): VideoPreset;
+declare const VIDEO_EXTENSIONS: readonly string[];
+/** Shared by the video and chroma-key-video plugins (identical transcode inputs). */
+declare function validateVideoParameters(label: string, value: unknown): VideoParameters;
+declare const videoPlugin: AssetTypePluginDescriptor<VideoParameters, VideoPluginConfig>;
+//#endregion
+//#region src/config.d.ts
+interface FundusConfig {
+  /** Directory holding the raw originals (never delivered). */
+  rawDir: string;
+  /** Directory processed proxies are written to (conventionally under `static/`). */
+  proxyDir: string;
+  /** URL prefix baked into generated proxy `src` values, e.g. '/fundus/'. */
+  proxyBasePath: string;
+  /** Path of the library JSON file (the SSOT). */
+  library: string;
+  /** Directory the generated manifest modules land in. */
+  manifestsDir: string;
+  /**
+   * Per-plugin configuration; each plugin owns its namespace and schema.
+   * chroma-key-video has no namespace — it shares the video plugin's presets
+   * (and ffmpeg/ffprobe path overrides) .
+   */
+  plugins?: {
+    image?: ImagePluginConfig;
+    slice?: SlicePluginConfig;
+    video?: VideoPluginConfig;
+    audio?: AudioPluginConfig;
+  };
+}
+/** Identity helper so the host config file gets full typing + completion. */
+declare function defineConfig(config: FundusConfig): FundusConfig;
+//#endregion
+//#region src/chroma-key.d.ts
+/**
+ * Chroma-key parameter data: the keying values the chroma-key-video plugin
+ * stores per asset and the runtime's WebGL renderer consumes. The parameter
+ * names and defaults follow the public UnityChromakey shader; this module is
+ * environment-free data only — the GL engine lives in `@fundus/runtime`.
+ */
+interface ChromaKeyParameters {
+  /** RGB 0–1 each. The greenscreen color to key out. */
+  keyColor: [number, number, number];
+  /** Chroma distance below which a pixel is fully keyed. */
+  colorCutoff: number;
+  /** Chroma distance band over which the key fades out. */
+  colorFeathering: number;
+  /** Blend toward the 3×3-blurred mask, 0 = unfeathered. */
+  maskFeathering: number;
+  /** Lower smoothstep edge re-hardening the feathered mask. */
+  sharpening: number;
+  /** How strongly green spill is pulled toward the red/blue average. */
+  despill: number;
+  /** Luminance removed by the despill that is added back. */
+  despillLuminanceAdd: number;
+}
+/** The upstream shader's property defaults — a freshly ingested asset starts here. */
+declare const DEFAULT_CHROMA_KEY_PARAMETERS: ChromaKeyParameters;
+/**
+ * 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.
+ */
+declare function validateChromaKeyParameters(value: unknown): ChromaKeyParameters;
+//#endregion
+//#region src/manifest-entry.d.ts
+/**
+ * Pre-inline manifest-entry data. Reference fields may still contain
+ * `{ $asset }` markers; codegen narrows this to `ManifestEntry` after inlining.
+ */
+type ManifestEntryData = {
+  kind: string;
+  src: string;
+} & Record<string, unknown>;
+interface ImageManifestEntry {
+  kind: 'image';
+  /** Delivered proxy URL (`proxyBasePath` + proxy file name). */
+  src: string;
+  /** Intrinsic pixel dimensions of the delivered proxy. */
+  width: number;
+  height: number;
+}
+interface SliceManifestEntry {
+  kind: 'slice';
+  /** Delivered proxy URL (`proxyBasePath` + proxy file name). */
+  src: string;
+  slicing: Slicing;
+  /** Pixel dimensions of the delivered image the insets are measured in. */
+  sourceWidth: number;
+  sourceHeight: number;
+}
+interface VideoManifestEntry {
+  kind: 'video';
+  /** Delivered proxy URL (`proxyBasePath` + proxy file name). */
+  src: string;
+  /** Intrinsic pixel dimensions of the delivered proxy. */
+  width: number;
+  height: number;
+  durationMs: number;
+}
+interface ChromaKeyVideoManifestEntry {
+  kind: 'chroma-key-video';
+  /** Delivered proxy URL (`proxyBasePath` + proxy file name). */
+  src: string;
+  /** Intrinsic pixel dimensions of the delivered proxy. */
+  width: number;
+  height: number;
+  durationMs: number;
+  chromaKey: ChromaKeyParameters;
+  /** Grayscale shape mask — the referenced image's entry, inlined by codegen. */
+  mask?: ImageManifestEntry;
+  /** WebGL2-unavailable fallback — the referenced image's entry, inlined by codegen. */
+  fallback?: ImageManifestEntry;
+}
+interface AudioManifestEntry {
+  kind: 'audio';
+  /** Delivered proxy URL (`proxyBasePath` + proxy file name). */
+  src: string;
+  durationMs: number;
+}
+type ManifestEntry = ImageManifestEntry | SliceManifestEntry | VideoManifestEntry | ChromaKeyVideoManifestEntry | AudioManifestEntry;
+/** Preload options of the image kind: decode the fetched file up front. */
+interface ImagePreloadOptions {
+  /** Decode via an HTMLImageElement after fetching (default true). */
+  decode?: boolean;
+}
+/**
+ * Preload options of the slice kind. A slice is image-backed, so it carries
+ * the same decode switch — typed per kind (not shared), so kinds can diverge.
+ */
+interface SlicePreloadOptions {
+  /** Decode via an HTMLImageElement after fetching (default true). */
+  decode?: boolean;
+}
+/**
+ * Preload options of the video kind. Retention (full fetch + object URL) is
+ * always on  — no options yet; the namespaced slot is the API.
+ */
+interface VideoPreloadOptions {}
+/**
+ * Preload options of the chroma-key-video kind. No options yet; the
+ * namespaced slot is the API.
+ */
+interface ChromaKeyVideoPreloadOptions {}
+/** Preload options of the audio kind. Retention is always on — no options yet. */
+interface AudioPreloadOptions {}
+/**
+ * Options for `Manifest.preload()`, namespaced per asset kind exactly like
+ * plugin configuration lives under `plugins.<type>` in `fundus.config.ts`
+ *; each kind that has preload options declares its own type here,
+ * and adding a kind is purely additive. An option applies to every entry of
+ * that kind, including entries reached via the inlined reference closure.
+ */
+interface PreloadOptions {
+  image?: ImagePreloadOptions;
+  slice?: SlicePreloadOptions;
+  video?: VideoPreloadOptions;
+  chromaKeyVideo?: ChromaKeyVideoPreloadOptions;
+  audio?: AudioPreloadOptions;
+}
+//#endregion
+//#region src/manifest-membership.d.ts
+/** One derived passive membership, with the attribution that explains it. */
+interface PassiveMember {
+  assetId: AssetId;
+  /**
+   * The explicit members of the manifest whose reference closure contains
+   * this asset — the answer to "why is this here". Attribution is to the
+   * explicit-member *roots*, so a chain `a → b → c` attributes both `b` and
+   * `c` to `a` (sorted, at least one entry).
+   */
+  via: AssetId[];
+}
+/** One manifest's full membership picture: explicit (stored) + passive (derived). */
+interface ManifestMembership {
+  /** Members stored in the library — the manifest's typed API surface (sorted). */
+  explicitMemberIds: AssetId[];
+  /**
+   * Members derived from the reference graph: in the explicit members'
+   * reference closure without being explicit themselves. Delivered and
+   * preloaded with the manifest, but inlined-only in the generated module —
+   * never a top-level typed property. Sorted by asset id. An asset that is
+   * both explicit and referenced is an explicit member, full stop.
+   */
+  passiveMembers: PassiveMember[];
+  /** The delivery set: explicit ∪ passive. */
+  deliveredAssetIds: Set<AssetId>;
+}
+/**
+ * Membership per manifest name. Covers every name in `library.manifests` plus
+ * any name an asset record points at — a record referencing an unknown
+ * manifest is a validation error, but delivery semantics must not silently
+ * flip on a hand-edited library, so such names still deliver here.
+ */
+type LibraryMembership = Record<ManifestName, ManifestMembership>;
+/**
+ * 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.
+ */
+declare function computeLibraryMembership(library: Library, referencesByAsset: ReferencesByAsset): LibraryMembership;
+/**
+ * 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.
+ */
+declare function allDeliveredAssetIds(membership: LibraryMembership): Set<AssetId>;
+//#endregion
+//#region src/plugins/chroma-key-video.d.ts
+interface ChromaKeyVideoParameters extends VideoParameters {
+  chromaKey: ChromaKeyParameters;
+  /** Grayscale shape mask multiplied onto the keyed alpha (an `image` asset). */
+  mask?: AssetReference;
+  /** Static image rendered when WebGL2 is unavailable (an `image` asset). */
+  fallback?: AssetReference;
+}
+/**
+ * Shares the video plugin's preset namespace (chroma-key-video builds
+ * on video's processing) — it has no config namespace of its own in M3.
+ */
+type ChromaKeyVideoPluginConfig = VideoPluginConfig;
+declare const chromaKeyVideoPlugin: AssetTypePluginDescriptor<ChromaKeyVideoParameters, ChromaKeyVideoPluginConfig>;
+//#endregion
+export { AUDIO_BUILT_IN_PRESETS, AUDIO_EXTENSIONS, type ApiErrorDto, type AssetId, type AssetRecord, type AssetReference, type AssetReferenceLinkDto, type AssetReferencesDto, type AssetStateDto, type AssetTypePluginDescriptor, type AudioManifestEntry, type AudioParameters, type AudioPluginConfig, type AudioPreloadOptions, type AudioPreset, type ChromaKeyParameters, type ChromaKeyVideoManifestEntry, type ChromaKeyVideoParameters, type ChromaKeyVideoPreloadOptions, type CollectedReference, type CreateFolderRequestDto, type CreateManifestRequestDto, DEFAULT_CHROMA_KEY_PARAMETERS, type DeleteAssetsRequestDto, FOLDER_SENTINEL, type FundusConfig, type FundusStateDto, IMAGE_BUILT_IN_PRESETS, type ImageFormat, type ImageManifestEntry, type ImageParameters, type ImagePluginConfig, type ImagePreloadOptions, type ImagePreset, type Library, type LibraryMembership, MANIFEST_COLORS, MANIFEST_EMOJIS, type ManifestColor, type ManifestEntry, type ManifestEntryData, type ManifestMembership, type ManifestMembershipDto, type ManifestName, type ManifestRecord, type MoveAssetsRequestDto, type PassiveManifestMembershipDto, type PassiveMember, type PassiveMemberDto, type PatchAssetRequestDto, type PatchFolderRequestDto, type PatchManifestRequestDto, type PluginDescriptorRegistry, type PreloadOptions, type ProxyStateDto, RASTER_IMAGE_EXTENSIONS, RESERVED_ASSET_IDS, ROOT_FOLDER, type ReferencesByAsset, SLICE_BUILT_IN_PRESETS, type SliceInsets, type SliceManifestEntry, type SliceMode, type SliceParameters, type SlicePluginConfig, type SlicePreloadOptions, type Slicing, VIDEO_BUILT_IN_PRESETS, VIDEO_EXTENSIONS, type ValidationIssueDto, type VideoManifestEntry, type VideoParameters, type VideoPluginConfig, type VideoPreloadOptions, type VideoPreset, 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 };