@embedpdf/angular 3.0.0-next.14 → 3.0.0-next.15

package/dist/fesm2022/embedpdf-angular-runtime.mjs

@@ -1,150 +1,420 @@
-import { createKernel, docInfoListEquals } from '@embedpdf/core';
+import { mergeSettings, viewerSettingsOf, VIEWER_WHOLE_SETTINGS, VIEWER_DEFAULTS, shallowEqual, DocumentsToken, PluginError, isLocalEngine, createKernel, isPluginError, returnsPromise, isReadMember, documentsState, documentState } from '@embedpdf/core';
 export * from '@embedpdf/core';
+import { browserClock, pageClientSpace, pageLayersOf, createFontMounts, epdfThemeVariables } from '@embedpdf/web';
+export { mountWebFont, saveFile } from '@embedpdf/web';
 import * as i0 from '@angular/core';
-import { inject, PLATFORM_ID, signal, computed, Injectable, makeEnvironmentProviders, InjectionToken, input, forwardRef, Directive, ViewContainerRef, TemplateRef, effect, ChangeDetectionStrategy, Component } from '@angular/core';
+import { InjectionToken, signal, computed, inject, Injector, PLATFORM_ID, DestroyRef, untracked, runInInjectionContext, Injectable, effect, input, forwardRef, Directive, TemplateRef, ViewContainerRef, ChangeDetectorRef, afterNextRender, ElementRef, ChangeDetectionStrategy, Component, isDevMode } from '@angular/core';
 import { isPlatformBrowser } from '@angular/common';
+import { Observable } from 'rxjs';
 
 /**
- * The kernel host — one service owns the kernel; ONE tick signal bridges the
- * kernel's single change stream into Angular's signal graph. Everything else in
- * this adapter is `computed()` over it (`value()` is Angular's `useKernelValue`).
+ * The adapter's numbered errors, written like Angular's own (`NG0201`): a code, what went wrong,
+ * how to fix it, and the page that explains it. A code keeps its meaning once it ships, so a
+ * search for `EPDF-101` always finds the right answer.
  *
- * Two hosting modes share this class:
- *   component-hosted  `<epdf-viewer [engine] [plugins]>`  (framework parity)
- *   provider-hosted   `provideEmbedPdf({...})` at route/app level
+ * Errors about the document (no document open yet, a permission missing) are the plugins'
+ * `PluginError`s, the same in every framework; these are only about how the app set up the
+ * adapter.
+ */
+const ERRORS_PAGE = 'https://www.embedpdf.com/docs/headless/angular/errors';
+/** A setup mistake, with its code: `EPDF-101`. */
+class EpdfError extends Error {
+    code;
+    name = 'EpdfError';
+    constructor(code, problem) {
+        super(`${code}: ${problem} See ${ERRORS_PAGE}#${code.toLowerCase()}`);
+        this.code = code;
+    }
+}
+/** EPDF-101: a service, component or directive of the viewer, with no viewer above it. */
+const noViewerError = (what) => new EpdfError('EPDF-101', `${what} found no viewer. Add provideEmbedPdf() to this component's providers, or to your app config.`);
+/** EPDF-102: a plugin's service, where no viewer above it has that plugin. */
+const noPluginError = (service, feature) => new EpdfError('EPDF-102', `inject(${service}) found no viewer with its plugin. Add ${feature} to provideEmbedPdf() ` +
+    `in this component's providers, or in your app config.`);
+/** EPDF-103: something that draws on a page, outside a page. */
+const outsidePageError = (what) => new EpdfError('EPDF-103', `${what} draws on a page. Put it inside <ng-template epdfPage> in an <epdf-stage>.`);
+/** EPDF-104: part of a Stage, outside one. */
+const outsideStageError = (what) => new EpdfError('EPDF-104', `${what} belongs to a Stage. Put it inside <epdf-stage>.`);
+/** EPDF-105: a call that needs the engine, made while rendering on the server. */
+const onServerError = (what) => new EpdfError('EPDF-105', `${what} needs the engine, which runs in the browser only. Call it from an event or ` +
+    `afterNextRender(), or put the viewer in a @defer block.`);
+
+/**
+ * The DI tokens the runtime's pieces share, in a file of their own so the pieces that provide
+ * them and the ones that read them never import each other.
+ */
+const EPDF_DOCUMENT_SCOPE = new InjectionToken('EPDF_DOCUMENT_SCOPE');
+const EPDF_SETUP = new InjectionToken('EPDF_SETUP');
+
+/**
+ * Settings before the kernel exists. With an engine that loads lazily, the app can read and
+ * change a plugin's settings (and the viewer's) before the kernel is there to keep them. This
+ * keeps the changes in order, shows what they add up to, and hands them to the kernel when it
+ * arrives, so `settings()` and `updateSettings()` work from the first moment, as they do in
+ * every other framework.
  *
- * CONSTRUCTION RULE (library law): nothing may read `host.kernel` while a
- * component is being CONSTRUCTED. Component-hosted configs resolve their inputs
- * lazily, so the kernel materializes on first real read (a template binding, an
- * effect) — after inputs are set. Every inject* primitive returns signals or
- * lazy methods and therefore respects this for free; only the raw
- * `injectKernel()` escape hatch can violate it (its doc says so).
+ * The merge is the kernel's own (`mergeSettings` from `@embedpdf/core`), so the settings shown
+ * before the kernel exists are the ones it then has.
+ */
+/** One settings store's changes, kept until the kernel takes them. */
+class SettingsBeforeStart {
+    changes = signal([], ...(ngDevMode ? [{ debugName: "changes" }] : []));
+    /** The settings the changes add up to, over what the app registered. */
+    current;
+    constructor(declaration) {
+        const registered = mergeSettings(declaration.defaults, declaration.registered, declaration.whole);
+        this.current = computed(() => this.changes().reduce((settings, change) => change === 'reset' ? registered : mergeSettings(settings, change, declaration.whole), registered), ...(ngDevMode ? [{ debugName: "current" }] : []));
+    }
+    update(change) {
+        this.changes.update((changes) => [...changes, change]);
+    }
+    reset() {
+        this.changes.update((changes) => [...changes, 'reset']);
+    }
+    /** Hand the changes to the kernel's store, in order, and forget them. */
+    applyTo(store) {
+        for (const change of this.changes()) {
+            if (change === 'reset')
+                store.resetSettings();
+            else
+                store.updateSettings(change);
+        }
+        this.changes.set([]);
+    }
+}
+
+/**
+ * The viewer behind `provideEmbedPdf()`: one per injector that provides it. In the browser it
+ * creates the kernel as soon as the engine is there (at once for an engine instance, later for a
+ * factory that loads one), starts it, opens the initial documents, runs the features' `setup`,
+ * and destroys it all with the injector. Given a kernel (`provideEmbedPdf({ kernel })`), it uses
+ * that one as it is, and leaves starting and destroying it to whoever made it.
+ *
+ * The kernel has one change stream; the host turns each change into a write of `revision`, and
+ * every signal in the adapter is a `computed()` over it (`read()`), which keeps its value, and
+ * wakes nothing, while what it reads is unchanged.
  *
- * SSR CONTRACT: the EmbedPDF subtree is browser-only. On the server the host
- * never boots and any `kernel` read throws — wrap the viewer region in `@defer`
- * (which renders its placeholder on the server) or a platform-guarded `@if`.
+ * On the server the host creates no kernel: every read gives its empty value and a call that
+ * needs the engine throws EPDF-105, so the page around the viewer still renders.
+ */
+/**
+ * The viewer's settings as the config gives them (a setting left out is its default), the same
+ * way every framework's viewer reads its props; what `resetSettings()` goes back to. A kernel
+ * given has its own.
  */
