fundus 0.0.2 → 0.0.4

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

@@ -1,46 +1,49 @@
-import { AudioManifestEntry, PreloadOptions } from "#fundus/core";
-
-//#region src/kind-handlers.d.ts
+/**
+ * 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 — image-backed kinds
+ * fetch + optionally decode, media kinds (video/audio) fetch fully and mint
+ * an object URL — and how what it loaded is disposed (revoke the object URL;
+ * image-backed kinds have nothing to dispose). An unknown kind falls back to
+ * a plain full fetch: no decode, no retention.
+ *
+ * Handlers are pure strategy: refcounting, cross-manifest dedup, and
+ * in-flight bookkeeping live in the module-wide registry
+ * (preload-registry.ts); kind-agnostic orchestration lives in `Manifest`.
+ */
+import type { AudioManifestEntry, PreloadOptions } from '../core/index.js';
 /** The playable URL hosts feed to their own audio engine. */
-declare function audioSourceOf(entry: AudioManifestEntry): string;
+export 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;
+export 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;
+export 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>;
+export 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;
+export 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 };
+export declare function runtimeHandlerFor(kind: string): KindRuntimeHandler;

package/dist/runtime/kind-handlers.js

@@ -1,86 +1,104 @@
-import { resolveRetainedSource } from "./preload-registry.js";
-//#region src/kind-handlers.ts
+import { plugins } from '../core/plugins/registry.js';
+import { resolveRetainedSource } from './preload-registry.js';
 /** The playable URL hosts feed to their own audio engine. */
