fundus 0.29.0 → 0.29.2

package/dist/runtime/kind-handlers.js

@@ -1,3 +1,17 @@
+/**
+ * The runtime part of the type-plugin contract: per-kind preload
+ * strategy and its inverse release strategy. Each first-party kind registers
+ * a handler that knows how its delivered file is loaded — images fetch and
+ * retain a decoded element, slices too, media kinds (video/audio) fetch
+ * fully and mint an object URL — and how what it loaded is disposed (revoke
+ * the object URL; decoded elements have nothing to dispose). An unknown kind
+ * falls back to a plain full fetch: no decode, no retention.
+ *
+ * Handlers are pure strategy: refcounting, cross-holder dedup, and
+ * in-flight bookkeeping live in the module-wide registry
+ * (preload-registry.ts); kind-agnostic orchestration lives in `Manifest` and
+ * `retainEntry`.
+ */
 import { plugins } from '../core/plugins/registry.js';
 /**
  * Entry kinds whose delivered file is retained as an object URL by
@@ -46,13 +60,21 @@ function verifyByteSize(url, expected, actual) {
     }
 }
 /**
- * The image strategy: fetch the full file, then decode it via an
+ * The image and slice strategy: fetch the full file, then decode it via an
  * HTMLImageElement where a DOM exists (the browser serves the bytes from
- * cache); headless environments (Node tests, SSR) skip decoding.
- * Retains the decoded element for canvas drawing until the last holder releases.
- * Nothing to explicitly dispose — release drops the registry's reference.
+ * cache); headless environments (Node tests, SSR) skip decoding. Retains the
+ * decoded element until the last holder releases, so canvas drawing and
+ * `SliceSourceLifecycle` commit synchronously — a preloaded slice paints in
+ * its mount frame — and a one-slice's mounted `<img>` paints from a warm
+ * cache. Nothing to explicitly dispose — release drops the registry's
+ * reference.
+ *
+ * Deliberately not an ImageBitmap: WebKit on iOS can empty a bitmap while the
+ * app is in the background (memory pressure, GPU process restart) yet keep
+ * its size, so every later draw or texture upload from it is silently blank.
+ * An element whose decoded pixels were purged is decoded again from its file.
  */
-const imageHandler = {
+const decodedImageHandler = {
     async preload(url, byteSize) {
         const response = await fetchCompletely(url);
         // Read the body fully so the file is actually transferred (and
@@ -68,48 +90,6 @@ const imageHandler = {
         return {};
     }
 };
-/**
- * The slice strategy: fetch the full file and retain a decoded form while
- * held, chosen by the entry's slicing mode. Multi-cell slices (nine,
- * three-*) draw through a canvas and retain the pixels as an ImageBitmap —
- * unlike a throwaway decode into the browser's evictable image cache, the
- * bitmap survives memory pressure and lets `SliceSourceLifecycle` commit
- * synchronously, so a preloaded slice paints in its mount frame. One-slice
- * sources render as a plain `<img>`, which cannot paint from a bitmap: they
- * retain the decoded HTMLImageElement instead — the same synchronous commit,
- * and its decode warms the (evictable) cache the mounted `<img>` paints
- * from. Release closes the bitmap; a retained element has nothing to
- * dispose. Slice sources are small (the insets cover every rendered size),
- * so retention is cheap. Environments without `createImageBitmap` retain the
- * decoded element for every mode.
- *
- * Bitmaps are premultiplied so WebGL uploads match the premultiplied texture a
- * retained element yields with `UNPACK_PREMULTIPLY_ALPHA_WEBGL` (bitmaps ignore
- * that flag); Canvas 2D draws either form identically.
- */
-const sliceHandler = {
-    async preload(url, byteSize, entry) {
-        const response = await fetchCompletely(url);
-        const blob = await response.blob();
-        verifyByteSize(url, byteSize, blob.size);
-        const oneSlice = entry?.slicing?.mode === 'one';
-        if (!oneSlice && typeof globalThis.createImageBitmap === 'function') {
-            return {
-                imageBitmap: await globalThis.createImageBitmap(blob, { premultiplyAlpha: 'premultiply' })
-            };
-        }
-        if (typeof globalThis.Image === 'function') {
-            const image = new globalThis.Image();
-            image.src = url;
-            await image.decode();
-            return { image };
-        }
-        return {};
-    },
-    release(resources) {
-        resources.imageBitmap?.close();
-    }
-};
 /**
  * The retained-media strategy (video, chroma-key-video, audio): fetch the
  * full file and retain it as an object URL so later playback does not touch
@@ -140,8 +120,8 @@ const unknownKindHandler = {
     }
 };
 const runtimeHandlerCatalogue = {
-    image: imageHandler,
-    slice: sliceHandler,
+    image: decodedImageHandler,
+    slice: decodedImageHandler,
     video: retainedMediaHandler,
     'chroma-key-video': retainedMediaHandler,
     audio: retainedMediaHandler

package/dist/runtime/manifest.d.ts

@@ -16,12 +16,6 @@ export interface EntrySource {
     url: string;
     kind: string;
     byteSize: number;
-    /**
-     * The (possibly inlined) entry the source came from. Kind strategies read
-     * per-entry metadata from it — the slice handler picks its retention form
-     * by slicing mode. Orchestration itself never looks inside.
-     */
-    entry: Record<string, unknown>;
 }
 /** Reject an entry `byteSize` that is not a non-negative safe integer. */
 export declare function assertEntryByteSize(src: string, byteSize: unknown): asserts byteSize is number;
@@ -57,8 +51,8 @@ export declare class Manifest {
      * Drop this manifest's holds on everything it preloaded. Assets shared
      * with another holder (a manifest or a `retainEntry` handle) stay fully
      * alive for that holder; assets nobody holds anymore are disposed via their
-     * kind's release strategy (retained media object URLs are revoked, slice
-     * bitmaps closed, decoded image references dropped). Components fall back
+     * kind's release strategy (retained media object URLs are revoked,
+     * decoded image references dropped). Components fall back
      * to the network URL.
      *
      * Safe in every state: before or without `preload()` it is a no-op, and