+const registeredViewerSettings = (config) => viewerSettingsOf('kernel' in config ? {} : config);
+/**
+ * Whether `kernel` has a plugin that provides `token`. A document plugin's token has its scope
+ * (any other token reads as a workspace one), and a workspace plugin's capability is there from
+ * the moment the kernel is created.
+ */
+const kernelProvides = (kernel, token) => kernel.scopeOf(token) === 'document' || kernel.tryCapability(token) !== null;
+/** The settings of the plugin that provides `token` in `kernel`, or null when it has none. */
+function kernelSettingsOf(kernel, token) {
+    try {
+        return kernel.settingsOf(token);
+    }
+    catch {
+        // The kernel's answer for a token no plugin provides, or a plugin without settings.
+        return null;
+    }
+}
+/** What the viewer is doing, as a kernel someone else started says it. */
+const statusOfKernel = (status) => status === 'started' ? 'ready' : status === 'failed' ? 'error' : 'starting';
+const isPromiseLike = (value) => typeof value.then === 'function';
 class EpdfKernelHost {
+    setup = inject(EPDF_SETUP);
+    injector = inject(Injector);
+    /** Whether this is a browser. On the server the host creates no kernel. */
     browser = isPlatformBrowser(inject(PLATFORM_ID));
-    config = null;
-    _kernel = null;
-    /** The engine backing the kernel, and whether WE created it (a recipe) and
-     *  therefore must destroy it. A borrowed instance is left untouched. */
-    _engine = null;
+    /** The kernel `provideEmbedPdf({ kernel })` was given: someone else's, used as it is. */
+    given = 'kernel' in this.setup.config ? this.setup.config.kernel : null;
+    /** Every plugin the features register, in their order: none for a kernel given, which has its own. */
+    plugins = this.given
+        ? []
+        : this.setup.features.flatMap((feature) => feature.plugins);
+    kernelState = signal(null, ...(ngDevMode ? [{ debugName: "kernelState" }] : []));
+    revisionState = signal(0, ...(ngDevMode ? [{ debugName: "revisionState" }] : []));
+    statusState = signal('starting', ...(ngDevMode ? [{ debugName: "statusState" }] : []));
+    errorState = signal(null, ...(ngDevMode ? [{ debugName: "errorState" }] : []));
+    listeners = new Set();
+    viewerSettingsBeforeStart = new SettingsBeforeStart({
+        defaults: VIEWER_DEFAULTS,
+        registered: registeredViewerSettings(this.setup.config),
+        whole: VIEWER_WHOLE_SETTINGS,
+    });
+    pluginSettings = new Map();
+    pluginSettingsBeforeStart = new Map();
+    engine = null;
     ownsEngine = false;
-    unsubscribe = null;
-    initialDocuments;
-    booted = false;
+    stopListening = null;
     destroyed = false;
-    /** Bumped on every kernel notification — THE bridge from kernel-world to signals. */
-    tick = signal(0, ...(ngDevMode ? [{ debugName: "tick" }] : []));
-    /** Boot lifecycle. `ready`/`error` are derived sugar over it. */
-    status = signal('starting', ...(ngDevMode ? [{ debugName: "status" }] : []));
-    /** The STARTUP failure, if any. Per-document open failures are tab state
-     *  (`DocInfo.status === 'error'`), not host state. */
-    error = signal(null, ...(ngDevMode ? [{ debugName: "error" }] : []));
-    /** True once `kernel.start()` resolved — which never touches the engine, so
-     *  the shell (and every workspace capability: i18n, view-manager, …) is alive
-     *  while WASM compiles or the transport connects. Workspace chrome may render
-     *  before this; gate on it (or on the document gate) where it matters. */
-    ready = computed(() => this.status() === 'ready', ...(ngDevMode ? [{ debugName: "ready" }] : []));
-    /** Register the (deferred) config. Called exactly once, by `EpdfViewer`'s
-     *  constructor or `provideEmbedPdf`'s factory. */
-    connect(config) {
-        if (this.config || this._kernel) {
-            throw new Error('[embedpdf] kernel already configured for this injector');
-        }
-        this.config = config;
-    }
-    /** The kernel — materialized on first read (see the construction rule above). */
-    get kernel() {
-        if (!this._kernel) {
-            if (!this.browser) {
-                throw new Error('[embedpdf] the viewer does not render on the server — wrap the EmbedPDF subtree in @defer (its placeholder renders during SSR) or a browser-only @if');
-            }
-            if (!this.config) {
-                throw new Error('[embedpdf] no kernel: wrap this subtree in <epdf-viewer> or add provideEmbedPdf(...) to your providers');
-            }
-            const { engine, plugins, initialDocuments } = this.config();
-            // A thunk is host-owned: call it now, destroy on teardown. An instance is
-            // borrowed and left untouched. Either way construction is synchronous and
-            // inert (engines boot lazily on first use).
-            this.ownsEngine = typeof engine === 'function';
-            this._engine = this.ownsEngine ? engine() : engine;
-            try {
-                this._kernel = createKernel({ engine: this._engine, plugins });
-            }
-            catch (error) {
-                // ngOnDestroy() only tears down via `_kernel`, which stays null on this
-                // path — so an owned engine must be destroyed HERE or it leaks.
-                if (this.ownsEngine)
-                    void this._engine.destroy();
-                this._engine = null;
-                this.ownsEngine = false;
-                throw error;
-            }
-            // Warm up only once the kernel exists (a plugin-planning throw must not
-            // start a boot we'd immediately have to unwind) — `warmup()` overlaps the
-            // WASM/transport boot with the rest of initialization.
-            this._engine.warmup?.();
-            this.initialDocuments = initialDocuments;
-            this.unsubscribe = this._kernel.subscribe(() => this.tick.update((n) => n + 1));
-        }
-        return this._kernel;
-    }
-    /** Start the kernel and open initial documents in the background. Idempotent;
-     *  a no-op on the server and after destroy. */
-    boot() {
-        if (this.booted || this.destroyed || !this.browser)
+    /**
+     * The kernel, once it exists: null while a lazily loaded engine is on its way, and on the
+     * server, where only a kernel given is there.
+     */
+    kernel = this.kernelState.asReadonly();
+    /** Goes up on every change of the kernel's state. */
+    revision = this.revisionState.asReadonly();
+    /** A kernel given says it itself: someone else starts it. */
+    status = this.given
+        ? this.read((kernel) => statusOfKernel(kernel.status()), () => 'starting')
+        : this.statusState.asReadonly();
+    /** Why the viewer failed to start, when `status()` is `'error'`. */
+    error = this.errorState.asReadonly();
+    /** The viewer's own settings, before the kernel exists and after. */
+    viewerSettings = this.read((kernel) => kernel.getSettings(), () => this.viewerSettingsBeforeStart.current(), shallowEqual);
+    constructor() {
+        inject(DestroyRef).onDestroy(() => this.destroy());
+        const { config } = this.setup;
+        // A kernel given is the kernel, wherever it was made.
+        if ('kernel' in config)
+            this.adopt(config.kernel);
+        if (!this.browser)
             return;
-        this.booted = true;
-        const kernel = this.kernel;
-        void (async () => {
-            try {
-                await kernel.start();
-            }
-            catch (err) {
-                if (!this.destroyed) {
-                    this.error.set(err);
-                    this.status.set('error');
-                }
-                return;
-            }
-            if (this.destroyed)
-                return;
-            this.status.set('ready');
-            // Kernel-owned boot policy: all tabs appear immediately in array order;
-            // the `active` entry (else the first) is selected; per-document
-            // failures surface as that tab's `error`/`locked` status (this host's
-            // `error` signal reports only startup failures).
-            kernel.documents.openAll(this.initialDocuments ?? []);
-        })();
-    }
-    /** Read a value derived from the kernel, cached by equality — Angular's
-     *  `useKernelValue`. The selector re-runs per kernel notification (cheap);
-     *  `equal` decides whether dependents ever see it. */
-    value(select, equal = Object.is) {
+        if (!('kernel' in config))
+            this.start(config);
+        // After construction, because a feature's setup injects services, and they inject this host.
+        queueMicrotask(() => this.runFeatureSetups());
+    }
+    /**
+     * A value read from the kernel, as a signal: `select` runs again after each change of the
+     * kernel's state, and the signal changes only when `equal` says the value did. `empty` is its
+     * value while there is no kernel.
+     */
+    read(select, empty, equal = Object.is) {
         return computed(() => {
-            this.tick();
-            return select(this.kernel);
+            this.revisionState();
+            const kernel = this.kernelState();
+            return kernel ? select(kernel) : empty();
         }, { equal });
     }
-    ngOnDestroy() {
+    /** Call `listener` after each change of the kernel's state, and once when the kernel arrives. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    /**
+     * An event of the kernel itself (its settings, a plugin's settings store), as an RxJS
+     * stream. A subscription made before the kernel exists starts listening when it arrives.
+     */
+    stream(pick) {
+        return new Observable((subscriber) => {
+            let listening = null;
+            const listen = () => {
+                const kernel = untracked(this.kernelState);
+                if (!kernel || listening)
+                    return;
+                listening = new AbortController();
+                pick(kernel)((event) => subscriber.next(event), { signal: listening.signal });
+            };
+            const stop = this.subscribe(listen);
+            listen();
+            return () => {
+                stop();
+                listening?.abort();
+            };
+        });
+    }
+    /** Whether a plugin of this viewer provides `token` (the documents are always there). */
+    provides(token) {
+        if (token === DocumentsToken)
+            return true;
+        return this.given ? kernelProvides(this.given, token) : this.pluginFor(token) !== null;
+    }
+    /** Whether the plugin of this viewer that provides `token` has settings. */
+    hasSettings(token) {
+        return this.given
+            ? kernelSettingsOf(this.given, token) !== null
+            : Boolean(this.pluginFor(token)?.settings);
+    }
+    /**
+     * The kernel, for `call` (`'zoomIn()'`) on `capability` (`'stage'`), which needs it now:
+     * `not-ready` while the engine is still on its way, EPDF-105 on the server.
+     */
+    requireKernel(capability, call) {
+        const kernel = this.kernelState();
+        if (kernel)
+            return kernel;
+        if (!this.browser)
+            throw onServerError(call);
+        throw new PluginError('not-ready', capability, 'the viewer is still starting');
+    }
+    updateViewerSettings(change) {
+        const kernel = this.kernelState();
+        if (kernel)
+            kernel.updateSettings(change);
+        else
+            this.viewerSettingsBeforeStart.update(change);
+    }
+    resetViewerSettings() {
+        const kernel = this.kernelState();
+        if (kernel)
+            kernel.resetSettings();
+        else
+            this.viewerSettingsBeforeStart.reset();
+    }
+    /**
+     * A plugin's settings, with or without a document, and before the kernel too: they belong to
+     * the plugin as the app registered it. One binding per plugin, shared by every service.
+     */
+    settingsOf(token) {
+        const known = this.pluginSettings.get(token);
+        if (known)
+            return known;
+        const binding = this.given
+            ? this.givenSettingsOf(this.given, token)
+            : this.registeredSettingsOf(token);
+        this.pluginSettings.set(token, binding);
+        return binding;
+    }
+    /** A registered plugin's settings, kept from before the kernel exists. */
+    registeredSettingsOf(token) {
+        const plugin = this.pluginFor(token);
+        const declaration = plugin?.settings;
+        if (!plugin || !declaration) {
+            throw new PluginError('unsupported', token.name, 'this plugin has no settings');
+        }
+        const before = new SettingsBeforeStart(declaration);
+        this.pluginSettingsBeforeStart.set(plugin, before);
+        const store = (kernel) => kernel.settingsOf(token);
+        return {
+            current: this.read((kernel) => store(kernel).getSettings(), () => before.current(), shallowEqual),
+            update: (change) => {
+                const kernel = this.kernelState();
+                if (kernel)
+                    store(kernel).updateSettings(change);
+                else
+                    before.update(change);
+            },
+            reset: () => {
+                const kernel = this.kernelState();
+                if (kernel)
+                    store(kernel).resetSettings();
+                else
+                    before.reset();
+            },
+        };
+    }
+    /** A plugin's settings in a kernel given, which is there from the start. */
+    givenSettingsOf(kernel, token) {
+        const store = kernelSettingsOf(kernel, token);
+        if (!store)
+            throw new PluginError('unsupported', token.name, 'this plugin has no settings');
+        const current = () => store.getSettings();
+        return {
+            current: this.read(current, current, shallowEqual),
+            update: (change) => store.updateSettings(change),
+            reset: () => store.resetSettings(),
+        };
+    }
+    pluginFor(token) {
+        return this.plugins.find((plugin) => plugin.token === token) ?? null;
+    }
+    // ── lifetime ────────────────────────────────────────────────────────────────
+    /** Follow a kernel someone else made: its changes, and nothing of its lifetime. */
+    adopt(kernel) {
+        this.stopListening = kernel.subscribe(() => this.changed());
+        this.kernelState.set(kernel);
+        this.changed();
+    }
+    start(config) {
+        const source = config.engine;
+        const owned = typeof source === 'function';
+        let made;
+        try {
+            made = owned ? source() : source;
+        }
+        catch (error) {
+            this.fail(error);
+            return;
+        }
+        if (isPromiseLike(made)) {
+            made.then((engine) => this.attach(config, engine, owned), (error) => this.fail(error));
+        }
+        else {
+            this.attach(config, made, owned);
+        }
+    }
+    /** Create and start the kernel over `engine`. An engine this viewer made is destroyed with it. */
+    attach(config, engine, owned) {
+        if (this.destroyed) {
+            if (owned)
+                void engine.destroy();
+            return;
+        }
+        // Warming a local engine up now overlaps its WebAssembly boot with the plugins' setup.
+        if (isLocalEngine(engine))
+            engine.warmup();
+        let kernel;
+        try {
+            kernel = createKernel({
+                engine,
+                plugins: [...this.plugins],
+                settings: registeredViewerSettings(config),
+                clock: browserClock(),
+            });
+        }
+        catch (error) {
+            if (owned)
+                void engine.destroy();
+            this.fail(error);
+            return;
+        }
+        this.engine = engine;
+        this.ownsEngine = owned;
+        this.viewerSettingsBeforeStart.applyTo(kernel);
+        for (const [plugin, before] of this.pluginSettingsBeforeStart) {
+            before.applyTo(kernel.settingsOf(plugin.token));
+        }
+        this.stopListening = kernel.subscribe(() => this.changed());
+        this.kernelState.set(kernel);
+        this.changed();
+        kernel.start().then(() => {
+            if (this.destroyed)
+                return;
+            this.statusState.set('ready');
+            // Every tab appears at once, in order; a document that fails shows it in its own tab.
+            kernel.documents.openAll(config.initialDocuments ?? []);
+        }, (error) => {
+            if (!this.destroyed)
+                this.fail(error);
+        });
+    }
+    changed() {
+        this.revisionState.update((revision) => revision + 1);
+        for (const listener of [...this.listeners])
+            listener();
+    }
+    fail(error) {
+        this.errorState.set(error);
+        this.statusState.set('error');
+        console.error('[embedpdf] the viewer failed to start', error);
+    }
+    runFeatureSetups() {
+        if (this.destroyed)
+            return;
+        for (const feature of this.setup.features) {
+            if (feature.setup)
+                runInInjectionContext(this.injector, feature.setup);
+        }
+    }
+    destroy() {
         if (this.destroyed)
             return;
         this.destroyed = true;
-        this.unsubscribe?.();
-        // destroy() owns the full teardown now: it joins an in-flight start, closes
-        // every document (engine handles included), and unwinds workspace plugins.
-        // Async + idempotent, so fire-and-forget is safe in a sync ngOnDestroy.
-        // Then destroy the engine IF we own it (a thunk) — kernel first so handles
-        // close before the engine goes; `engine.destroy()` joins any in-flight
-        // boot or no-ops if it never started.
-        if (this._kernel) {
-            const engine = this._engine;
-            const owns = this.ownsEngine;
-            void this._kernel.destroy().then(() => {
-                if (owns && engine)
+        this.stopListening?.();
+        this.listeners.clear();
+        // A kernel given is its maker's to destroy.
+        if (this.given)
+            return;
+        const kernel = this.kernelState();
+        const engine = this.engine;
+        const owned = this.ownsEngine;
+        // The kernel first, which closes every document's engine handle, then the engine it ran on.
+        if (kernel) {
+            void kernel.destroy().then(() => {
+                if (owned && engine)
                     void engine.destroy();
             });
         }
@@ -154,349 +424,836 @@ class EpdfKernelHost {
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfKernelHost, decorators: [{
             type: Injectable
-        }] });
-/**
- * Host the kernel in an environment injector (route or application providers).
- * The kernel's lifetime is the injector's — a route-level workspace tears down
- * when the route does. Unlocks chrome OUTSIDE any viewer subtree: a toolbar in
- * the app header and the stage in the main outlet share this one kernel.
- */
-function provideEmbedPdf(config) {
-    return makeEnvironmentProviders([
-        {
-            provide: EpdfKernelHost,
-            useFactory: () => {
-                const host = new EpdfKernelHost();
-                host.connect(() => config);
-                host.boot();
-                return host;
-            },
-        },
-    ]);
-}
-
-/**
- * DI tokens shared by the runtime's primitives and directives — split out so
- * `inject.ts` (consumers) and `scope.ts` (providers) never import each other.
- */
-const EPDF_DOCUMENT_SCOPE = new InjectionToken('EPDF_DOCUMENT_SCOPE');
+        }], ctorParameters: () => [] });
 
 /**
- * The inject* primitives — Angular's spelling of the React runtime hooks
- * (`use*` → `inject*`, plain values → signals, same names otherwise).
+ * How the adapter reaches a plugin: its capability token, resolved for one document (the one in
+ * scope, else the active one) after every change of the kernel. A `CapabilityBinding` turns that
+ * into what Angular code wants: signals for values, late-bound methods for calls, and RxJS
+ * streams for events. Services, the Stage and the page layers are all built on it.
  *
- * All of them must run in an injection context (a constructor / field
- * initializer, like `inject()` itself). None of them read `host.kernel` during
- * construction — they return signals or lazy methods, so they are safe in
- * component-hosted mode where the kernel materializes after construction.
+ * Resolution is a read, not a cache: a document becomes resolvable when it's ready, while its
+ * id stays the same, so a capability looked up once by id would go stale.
  */
-const shallowArray = (a, b) => a === b || (a.length === b.length && a.every((x, i) => x === b[i]));
-function injectKernelHost() {
+/** The viewer above this injection context; EPDF-101, naming `what`, when there is none. */
+function injectKernelHost(what) {
     const host = inject(EpdfKernelHost, { optional: true });
-    if (!host) {
-        throw new Error('[embedpdf] no kernel: wrap this subtree in <epdf-viewer> or add provideEmbedPdf(...) to your providers');
-    }
+    if (!host)
+        throw noViewerError(what);
     return host;
 }
-/** The raw kernel — materializes it immediately. Do NOT call while a component
- *  is being constructed in component-hosted mode (inputs are not set yet);
- *  prefer the signal-returning primitives, which defer the first kernel read. */
-function injectKernel() {
-    return injectKernelHost().kernel;
-}
-/** Read a value derived from the kernel, cached by equality — `useKernelValue`. */
-function injectKernelValue(select, equal) {
-    return injectKernelHost().value(select, equal);
+const FOLLOW_ACTIVE = signal(null).asReadonly();
+/**
+ * The document this injection context talks to: the id the nearest `[epdfDocumentScope]` (or a
+ * Stage with a `[document]`) gives, or null to follow the active document.
+ */
+function injectDocumentScope() {
+    return inject(EPDF_DOCUMENT_SCOPE, { optional: true })?.id ?? FOLLOW_ACTIVE;
 }
-function injectActiveDocumentId() {
-    return injectKernelValue((k) => k.documents.activeId());
+/**
+ * A plugin's capability for this injection context's document, as a signal: null while it
+ * can't resolve (no such plugin, no document, or one that isn't ready yet). For plugin authors;
+ * apps use a plugin's service (`inject(EpdfSearch)`). Call it in an injection context.
+ */
+function injectCapability(token) {
+    const binding = new CapabilityBinding(injectKernelHost(`injectCapability(${token.name})`), () => token, injectDocumentScope());
+    return binding.capability;
 }
-/** The document id for this injector subtree: the nearest `[epdfDocumentScope]`,
- *  else the active document. */
-function injectDocumentId() {
-    const scope = inject(EPDF_DOCUMENT_SCOPE, { optional: true });
-    const active = injectActiveDocumentId();
-    return computed(() => scope?.id() ?? active());
+/** One capability token, for one document, as signals, calls and streams. */
+class CapabilityBinding {
+    host;
+    token;
+    documentId;
+    /** The capability, or null while it can't resolve. */
+    capability;
+    /**
+     * @param token the token to resolve; a function, because a component's token is an input
+     * @param documentId the document to resolve it for, or null for the active one
+     */
+    constructor(host, token, documentId) {
+        this.host = host;
+        this.token = token;
+        this.documentId = documentId;
+        this.capability = host.read((kernel) => this.resolve(kernel), () => null);
+    }
+    /**
+     * A value read through the capability, as a signal that changes only when `equal` says the
+     * value did. `empty` while the capability can't resolve, and for the one read that can land
+     * between a document closing and its capability going away.
+     */
+    select(read, empty, equal = shallowEqual) {
+        return this.host.read((kernel) => {
+            const capability = this.resolve(kernel);
+            if (!capability)
+                return empty;
+            try {
+                return read(capability);
+            }
+            catch {
+                return empty;
+            }
+        }, () => empty, equal);
+    }
+    /**
+     * The capability, for `call`, which needs it now. Without a document a document plugin
+     * refuses with `not-ready` ("no document is open"), the same refusal every framework's
+     * stand-in gives (`standInFor` in `@embedpdf/core`); a token no plugin provides throws the
+     * kernel's reason, because that is a setup mistake.
+     */
+    require(call) {
+        const token = this.token();
+        const kernel = this.host.requireKernel(token.name, call);
+        const documentId = untracked(this.documentId) ?? undefined;
+        const capability = kernel.tryCapability(token, documentId);
+        if (capability)
+            return capability;
+        if (kernel.scopeOf(token) === 'document') {
+            throw new PluginError('not-ready', token.name, 'no document is open');
+        }
+        return kernel.capability(token, documentId);
+    }
+    /**
+     * The capability's method `name`, looked up when it's called, so a method kept in a field
+     * acts on the document current at that moment. The same function for the binding's lifetime.
+     *
+     * A read (a method named `get*`, `list*`, `is*`, `has*` or `can*`: `canUpdate()`,
+     * `getZoomLevel()`) is state too: called in a template, a `computed()` or an `effect()`, it's
+     * read again after each change of the kernel and of the document in scope, and wakes its
+     * reader only when its answer changes. So a button it disables follows the selection, the
+     * active document and its permissions. Other methods track nothing: an `effect()` that calls a
+     * verb doesn't run again because the verb changed the document.
+     *
+     * Without a document a method refuses with `not-ready`: one that returns a promise (the token's
+     * `promises`) returns the refusal as a rejected promise, so `.catch()` sees it; others throw.
+     */
+    method(name) {
+        return this.late(String(name), (capability) => capability, name);
+    }
+    /**
+     * The method `name` of the capability's namespace `namespace` (`custom.update()`), late-bound
+     * the way {@link method} is. A service gives a namespace an object of its own
+     * (`metadata.custom`), built from these, {@link select} and {@link stream}.
+     */
+    namespaceMethod(namespace, name) {
+        return this.late(`${String(namespace)}.${String(name)}`, (capability) => capability[namespace], name);
+    }
+    /**
+     * One of the capability's events, as an RxJS stream. A subscription follows the document:
+     * when it changes (another tab, a document that opens or closes), it moves to the new
+     * document's capability. Nothing is emitted while there is none.
+     */
+    stream(pick) {
+        return new Observable((subscriber) => {
+            let current = null;
+            let listening = null;
+            const follow = () => {
+                const kernel = untracked(this.host.kernel);
+                const next = kernel ? untracked(() => this.resolve(kernel)) : null;
+                if (next === current)
+                    return;
+                listening?.abort();
+                listening = null;
+                current = next;
+                if (!next)
+                    return;
+                listening = new AbortController();
+                pick(next)((event) => subscriber.next(event), { signal: listening.signal });
+            };
+            const stop = this.host.subscribe(follow);
+            follow();
+            return () => {
+                stop();
+                listening?.abort();
+            };
+        });
+    }
+    resolve(kernel) {
+        return kernel.tryCapability(this.token(), this.documentId() ?? undefined);
+    }
+    /** `owner(capability)[name]`, looked up when called; a read tracks what its answer reads. */
+    late(label, owner, name) {
+        const call = `${label}()`;
+        const run = (args) => {
+            let target;
+            try {
+                target = owner(this.require(call));
+            }
+            catch (error) {
+                // Not ready: a method that returns a promise rejects, as the capability would.
+                if (isPluginError(error, 'not-ready') && returnsPromise(this.token(), label)) {
+                    return Promise.reject(error);
+                }
+                throw error;
+            }
+            return target[name].apply(target, args);
+        };
+        if (!isReadMember(String(name))) {
+            return ((...args) => untracked(() => run(args)));
+        }
+        // A computed of its own for each call: whoever reads the check depends on its answer, not
+        // on every change of the kernel. Outside a reactive context it's one plain call.
+        return ((...args) => computed(() => {
+            this.documentId();
+            this.host.revision();
+            return run(args);
+        })());
+    }
 }
+
 /**
- * Resolve a capability against a REACTIVE token — for components that take the
- * token as an input (`injectCapability` is the fixed-token sugar). Resolution
- * is a REACTIVE read (`tryCapability` through the kernel's one change
- * stream), not a computed over the document id — under the request-time
- * lifecycle a document can become resolvable while its id stays the same, so
- * any id-keyed cache goes stale; subscribing makes staleness structurally
- * impossible. Fail-fast like React's `useCapability`: while unresolvable,
- * this re-runs the strict resolver so the kernel's truthful reason (`no
- * capability` / `no document` / `document is loading|locked`) is what throws.
- */
-function injectCapabilityFor(token) {
-    const host = injectKernelHost();
-    const scope = inject(EPDF_DOCUMENT_SCOPE, { optional: true });
-    const cap = host.value((k) => k.tryCapability(token(), scope?.id() ?? undefined));
-    return computed(() => cap() ?? host.kernel.capability(token(), scope?.id() ?? undefined));
-}
-function injectCapability(token) {
-    return injectCapabilityFor(() => token);
+ * One service per plugin: `inject(EpdfSearch)` has the plugin's methods, every value of its
+ * State table as a signal (`search.hitCount()`), its events as RxJS streams
+ * (`search.completed$`), and, when the plugin has settings, `settings()`, `getSettings()`,
+ * `updateSettings()`, `resetSettings()` and `settingsChanged$`. `pluginService()` builds all of that from what the
+ * plugin declares already, so a plugin's service is a few lines; the package README's "Adding a
+ * plugin binding" shows one.
+ *
+ * A service acts on the document of the injector that created it: under `[epdfDocumentScope]`
+ * that document, else the active one. Its methods are looked up when they're called, so a
+ * method kept in a field acts on the document current at that moment.
+ */
+/**
+ * The base every plugin service extends. Its members are for the service's own class, which
+ * adds what the generic part can't: a signal with arguments (`hitsOn(page)`), a namespace
+ * (`custom.fields()`), a helper that needs the caller's injection context.
+ */
+class EpdfPluginService {
+    /** The plugin's capability for this service's document. */
+    binding;
+    constructor(spec) {
+        const host = inject(EpdfKernelHost, { optional: true });
+        // A plugin's service names its feature, whether the viewer is missing or only the plugin.
+        if (spec.feature && !host?.provides(spec.token))
+            throw noPluginError(spec.name, spec.feature);
+        if (!host)
+            throw noViewerError(`inject(${spec.name})`);
+        this.binding = new CapabilityBinding(host, () => spec.token, injectDocumentScope());
+    }
 }
-/** Like `injectCapabilityFor`, but null while the token can't resolve (no
- *  plugin, no document, or a document that isn't ready yet). */
-function injectOptionalCapabilityFor(token) {
-    const host = injectKernelHost();
-    const scope = inject(EPDF_DOCUMENT_SCOPE, { optional: true });
-    return host.value((k) => k.tryCapability(token(), scope?.id() ?? undefined));
+/**
+ * The base class of a plugin's service, built from the plugin's declarations:
+ *
+ *   @Injectable({ providedIn: 'root' })
+ *   export class EpdfSearch extends pluginService({
+ *     name: 'EpdfSearch',
+ *     feature: 'withSearch()',
+ *     token: SearchToken,
+ *     state: searchState,
+ *     methods: ['search', 'clear', 'goToHit'],
+ *     events: ['onCompleted'],
+ *   }) {}
+ *
+ * `providedIn: 'root'` is only the fallback that turns a missing viewer into EPDF-102: the
+ * service's feature provides it next to the viewer, and `[epdfDocumentScope]` again.
+ */
+function pluginService(spec) {
+    class PluginService extends EpdfPluginService {
+        constructor() {
+            super(spec);
+            const members = this;
+            const binding = this.binding;
+            if (spec.state) {
+                const state = spec.state;
+                // One read of the whole table, compared field by field, then one signal per field: a
+                // template that reads `hitCount()` wakes only when the hit count changes.
+                const whole = binding.select((capability) => state.read(capability), state.empty);
+                for (const field of Object.keys(state.empty)) {
+                    members[field] = computed(() => whole()[field]);
+                }
+            }
+            const ensure = spec.ensure ?? spec.state?.ensure;
+            if (ensure) {
+                effect(() => {
+                    const capability = binding.capability();
+                    // The state says when the load fails (its status), so the rejection has nothing to add.
+                    if (capability)
+                        untracked(() => ensure(capability).catch(() => { }));
+                });
+            }
+            for (const name of spec.methods)
+                members[name] = binding.method(name);
+            for (const event of spec.events ?? []) {
+                const stream = `${event.charAt(2).toLowerCase()}${event.slice(3)}$`;
+                members[stream] = binding.stream((capability) => capability[event]);
+            }
+            // Settings belong to the plugin as the app registered it, not to a document: they work
+            // with no document open, and before the kernel exists.
+            const host = binding.host;
+            if (host.hasSettings(spec.token)) {
+                const settings = host.settingsOf(spec.token);
+                members['settings'] = settings.current;
+                // A read, like every `get*` method: a template or an effect that calls it follows it.
+                members['getSettings'] = () => settings.current();
+                members['updateSettings'] = settings.update;
+                members['resetSettings'] = settings.reset;
+                members['settingsChanged$'] = host.stream((kernel) => kernel.settingsOf(spec.token).onSettingsChanged);
+            }
+        }
+    }
+    return PluginService;
 }
-function injectOptionalCapability(token) {
-    return injectOptionalCapabilityFor(() => token);
+
+/**
+ * The viewer's own services, which `provideEmbedPdf()` always has:
+ *
+ *   inject(EpdfViewer)     the viewer's settings (`identity`, `scope`, `accent`, `page`) and status
+ *   inject(EpdfDocuments)  open, close, unlock and download documents; every tab, as signals
+ *   inject(EpdfDocument)   the document this part of the template talks to, as signals
+ */
+/**
+ * The viewer itself: its settings, and whether it started. The config given to
+ * `provideEmbedPdf()` is read once; what may change while the app runs changes here:
+ *
+ *   effect(() => viewer.updateSettings({ identity: auth.identity() }));
+ *
+ * Documents opened after a change of `identity` or `scope` use the new value; open ones keep
+ * theirs.
+ */
+class EpdfViewer {
+    host = injectKernelHost('inject(EpdfViewer)');
+    /** The viewer's settings: `identity`, `scope`, `accent` and `page`. */
+    settings = this.host.viewerSettings;
+    /** `'starting'`, `'ready'`, or `'error'` when the engine or a plugin failed to start. */
+    status = this.host.status;
+    /** Why the viewer failed to start, when `status()` is `'error'`. */
+    error = this.host.error;
+    /** Fires once for each call that changed a setting. */
+    settingsChanged$ = this.host.stream((kernel) => kernel.onSettingsChanged);
+    /** Merge `changes` into the viewer's settings: `page` merges, `identity` and `scope` replace. */
+    updateSettings(changes) {
+        this.host.updateViewerSettings(changes);
+    }
+    /** Go back to the settings `provideEmbedPdf()` was given. */
+    resetSettings() {
+        this.host.resetViewerSettings();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfViewer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfViewer, providedIn: 'root' });
 }
-/** Subscribe to a selector over a (document-resolved) capability. */
-function injectSelectorFor(token, select, equal) {
-    const host = injectKernelHost();
-    const cap = injectCapabilityFor(token);
-    return host.value(() => select(cap()), equal);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfViewer, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+/**
+ * The documents: open, close, unlock, retry and download them, and every tab with the active
+ * one as signals (`documents()`, `activeId()`). Under `[epdfDocumentScope]` the calls that
+ * leave out the document use that one: `download()` downloads the document in scope.
+ */
+class EpdfDocuments extends pluginService({
+    name: 'EpdfDocuments',
+    token: DocumentsToken,
+    state: documentsState,
+    methods: [
+        'open',
+        'canOpenFiles',
+        'openAll',
+        'retry',
+        'rename',
+        'unlock',
+        'close',
+        'closeAll',
+        'setActive',
+        'getActiveId',
+        'getActive',
+        'list',
+        'get',
+        'has',
+        'getCount',
+        'getOrder',
+        'setOrder',
+        'move',
+        'swap',
+        'download',
+        'downloadLayer',
+        'canDownload',
+        'canPrint',
+        'listPages',
+        'getPage',
+        'getPageIndex',
+        'getRevision',
+    ],
+    events: [
+        'onOpened',
+        'onOpenFailed',
+        'onLocked',
+        'onClosed',
+        'onActiveChanged',
+        'onPagesChanged',
+        'onUnsavedChangesChanged',
+    ],
+}) {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocuments, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocuments, providedIn: 'root' });
 }
-function injectSelector(token, select, equal) {
-    return injectSelectorFor(() => token, select, equal);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocuments, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+const NO_PAGES = Object.freeze([]);
+/**
+ * The document this part of the template talks to: the one `[epdfDocumentScope]` names, else
+ * the active one. Its fields are signals (`id()`, `name()`, `status()`, `pageCount()`,
+ * `hasUnsavedChanges()`, `passwordProvided()`, `error()`), and `pages()` its pages. With no
+ * document it reads as one still on its way: an empty `id` and `status() === 'loading'`.
+ */
+class EpdfDocument extends pluginService({
+    name: 'EpdfDocument',
+    token: DocumentsToken,
+    state: documentState,
+    methods: [],
+}) {
+    /**
+     * The document's pages, in order: each with its `ref`, `index`, `label`, size and rotation.
+     * Needs no Stage. The same array until a page is added, removed, moved or rotated; empty
+     * with no document.
+     */
+    pages = this.binding.select((documents) => documents.listPages(), NO_PAGES, Object.is);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocument, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocument, providedIn: 'root' });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocument, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const scopedServices = [EpdfDocuments, EpdfDocument];
 /**
- * Null-safe `injectSelector`: `fallback` whenever the token can't resolve — no
- * provider, or a document-scoped token with no document. For chrome that stays
- * mounted across the empty-workspace state (a zoom readout, a mode band).
- * `injectSelector` stays strict (fail-fast) for code that KNOWS a document
- * exists — e.g. anything behind the document gate.
+ * Every service that acts on one document: the viewer's own, and each feature's, added when a
+ * `provideEmbedPdf()` call names the feature. `[epdfDocumentScope]` and a Stage list this array
+ * in their `providers`, so a service injected under them acts on their document.
  *
- * The `select` guard also swallows reads through a capability whose document
- * closed between the store notification and this read — that teardown race
- * resolves to `fallback` for one frame, then recomputes against the new state.
- */
-function injectOptionalSelectorFor(token, select, fallback, equal) {
-    const host = injectKernelHost();
-    const cap = injectOptionalCapabilityFor(token);
-    return host.value(() => {
-        const c = cap();
-        if (c === null)
-            return fallback;
-        try {
-            return select(c);
-        }
-        catch {
-            return fallback;
+ * It is one array that grows, not a copy: Angular reads a directive's providers when its
+ * template is first created, which is after the `provideEmbedPdf()` calls in decorators and the
+ * app config ran. A service whose feature is first named later (a lazily loaded route's
+ * providers) is still provided by its viewer, and acts on the active document there.
+ */
+const EPDF_SCOPED_SERVICES = scopedServices;
+/** The viewer, with the plugins its features register; or the viewer of a kernel given. */
+function provideEmbedPdf(config, ...features) {
+    for (const feature of features) {
+        for (const service of feature.services ?? []) {
+            if (!scopedServices.includes(service))
+                scopedServices.push(service);
         }
-    }, equal);
-}
-function injectOptionalSelector(token, select, fallback, equal) {
-    return injectOptionalSelectorFor(() => token, select, fallback, equal);
-}
-function injectDocuments() {
-    const host = injectKernelHost();
-    return {
-        docs: host.value((k) => k.documents.list(), docInfoListEquals),
-        activeId: host.value((k) => k.documents.activeId()),
-        open: (input, options) => host.kernel.documents.open(input, options),
-        unlock: (id, input) => host.kernel.documents.unlock(id, input),
-        close: (id) => host.kernel.documents.close(id),
-        setActive: (id) => host.kernel.documents.setActive(id),
-        move: (id, toIndex) => host.kernel.documents.move(id, toIndex),
-        swap: (a, b) => host.kernel.documents.swap(a, b),
-        download: (id, opts) => host.kernel.documents.download(id, opts),
-        downloadLayer: (id) => host.kernel.documents.downloadLayer(id),
-    };
+    }
+    const setup = { config, features };
+    return [
+        { provide: EPDF_SETUP, useValue: setup },
+        EpdfKernelHost,
+        EpdfViewer,
+        EpdfDocuments,
+        EpdfDocument,
+        ...features.flatMap((feature) => [...(feature.services ?? []), ...(feature.providers ?? [])]),
+    ];
 }
 
 /**
- * Document scoping — hierarchical DI is Angular's native React-context.
+ * Which document a part of the template talks to, and whether it has one:
  *
- * `[epdfDocumentScope]` binds a subtree to a SPECIFIC document (panes,
- * comparison); `*epdfDocumentGate` renders a subtree only WHILE it has one.
- * The gate is a structural directive on purpose: a template genuinely defers
- * creation, which a conditional `<ng-content>` slot cannot (Angular
- * instantiates projected content eagerly). Document-scoped UI — the Stage,
- * zoom/page controls, panels — belongs behind it (or behind the app's own
- * `@if (documentId())`); workspace chrome lives outside it.
+ *   <div [epdfDocumentScope]="id">       everything inside talks to that document
+ *   <epdf-stage *epdfDocumentGate="let document; fallback: opening; locked: locked; error: failed">
+ *
+ * The gate is a structural directive on purpose: a template really defers creating what's
+ * inside, which a conditional `<ng-content>` can't (Angular creates projected content whether
+ * or not it's shown). Document UI (the Stage, a page counter) goes behind it; workspace UI (a
+ * toolbar frame, an open button) stays outside and renders at once.
+ */
+/**
+ * Binds everything inside the element to one document: services injected there, the Stage
+ * and its layers act on it instead of the active document.
  */
 class EpdfDocumentScope {
+    /** The document's id. */
     id = input.required(...(ngDevMode ? [{ debugName: "id", alias: 'epdfDocumentScope' }] : [{ alias: 'epdfDocumentScope' }]));
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocumentScope, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.2.4", type: EpdfDocumentScope, isStandalone: true, selector: "[epdfDocumentScope]", inputs: { id: { classPropertyName: "id", publicName: "epdfDocumentScope", isSignal: true, isRequired: true, transformFunction: null } }, providers: [{ provide: EPDF_DOCUMENT_SCOPE, useExisting: forwardRef(() => EpdfDocumentScope) }], ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.2.4", type: EpdfDocumentScope, isStandalone: true, selector: "[epdfDocumentScope]", inputs: { id: { classPropertyName: "id", publicName: "epdfDocumentScope", isSignal: true, isRequired: true, transformFunction: null } }, providers: [
+            { provide: EPDF_DOCUMENT_SCOPE, useExisting: forwardRef(() => EpdfDocumentScope) },
+            // A service injected inside gets an instance of its own here, bound to this document.
+            EPDF_SCOPED_SERVICES,
+        ], ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocumentScope, decorators: [{
             type: Directive,
             args: [{
                     selector: '[epdfDocumentScope]',
-                    standalone: true,
-                    providers: [{ provide: EPDF_DOCUMENT_SCOPE, useExisting: forwardRef(() => EpdfDocumentScope) }],
+                    providers: [
+                        { provide: EPDF_DOCUMENT_SCOPE, useExisting: forwardRef(() => EpdfDocumentScope) },
+                        // A service injected inside gets an instance of its own here, bound to this document.
+                        EPDF_SCOPED_SERVICES,
+                    ],
                 }]
         }] });
 /**
- * Render the host template only while this subtree has a document — the
- * structural way to say "this UI is defined over a document". Sibling of
- * `[epdfDocumentScope]`, which picks WHICH document; this one handles WHETHER.
+ * Renders its content only while this part of the template has a ready document, with that
+ * document as `let document`. Otherwise it renders `locked` for a document waiting for its
+ * password, `error` for one that couldn't be opened, and `fallback` for everything else (none
+ * open yet, still opening), each with the document as `let-document`. Without `locked` or
+ * `error` those states show `fallback` too.
  *
- *   <section *epdfDocumentGate="; fallback: empty">…document UI…</section>
- *   <ng-template #empty>Drop a PDF to get started</ng-template>
+ *   <epdf-stage *epdfDocumentGate="let document; fallback: opening; locked: locked; error: failed">
+ *   <ng-template #opening>Opening…</ng-template>
+ *   <ng-template #locked let-document><app-password-form [document]="document" /></ng-template>
  *
- * The subtree stays mounted across a CHANGE of document (active-tab switch) —
- * only the has-a-document boolean creates/destroys it.
+ * The content stays mounted when another ready document becomes the active one; only its
+ * `document` changes.
  */
 class EpdfDocumentGate {
-    /** Shown while this subtree has NO document (empty workspace, docs still opening). */
+    /** Shown while there is no ready document: none is open, or it's still opening. */
     fallback = input(null, ...(ngDevMode ? [{ debugName: "fallback", alias: 'epdfDocumentGateFallback' }] : [{
             alias: 'epdfDocumentGateFallback',
         }]));
+    /** Shown while the document waits for its password; `fallback` without it. */
+    locked = input(null, ...(ngDevMode ? [{ debugName: "locked", alias: 'epdfDocumentGateLocked' }] : [{
+            alias: 'epdfDocumentGateLocked',
+        }]));
+    /** Shown when the document couldn't be opened; `fallback` without it. */
+    error = input(null, ...(ngDevMode ? [{ debugName: "error", alias: 'epdfDocumentGateError' }] : [{
+            alias: 'epdfDocumentGateError',
+        }]));
+    static ngTemplateContextGuard(_gate, context) {
+        return true;
+    }
     constructor() {
-        const docId = injectDocumentId();
-        const hasDocument = computed(() => docId() !== null, ...(ngDevMode ? [{ debugName: "hasDocument" }] : []));
-        const container = inject(ViewContainerRef);
+        const document = new CapabilityBinding(injectKernelHost('*epdfDocumentGate'), () => DocumentsToken, injectDocumentScope()).select(documentState.read, documentState.empty);
         const content = inject(TemplateRef);
+        const container = inject(ViewContainerRef);
+        const changes = inject(ChangeDetectorRef);
+        let shown = null;
         effect(() => {
-            container.clear();
-            if (hasDocument()) {
-                container.createEmbeddedView(content);
-            }
-            else {
-                // `fallback` is only tracked while gated — swapping fallback templates
-                // never recreates live document UI.
-                const fallbackTemplate = this.fallback();
-                if (fallbackTemplate)
-                    container.createEmbeddedView(fallbackTemplate);
-            }
+            const current = document();
+            const template = this.templateFor(current, content);
+            untracked(() => {
+                if (shown && shown.template === template) {
+                    // The same template for another document (a tab switch): keep the view, pass it on.
+                    shown.view.context.$implicit = current;
+                    shown.view.markForCheck();
+                    return;
+                }
+                container.clear();
+                shown = template
+                    ? { template, view: container.createEmbeddedView(template, { $implicit: current }) }
+                    : null;
+                changes.markForCheck();
+            });
         });
     }
+    templateFor(document, content) {
+        if (document.status === 'ready')
+            return content;
+        const locked = this.locked();
+        if (document.status === 'locked' && locked)
+            return locked;
+        const failed = this.error();
+        if (document.status === 'error' && failed)
+            return failed;
+        return this.fallback() ?? null;
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocumentGate, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.2.4", type: EpdfDocumentGate, isStandalone: true, selector: "[epdfDocumentGate]", inputs: { fallback: { classPropertyName: "fallback", publicName: "epdfDocumentGateFallback", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.2.4", type: EpdfDocumentGate, isStandalone: true, selector: "[epdfDocumentGate]", inputs: { fallback: { classPropertyName: "fallback", publicName: "epdfDocumentGateFallback", isSignal: true, isRequired: false, transformFunction: null }, locked: { classPropertyName: "locked", publicName: "epdfDocumentGateLocked", isSignal: true, isRequired: false, transformFunction: null }, error: { classPropertyName: "error", publicName: "epdfDocumentGateError", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfDocumentGate, decorators: [{
             type: Directive,
-            args: [{ selector: '[epdfDocumentGate]', standalone: true }]
+            args: [{ selector: '[epdfDocumentGate]' }]
         }], ctorParameters: () => [] });
 
 /**
- * `<epdf-viewer>` — component-hosted kernel (framework parity with React's
- * `<Viewer>`). Provides `EpdfKernelHost` at its element injector, boots it, and
- * projects content UNCONDITIONALLY: it is NOT a gate. Angular instantiates
- * projected content eagerly whether or not a slot renders it, so a conditional
- * `<ng-content>` cannot defer anything — real gating belongs to templates the
- * APP owns: `@if (ready())` for boot chrome, `*epdfDocumentGate` (or
- * `@if (documentId())`) for document UI.
+ * The page context: what a layer drawn on a page knows about that page. A layer reads only
+ * this, never the Stage, so the same layer works on a Stage's page and on a standalone page
+ * view. Inside `<ng-template epdfPage>`, `let-page` gives it to the template and `injectPage()`
+ * to a component.
  *
- * Prefer `provideEmbedPdf(...)` at route/app level when chrome lives outside
- * one subtree; this component is sugar over the same host.
- */
-class EpdfViewer {
-    /** The engine, as an instance OR a thunk ({@link EngineFactory}). An
-     *  instance is borrowed (never destroyed here); a thunk is host-owned
-     *  (constructed then destroyed with the viewer). See EmbedPdfConfig.
-     *  Init-only: the kernel is built once from the first values; recreate the
-     *  viewer (e.g. with @if) to swap it. */
-    engine = input.required(...(ngDevMode ? [{ debugName: "engine" }] : []));
-    plugins = input.required(...(ngDevMode ? [{ debugName: "plugins" }] : []));
-    initialDocuments = input(...(ngDevMode ? [undefined, { debugName: "initialDocuments" }] : []));
-    /** The host this viewer provides — exposed so a template reference can read
-     *  `viewer.host.ready()` / `.status()` without extra imports. */
-    host = inject(EpdfKernelHost, { self: true });
-    constructor() {
-        // Deferred config: inputs are READ on first kernel access, which happens
-        // after construction (a template binding or effect) — never here.
-        this.host.connect(() => ({
-            engine: this.engine(),
-            plugins: this.plugins(),
-            initialDocuments: this.initialDocuments(),
-        }));
-    }
-    ngOnInit() {
-        // Inputs are set by now; materializes the kernel and starts it (no-op on
-        // the server — the SSR contract lives on the host).
-        this.host.boot();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfViewer, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "20.2.4", type: EpdfViewer, isStandalone: true, selector: "epdf-viewer", inputs: { engine: { classPropertyName: "engine", publicName: "engine", isSignal: true, isRequired: true, transformFunction: null }, plugins: { classPropertyName: "plugins", publicName: "plugins", isSignal: true, isRequired: true, transformFunction: null }, initialDocuments: { classPropertyName: "initialDocuments", publicName: "initialDocuments", isSignal: true, isRequired: false, transformFunction: null } }, host: { styleAttribute: "display: contents;" }, providers: [EpdfKernelHost], ngImport: i0, template: `<ng-content />`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfViewer, decorators: [{
-            type: Component,
-            args: [{
-                    selector: 'epdf-viewer',
-                    standalone: true,
-                    changeDetection: ChangeDetectionStrategy.OnPush,
-                    providers: [EpdfKernelHost],
-                    // Layout-transparent, like React's element-less <Viewer>.
-                    host: { style: 'display: contents;' },
-                    template: `<ng-content />`,
-                }]
-        }], ctorParameters: () => [] });
-
-/**
- * PageContext — the seam. A layer depends ONLY on this, never on the Stage, so
- * the same layer works inside a virtualized `<epdf-stage>` page and a future
- * standalone `<epdf-page-view>`.
- *
- * THE STABILITY INVARIANT (the one performance rule of this adapter): a page's
- * context is ONE STABLE OBJECT per mounted surface — identity never changes;
- * the volatile parts (`transform`, `frame`, `pageIndex`) are signals INSIDE it.
- * The per-page injector providing `EPDF_PAGE` is likewise created once. Camera
- * frames then flow as signal writes — `NgTemplateOutlet` never recreates the
- * embedded views, in-flight renders survive, and updates stay per-binding.
- * Never rebuild the context or the injector per frame.
+ * One context per page on screen, for as long as the page is shown: its identity never
+ * changes, and what moves (`pageIndex`, `frame`, `transform`) are signals inside it. The
+ * template outlet then keeps every layer while the camera moves, and a camera frame updates
+ * only the bindings that read the transform. Never build a new context per frame.
  *
- * Coordinate math lives in `@embedpdf/core-geometry`'s `PageTransform` — verified
- * once, not re-derived per framework adapter (`toContentPoint` mirrors React's
- * `makePageContext` exactly).
+ * The coordinate math is `PageTransform` from `@embedpdf/core-geometry`, and the client-space
+ * conversions are `pageClientSpace` from `@embedpdf/web`, both shared by every framework.
  */
 const EPDF_PAGE = new InjectionToken('EPDF_PAGE');
-function injectPage() {
+/** The page this component is drawn on; EPDF-103, naming `what`, outside a page. */
+function injectPage(what = 'This component') {
     const page = inject(EPDF_PAGE, { optional: true });
-    if (!page) {
-        throw new Error('[embedpdf] injectPage() must be used inside an <epdf-stage> page template');
-    }
+    if (!page)
+        throw outsidePageError(what);
     return page;
 }
-/** Build a page context from its reactive parts. `documentId`/`pon` are thunks
- *  because inputs aren't readable at construction — both are stable per surface. */
+/**
+ * A page context from its parts. `documentId` and `ref` are functions because a component's
+ * inputs aren't set yet when it's constructed; both stay the same for the page's lifetime.
+ */
 function createPageContext(parts) {
     const { transform, getRect } = parts;
     return {
         get documentId() {
             return parts.documentId();
         },
-        get pon() {
-            return parts.pon();
+        get ref() {
+            return parts.ref();
+        },
+        get view() {
+            return parts.view();
         },
         pageIndex: parts.pageIndex,
         frame: parts.frame,
         transform,
-        toContentPoint: (clientX, clientY) => {
-            // Client → box-local view px, then invert rotation + scale via the
-            // transform (verified once in geometry, not re-derived per adapter).
-            const r = getRect();
-            return transform().viewToContent({ x: clientX - r.left, y: clientY - r.top });
-        },
-        toClientPoint: (p) => {
-            // Exact inverse of `toContentPoint`, offset by the same live display-box
-            // origin — the two can never drift.
-            const r = getRect();
-            const v = transform().contentToView(p);
-            return { x: r.left + v.x, y: r.top + v.y };
-        },
-        toClientRect: (rect) => {
-            const r = getRect();
-            const v = transform().contentToViewRect(rect);
-            return { x: r.left + v.x, y: r.top + v.y, width: v.width, height: v.height };
-        },
+        ...(parts.getViewDemand ? { getViewDemand: parts.getViewDemand } : {}),
+        // Client pixels to pixels in the page's box, then the transform undoes the turn and the scale,
+        // against the transform the signal holds when a conversion runs.
+        ...pageClientSpace(transform, getRect),
     };
 }
 
 /**
- * @embedpdf/angular/runtime — the trunk: the generic kernel binding.
+ * The Angular side of `@embedpdf/web`'s page layers: a layer says, for as long as it's there,
+ * which part of its page it paints, and the render layer reads which parts are painted, to leave
+ * them out of the page's picture.
+ */
+/**
+ * Say, for as long as this component is there, that it paints `part` of its page (`pageRef()`,
+ * the page context's `ref`; `null` while it paints nothing). Call it in an injection context.
+ */
+function paintsPagePart(pageRef, part) {
+    effect((onCleanup) => {
+        const ref = pageRef();
+        if (ref)
+            onCleanup(untracked(() => pageLayersOf(ref).paint(part)));
+    });
+}
+/**
+ * Which parts of the page (`pageRef()`, the page context's `ref`) the layers on it paint: `null`
+ * until the first render is done, when every layer made with this one has said what it paints,
+ * so the page's picture is never asked for with a part another layer is about to take. Call it
+ * in an injection context.
+ */
+function injectPaintedParts(pageRef) {
+    const painted = signal(null, ...(ngDevMode ? [{ debugName: "painted" }] : []));
+    const injector = inject(Injector);
+    afterNextRender(() => {
+        effect((onCleanup) => {
+            const layers = pageLayersOf(pageRef());
+            untracked(() => painted.set(layers.painted()));
+            onCleanup(layers.subscribe(() => painted.set(layers.painted())));
+        }, { injector });
+    });
+    return painted.asReadonly();
+}
+
+/**
+ * Scene shapes as SVG elements: `@embedpdf/web`'s element descriptions (`svgShapesOf`), one
+ * element each, a clipping `svg` with its children. The annotation and form layers draw their
+ * scenes through `<svg:g [epdfSvgShapes]>` inside an `<svg>`.
+ */
+/**
+ * An SVG element's attributes from a record of SVG names (`stroke-width`), as `@embedpdf/web`
+ * describes a scene node (templates can't spread). Set again when the record changes; an
+ * attribute that left the record is removed.
+ */
+class EpdfSvgAttributes {
+    attributes = input.required(...(ngDevMode ? [{ debugName: "attributes", alias: 'epdfSvgAttributes' }] : [{
+            alias: 'epdfSvgAttributes',
+        }]));
+    constructor() {
+        const element = inject(ElementRef).nativeElement;
+        let shown = {};
+        effect(() => {
+            const next = this.attributes();
+            for (const name of Object.keys(shown)) {
+                if (!(name in next))
+                    element.removeAttribute(name);
+            }
+            for (const [name, value] of Object.entries(next)) {
+                if (shown[name] !== value)
+                    element.setAttribute(name, String(value));
+            }
+            shown = next;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfSvgAttributes, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.2.4", type: EpdfSvgAttributes, isStandalone: true, selector: "[epdfSvgAttributes]", inputs: { attributes: { classPropertyName: "attributes", publicName: "epdfSvgAttributes", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfSvgAttributes, decorators: [{
+            type: Directive,
+            args: [{ selector: '[epdfSvgAttributes]' }]
+        }], ctorParameters: () => [] });
+/** The shapes, in drawing order, in the `<svg:g>` it's on, and the faces their text draws in. */
+class EpdfSvgShapes {
+    shapes = input.required(...(ngDevMode ? [{ debugName: "shapes", alias: 'epdfSvgShapes' }] : [{ alias: 'epdfSvgShapes' }]));
+    constructor() {
+        if (!isPlatformBrowser(inject(PLATFORM_ID)))
+            return;
+        // The faces of this level's text, while it shows: a clipping `svg` mounts its children's.
+        const mounts = createFontMounts();
+        inject(DestroyRef).onDestroy(() => mounts.release());
+        effect(() => mounts.mount(this.shapes().flatMap((shape) => (shape.program ? [shape.program] : []))));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfSvgShapes, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.2.4", type: EpdfSvgShapes, isStandalone: true, selector: "g[epdfSvgShapes]", inputs: { shapes: { classPropertyName: "shapes", publicName: "epdfSvgShapes", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+    @for (shape of shapes(); track $index) {
+      @switch (shape.tag) {
+        @case ('rect') {
+          <svg:rect
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:rect>
+        }
+        @case ('ellipse') {
+          <svg:ellipse
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:ellipse>
+        }
+        @case ('line') {
+          <svg:line
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:line>
+        }
+        @case ('path') {
+          <svg:path
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:path>
+        }
+        @case ('polygon') {
+          <svg:polygon
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:polygon>
+        }
+        @case ('polyline') {
+          <svg:polyline
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:polyline>
+        }
+        @case ('text') {
+          <svg:text
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+            [textContent]="shape.text ?? ''"
+          ></svg:text>
+        }
+        @case ('svg') {
+          <svg:svg [epdfSvgAttributes]="shape.attributes">
+            <svg:g [epdfSvgShapes]="shape.children ?? []"></svg:g>
+          </svg:svg>
+        }
+      }
+    }
+  `, isInline: true, dependencies: [{ kind: "component", type: EpdfSvgShapes, selector: "g[epdfSvgShapes]", inputs: ["epdfSvgShapes"] }, { kind: "directive", type: EpdfSvgAttributes, selector: "[epdfSvgAttributes]", inputs: ["epdfSvgAttributes"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: EpdfSvgShapes, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'g[epdfSvgShapes]',
+                    imports: [EpdfSvgAttributes],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    @for (shape of shapes(); track $index) {
+      @switch (shape.tag) {
+        @case ('rect') {
+          <svg:rect
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:rect>
+        }
+        @case ('ellipse') {
+          <svg:ellipse
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:ellipse>
+        }
+        @case ('line') {
+          <svg:line
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:line>
+        }
+        @case ('path') {
+          <svg:path
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:path>
+        }
+        @case ('polygon') {
+          <svg:polygon
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:polygon>
+        }
+        @case ('polyline') {
+          <svg:polyline
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+          ></svg:polyline>
+        }
+        @case ('text') {
+          <svg:text
+            [epdfSvgAttributes]="shape.attributes"
+            [style.mix-blend-mode]="shape.blend ?? null"
+            [textContent]="shape.text ?? ''"
+          ></svg:text>
+        }
+        @case ('svg') {
+          <svg:svg [epdfSvgAttributes]="shape.attributes">
+            <svg:g [epdfSvgShapes]="shape.children ?? []"></svg:g>
+          </svg:svg>
+        }
+      }
+    }
+  `,
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Development-time guardrails. Each warning fires once (by key), says what is wrong and what to
+ * do instead, and stays quiet in production builds (Angular's `isDevMode()`).
+ */
+const warned = new Set();
+/** Warn once per key. Quiet in production. */
+function devWarn(key, message) {
+    if (!isDevMode() || warned.has(key))
+        return;
+    warned.add(key);
+    console.warn(`[embedpdf] ${message}`);
+}
+/** For tests: forget every warning, so one can fire again. */
+function resetDevWarnings() {
+    warned.clear();
+}
+
+/**
+ * `epdfTheme()`: a theme written with setting names, as the CSS variables for the element
+ * around your viewer. The variables and their lookup are framework-free (`@embedpdf/web`); this
+ * types the result for Angular's `[style]` binding, which sets custom properties as they are.
+ */
+/**
+ * The CSS variables of a theme: `<div [style]="theme()">` with
+ * `theme = computed(() => epdfTheme({ accent: this.accent() }))`. Everything inside follows
+ * them, and a CSS variable set in a stylesheet still wins over a setting.
+ */
+function epdfTheme(theme) {
+    return epdfThemeVariables(theme);
+}
+
+/**
+ * @embedpdf/angular/runtime: the viewer and what every feature builds on.
  *
- * Binds the kernel's one change stream to Angular signals (one tick signal +
- * computed), resolves capabilities (document-scoped ones against the active or
- * `[epdfDocumentScope]`-given document), and provides the page context seam.
- * Every feature entry point and layer rides on this — there is no per-plugin
- * framework code.
+ *   provideEmbedPdf(config, ...features)    the viewer, as providers
+ *   inject(EpdfViewer)                      its settings and status
+ *   inject(EpdfDocuments), EpdfDocument     the documents, as methods, signals and streams
+ *   [epdfDocumentScope], *epdfDocumentGate  which document a part of the template talks to
+ *   pluginService(), EpdfPluginService      how a plugin's service is built
+ *   EPDF_PAGE, injectPage()                 the page a layer draws on
+ *   paintsPagePart(), injectPaintedParts()  which parts of a page its layers paint
+ *   <svg:g [epdfSvgShapes]>                 a scene's shapes as SVG elements
  */
-// One-line-per-feature: registration travels with the UI.
+// The core's types and helpers, so app code has one import for the viewer.
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { EPDF_DOCUMENT_SCOPE, EPDF_PAGE, EpdfDocumentGate, EpdfDocumentScope, EpdfKernelHost, EpdfViewer, createPageContext, injectActiveDocumentId, injectCapability, injectCapabilityFor, injectDocumentId, injectDocuments, injectKernel, injectKernelHost, injectKernelValue, injectOptionalCapability, injectOptionalCapabilityFor, injectOptionalSelector, injectOptionalSelectorFor, injectPage, injectSelector, injectSelectorFor, provideEmbedPdf, shallowArray };
+export { CapabilityBinding, EPDF_DOCUMENT_SCOPE, EPDF_PAGE, EPDF_SCOPED_SERVICES, EPDF_SETUP, EpdfDocument, EpdfDocumentGate, EpdfDocumentScope, EpdfDocuments, EpdfError, EpdfKernelHost, EpdfPluginService, EpdfSvgAttributes, EpdfSvgShapes, EpdfViewer, createPageContext, devWarn, epdfTheme, injectCapability, injectDocumentScope, injectKernelHost, injectPage, injectPaintedParts, noPluginError, noViewerError, onServerError, outsidePageError, outsideStageError, paintsPagePart, pluginService, provideEmbedPdf, resetDevWarnings };
 //# sourceMappingURL=embedpdf-angular-runtime.mjs.map