fundus 0.11.0 → 0.12.0

package/dist/runtime/components/SliceCanvas.svelte

@@ -13,25 +13,28 @@
 	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.
+	size — exactly where the DOM backend positions its border-image paint.
 -->
 <script lang="ts">
-	import type { SliceManifestEntry } from '../../core/index.js';
-	import { computeCanvasPaintLayout, computeRenderCells } from '../geometry.js';
+	import {
+		computeCanvasPaintLayout,
+		computeRenderCells,
+		type CanvasPaintLayout
+	} from '../geometry.js';
 	import { observeBorderBoxSize } from '../observe-border-box-size.js';
+	import type { LoadedSliceSnapshot } from '../slice-source-lifecycle.js';
 
 	interface Props {
-		src: SliceManifestEntry;
+		snapshot: LoadedSliceSnapshot | null;
 		/** Accessible label for the rendered graphic. */
 		alt?: string;
 		class?: string;
 	}
 
-	let { src, alt = '', class: className = '' }: Props = $props();
+	let { snapshot, 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);
@@ -39,23 +42,6 @@
 	// 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
@@ -83,40 +69,65 @@
 		});
 	});
 
-	const layout = $derived(computeCanvasPaintLayout(src, boxWidth, boxHeight, devicePixelRatio));
+	const emptyLayout: CanvasPaintLayout = {
+		cssLeft: 0,
+		cssTop: 0,
+		cssWidth: 0,
+		cssHeight: 0,
+		backingWidth: 0,
+		backingHeight: 0,
+		originX: 0,
+		originY: 0
+	};
+	const layout = $derived.by(() => {
+		const current = snapshot;
+		return current
+			? computeCanvasPaintLayout(current.entry, boxWidth, boxHeight, devicePixelRatio)
+			: emptyLayout;
+	});
 
-	// Redraw when the box size, image, entry, DPR, or window changes.
+	// Redraw only when a committed snapshot, the box, DPR, or window changes.
 	$effect(() => {
-		void image;
-		void src;
-		void layout;
+		const current = snapshot;
+		const currentLayout = layout;
 		void redrawTick;
-		draw();
+		draw(current, currentLayout);
 	});
 