-function audioSourceOf(entry) {
-	return resolveRetainedSource(entry.src);
+export function audioSourceOf(entry) {
+    return resolveRetainedSource(entry.src);
 }
 /** Entry kinds whose delivered file is an image the browser can pre-decode. */
-const IMAGE_BACKED_KINDS = new Set(["image", "slice"]);
+const IMAGE_BACKED_KINDS = new Set(['image', 'slice']);
 /**
-* 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.
-*/
-const RETAINED_KINDS = new Set([
-	"video",
-	"chroma-key-video",
-	"audio"
+ * 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.
+ */
+const RETAINED_KIND_CATALOGUE = new Set([
+    'video',
+    'chroma-key-video',
+    'audio'
 ]);
+export const RETAINED_KINDS = new Set([...RETAINED_KIND_CATALOGUE].filter((kind) => plugins.has(kind)));
 /**
-* 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).
-*/
-function shouldDecode(kind, options) {
-	if (!IMAGE_BACKED_KINDS.has(kind)) return false;
-	return options[kind]?.decode ?? true;
+ * 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).
+ */
+export function shouldDecode(kind, options) {
+    if (!IMAGE_BACKED_KINDS.has(kind))
+        return false;
+    // The image-backed check above narrows the kind — only these carry `decode`.
+    const kindOptions = options[kind];
+    return kindOptions?.decode ?? true;
 }
 /** Fetch a source, throwing a uniform error on a non-OK response. */
 async function fetchCompletely(url) {
-	const response = await fetch(url);
-	if (!response.ok) throw new Error(`Preloading "${url}" failed: ${response.status} ${response.statusText}.`);
-	return response;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Preloading "${url}" failed: ${response.status} ${response.statusText}.`);
+    }
+    return response;
 }
 /**
-* The image-backed strategy (image, slice): fetch the full file, then decode
-* by default. Decoding goes via an HTMLImageElement where a DOM exists (the
-* browser serves the bytes from cache); headless environments (Node tests,
-* SSR) skip decoding. Nothing to release — the browser cache owns the bytes.
-*/
+ * The image-backed strategy (image, slice): fetch the full file, then decode
+ * by default. Decoding goes via an HTMLImageElement where a DOM exists (the
+ * browser serves the bytes from cache); headless environments (Node tests,
+ * SSR) skip decoding. Nothing to release — the browser cache owns the bytes.
+ */
 function imageBackedHandler(kind) {
-	return { async preload(url, options) {
-		await (await fetchCompletely(url)).arrayBuffer();
-		if (shouldDecode(kind, options) && typeof globalThis.Image === "function") {
-			const image = new globalThis.Image();
-			image.src = url;
-			await image.decode();
-		}
-		return {};
-	} };
+    return {
+        async preload(url, options) {
+            const response = await fetchCompletely(url);
+            // Read the body fully so the file is actually transferred (and
+            // cached), not just the response headers.
+            await response.arrayBuffer();
+            if (shouldDecode(kind, options) && typeof globalThis.Image === 'function') {
+                const image = new globalThis.Image();
+                image.src = url;
+                await image.decode();
+            }
+            return {};
+        }
+    };
 }
 /**
-* 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
-* the network. Release revokes the URL, freeing the
-* retained memory. Environments without object URLs (SSR) still fetch fully
-* but retain nothing.
-*/
+ * 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
+ * the network. Release revokes the URL, freeing the
+ * retained memory. Environments without object URLs (SSR) still fetch fully
+ * but retain nothing.
+ */
 const retainedMediaHandler = {
-	async preload(url) {
-		const blob = await (await fetchCompletely(url)).blob();
-		if (typeof URL.createObjectURL !== "function") return {};
-		return { objectUrl: URL.createObjectURL(blob) };
-	},
-	release(resources) {
-		if (resources.objectUrl !== void 0 && typeof URL.revokeObjectURL === "function") URL.revokeObjectURL(resources.objectUrl);
-	}
+    async preload(url) {
+        const response = await fetchCompletely(url);
+        const blob = await response.blob();
+        if (typeof URL.createObjectURL !== 'function')
+            return {};
+        return { objectUrl: URL.createObjectURL(blob) };
+    },
+    release(resources) {
+        if (resources.objectUrl !== undefined && typeof URL.revokeObjectURL === 'function') {
+            URL.revokeObjectURL(resources.objectUrl);
+        }
+    }
 };
 /** Fallback for kinds without a registered handler: plain full fetch. */
-const unknownKindHandler = { async preload(url) {
-	await (await fetchCompletely(url)).arrayBuffer();
-	return {};
-} };
-/** The statically registered first-party handlers. */
-const handlerByKind = new Map([
-	["image", imageBackedHandler("image")],
-	["slice", imageBackedHandler("slice")],
-	...[...RETAINED_KINDS].map((kind) => [kind, retainedMediaHandler])
-]);
+const unknownKindHandler = {
+    async preload(url) {
+        await (await fetchCompletely(url)).arrayBuffer();
+        return {};
+    }
+};
+const runtimeHandlerCatalogue = {
+    image: imageBackedHandler('image'),
+    slice: imageBackedHandler('slice'),
+    video: retainedMediaHandler,
+    'chroma-key-video': retainedMediaHandler,
+    audio: retainedMediaHandler
+};
+/** The runtime facets of the centrally registered plugins. */
+const handlerByKind = new Map(Object.entries(plugins.project(runtimeHandlerCatalogue, 'runtime handler')));
 /** The runtime handler owning `kind`'s preload/release strategy (fallback for unknown kinds). */
-function runtimeHandlerFor(kind) {
-	return handlerByKind.get(kind) ?? unknownKindHandler;
+export function runtimeHandlerFor(kind) {
+    return handlerByKind.get(kind) ?? unknownKindHandler;
 }
-//#endregion
-export { RETAINED_KINDS, audioSourceOf, runtimeHandlerFor, shouldDecode };

package/dist/runtime/manifest.d.ts

@@ -1,10 +1,18 @@
-import { ManifestEntry, PreloadOptions } from "#fundus/core";
-
-//#region src/manifest.d.ts
+/**
+ * The runtime manifest: generated modules call `createManifest` with data-only
+ * entries, and the entries become direct, typed, readonly properties
+ * — no global registry, no string keys, a removed asset is a compile error.
+ *
+ * `Manifest` owns only kind-agnostic orchestration — entry-source collection
+ * (including inlined reference entries), URL dedup, in-flight/idempotency.
+ * How each kind actually loads (decode, retention) is the per-kind runtime
+ * handler's strategy — see kind-handlers.ts.
+ */
+import type { ManifestEntry, PreloadOptions } from '../core/index.js';
 /** One deliverable file of an entry: its URL and the owning entry's kind. */
-interface EntrySource {
-  url: string;
-  kind: string;
+export interface EntrySource {
+    url: string;
+    kind: string;
 }
 /**
  * Collect every deliverable URL of an entry, including the entries codegen
@@ -12,49 +20,47 @@ interface EntrySource {
  * a string `kind` is an entry, and its `src` (when present) is a source.
  * Generic by design: adding a kind does not change preload orchestration.
  */
-declare function collectEntrySources(entry: ManifestEntry): EntrySource[];
-declare class Manifest {
-  #private;
-  constructor(entries: Record<string, ManifestEntry>);
-  /**
-   * Fetch every deliverable file of this manifest up front — including the
-   * reference closure, which codegen inlined into the entries — and decode
-   * image-backed entries. Options are namespaced per asset kind, mirroring
-   * `plugins.<type>` in the config: `{ image: { decode: false } }`
-   * skips decoding for image entries only; slices keep decoding unless
-   * `slice: { decode: false }` is passed too. An option applies to every
-   * entry of its kind, inlined reference entries included.
-   *
-   * Idempotent and concurrent-safe: one in-flight promise per manifest; a
-   * second call joins it (or resolves immediately once done), and URLs shared
-   * by several entries are fetched once. Sharing goes further than this
-   * manifest: every URL is acquired through the module-wide refcounted
-   * registry, so a URL another manifest already preloaded (or is preloading)
-   * is never fetched again — this manifest just takes a hold on it. A failed
-   * preload rolls back this manifest's holds and clears the in-flight state
-   * so it can be retried. A joined call's options are ignored: options apply
-   * per preload run (the first call after construction or `release()`).
-   */
-  preload(options?: PreloadOptions): Promise<void>;
-  /**
-   * Drop this manifest's holds on everything it preloaded. Assets shared
-   * with another preloaded manifest stay fully alive for that holder; assets
-   * nobody holds anymore are disposed via their kind's release strategy
-   * (retained media object URLs are revoked, freeing the memory). Consumers
-   * of a fully released source fall back to its network URL.
-   *
-   * Safe in every state: before or without `preload()` it is a no-op, and
-   * calling it while a `preload()` is still in flight drops the holds
-   * without cancelling — when the in-flight load completes unheld, the
-   * registry disposes it immediately (no leak). Afterwards the manifest's
-   * preload state is reset, so a later `preload()` re-acquires from scratch.
-   */
-  release(): void;
+export declare function collectEntrySources(entry: ManifestEntry): EntrySource[];
+export declare class Manifest {
+    #private;
+    constructor(entries: Record<string, ManifestEntry>);
+    /**
+     * Fetch every deliverable file of this manifest up front — including the
+     * reference closure, which codegen inlined into the entries — and decode
+     * image-backed entries. Options are namespaced per asset kind, mirroring
+     * `plugins.<type>` in the config: `{ image: { decode: false } }`
+     * skips decoding for image entries only; slices keep decoding unless
+     * `slice: { decode: false }` is passed too. An option applies to every
+     * entry of its kind, inlined reference entries included.
+     *
+     * Idempotent and concurrent-safe: one in-flight promise per manifest; a
+     * second call joins it (or resolves immediately once done), and URLs shared
+     * by several entries are fetched once. Sharing goes further than this
+     * manifest: every URL is acquired through the module-wide refcounted
+     * registry, so a URL another manifest already preloaded (or is preloading)
+     * is never fetched again — this manifest just takes a hold on it. A failed
+     * preload rolls back this manifest's holds and clears the in-flight state
+     * so it can be retried. A joined call's options are ignored: options apply
+     * per preload run (the first call after construction or `release()`).
+     */
+    preload(options?: PreloadOptions): Promise<void>;
+    /**
+     * Drop this manifest's holds on everything it preloaded. Assets shared
+     * with another preloaded manifest stay fully alive for that holder; assets
+     * nobody holds anymore are disposed via their kind's release strategy
+     * (retained media object URLs are revoked, freeing the memory). Consumers
+     * of a fully released source fall back to its network URL.
+     *
+     * Safe in every state: before or without `preload()` it is a no-op, and
+     * calling it while a `preload()` is still in flight drops the holds
+     * without cancelling — when the in-flight load completes unheld, the
+     * registry disposes it immediately (no leak). Afterwards the manifest's
+     * preload state is reset, so a later `preload()` re-acquires from scratch.
+     */
+    release(): void;
 }
 /**
  * Construct a manifest whose entries are direct readonly properties:
  * `mainCatalog.navigationPanel` is fully typed, and a typo is a compile error.
  */
-declare function createManifest<T extends Record<string, ManifestEntry>>(entries: T): Manifest & Readonly<T>;
-//#endregion
-export { EntrySource, Manifest, collectEntrySources, createManifest };
+export declare function createManifest<T extends Record<string, ManifestEntry>>(entries: T): Manifest & Readonly<T>;

package/dist/runtime/manifest.js

@@ -1,117 +1,137 @@
-import { acquireSource, releaseSource } from "./preload-registry.js";
-//#region src/manifest.ts
+import { acquireSource, releaseSource } from './preload-registry.js';
 /**
-* Collect every deliverable URL of an entry, including the entries codegen
-* inlined in place of asset references: any nested object carrying
-* a string `kind` is an entry, and its `src` (when present) is a source.
-* Generic by design: adding a kind does not change preload orchestration.
-*/
-function collectEntrySources(entry) {
-	const sources = [];
-	visit(entry);
-	return sources;
-	function visit(value) {
-		if (Array.isArray(value)) {
-			for (const element of value) visit(element);
-			return;
-		}
-		if (typeof value !== "object" || value === null) return;
-		const record = value;
-		if (typeof record.kind === "string" && typeof record.src === "string") sources.push({
-			url: record.src,
-			kind: record.kind
-		});
-		for (const nested of Object.values(record)) visit(nested);
-	}
+ * Collect every deliverable URL of an entry, including the entries codegen
+ * inlined in place of asset references: any nested object carrying
+ * a string `kind` is an entry, and its `src` (when present) is a source.
+ * Generic by design: adding a kind does not change preload orchestration.
+ */
+export function collectEntrySources(entry) {
+    const sources = [];
+    visit(entry);
+    return sources;
+    function visit(value) {
+        if (Array.isArray(value)) {
+            for (const element of value)
+                visit(element);
+            return;
+        }
+        if (typeof value !== 'object' || value === null)
+            return;
+        const record = value;
+        if (typeof record.kind === 'string' && typeof record.src === 'string') {
+            sources.push({ url: record.src, kind: record.kind });
+        }
+        for (const nested of Object.values(record))
+            visit(nested);
+    }
+}
+export class Manifest {
+    #entries;
+    #preloading = null;
+    /**
+     * URLs this manifest currently holds in the module-wide registry (each
+     * held at most once — the registry's reference count counts holding
+     * manifests, not preload calls). Replaced wholesale by `release()`: an
+     * in-flight preload run keeps operating on the set object it captured, so
+     * a release during the run (which drains that set) turns the run's own
+     * failure rollback into a no-op instead of a double release.
+     */
+    #heldUrls = new Set();
+    constructor(entries) {
+        for (const key of Object.keys(entries)) {
+            // Belt-and-braces with core's reserved-id check: codegen validates ids, but a
+            // hand-written call must not silently shadow a class member either.
+            if (key in this) {
+                throw new Error(`Manifest entry id "${key}" collides with a Manifest member.`);
+            }
+        }
+        Object.assign(this, entries);
+        this.#entries = entries;
+    }
+    /**
+     * Fetch every deliverable file of this manifest up front — including the
+     * reference closure, which codegen inlined into the entries — and decode
+     * image-backed entries. Options are namespaced per asset kind, mirroring
+     * `plugins.<type>` in the config: `{ image: { decode: false } }`
+     * skips decoding for image entries only; slices keep decoding unless
+     * `slice: { decode: false }` is passed too. An option applies to every
+     * entry of its kind, inlined reference entries included.
+     *
+     * Idempotent and concurrent-safe: one in-flight promise per manifest; a
+     * second call joins it (or resolves immediately once done), and URLs shared
+     * by several entries are fetched once. Sharing goes further than this
+     * manifest: every URL is acquired through the module-wide refcounted
+     * registry, so a URL another manifest already preloaded (or is preloading)
+     * is never fetched again — this manifest just takes a hold on it. A failed
+     * preload rolls back this manifest's holds and clears the in-flight state
+     * so it can be retried. A joined call's options are ignored: options apply
+     * per preload run (the first call after construction or `release()`).
+     */
+    preload(options = {}) {
+        if (!this.#preloading) {
+            const tracked = this.#preloadAll(options, this.#heldUrls).catch((cause) => {
+                // Reset for retry — unless release() or a follow-up preload()
+                // already superseded this run while it was in flight.
+                if (this.#preloading === tracked)
+                    this.#preloading = null;
+                throw cause;
+            });
+            this.#preloading = tracked;
+        }
+        return this.#preloading;
+    }
+    /**
+     * Drop this manifest's holds on everything it preloaded. Assets shared
+     * with another preloaded manifest stay fully alive for that holder; assets
+     * nobody holds anymore are disposed via their kind's release strategy
+     * (retained media object URLs are revoked, freeing the memory). Consumers
+     * of a fully released source fall back to its network URL.
+     *
+     * Safe in every state: before or without `preload()` it is a no-op, and
+     * calling it while a `preload()` is still in flight drops the holds
+     * without cancelling — when the in-flight load completes unheld, the
+     * registry disposes it immediately (no leak). Afterwards the manifest's
+     * preload state is reset, so a later `preload()` re-acquires from scratch.
+     */
+    release() {
+        const held = this.#heldUrls;
+        this.#heldUrls = new Set();
+        this.#preloading = null;
+        for (const url of held)
+            releaseSource(url);
+        // Drain the old set so an in-flight run's failure rollback (which
+        // captured it) finds nothing left to release.
+        held.clear();
+    }
+    async #preloadAll(options, held) {
+        const kindByUrl = new Map();
+        for (const entry of Object.values(this.#entries)) {
+            for (const source of collectEntrySources(entry)) {
+                if (!kindByUrl.has(source.url))
+                    kindByUrl.set(source.url, source.kind);
+            }
+        }
+        const acquisitions = [];
+        for (const [url, kind] of kindByUrl) {
+            held.add(url);
+            acquisitions.push(acquireSource(url, kind, options));
+        }
+        const outcomes = await Promise.allSettled(acquisitions);
+        const failure = outcomes.find((outcome) => outcome.status === 'rejected');
+        if (failure) {
+            // Roll back every hold of this run — unless release() already
+            // dropped them mid-flight (it drains the captured set).
+            for (const url of held)
+                releaseSource(url);
+            held.clear();
+            throw failure.reason;
+        }
+    }
 }
-var Manifest = class {
-	#entries;
-	#preloading = null;
-	/**
-	* URLs this manifest currently holds in the module-wide registry (each
-	* held at most once — the registry's reference count counts holding
-	* manifests, not preload calls). Replaced wholesale by `release()`: an
-	* in-flight preload run keeps operating on the set object it captured, so
-	* a release during the run (which drains that set) turns the run's own
-	* failure rollback into a no-op instead of a double release.
-	*/
-	#heldUrls = /* @__PURE__ */ new Set();
-	constructor(entries) {
-		for (const key of Object.keys(entries)) if (key in this) throw new Error(`Manifest entry id "${key}" collides with a Manifest member.`);
-		Object.assign(this, entries);
-		this.#entries = entries;
-	}
-	/**
-	* Fetch every deliverable file of this manifest up front — including the
-	* reference closure, which codegen inlined into the entries — and decode
-	* image-backed entries. Options are namespaced per asset kind, mirroring
-	* `plugins.<type>` in the config: `{ image: { decode: false } }`
-	* skips decoding for image entries only; slices keep decoding unless
-	* `slice: { decode: false }` is passed too. An option applies to every
-	* entry of its kind, inlined reference entries included.
-	*
-	* Idempotent and concurrent-safe: one in-flight promise per manifest; a
-	* second call joins it (or resolves immediately once done), and URLs shared
-	* by several entries are fetched once. Sharing goes further than this
-	* manifest: every URL is acquired through the module-wide refcounted
-	* registry, so a URL another manifest already preloaded (or is preloading)
-	* is never fetched again — this manifest just takes a hold on it. A failed
-	* preload rolls back this manifest's holds and clears the in-flight state
-	* so it can be retried. A joined call's options are ignored: options apply
-	* per preload run (the first call after construction or `release()`).
-	*/
-	preload(options = {}) {
-		if (!this.#preloading) {
-			const tracked = this.#preloadAll(options, this.#heldUrls).catch((cause) => {
-				if (this.#preloading === tracked) this.#preloading = null;
-				throw cause;
-			});
-			this.#preloading = tracked;
-		}
-		return this.#preloading;
-	}
-	/**
-	* Drop this manifest's holds on everything it preloaded. Assets shared
-	* with another preloaded manifest stay fully alive for that holder; assets
-	* nobody holds anymore are disposed via their kind's release strategy
-	* (retained media object URLs are revoked, freeing the memory). Consumers
-	* of a fully released source fall back to its network URL.
-	*
-	* Safe in every state: before or without `preload()` it is a no-op, and
-	* calling it while a `preload()` is still in flight drops the holds
-	* without cancelling — when the in-flight load completes unheld, the
-	* registry disposes it immediately (no leak). Afterwards the manifest's
-	* preload state is reset, so a later `preload()` re-acquires from scratch.
-	*/
-	release() {
-		const held = this.#heldUrls;
-		this.#heldUrls = /* @__PURE__ */ new Set();
-		this.#preloading = null;
-		for (const url of held) releaseSource(url);
-		held.clear();
-	}
-	async #preloadAll(options, held) {
-		const kindByUrl = /* @__PURE__ */ new Map();
-		for (const entry of Object.values(this.#entries)) for (const source of collectEntrySources(entry)) if (!kindByUrl.has(source.url)) kindByUrl.set(source.url, source.kind);
-		const acquisitions = [];
-		for (const [url, kind] of kindByUrl) {
-			held.add(url);
-			acquisitions.push(acquireSource(url, kind, options));
-		}
-		const failure = (await Promise.allSettled(acquisitions)).find((outcome) => outcome.status === "rejected");
-		if (failure) {
-			for (const url of held) releaseSource(url);
-			held.clear();
-			throw failure.reason;
-		}
-	}
-};
 /**
-* Construct a manifest whose entries are direct readonly properties:
-* `mainCatalog.navigationPanel` is fully typed, and a typo is a compile error.
-*/
-function createManifest(entries) {
-	return new Manifest(entries);
+ * Construct a manifest whose entries are direct readonly properties:
+ * `mainCatalog.navigationPanel` is fully typed, and a typo is a compile error.
+ */
+export function createManifest(entries) {
+    return new Manifest(entries);
 }
-//#endregion
-export { Manifest, collectEntrySources, createManifest };

package/dist/runtime/observe-border-box-size.d.ts

@@ -1,5 +1,2 @@
-//#region src/observe-border-box-size.d.ts
 /** Observe an element's layout border-box size in whole CSS pixels. */
-declare function observeBorderBoxSize(element: HTMLElement, onSize: (width: number, height: number) => void): () => void;
-//#endregion
-export { observeBorderBoxSize };
+export declare function observeBorderBoxSize(element: HTMLElement, onSize: (width: number, height: number) => void): () => void;

package/dist/runtime/observe-border-box-size.js

@@ -1,12 +1,11 @@
-//#region src/observe-border-box-size.ts
 /** Observe an element's layout border-box size in whole CSS pixels. */
-function observeBorderBoxSize(element, onSize) {
-	const observer = new ResizeObserver((entries) => {
-		const size = entries[0]?.borderBoxSize?.[0];
-		onSize(Math.round(size?.inlineSize ?? element.offsetWidth), Math.round(size?.blockSize ?? element.offsetHeight));
-	});
-	observer.observe(element);
-	return () => observer.disconnect();
+export function observeBorderBoxSize(element, onSize) {
+    const observer = new ResizeObserver((entries) => {
+        // Measure layout, not getBoundingClientRect(): transforms must not freeze
+        // render geometry after an animation because they do not retrigger resize.
+        const size = entries[0]?.borderBoxSize?.[0];
+        onSize(Math.round(size?.inlineSize ?? element.offsetWidth), Math.round(size?.blockSize ?? element.offsetHeight));
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
 }
-//#endregion
-export { observeBorderBoxSize };