package/dist/runtime/manifest.js

@@ -34,8 +34,7 @@ export function collectEntrySources(entry) {
                 id: record.id,
                 url: record.src,
                 kind: record.kind,
-                byteSize: record.byteSize,
-                entry: record
+                byteSize: record.byteSize
             });
         }
         for (const nested of Object.values(record))
@@ -97,8 +96,8 @@ export class Manifest {
      * Drop this manifest's holds on everything it preloaded. Assets shared
      * with another holder (a manifest or a `retainEntry` handle) stay fully
      * alive for that holder; assets nobody holds anymore are disposed via their
-     * kind's release strategy (retained media object URLs are revoked, slice
-     * bitmaps closed, decoded image references dropped). Components fall back
+     * kind's release strategy (retained media object URLs are revoked,
+     * decoded image references dropped). Components fall back
      * to the network URL.
      *
      * Safe in every state: before or without `preload()` it is a no-op, and
@@ -132,7 +131,7 @@ export class Manifest {
         const acquisitions = [];
         for (const [url, source] of sourceByUrl) {
             held.add(url);
-            acquisitions.push(acquireSource(url, source.kind, source.byteSize, source.entry));
+            acquisitions.push(acquireSource(url, source.kind, source.byteSize));
         }
         const outcomes = await Promise.allSettled(acquisitions);
         const failure = outcomes.find((outcome) => outcome.status === 'rejected');

package/dist/runtime/preload-registry.d.ts

@@ -5,7 +5,7 @@
  * load clears the in-flight state so the URL stays retryable; the caller
  * rolls back its own hold via `releaseSource`.
  */
-export declare function acquireSource(url: string, kind: string, byteSize: number, sourceEntry?: Record<string, unknown>): Promise<void>;
+export declare function acquireSource(url: string, kind: string, byteSize: number): Promise<void>;
 /**
  * Drop one hold on `url`. At zero holds the kind handler's release strategy
  * runs (object URL revoked) and the entry is cleared — unless the load is
@@ -20,13 +20,11 @@ export declare function releaseSource(url: string): void;
  */
 export declare function resolveRetainedSource(url: string): string;
 /**
- * The retained decoded source of an image or slice URL while a holder holds
- * it — a multi-cell slice bitmap or decoded image element — or `null` when
- * not (or no longer) preloaded; the consumer then
- * falls back to an async image load. Never returns a closed bitmap: closing
- * happens only when the entry is dropped from the registry.
+ * The retained decoded element of an image or slice URL while a holder holds
+ * it, or `null` when not (or no longer) preloaded; the consumer then falls
+ * back to an async image load.
  */
-export declare function resolveRetainedImageSource(url: string): ImageBitmap | HTMLImageElement | null;
+export declare function resolveRetainedImageSource(url: string): HTMLImageElement | null;
 /**
  * A source's preload state, for render-time diagnostics:
  * - `loaded` — fully preloaded and held (every kind resolves non-null

package/dist/runtime/preload-registry.js

@@ -26,7 +26,7 @@ const registryByUrl = new Map();
  * load clears the in-flight state so the URL stays retryable; the caller
  * rolls back its own hold via `releaseSource`.
  */
-export function acquireSource(url, kind, byteSize, sourceEntry) {
+export function acquireSource(url, kind, byteSize) {
     let entry = registryByUrl.get(url);
     if (!entry) {
         entry = { kind, byteSize, referenceCount: 0, pending: null, resources: null };
@@ -42,7 +42,7 @@ export function acquireSource(url, kind, byteSize, sourceEntry) {
     if (!pending) {
         const acquired = entry;
         pending = runtimeHandlerFor(kind)
-            .preload(url, byteSize, sourceEntry)
+            .preload(url, byteSize)
             .then((resources) => {
             acquired.pending = null;
             if (acquired.referenceCount === 0) {
@@ -92,15 +92,12 @@ export function resolveRetainedSource(url) {
     return registryByUrl.get(url)?.resources?.objectUrl ?? url;
 }
 /**
- * The retained decoded source of an image or slice URL while a holder holds
- * it — a multi-cell slice bitmap or decoded image element — or `null` when
- * not (or no longer) preloaded; the consumer then
- * falls back to an async image load. Never returns a closed bitmap: closing
- * happens only when the entry is dropped from the registry.
+ * The retained decoded element of an image or slice URL while a holder holds
+ * it, or `null` when not (or no longer) preloaded; the consumer then falls
+ * back to an async image load.
  */
 export function resolveRetainedImageSource(url) {
-    const resources = registryByUrl.get(url)?.resources;
-    return resources?.imageBitmap ?? resources?.image ?? null;
+    return registryByUrl.get(url)?.resources?.image ?? null;
 }
 export function sourceStatus(url) {
     const entry = registryByUrl.get(url);

package/dist/runtime/retained-entry.d.ts

@@ -13,7 +13,7 @@ import type { ManifestEntry } from '../core/index.js';
  */
 export type RetainedSourceOf<E extends ManifestEntry> = E extends {
     kind: 'image' | 'slice';
-} ? HTMLImageElement | ImageBitmap : E extends {
+} ? HTMLImageElement : E extends {
     kind: 'video' | 'chroma-key-video' | 'audio';
 } ? string : never;
 /** One hold on an entry's loaded source, from `retainEntry`. */

package/dist/runtime/retained-entry.js

@@ -43,7 +43,7 @@ export async function retainEntry(entry) {
     const { id, kind, src, byteSize } = entry;
     assertEntryByteSize(src, byteSize);
     try {
-        await acquireSource(src, kind, byteSize, entry);
+        await acquireSource(src, kind, byteSize);
     }
     catch (cause) {
         releaseSource(src);

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

@@ -1,18 +1,10 @@
 import type { SliceManifestEntry } from '../core/index.js';
-/** What a committed slice draws from: a decoded element or a retained bitmap. */
-export type SliceRenderSource = HTMLImageElement | ImageBitmap;
 export interface LoadedSliceSnapshot {
     entry: SliceManifestEntry;
-    image: SliceRenderSource;
+    image: HTMLImageElement;
 }
 export type SliceImageLoader = (url: string) => Promise<HTMLImageElement>;
-export type RetainedSliceSourceResolver = (url: string) => SliceRenderSource | null;
-/**
- * Whether a committed source can no longer be drawn: a preload-retained
- * bitmap is closed when its last hold is released, and drawing a closed
- * bitmap throws. A detached source is dropped and reloaded asynchronously.
- */
-export declare function isDetachedSliceSource(image: SliceRenderSource): boolean;
+export type RetainedSliceSourceResolver = (url: string) => HTMLImageElement | null;
 export declare function loadSliceImage(url: string): Promise<HTMLImageElement>;
 /** Coordinates requested slice entries with the last image-ready snapshot. */
 export declare class SliceSourceLifecycle {

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

@@ -1,12 +1,4 @@
 import { resolveRetainedImageSource } from './preload-registry.js';
-/**
- * Whether a committed source can no longer be drawn: a preload-retained
- * bitmap is closed when its last hold is released, and drawing a closed
- * bitmap throws. A detached source is dropped and reloaded asynchronously.
- */
-export function isDetachedSliceSource(image) {
-    return typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap && image.width === 0;
-}
 export function loadSliceImage(url) {
     const image = new Image();
     image.decoding = 'async';
@@ -32,12 +24,11 @@ export class SliceSourceLifecycle {
             return;
         this.#requestedEntry = entry;
         const displayed = this.#displayedSnapshot;
-        if (displayed?.entry.src === entry.src && !isDetachedSliceSource(displayed.image)) {
+        if (displayed?.entry.src === entry.src) {
             this.#commitSnapshot({ entry, image: displayed.image });
             return;
         }
-        // A preload-retained source (the pinned bitmap of a multi-cell slice,
-        // the decoded element of a one-slice) commits synchronously — the slice
+        // A preload-retained decoded element commits synchronously — the slice
         // paints in its mount frame instead of one decode roundtrip later.
         const retained = this.#resolveRetained(entry.src);
         if (retained) {

package/dist/server/concurrency.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read-only filesystem, sharp, and ffprobe work is dominated by I/O and child
+ * process latency, so a handful of concurrent jobs hides most of it without
+ * flooding libuv's thread pool or spawning one process per asset.
+ */
+export declare const IO_CONCURRENCY = 8;
+/**
+ * Map items with at most `limit` callbacks pending. Results keep input order,
+ * so callers stay deterministic regardless of completion order. A rejection
+ * rejects the whole map; callers that must not fail wholesale catch per item.
+ */
+export declare function mapConcurrent<T, R>(items: readonly T[], limit: number, map: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/server/concurrency.js

@@ -0,0 +1,23 @@
+/**
+ * Read-only filesystem, sharp, and ffprobe work is dominated by I/O and child
+ * process latency, so a handful of concurrent jobs hides most of it without
+ * flooding libuv's thread pool or spawning one process per asset.
+ */
+export const IO_CONCURRENCY = 8;
+/**
+ * Map items with at most `limit` callbacks pending. Results keep input order,
+ * so callers stay deterministic regardless of completion order. A rejection
+ * rejects the whole map; callers that must not fail wholesale catch per item.
+ */
+export async function mapConcurrent(items, limit, map) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await map(items[index], index);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(Math.max(1, limit), items.length) }, worker));
+    return results;
+}

package/dist/server/image-duplicates.js

@@ -8,6 +8,7 @@
 import { join } from 'node:path';
 import sharp from 'sharp';
 import { compareCodeUnits } from '../core/index.js';
+import { IO_CONCURRENCY, mapConcurrent } from './concurrency.js';
 export const IMAGE_DUPLICATE_HASH_SIZE = 8;
 export const IMAGE_DUPLICATE_MAX_DISTANCE = 5;
 export const IMAGE_DUPLICATE_MAX_COLOR_DISTANCE = 32;
@@ -98,20 +99,21 @@ export class ImageDuplicateDetector {
             if (!activeHashes.has(hash))
                 this.#fingerprints.delete(hash);
         }
-        const readable = [];
-        for (const [id, record] of images) {
+        const fingerprints = await mapConcurrent(images, IO_CONCURRENCY, async ([id, record]) => {
             let fingerprint = this.#fingerprints.get(record.rawHash);
             if (!fingerprint) {
                 fingerprint = imageFingerprint(join(rawDir, record.raw), IMAGE_DUPLICATE_HASH_SIZE);
                 this.#fingerprints.set(record.rawHash, fingerprint);
             }
             try {
-                readable.push({ id, fingerprint: await fingerprint });
+                return { id, fingerprint: await fingerprint };
             }
             catch {
                 this.#fingerprints.delete(record.rawHash);
+                return null;
             }
-        }
+        });
+        const readable = fingerprints.filter((entry) => entry !== null);
         const duplicates = new Map();
         for (let leftIndex = 0; leftIndex < readable.length; leftIndex++) {
             for (let rightIndex = leftIndex + 1; rightIndex < readable.length; rightIndex++) {

package/dist/server/operations.d.ts

@@ -42,6 +42,13 @@ export declare class FundusOperations {
     openUsageLocation(token: unknown): Promise<void>;
     /** Read-only state snapshot, serialized with mutations but never processing or writing. */
     state(): Promise<FundusStateDto>;
+    /**
+     * Fill the image-fingerprint and proxy-probe caches without scanning raws or
+     * joining the operation queue, so an early editor reconcile shares this
+     * in-flight work instead of waiting behind it. Both caches are keyed by
+     * content, so a concurrent mutation can only make an entry unused.
+     */
+    warmCaches(): Promise<void>;
     /** Reconcile only changes that are safe without a user decision: unique moves and deletions. */
     reconcileRawState(): Promise<FundusStateDto>;
     /** Adopt an already-existing raw file without copying, renaming, or deleting it. */

package/dist/server/operations.js

@@ -11,7 +11,7 @@ import { assetIdError, allDeliveredAssetIds, canonicalizeParameters, collectAllR
 import { LibraryStore } from './library-store.js';
 import { generateManifestModules, locateGeneratedAssetDeclaration, manifestModuleFileName } from './codegen.js';
 import { descriptorsByType, serverPluginForType, serverPluginsByType } from './plugins.js';
-import { processAssets, readCurrentProxy } from './processing/processor.js';
+import { processAssets, ProxyInfoCache, readCurrentProxy } from './processing/processor.js';
 import { encodeRelativePathForUrl } from './folder-filesystem.js';
 import { classifyRawDirectory, verifyStableRawFile } from './raw-reconciliation.js';
 import { rawSafetyIssues } from './raw-safety.js';
@@ -19,6 +19,7 @@ import { serverImporters } from './importers.js';
 import { SourceImportError } from './importers/contract.js';
 import { validateFigmaSourceParameters } from './importers/figma.js';
 import { currentGitBranch, gitAssetChanges } from './git.js';
+import { IO_CONCURRENCY, mapConcurrent } from './concurrency.js';
 import { FundusUsageAnalyzer, usageSnapshotRevision } from './usage.js';
 import { ImageDuplicateDetector } from './image-duplicates.js';
 /**
@@ -71,6 +72,7 @@ export class FundusOperations {
     #importers;
     #usageAnalyzer;
     #duplicateDetector = new ImageDuplicateDetector();
+    #proxyInfoCache = new ProxyInfoCache();
     #operationQueue = Promise.resolve();
     #pipelineQueue = Promise.resolve();
     constructor(config, registry = serverPluginsByType, importerRegistry = serverImporters) {
@@ -180,6 +182,20 @@ export class FundusOperations {
         const classification = await this.#classifyRawDirectory(library);
         return this.#snapshotState(library, classification);
     }
+    /**
+     * Fill the image-fingerprint and proxy-probe caches without scanning raws or
+     * joining the operation queue, so an early editor reconcile shares this
+     * in-flight work instead of waiting behind it. Both caches are keyed by
+     * content, so a concurrent mutation can only make an entry unused.
+     */
+    async warmCaches() {
+        const library = await this.#store.read();
+        const delivered = allDeliveredAssetIds(computeLibraryMembership(library, collectAllReferences(library, descriptorsByType(this.#registry))));
+        await Promise.all([
+            this.#duplicateDetector.find(library, this.#config.rawDir),
+            mapConcurrent([...delivered].sort(compareCodeUnits), IO_CONCURRENCY, (assetId) => this.#proxyState(assetId, library.assets[assetId], delivered))
+        ]);
+    }
     /** Reconcile only changes that are safe without a user decision: unique moves and deletions. */
     reconcileRawState() {
         return this.#enqueueOperation(async () => {
@@ -921,15 +937,42 @@ export class FundusOperations {
             state: await this.#snapshotState(latestLibrary, latestClassification, pipelineIssues)
         };
     }
+    async #proxyState(assetId, record, delivered) {
+        if (!delivered.has(assetId))
+            return { proxy: null };
+        try {
+            const currentProxy = await readCurrentProxy(assetId, record, this.#config, this.#registry, this.#proxyInfoCache);
+            if (!currentProxy) {
+                return {
+                    proxy: null,
+                    warning: 'Proxy is stale or missing — it will be (re)processed on the next save.'
+                };
+            }
+            return {
+                proxy: {
+                    url: `/files/proxy/${encodeRelativePathForUrl(currentProxy.relativePath)}`,
+                    upToDate: true,
+                    ...currentProxy
+                }
+            };
+        }
+        catch (cause) {
+            return { proxy: null, warning: cause instanceof Error ? cause.message : String(cause) };
+        }
+    }
     async #buildState(library, issues, classification) {
-        const [gitBranch, changedGitAssets] = await Promise.all([
-            currentGitBranch(this.#config.projectRoot),
-            gitAssetChanges(this.#config.projectRoot, this.#config.library, library)
-        ]);
         const referencesByAsset = collectAllReferences(library, descriptorsByType(this.#registry));
-        const duplicatesByAsset = await this.#duplicateDetector.find(library, this.#config.rawDir);
         const membershipByManifest = computeLibraryMembership(library, referencesByAsset);
         const delivered = allDeliveredAssetIds(membershipByManifest);
+        const assetIds = Object.keys(library.assets).sort(compareCodeUnits);
+        // Independent I/O-bound reads; run together so large libraries load in parallel.
+        const [gitBranch, changedGitAssets, duplicatesByAsset, proxies] = await Promise.all([
+            currentGitBranch(this.#config.projectRoot),
+            gitAssetChanges(this.#config.projectRoot, this.#config.library, library),
+            this.#duplicateDetector.find(library, this.#config.rawDir),
+            mapConcurrent(assetIds, IO_CONCURRENCY, (assetId) => this.#proxyState(assetId, library.assets[assetId], delivered))
+        ]);
+        this.#proxyInfoCache.retain(delivered);
         // Per asset: the manifests it is a passive member of, with attribution.
         const passiveManifestsByAsset = new Map();
         for (const manifestName of Object.keys(library.manifests).sort(compareCodeUnits)) {
@@ -954,7 +997,7 @@ export class FundusOperations {
             requiredByAsset.set(dependency.id, [...dependency.sources]);
         }
         const assets = [];
-        for (const assetId of Object.keys(library.assets).sort(compareCodeUnits)) {
+        for (const [index, assetId] of assetIds.entries()) {
             const record = library.assets[assetId];
             const warnings = [];
             for (const issue of issues) {
@@ -971,25 +1014,9 @@ export class FundusOperations {
             if (record.importSource && !this.#importers.has(record.importSource.importer)) {
                 warnings.push(`Importer "${record.importSource.importer}" is unavailable; the local raw file remains usable.`);
             }
-            let proxy = null;
-            if (delivered.has(assetId)) {
-                try {
-                    const currentProxy = await readCurrentProxy(assetId, record, this.#config, this.#registry);
-                    if (currentProxy) {
-                        proxy = {
-                            url: `/files/proxy/${encodeRelativePathForUrl(currentProxy.relativePath)}`,
-                            upToDate: true,
-                            ...currentProxy
-                        };
-                    }
-                    else {
-                        warnings.push('Proxy is stale or missing — it will be (re)processed on the next save.');
-                    }
-                }
-                catch (cause) {
-                    warnings.push(cause instanceof Error ? cause.message : String(cause));
-                }
-            }
+            const { proxy, warning: proxyWarning } = proxies[index];
+            if (proxyWarning)
+                warnings.push(proxyWarning);
             assets.push({
                 id: assetId,
                 type: record.type,

package/dist/server/processing/processor.d.ts

@@ -1,3 +1,19 @@
+/**
+ * The processing pipeline: every delivered asset gets exactly one
+ * proxy named `<assetId>.<jobHash>.<extension>`. Delivered = explicit or
+ * passive member of ≥ 1 manifest (codegen inlines referenced
+ * entries, so a passive member's proxy must exist even when the asset is in
+ * no manifest itself). Because the name is computable without running the job,
+ * staleness is a name check: expected name exists → up to date, else →
+ * process. Afterwards, files in the proxy directory that no asset expects are
+ * pruned.
+ *
+ * Type-agnostic: every per-type decision (preset resolution, extension, the
+ * sharp/ffmpeg step, proxy probing) lives on the server plugins; this module
+ * only consults the registry — which it takes as a parameter, so tests can
+ * drive the pipeline with fixture asset types.
+ */
+import { type Stats } from 'node:fs';
 import { type AssetId, type AssetRecord, type Library } from '../../core/index.js';
 import type { ResolvedFundusConfig } from '../config-loader.js';
 import type { AssetProxyInfo, ProxyOutputInfo, ServerPluginRegistry } from '../plugins/contract.js';
@@ -35,8 +51,20 @@ export declare function expectedProxyRelativePath(assetId: string, record: Asset
  * strategy: image-backed proxies via sharp, media proxies via ffprobe.
  */
 export declare function readProxyOutputInfo(record: AssetRecord, proxyPath: string, config: ResolvedFundusConfig, registry?: ServerPluginRegistry): Promise<ProxyOutputInfo>;
+/**
+ * Probed proxy output info, reused across editor snapshots so unchanged proxies
+ * skip sharp and ffprobe. Proxy names are content-addressed, so an entry stays
+ * valid while the proxy and the raw source handed to the probe keep their stat
+ * identity. In-flight probes are shared, so concurrent readers never probe twice.
+ */
+export declare class ProxyInfoCache {
+    #private;
+    read(assetId: AssetId, proxyPath: string, proxyStat: Stats, rawPath: string, probe: () => Promise<ProxyOutputInfo>): Promise<ProxyOutputInfo>;
+    /** Forget assets that no longer exist or are no longer delivered. */
+    retain(assetIds: ReadonlySet<AssetId>): void;
+}
 /** Read one asset's current proxy projection, or null when its expected file is absent. */
-export declare function readCurrentProxy(assetId: string, record: AssetRecord, config: ResolvedFundusConfig, registry?: ServerPluginRegistry): Promise<AssetProxyInfo | null>;
+export declare function readCurrentProxy(assetId: string, record: AssetRecord, config: ResolvedFundusConfig, registry?: ServerPluginRegistry, cache?: ProxyInfoCache): Promise<AssetProxyInfo | null>;
 /**
  * The delivered set: every explicit or passive member of ≥ 1 manifest —
  * derived by the shared membership computation. Assets outside

package/dist/server/processing/processor.js

@@ -65,17 +65,54 @@ export function expectedProxyRelativePath(assetId, record, config, registry = se
 export async function readProxyOutputInfo(record, proxyPath, config, registry = serverPluginsByType) {
     return serverPluginForType(record.type, registry).readProxyInfo(proxyPath, config, join(config.rawDir, record.raw));
 }
+function statIdentity(value) {
+    return `${value.dev}:${value.ino}:${value.size}:${value.mtimeMs}:${value.ctimeMs}`;
+}
+/**
+ * Probed proxy output info, reused across editor snapshots so unchanged proxies
+ * skip sharp and ffprobe. Proxy names are content-addressed, so an entry stays
+ * valid while the proxy and the raw source handed to the probe keep their stat
+ * identity. In-flight probes are shared, so concurrent readers never probe twice.
+ */
+export class ProxyInfoCache {
+    #entries = new Map();
+    async read(assetId, proxyPath, proxyStat, rawPath, probe) {
+        const rawIdentity = await stat(rawPath).then(statIdentity, () => 'missing');
+        const identity = `${proxyPath}|${statIdentity(proxyStat)}|${rawIdentity}`;
+        const cached = this.#entries.get(assetId);
+        if (cached?.identity === identity)
+            return cached.info;
+        const entry = { identity, info: probe() };
+        this.#entries.set(assetId, entry);
+        try {
+            return await entry.info;
+        }
+        catch (cause) {
+            if (this.#entries.get(assetId) === entry)
+                this.#entries.delete(assetId);
+            throw cause;
+        }
+    }
+    /** Forget assets that no longer exist or are no longer delivered. */
+    retain(assetIds) {
+        for (const assetId of this.#entries.keys()) {
+            if (!assetIds.has(assetId))
+                this.#entries.delete(assetId);
+        }
+    }
+}
 /** Read one asset's current proxy projection, or null when its expected file is absent. */
-export async function readCurrentProxy(assetId, record, config, registry = serverPluginsByType) {
+export async function readCurrentProxy(assetId, record, config, registry = serverPluginsByType, cache) {
     const fileName = expectedProxyFileName(assetId, record, config, registry);
     const relativePath = expectedProxyRelativePath(assetId, record, config, registry);
     const proxyPath = join(config.proxyDir, relativePath);
     if (!existsSync(proxyPath))
         return null;
-    const [outputInfo, proxyStat] = await Promise.all([
-        readProxyOutputInfo(record, proxyPath, config, registry),
-        stat(proxyPath)
-    ]);
+    const proxyStat = await stat(proxyPath);
+    const probe = () => readProxyOutputInfo(record, proxyPath, config, registry);
+    const outputInfo = cache
+        ? await cache.read(assetId, proxyPath, proxyStat, join(config.rawDir, record.raw), probe)
+        : await probe();
     return { assetId, fileName, relativePath, ...outputInfo, fileSize: proxyStat.size };
 }
 /**