-	function draw(): void {
+	function draw(current: LoadedSliceSnapshot | null, currentLayout: CanvasPaintLayout): void {
 		const element = canvas;
-		const source = image;
-		if (!element || !source) return;
-		if (boxWidth === 0 || boxHeight === 0) {
+		if (!element) return;
+		if (!current || boxWidth === 0 || boxHeight === 0) {
 			element.width = 0;
 			element.height = 0;
 			return;
 		}
 
-		element.width = layout.backingWidth;
-		element.height = layout.backingHeight;
+		element.width = currentLayout.backingWidth;
+		element.height = currentLayout.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.setTransform(
+			devicePixelRatio,
+			0,
+			0,
+			devicePixelRatio,
+			currentLayout.originX,
+			currentLayout.originY
+		);
+		context.clearRect(
+			currentLayout.cssLeft,
+			currentLayout.cssTop,
+			currentLayout.cssWidth,
+			currentLayout.cssHeight
+		);
+
+		for (const cell of computeRenderCells(current.entry, boxWidth, boxHeight)) {
 			context.drawImage(
-				source,
+				current.image,
 				cell.sx,
 				cell.sy,
 				cell.sw,

package/dist/runtime/components/SliceCanvas.svelte.d.ts

@@ -1,6 +1,6 @@
-import type { SliceManifestEntry } from '../../core/index.js';
+import type { LoadedSliceSnapshot } from '../slice-source-lifecycle.js';
 interface Props {
-    src: SliceManifestEntry;
+    snapshot: LoadedSliceSnapshot | null;
     /** Accessible label for the rendered graphic. */
     alt?: string;
     class?: string;

package/dist/runtime/components/SliceDom.svelte

@@ -5,33 +5,96 @@
 	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.
+	Fills its container and measures it (ResizeObserver), then paints the complete
+	slice through one CSS border-image. The browser still stretches the same source
+	regions computed by `computeRenderCells`, but rasterizes them as one border
+	image instead of separate clipped elements. Shared slice edges therefore cannot
+	expose the background under fractional transforms.
+	With overdraw the paint element extends 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 '../../core/index.js';
-	import { computeRenderCells, effectiveOverdraw } from '../geometry.js';
+	import type { SliceInsets, SliceManifestEntry } from '../../core/index.js';
+	import { computeRenderCells, effectiveInsets, effectiveOverdraw } from '../geometry.js';
 	import { observeBorderBoxSize } from '../observe-border-box-size.js';
+	import type { LoadedSliceSnapshot } from '../slice-source-lifecycle.js';
 
 	interface Props {
-		src: SliceManifestEntry;
+		snapshot: LoadedSliceSnapshot | null;
 		/** Accessible label for the rendered graphic. */
 		alt?: string;
 		class?: string;
 	}
 
-	let { src, alt = '', class: className = '' }: Props = $props();
+	let { snapshot, alt = '', class: className = '' }: Props = $props();
 
 	let root = $state<HTMLDivElement>();
 	let boxWidth = $state(0);
 	let boxHeight = $state(0);
 
+	interface BorderImagePaint {
+		left: number;
+		top: number;
+		width: number;
+		height: number;
+		slices: SliceInsets;
+		widths: SliceInsets;
+	}
+
+	function clamp(value: number, min: number, max: number): number {
+		return Math.max(min, Math.min(max, value));
+	}
+
+	function computeBorderImagePaint(
+		entry: SliceManifestEntry,
+		width: number,
+		height: number
+	): BorderImagePaint | null {
+		const cells = computeRenderCells(entry, width, height);
+		if (cells.length === 0) return null;
+
+		const effective = effectiveInsets(entry);
+		const leftSlice = clamp(effective.left, 0, entry.sourceWidth);
+		const rightSlice = clamp(effective.right, 0, entry.sourceWidth - leftSlice);
+		const topSlice = clamp(effective.top, 0, entry.sourceHeight);
+		const bottomSlice = clamp(effective.bottom, 0, entry.sourceHeight - topSlice);
+		const slices = {
+			top: topSlice,
+			right: rightSlice,
+			bottom: bottomSlice,
+			left: leftSlice
+		};
+		const left = Math.min(...cells.map((cell) => cell.dx));
+		const top = Math.min(...cells.map((cell) => cell.dy));
+		const right = Math.max(...cells.map((cell) => cell.dx + cell.dw));
+		const bottom = Math.max(...cells.map((cell) => cell.dy + cell.dh));
+
+		return {
+			left,
+			top,
+			width: right - left,
+			height: bottom - top,
+			slices,
+			widths: {
+				top: cells.find((cell) => topSlice > 0 && cell.sy === 0 && cell.sh === topSlice)?.dh ?? 0,
+				right:
+					cells.find(
+						(cell) =>
+							rightSlice > 0 && cell.sx === entry.sourceWidth - rightSlice && cell.sw === rightSlice
+					)?.dw ?? 0,
+				bottom:
+					cells.find(
+						(cell) =>
+							bottomSlice > 0 &&
+							cell.sy === entry.sourceHeight - bottomSlice &&
+							cell.sh === bottomSlice
+					)?.dh ?? 0,
+				left: cells.find((cell) => leftSlice > 0 && cell.sx === 0 && cell.sw === leftSlice)?.dw ?? 0
+			}
+		};
+	}
+
 	$effect(() => {
 		const element = root;
 		if (!element) return;
@@ -41,9 +104,11 @@
 		});
 	});
 
-	const cells = $derived(computeRenderCells(src, boxWidth, boxHeight));
+	const entry = $derived(snapshot?.entry ?? null);
+	const paint = $derived(entry ? computeBorderImagePaint(entry, boxWidth, boxHeight) : null);
 	const hasOverdraw = $derived.by(() => {
-		const overdraw = effectiveOverdraw(src);
+		if (!entry) return false;
+		const overdraw = effectiveOverdraw(entry);
 		return overdraw.top > 0 || overdraw.right > 0 || overdraw.bottom > 0 || overdraw.left > 0;
 	});
 </script>
@@ -55,25 +120,18 @@
 	role={alt ? 'img' : undefined}
 	aria-label={alt || undefined}
 >
-	{#each cells as cell (cell.key)}
+	{#if entry && paint}
 		<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}
+			class="fundus-slice__paint"
+			style:left="{paint.left}px"
+			style:top="{paint.top}px"
+			style:width="{paint.width}px"
+			style:height="{paint.height}px"
+			style:border-image-source={`url(${JSON.stringify(entry.src)})`}
+			style:border-image-slice={`${paint.slices.top} ${paint.slices.right} ${paint.slices.bottom} ${paint.slices.left} fill`}
+			style:border-image-width={`${paint.widths.top}px ${paint.widths.right}px ${paint.widths.bottom}px ${paint.widths.left}px`}
+		></div>
+	{/if}
 </div>
 
 <style>
@@ -84,21 +142,17 @@
 		overflow: hidden;
 	}
 
-	/* Overdraw cells deliberately extend past the box — don't clip them. */
+	/* Overdraw deliberately extends the paint past the box — don't clip it. */
 	.fundus-slice--overdraw {
 		overflow: visible;
 	}
 
-	.fundus-slice__cell {
-		position: absolute;
-		overflow: hidden;
-	}
-
-	.fundus-slice__cell img {
+	.fundus-slice__paint {
 		position: absolute;
-		max-width: none;
-		max-height: none;
+		box-sizing: border-box;
+		border-width: 0;
+		border-style: solid;
+		border-image-repeat: stretch;
 		pointer-events: none;
-		user-select: none;
 	}
 </style>

package/dist/runtime/components/SliceDom.svelte.d.ts

@@ -1,6 +1,6 @@
-import type { SliceManifestEntry } from '../../core/index.js';
+import type { LoadedSliceSnapshot } from '../slice-source-lifecycle.js';
 interface Props {
-    src: SliceManifestEntry;
+    snapshot: LoadedSliceSnapshot | null;
     /** Accessible label for the rendered graphic. */
     alt?: string;
     class?: string;

package/dist/runtime/slice-source-lifecycle.d.ts

@@ -0,0 +1,14 @@
+import type { SliceManifestEntry } from '../core/index.js';
+export interface LoadedSliceSnapshot {
+    entry: SliceManifestEntry;
+    image: HTMLImageElement;
+}
+export type SliceImageLoader = (url: string) => Promise<HTMLImageElement>;
+export declare function loadSliceImage(url: string): Promise<HTMLImageElement>;
+/** Coordinates requested slice entries with the last image-ready snapshot. */
+export declare class SliceSourceLifecycle {
+    #private;
+    constructor(commit: (snapshot: LoadedSliceSnapshot) => void, loadImage?: SliceImageLoader);
+    request(entry: SliceManifestEntry): void;
+    dispose(): void;
+}

package/dist/runtime/slice-source-lifecycle.js

@@ -0,0 +1,70 @@
+export function loadSliceImage(url) {
+    const image = new Image();
+    image.decoding = 'async';
+    image.src = url;
+    return image.decode().then(() => image);
+}
+/** Coordinates requested slice entries with the last image-ready snapshot. */
+export class SliceSourceLifecycle {
+    #loadImage;
+    #commit;
+    #requestedEntry = null;
+    #displayedSnapshot = null;
+    #inFlight = new Map();
+    #disposed = false;
+    constructor(commit, loadImage = loadSliceImage) {
+        this.#commit = commit;
+        this.#loadImage = loadImage;
+    }
+    request(entry) {
+        if (this.#disposed)
+            return;
+        this.#requestedEntry = entry;
+        const displayed = this.#displayedSnapshot;
+        if (displayed?.entry.src === entry.src) {
+            this.#commitSnapshot({ entry, image: displayed.image });
+            return;
+        }
+        if (this.#inFlight.has(entry.src))
+            return;
+        let promise;
+        try {
+            promise = Promise.resolve(this.#loadImage(entry.src));
+        }
+        catch (error) {
+            promise = Promise.reject(error);
+        }
+        const load = { promise };
+        this.#inFlight.set(entry.src, load);
+        void promise.then((image) => this.#settleSuccess(entry.src, load, image), () => this.#settleFailure(entry.src, load));
+    }
+    dispose() {
+        if (this.#disposed)
+            return;
+        this.#disposed = true;
+        this.#requestedEntry = null;
+        this.#displayedSnapshot = null;
+        this.#inFlight.clear();
+    }
+    #settleSuccess(url, load, image) {
+        if (this.#inFlight.get(url) !== load)
+            return;
+        this.#inFlight.delete(url);
+        if (this.#disposed)
+            return;
+        const requested = this.#requestedEntry;
+        if (!requested || requested.src !== url)
+            return;
+        this.#commitSnapshot({ entry: requested, image });
+    }
+    #settleFailure(url, load) {
+        if (this.#inFlight.get(url) === load)
+            this.#inFlight.delete(url);
+    }
+    #commitSnapshot(snapshot) {
+        if (this.#disposed)
+            return;
+        this.#displayedSnapshot = snapshot;
+        this.#commit(snapshot);
+    }
+}

package/dist/server/check.d.ts

@@ -4,7 +4,7 @@ import type { ServerPluginRegistry } from './plugins/contract.js';
 /** One machine-readable check finding (the `--json` failure-list shape, M9). */
 export interface CheckFinding {
     /** The failure category. */
-    kind: 'validation' | 'proxy-missing' | 'proxy-unresolvable' | 'proxy-orphaned' | 'module-missing' | 'module-out-of-sync' | 'module-stray' | 'module-regeneration-failed' | 'unreachable-asset' | 'raw-hash-drift' | 'raw-type-incompatible' | 'raw-scan-incomplete' | 'raw-unmanaged';
+    kind: 'validation' | 'proxy-missing' | 'proxy-unresolvable' | 'proxy-orphaned' | 'module-missing' | 'module-out-of-sync' | 'module-stray' | 'module-regeneration-failed' | 'unreachable-asset' | 'potential-image-duplicate' | 'raw-hash-drift' | 'raw-type-incompatible' | 'raw-scan-incomplete' | 'raw-unmanaged';
     message: string;
     /** The asset the finding concerns, where applicable. */
     assetId?: string;

package/dist/server/check.js

@@ -2,7 +2,8 @@
  * `fundus check` — the verify-only CI gate: no writes, ever. It
  * fails when the library does not validate, when a committed proxy is stale,
  * missing, or orphaned, or when a generated manifest module differs from an
- * in-memory regeneration. Warnings (unreachable assets) are
+ * in-memory regeneration. Warnings (unreachable assets and potential image
+ * duplicates) are
  * treated as errors unless `--allow-warnings` downgrades them — errors are
  * never downgradable.
  */
@@ -17,6 +18,7 @@ import { buildManifestEntries, manifestModuleFileName, renderManifestModule, str
 import { descriptorsByType, serverPluginsByType } from './plugins.js';
 import { deliveredAssetIds, expectedProxyRelativePath, isProxyFileName, readCurrentProxy } from './processing/processor.js';
 import { listRelativeFiles } from './folder-filesystem.js';
+import { ImageDuplicateDetector } from './image-duplicates.js';
 /** The human rendering of a finding — `[assetId] message`, as `fundus check` prints it. */
 export function formatCheckFinding(finding) {
     return `${finding.assetId ? `[${finding.assetId}] ` : ''}${finding.message}`;
@@ -109,12 +111,24 @@ export async function runCheck(projectRoot, registry = serverPluginsByType) {
         await checkGeneratedModules(report, library, config, proxies, registry);
         await checkStrayModules(report, library, config);
     }
-    // 4. Warnings: unreachable assets only. Raw drift is always a hard CI failure.
+    // 4. Advisory warnings. Raw drift is always a hard CI failure.
     collectUnreachableAssets(report, library, delivered);
+    collectPotentialImageDuplicates(report, await new ImageDuplicateDetector().find(library, config.rawDir));
     report.errors.sort((left, right) => compareCodeUnits(`${left.fileName ?? ''}|${left.assetId ?? ''}|${left.kind}|${left.message}`, `${right.fileName ?? ''}|${right.assetId ?? ''}|${right.kind}|${right.message}`));
     report.warnings.sort((left, right) => compareCodeUnits(`${left.assetId ?? ''}|${left.kind}|${left.message}`, `${right.assetId ?? ''}|${right.kind}|${right.message}`));
     return report;
 }
+function collectPotentialImageDuplicates(report, duplicatesByAsset) {
+    for (const [assetId, duplicateIds] of duplicatesByAsset) {
+        report.warnings.push({
+            kind: 'potential-image-duplicate',
+            message: duplicateIds.length === 1
+                ? `Potential image duplicate of "${duplicateIds[0]}".`
+                : `Potential image duplicates: ${duplicateIds.map((id) => `"${id}"`).join(', ')}.`,
+            assetId
+        });
+    }
+}
 /** Pure expansion of a raw classification into canonical hard check findings. */
 export function rawCheckFindings(library, raw, registry, validationIssues) {
     const findings = [];

package/dist/server/cli-commands.d.ts

@@ -25,5 +25,5 @@ export declare const MANIFEST_PALETTE_HELP = "fundus manifest palette \u2014 lis
 export declare function runManifestCommand(argumentList: string[]): Promise<void>;
 export declare const BUILD_HELP = "fundus build \u2014 run the headless pipeline\n\nUsage: fundus build [--json]\n\nValidates the library, processes every stale or missing proxy, prunes\norphaned proxies, and regenerates all manifest modules. Deterministic\nand idempotent: a second run on an unchanged project processes nothing\nand rewrites byte-identical modules. Run it in CI, postinstall, or\nbefore the host build; commit the result.\n\nFlags:\n  --json   print {\"ok\": true, \"processed\": [\u2026], \"upToDate\": [\u2026],\n           \"prunedProxies\": [\u2026], \"modulesWritten\": [\u2026],\n           \"modulesRemoved\": [\u2026]} \u2014 asset ids for processing,\n           file names for pruning/codegen\n  --help   this help\n\nA validation failure processes nothing and exits 1 (with --json:\n{\"error\": {\"message\": \u2026}}).\n\nExample:\n  fundus build --json | jq '.processed'\n";
 export declare function runBuildCommand(argumentList: string[]): Promise<void>;
-export declare const CHECK_HELP = "fundus check \u2014 verify the committed state (the CI gate)\n\nUsage: fundus check [--allow-warnings] [--json]\n\nVerify-only, no writes: the library must validate, every delivered\nasset's committed proxy must exist under its expected name (staleness\nis a name check), the proxy directory must hold no orphans, and every\ngenerated manifest module must be byte-identical to an in-memory\nregeneration. Warnings (such as unreachable assets) fail the check\nunless --allow-warnings downgrades them. New, missing, edited, or\ninvalid entries in the raw directory are hard errors:\nopen or refocus the Fundus editor and resolve its ingestion queue.\nRaw-file errors never downgrade.\n\nFlags:\n  --allow-warnings   exit 0 despite warnings (errors still fail)\n  --json             print one report document:\n                     {\"ok\": <pass/fail>, \"assetCount\": \u2026, \"manifestCount\": \u2026,\n                      \"errors\": [<finding>, \u2026], \"warnings\": [<finding>, \u2026],\n                      \"advisories\": [<non-fatal integration guidance>, \u2026]}\n                     where a finding is {\"kind\", \"message\"} plus\n                     \"assetId\" / \"manifest\" / \"fileName\" where applicable\n  --help             this help\n\nExit codes: 0 = clean (or warnings allowed), 1 = failed. A failure to\neven run the check (e.g. no fundus.config.ts) exits 1 with the usual\n{\"error\": {\"message\": \u2026}} envelope under --json.\n\nExample:\n  fundus check --json | jq '.errors[].kind'\n";
+export declare const CHECK_HELP = "fundus check \u2014 verify the committed state (the CI gate)\n\nUsage: fundus check [--allow-warnings] [--json]\n\nVerify-only, no writes: the library must validate, every delivered\nasset's committed proxy must exist under its expected name (staleness\nis a name check), the proxy directory must hold no orphans, and every\ngenerated manifest module must be byte-identical to an in-memory\nregeneration. Warnings (such as unreachable assets or potential image\nduplicates) fail the check\nunless --allow-warnings downgrades them. New, missing, edited, or\ninvalid entries in the raw directory are hard errors:\nopen or refocus the Fundus editor and resolve its ingestion queue.\nRaw-file errors never downgrade.\n\nFlags:\n  --allow-warnings   exit 0 despite warnings (errors still fail)\n  --json             print one report document:\n                     {\"ok\": <pass/fail>, \"assetCount\": \u2026, \"manifestCount\": \u2026,\n                      \"errors\": [<finding>, \u2026], \"warnings\": [<finding>, \u2026],\n                      \"advisories\": [<non-fatal integration guidance>, \u2026]}\n                     where a finding is {\"kind\", \"message\"} plus\n                     \"assetId\" / \"manifest\" / \"fileName\" where applicable\n  --help             this help\n\nExit codes: 0 = clean (or warnings allowed), 1 = failed. A failure to\neven run the check (e.g. no fundus.config.ts) exits 1 with the usual\n{\"error\": {\"message\": \u2026}} envelope under --json.\n\nExample:\n  fundus check --json | jq '.errors[].kind'\n";
 export declare function runCheckCommand(argumentList: string[]): Promise<void>;

package/dist/server/cli-commands.js

@@ -1502,7 +1502,8 @@ Verify-only, no writes: the library must validate, every delivered
 asset's committed proxy must exist under its expected name (staleness
 is a name check), the proxy directory must hold no orphans, and every
 generated manifest module must be byte-identical to an in-memory
-regeneration. Warnings (such as unreachable assets) fail the check
+regeneration. Warnings (such as unreachable assets or potential image
+duplicates) fail the check
 unless --allow-warnings downgrades them. New, missing, edited, or
 invalid entries in the raw directory are hard errors:
 open or refocus the Fundus editor and resolve its ingestion queue.

package/dist/server/image-duplicates.d.ts

@@ -0,0 +1,18 @@
+import { type Library } from '../core/index.js';
+export declare const IMAGE_DUPLICATE_HASH_SIZE = 8;
+export declare const IMAGE_DUPLICATE_MAX_DISTANCE = 5;
+export declare const IMAGE_DUPLICATE_MAX_COLOR_DISTANCE = 32;
+export declare const IMAGE_DUPLICATE_MAX_ALPHA_DISTANCE = 0.125;
+/** Compute the 64-bit horizontal difference hash described by the dHash algorithm. */
+export declare function imageDifferenceHash(filePath: string, hashSize?: number): Promise<Uint8Array>;
+/** Count differing bits between two equally sized perceptual hashes. */
+export declare function hammingDistance(left: Uint8Array, right: Uint8Array): number;
+/**
+ * Stateful so the editor can reuse fingerprints by content hash between state
+ * snapshots. Unreadable raws are omitted: duplicate detection is advisory and
+ * must not hide the editor or replace the pipeline's canonical diagnostics.
+ */
+export declare class ImageDuplicateDetector {
+    #private;
+    find(library: Library, rawDir: string): Promise<Map<string, string[]>>;
+}