fundus 0.0.2

package/dist/runtime/components/SliceCanvas.svelte

@@ -0,0 +1,162 @@
+<!--
+	Canvas slice backend using the entry-based API (slicing arrives inline on the
+	`SliceManifestEntry`). Private: hosts render `Slice.svelte`, which
+	dispatches between this and the DOM backend.
+
+	Fills its container and draws each slice cell with one `drawImage` into a
+	backing canvas sized to the box × devicePixelRatio (for crispness). A
+	ResizeObserver triggers a redraw on resize; window `resize` and DPR changes
+	(browser zoom, moving between displays) redraw too, and a reactive effect
+	redraws when the entry changes — so it also works live inside the editor.
+
+	The measured element is a wrapper div, not the canvas: with overdraw the
+	canvas is enlarged by the overdraw's destination size and offset negatively
+	(see `computeCanvasPaintLayout`), so the baked shadow/glow paints outside
+	the layout box while the wrapper (and therefore the layout) keeps the box
+	size — exactly where the DOM backend positions its overdraw cells.
+-->
+<script lang="ts">
+	import type { SliceManifestEntry } from '#fundus/core';
+	import { computeCanvasPaintLayout, computeRenderCells } from '../geometry';
+	import { observeBorderBoxSize } from '../observe-border-box-size';
+
+	interface Props {
+		src: SliceManifestEntry;
+		/** Accessible label for the rendered graphic. */
+		alt?: string;
+		class?: string;
+	}
+
+	let { src, alt = '', class: className = '' }: Props = $props();
+
+	let root = $state<HTMLDivElement>();
+	let canvas = $state<HTMLCanvasElement>();
+	let image = $state<HTMLImageElement>();
+	let boxWidth = $state(0);
+	let boxHeight = $state(0);
+	let devicePixelRatio = $state(1);
+	// Bumped by window `resize` so the draw effect re-runs even when neither the
+	// box nor the entry changed (belt and braces alongside the ResizeObserver).
+	let redrawTick = $state(0);
+
+	// Load the source image once per entry `src` — the same plain URL the DOM
+	// backend paints (slices are image-backed: the browser cache owns the bytes,
+	// preload retains nothing to resolve).
+	$effect(() => {
+		const sourceUrl = src.src;
+		const next = new Image();
+		let cancelled = false;
+		next.onload = () => {
+			if (!cancelled) image = next;
+		};
+		next.src = sourceUrl;
+		return () => {
+			cancelled = true;
+			next.onload = null;
+		};
+	});
+
+	// Track the display's devicePixelRatio: a resolution media query fires
+	// exactly when the DPR leaves the tracked value (browser zoom, moving the
+	// window to another display). The tracked state must be READ first — a
+	// state the effect writes before reading is deliberately not a dependency
+	// in Svelte, so a write-first version would never re-arm the query after
+	// the first transition. Reconciling via update() converges in one extra
+	// run when the real DPR drifted (mount, or a change event).
+	$effect(() => {
+		const trackedRatio = devicePixelRatio;
+		const query = window.matchMedia(`(resolution: ${trackedRatio}dppx)`);
+		const update = () => {
+			devicePixelRatio = window.devicePixelRatio || 1;
+		};
+		update();
+		query.addEventListener('change', update);
+		return () => query.removeEventListener('change', update);
+	});
+
+	$effect(() => {
+		const element = root;
+		if (!element) return;
+		return observeBorderBoxSize(element, (width, height) => {
+			boxWidth = width;
+			boxHeight = height;
+		});
+	});
+
+	const layout = $derived(computeCanvasPaintLayout(src, boxWidth, boxHeight, devicePixelRatio));
+
+	// Redraw when the box size, image, entry, DPR, or window changes.
+	$effect(() => {
+		void image;
+		void src;
+		void layout;
+		void redrawTick;
+		draw();
+	});
+
+	function draw(): void {
+		const element = canvas;
+		const source = image;
+		if (!element || !source) return;
+		if (boxWidth === 0 || boxHeight === 0) {
+			element.width = 0;
+			element.height = 0;
+			return;
+		}
+
+		element.width = layout.backingWidth;
+		element.height = layout.backingHeight;
+
+		const context = element.getContext('2d');
+		if (!context) return;
+		// Origin at the layout box's top-left, so the (possibly negative) cell
+		// coordinates from computeRenderCells apply directly.
+		context.setTransform(devicePixelRatio, 0, 0, devicePixelRatio, layout.originX, layout.originY);
+		context.clearRect(layout.cssLeft, layout.cssTop, layout.cssWidth, layout.cssHeight);
+
+		for (const cell of computeRenderCells(src, boxWidth, boxHeight)) {
+			context.drawImage(
+				source,
+				cell.sx,
+				cell.sy,
+				cell.sw,
+				cell.sh,
+				cell.dx,
+				cell.dy,
+				cell.dw,
+				cell.dh
+			);
+		}
+	}
+</script>
+
+<svelte:window onresize={() => (redrawTick += 1)} />
+
+<div
+	bind:this={root}
+	class="fundus-slice-canvas {className}"
+	role={alt ? 'img' : undefined}
+	aria-label={alt || undefined}
+>
+	<canvas
+		bind:this={canvas}
+		style:left="{layout.cssLeft}px"
+		style:top="{layout.cssTop}px"
+		style:width="{layout.cssWidth}px"
+		style:height="{layout.cssHeight}px"
+	></canvas>
+</div>
+
+<style>
+	.fundus-slice-canvas {
+		position: relative;
+		width: 100%;
+		height: 100%;
+	}
+
+	canvas {
+		position: absolute;
+		display: block;
+		pointer-events: none;
+	}
+</style>

package/dist/runtime/components/SliceDom.svelte

@@ -0,0 +1,104 @@
+<!--
+	DOM slice backend using the entry-based API: the slicing arrives inline on the
+	`SliceManifestEntry` (no registry, no manifest lookup). One component covers
+	all modes (nine / three-horizontal / three-vertical / one) — the mode lives
+	in the entry. Private: hosts render `Slice.svelte`, which dispatches between
+	this and the canvas backend.
+
+	Fills its container and measures it (ResizeObserver), then paints one cell per
+	slice region as an absolutely-positioned window onto the source image: a full
+	copy of the image is scaled and offset (percentages relative to the cell) so
+	the cell shows exactly its source region. Cells abut on integer pixels; corners
+	/ caps keep their aspect ratio (no distortion), the stretch bands fill the rest.
+	With overdraw the cells extend past the container (negative offsets), so the
+	root switches to overflow: visible and the baked shadow/glow draws outside the
+	layout box.
+-->
+<script lang="ts">
+	import type { SliceManifestEntry } from '#fundus/core';
+	import { computeRenderCells, effectiveOverdraw } from '../geometry';
+	import { observeBorderBoxSize } from '../observe-border-box-size';
+
+	interface Props {
+		src: SliceManifestEntry;
+		/** Accessible label for the rendered graphic. */
+		alt?: string;
+		class?: string;
+	}
+
+	let { src, alt = '', class: className = '' }: Props = $props();
+
+	let root = $state<HTMLDivElement>();
+	let boxWidth = $state(0);
+	let boxHeight = $state(0);
+
+	$effect(() => {
+		const element = root;
+		if (!element) return;
+		return observeBorderBoxSize(element, (width, height) => {
+			boxWidth = width;
+			boxHeight = height;
+		});
+	});
+
+	const cells = $derived(computeRenderCells(src, boxWidth, boxHeight));
+	const hasOverdraw = $derived.by(() => {
+		const overdraw = effectiveOverdraw(src);
+		return overdraw.top > 0 || overdraw.right > 0 || overdraw.bottom > 0 || overdraw.left > 0;
+	});
+</script>
+
+<div
+	bind:this={root}
+	class="fundus-slice {className}"
+	class:fundus-slice--overdraw={hasOverdraw}
+	role={alt ? 'img' : undefined}
+	aria-label={alt || undefined}
+>
+	{#each cells as cell (cell.key)}
+		<div
+			class="fundus-slice__cell"
+			style:left="{cell.dx}px"
+			style:top="{cell.dy}px"
+			style:width="{cell.dw}px"
+			style:height="{cell.dh}px"
+		>
+			<img
+				src={src.src}
+				alt=""
+				draggable="false"
+				style:width="{(src.sourceWidth / cell.sw) * 100}%"
+				style:height="{(src.sourceHeight / cell.sh) * 100}%"
+				style:left="{(-cell.sx / cell.sw) * 100}%"
+				style:top="{(-cell.sy / cell.sh) * 100}%"
+			/>
+		</div>
+	{/each}
+</div>
+
+<style>
+	.fundus-slice {
+		position: relative;
+		width: 100%;
+		height: 100%;
+		overflow: hidden;
+	}
+
+	/* Overdraw cells deliberately extend past the box — don't clip them. */
+	.fundus-slice--overdraw {
+		overflow: visible;
+	}
+
+	.fundus-slice__cell {
+		position: absolute;
+		overflow: hidden;
+	}
+
+	.fundus-slice__cell img {
+		position: absolute;
+		max-width: none;
+		max-height: none;
+		pointer-events: none;
+		user-select: none;
+	}
+</style>

package/dist/runtime/components/Video.svelte

@@ -0,0 +1,60 @@
+<!--
+	Plain playback wrapper for a video manifest entry: renders the delivered
+	proxy with its intrinsic width/height attributes so layout never shifts
+	while the file loads, from the retained object URL when preloaded. When,
+	where and how it plays is host behavior, so loop/playing/muted/controls stay props.
+-->
+<script lang="ts">
+	import type { VideoManifestEntry } from '#fundus/core';
+	import { resolveRetainedSource } from '../preload-registry';
+
+	interface Props {
+		src: VideoManifestEntry;
+		/** Loop playback (default false — a plain clip ends unless the host says otherwise). */
+		loop?: boolean;
+		/** Playback on/off (default true). */
+		playing?: boolean;
+		/** Muted (default true — required for autoplay in every mobile browser). */
+		muted?: boolean;
+		/** Show native playback controls (default false). */
+		controls?: boolean;
+		/** Bindable handle on the underlying element, so a host can drive playback itself. */
+		videoElement?: HTMLVideoElement;
+		class?: string;
+	}
+
+	let {
+		src,
+		loop = false,
+		playing = true,
+		muted = true,
+		controls = false,
+		videoElement = $bindable(),
+		class: className = ''
+	}: Props = $props();
+
+	const source = $derived(resolveRetainedSource(src.src));
+
+	$effect(() => {
+		const video = videoElement;
+		if (!video) return;
+		if (playing) {
+			video.play().catch(() => {});
+		} else {
+			video.pause();
+		}
+	});
+</script>
+
+<video
+	bind:this={videoElement}
+	src={source}
+	width={src.width}
+	height={src.height}
+	{loop}
+	{muted}
+	{controls}
+	playsinline
+	preload="auto"
+	class={className}
+></video>

package/dist/runtime/geometry.d.ts

@@ -0,0 +1,75 @@
+import { SliceInsets, SliceManifestEntry } from "#fundus/core";
+
+//#region src/geometry.d.ts
+/** One cell to paint: a source rect (px) drawn into a dest rect (CSS px). */
+interface RenderCell {
+  key: string;
+  /** Source rect, in source pixels. */
+  sx: number;
+  sy: number;
+  sw: number;
+  sh: number;
+  /** Destination rect within the box, in CSS pixels (integers, abutting). */
+  dx: number;
+  dy: number;
+  dw: number;
+  dh: number;
+}
+/**
+ * The insets that actually apply for the entry's mode: a 3-slice mode zeroes out
+ * the axis it does not use (and `one` uses none at all), so callers never have
+ * to special-case the mode.
+ */
+declare function effectiveInsets(entry: SliceManifestEntry): SliceInsets;
+/**
+ * The overdraw that actually applies: zeros when absent, clamped so a core of at
+ * least one source pixel remains on each axis.
+ */
+declare function effectiveOverdraw(entry: SliceManifestEntry): SliceInsets;
+/**
+ * The overdraw's per-side destination size in CSS pixels for a box — how far the
+ * painted slice extends past the layout box on each side. Rounded to integers so
+ * cells keep abutting on integer pixels. For a 9-slice the overdraw is a fixed
+ * band (÷ `pixelRatio`, like the corners); for the 3-slice modes it scales with
+ * the caps: box cross-axis ÷ the layout box (image minus overdraw). In `one`
+ * mode the image stretches per axis, so each axis scales independently.
+ */
+declare function computeOverdrawDestination(entry: SliceManifestEntry, boxWidth: number, boxHeight: number): SliceInsets;
+/**
+ * How the canvas backend's `<canvas>` relates to the layout box: with overdraw
+ * the canvas is enlarged by the overdraw's destination size and offset
+ * negatively, so the baked shadow/glow paints outside the layout box while the
+ * wrapper (and therefore the layout) keeps the box size. The backing store is
+ * the CSS size × `devicePixelRatio` (rounded) for crispness, and the paint
+ * origin sits at the layout box's top-left in device pixels — so the (possibly
+ * negative) cell coordinates from `computeRenderCells` apply directly.
+ */
+interface CanvasPaintLayout {
+  /** CSS offset of the canvas within the wrapper (0 or negative — overdraw). */
+  cssLeft: number;
+  cssTop: number;
+  /** CSS size of the canvas (box expanded by the overdraw's destination size). */
+  cssWidth: number;
+  cssHeight: number;
+  /** Backing-store size in device pixels (CSS size × devicePixelRatio). */
+  backingWidth: number;
+  backingHeight: number;
+  /** Paint origin (the layout box's top-left) in device pixels. */
+  originX: number;
+  originY: number;
+}
+/**
+ * The canvas geometry for a slice filling a `boxWidth × boxHeight` layout box
+ * at the given `devicePixelRatio` (the display's, not the asset's export
+ * scale). Pure — the canvas backend derives every size and offset from this.
+ */
+declare function computeCanvasPaintLayout(entry: SliceManifestEntry, boxWidth: number, boxHeight: number, devicePixelRatio: number): CanvasPaintLayout;
+/**
+ * Compute the cells to paint for a slice filling a `boxWidth × boxHeight` box.
+ * Returns an empty array for a zero-size box. With overdraw the cells cover the
+ * box expanded by `computeOverdrawDestination` on each side, so `dx`/`dy` can be
+ * negative and cells can extend past the box.
+ */
+declare function computeRenderCells(entry: SliceManifestEntry, boxWidth: number, boxHeight: number): RenderCell[];
+//#endregion
+export { CanvasPaintLayout, RenderCell, computeCanvasPaintLayout, computeOverdrawDestination, computeRenderCells, effectiveInsets, effectiveOverdraw };

package/dist/runtime/geometry.js

@@ -0,0 +1,209 @@
+import { createZeroInsets, slicedAxesFor } from "#fundus/core";
+//#region src/geometry.ts
+function clamp(value, min, max) {
+	return Math.max(min, Math.min(max, value));
+}
+/**
+* The insets that actually apply for the entry's mode: a 3-slice mode zeroes out
+* the axis it does not use (and `one` uses none at all), so callers never have
+* to special-case the mode.
+*/
+function effectiveInsets(entry) {
+	const { mode, insets } = entry.slicing;
+	const axes = slicedAxesFor(mode);
+	return {
+		top: axes.vertical ? insets.top : 0,
+		bottom: axes.vertical ? insets.bottom : 0,
+		left: axes.horizontal ? insets.left : 0,
+		right: axes.horizontal ? insets.right : 0
+	};
+}
+/**
+* The overdraw that actually applies: zeros when absent, clamped so a core of at
+* least one source pixel remains on each axis.
+*/
+function effectiveOverdraw(entry) {
+	const overdraw = entry.slicing.overdraw;
+	if (!overdraw) return createZeroInsets();
+	const width = entry.sourceWidth;
+	const height = entry.sourceHeight;
+	const left = clamp(overdraw.left, 0, Math.max(0, width - 1));
+	const right = clamp(overdraw.right, 0, Math.max(0, width - left - 1));
+	const top = clamp(overdraw.top, 0, Math.max(0, height - 1));
+	return {
+		top,
+		right,
+		bottom: clamp(overdraw.bottom, 0, Math.max(0, height - top - 1)),
+		left
+	};
+}
+/**
+* The layout box — the image minus its effective overdraw — in **source pixels**
+* Never smaller than one source pixel per axis (`effectiveOverdraw` guarantees
+* a remaining box).
+*/
+function sourceLayoutSize(entry) {
+	const overdraw = effectiveOverdraw(entry);
+	return {
+		width: Math.max(1, entry.sourceWidth - overdraw.left - overdraw.right),
+		height: Math.max(1, entry.sourceHeight - overdraw.top - overdraw.bottom)
+	};
+}
+/**
+* The overdraw's per-side destination size in CSS pixels for a box — how far the
+* painted slice extends past the layout box on each side. Rounded to integers so
+* cells keep abutting on integer pixels. For a 9-slice the overdraw is a fixed
+* band (÷ `pixelRatio`, like the corners); for the 3-slice modes it scales with
+* the caps: box cross-axis ÷ the layout box (image minus overdraw). In `one`
+* mode the image stretches per axis, so each axis scales independently.
+*/
+function computeOverdrawDestination(entry, boxWidth, boxHeight) {
+	const overdraw = effectiveOverdraw(entry);
+	if (overdraw.top === 0 && overdraw.right === 0 && overdraw.bottom === 0 && overdraw.left === 0) return overdraw;
+	const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
+	const sourceLayout = sourceLayoutSize(entry);
+	let horizontalScale;
+	let verticalScale;
+	if (entry.slicing.mode === "three-horizontal") horizontalScale = verticalScale = boxHeight / sourceLayout.height;
+	else if (entry.slicing.mode === "three-vertical") horizontalScale = verticalScale = boxWidth / sourceLayout.width;
+	else if (entry.slicing.mode === "one") {
+		horizontalScale = boxWidth / sourceLayout.width;
+		verticalScale = boxHeight / sourceLayout.height;
+	} else horizontalScale = verticalScale = 1 / pixelRatio;
+	return {
+		top: Math.round(overdraw.top * verticalScale),
+		right: Math.round(overdraw.right * horizontalScale),
+		bottom: Math.round(overdraw.bottom * verticalScale),
+		left: Math.round(overdraw.left * horizontalScale)
+	};
+}
+/**
+* The canvas geometry for a slice filling a `boxWidth × boxHeight` layout box
+* at the given `devicePixelRatio` (the display's, not the asset's export
+* scale). Pure — the canvas backend derives every size and offset from this.
+*/
+function computeCanvasPaintLayout(entry, boxWidth, boxHeight, devicePixelRatio) {
+	const overdrawDestination = computeOverdrawDestination(entry, boxWidth, boxHeight);
+	const cssWidth = boxWidth + overdrawDestination.left + overdrawDestination.right;
+	const cssHeight = boxHeight + overdrawDestination.top + overdrawDestination.bottom;
+	return {
+		cssLeft: -overdrawDestination.left + 0,
+		cssTop: -overdrawDestination.top + 0,
+		cssWidth,
+		cssHeight,
+		backingWidth: Math.round(cssWidth * devicePixelRatio),
+		backingHeight: Math.round(cssHeight * devicePixelRatio),
+		originX: overdrawDestination.left * devicePixelRatio,
+		originY: overdrawDestination.top * devicePixelRatio
+	};
+}
+/** Cumulative, rounded edges so adjacent cells abut exactly on integer pixels. */
+function cumulativeEdges(sizes) {
+	let accumulated = 0;
+	const edges = [0];
+	for (const size of sizes) {
+		accumulated += size;
+		edges.push(Math.round(accumulated));
+	}
+	return edges;
+}
+/**
+* Compute the cells to paint for a slice filling a `boxWidth × boxHeight` box.
+* Returns an empty array for a zero-size box. With overdraw the cells cover the
+* box expanded by `computeOverdrawDestination` on each side, so `dx`/`dy` can be
+* negative and cells can extend past the box.
+*/
+function computeRenderCells(entry, boxWidth, boxHeight) {
+	if (boxWidth <= 0 || boxHeight <= 0) return [];
+	const overdrawDestination = computeOverdrawDestination(entry, boxWidth, boxHeight);
+	const paintWidth = boxWidth + overdrawDestination.left + overdrawDestination.right;
+	const paintHeight = boxHeight + overdrawDestination.top + overdrawDestination.bottom;
+	const width = entry.sourceWidth;
+	const height = entry.sourceHeight;
+	const pixelRatio = entry.slicing.pixelRatio > 0 ? entry.slicing.pixelRatio : 1;
+	const mode = entry.slicing.mode;
+	const insets = effectiveInsets(entry);
+	const left = clamp(insets.left, 0, width);
+	const right = clamp(insets.right, 0, Math.max(0, width - left));
+	const top = clamp(insets.top, 0, height);
+	const bottom = clamp(insets.bottom, 0, Math.max(0, height - top));
+	const centerWidth = Math.max(0, width - left - right);
+	const centerHeight = Math.max(0, height - top - bottom);
+	let leftDestination;
+	let rightDestination;
+	if (mode === "three-horizontal") {
+		const scale = paintHeight / height;
+		leftDestination = left * scale;
+		rightDestination = right * scale;
+	} else {
+		leftDestination = left / pixelRatio;
+		rightDestination = right / pixelRatio;
+	}
+	const centerDestinationWidth = Math.max(0, paintWidth - leftDestination - rightDestination);
+	let topDestination;
+	let bottomDestination;
+	if (mode === "three-vertical") {
+		const scale = paintWidth / width;
+		topDestination = top * scale;
+		bottomDestination = bottom * scale;
+	} else {
+		topDestination = top / pixelRatio;
+		bottomDestination = bottom / pixelRatio;
+	}
+	const centerDestinationHeight = Math.max(0, paintHeight - topDestination - bottomDestination);
+	const sourceColumns = [
+		left,
+		centerWidth,
+		right
+	];
+	const sourceRows = [
+		top,
+		centerHeight,
+		bottom
+	];
+	const sourceColumnStarts = [
+		0,
+		left,
+		left + centerWidth
+	];
+	const sourceRowStarts = [
+		0,
+		top,
+		top + centerHeight
+	];
+	const columnEdges = cumulativeEdges([
+		leftDestination,
+		centerDestinationWidth,
+		rightDestination
+	]);
+	const rowEdges = cumulativeEdges([
+		topDestination,
+		centerDestinationHeight,
+		bottomDestination
+	]);
+	const cells = [];
+	for (let row = 0; row < 3; row++) for (let column = 0; column < 3; column++) {
+		const sw = sourceColumns[column];
+		const sh = sourceRows[row];
+		if (sw <= 0 || sh <= 0) continue;
+		const dx = columnEdges[column];
+		const dw = columnEdges[column + 1] - dx;
+		const dy = rowEdges[row];
+		const dh = rowEdges[row + 1] - dy;
+		if (dw <= 0 || dh <= 0) continue;
+		cells.push({
+			key: `${row}-${column}`,
+			sx: sourceColumnStarts[column],
+			sy: sourceRowStarts[row],
+			sw,
+			sh,
+			dx: dx - overdrawDestination.left,
+			dy: dy - overdrawDestination.top,
+			dw,
+			dh
+		});
+	}
+	return cells;
+}
+//#endregion
+export { computeCanvasPaintLayout, computeOverdrawDestination, computeRenderCells, effectiveInsets, effectiveOverdraw };

package/dist/runtime/index.d.ts

@@ -0,0 +1,9 @@
+import { Manifest, createManifest } from "./manifest.js";
+import { resolveRetainedSource } from "./preload-registry.js";
+import { audioSourceOf } from "./kind-handlers.js";
+import { AudioManifestEntry, AudioPreloadOptions, ChromaKeyParameters, ChromaKeyVideoManifestEntry, ChromaKeyVideoPreloadOptions, DEFAULT_CHROMA_KEY_PARAMETERS, ImageManifestEntry, ImagePreloadOptions, ManifestEntry, PreloadOptions, SliceManifestEntry, SlicePreloadOptions, VideoManifestEntry, VideoPreloadOptions } from "#fundus/core";
+import Image from "./components/Image.svelte";
+import Slice from "./components/Slice.svelte";
+import Video from "./components/Video.svelte";
+import ChromaKeyVideo from "./components/ChromaKeyVideo.svelte";
+export { type AudioManifestEntry, type AudioPreloadOptions, type ChromaKeyParameters, ChromaKeyVideo, type ChromaKeyVideoManifestEntry, type ChromaKeyVideoPreloadOptions, DEFAULT_CHROMA_KEY_PARAMETERS, Image, type ImageManifestEntry, type ImagePreloadOptions, Manifest, type ManifestEntry, type PreloadOptions, Slice, type SliceManifestEntry, type SlicePreloadOptions, Video, type VideoManifestEntry, type VideoPreloadOptions, audioSourceOf, createManifest, resolveRetainedSource };

package/dist/runtime/index.js

@@ -0,0 +1,9 @@
+import { audioSourceOf } from "./kind-handlers.js";
+import { resolveRetainedSource } from "./preload-registry.js";
+import { Manifest, createManifest } from "./manifest.js";
+import { DEFAULT_CHROMA_KEY_PARAMETERS } from "#fundus/core";
+import Image from "./components/Image.svelte";
+import Slice from "./components/Slice.svelte";
+import Video from "./components/Video.svelte";
+import ChromaKeyVideo from "./components/ChromaKeyVideo.svelte";
+export { ChromaKeyVideo, DEFAULT_CHROMA_KEY_PARAMETERS, Image, Manifest, Slice, Video, audioSourceOf, createManifest, resolveRetainedSource };

package/dist/runtime/kind-handlers.d.ts

@@ -0,0 +1,46 @@
+import { AudioManifestEntry, PreloadOptions } from "#fundus/core";
+
+//#region src/kind-handlers.d.ts
+/** The playable URL hosts feed to their own audio engine. */
+declare function audioSourceOf(entry: AudioManifestEntry): string;
+/**
+ * What a handler's `preload` acquired and its `release` must dispose. For
+ * retained media kinds this is the minted object URL; cache-backed kinds
+ * (image, slice, unknown) hold no disposable resources.
+ */
+interface KindHandlerResources {
+  /** Object URL minted over the fully fetched file (retained media kinds). */
+  objectUrl?: string;
+}
+/** How one asset kind preloads — and releases — its delivered file. */
+interface KindRuntimeHandler {
+  /**
+   * Fully load one source of this kind — the promise resolves only once the
+   * file is completely transferred (plus the kind's strategy: decoded /
+   * retained as an object URL) — and return the resources `release` disposes.
+   */
+  preload(url: string, options: PreloadOptions): Promise<KindHandlerResources>;
+  /**
+   * The inverse of `preload`: dispose the resources it returned (revoke the
+   * object URL). Omitted = the kind acquires nothing disposable.
+   */
+  release?(resources: KindHandlerResources): void;
+}
+/**
+ * Entry kinds whose delivered file is retained as an object URL by
+ * `preload()` while held. A chroma-key-video's own `src` is a video file, so
+ * it retains too; its inlined mask/fallback entries are `image` kind and
+ * follow the image handler via the source walk.
+ */
+declare const RETAINED_KINDS: ReadonlySet<string>;
+/**
+ * Whether a source of `kind` decodes under the given per-kind preload options
+ * (options are namespaced per plugin type, like `plugins.<type>` in
+ * the config). Image-backed kinds decode by default; each kind opts out
+ * independently (`{ image: { decode: false } }` leaves slices decoding).
+ */
+declare function shouldDecode(kind: string, options: PreloadOptions): boolean;
+/** The runtime handler owning `kind`'s preload/release strategy (fallback for unknown kinds). */
+declare function runtimeHandlerFor(kind: string): KindRuntimeHandler;
+//#endregion
+export { KindHandlerResources, KindRuntimeHandler, RETAINED_KINDS, audioSourceOf, runtimeHandlerFor, shouldDecode };