@embedpdf/react 3.0.0-next.13 → 3.0.0-next.15

package/dist/runtime-DBEBlpQV.d.cts

@@ -0,0 +1,237 @@
+import { AnyPlugin, CapabilityToken, DocumentInfo, DocumentsCapability, DocumentsState, Engine, EngineFactory, EventHook, FailedDocumentInfo, Identity, InitialDocument, Kernel, LockedDocumentInfo, PageInfo, ViewerPageSettings, ViewerSettings } from "@embedpdf/core";
+import * as React from "react";
+import { EpdfTheme, EpdfTheme as EpdfTheme$1, PageContext, makePageContext, mountWebFont, saveFile } from "@embedpdf/web";
+import { PageTransform } from "@embedpdf/core-geometry";
+import { PageViewDemand } from "@embedpdf/plugin-render/contract";
+//#region src/theme.d.ts
+/**
+ * The CSS variables of a theme, for a `style` prop: `<div style={epdfTheme({ accent })}>`.
+ * Everything inside the element follows them, and a CSS variable wins over any setting.
+ */
+declare function epdfTheme(theme: EpdfTheme): React.CSSProperties;
+//#endregion
+//#region src/runtime.d.ts
+declare function useKernel(): Kernel;
+interface KernelProviderProps {
+  kernel: Kernel;
+  children?: React.ReactNode;
+}
+/**
+ * Give a subtree a kernel someone else created and owns, so every hook in it
+ * works against that kernel. The full viewer's wrapper puts the children it
+ * slots into the viewer inside one. The provider never starts or destroys the
+ * kernel; `<Viewer>` is the component that owns one.
+ */
+declare function KernelProvider({ kernel, children }: KernelProviderProps): import("react/jsx-runtime").JSX.Element;
+declare const shallowArray: <T>(left: readonly T[], right: readonly T[]) => boolean;
+/** Read a value derived from the kernel, cached by equality (no tearing loop). */
+declare function useKernelValue<R>(select: (kernel: Kernel) => R, isEqual?: (left: R, right: R) => boolean): R;
+declare function useActiveDocumentId(): string | null;
+/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */
+declare function useDocumentId(): string | null;
+/**
+ * The document the nearest <DocumentScope> binds this subtree to, or null when
+ * it follows the active document. For resolvers that pass it to
+ * `kernel.tryCapability`, which reads the active document at call time; UI
+ * that needs the id itself uses {@link useDocumentId}.
+ */
+declare function useDocumentScope(): string | null;
+interface DocumentScopeProps {
+  id: string;
+  children: React.ReactNode;
+}
+/** Bind a subtree to a specific document (panes, comparison). */
+declare function DocumentScope({ id, children }: DocumentScopeProps): import("react/jsx-runtime").JSX.Element;
+interface DocumentGateProps {
+  /** Shown while this subtree has no document: none is open, or it's still opening. */
+  fallback?: React.ReactNode;
+  /** Shown while the document waits for its password; `fallback` without it. */
+  locked?: (document: LockedDocumentInfo) => React.ReactNode;
+  /** Shown when the document couldn't be opened, with why; `fallback` without it. */
+  error?: (document: FailedDocumentInfo) => React.ReactNode;
+  children?: React.ReactNode;
+}
+/**
+ * Render children only while this subtree has a ready document — the
+ * structural way to say "this UI is defined over a document". An empty
+ * workspace is a legitimate, designable state (the Viewer no longer blocks on
+ * documents so chrome can render at t≈0): workspace-scoped UI (toolbars,
+ * commands, i18n) lives outside the gate; document-scoped UI (Stage, panels,
+ * page chrome) lives inside it. A document that waits for its password, or
+ * failed, renders `locked` or `error` with it, or else `fallback`. Sibling of
+ * <DocumentScope>, which picks which document; this one handles whether.
+ */
+declare function DocumentGate({ fallback, locked, error, children }: DocumentGateProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Resolve a capability by token, binding document-scoped ones to this
+ * subtree's document. Resolution is a reactive read (`tryCapability` through
+ * the kernel's one change stream), not a memoized call — 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.
+ *
+ * Outside a document (none open, not ready yet, or none in scope), a document
+ * plugin resolves to its stand-in (`standInFor` from `@embedpdf/core`):
+ * rendering never fails, and a method called too early refuses with
+ * `not-ready` (a method that returns a promise rejects). A token no plugin
+ * provides still throws the kernel's reason, because that is a setup mistake.
+ */
+declare function useCapability<T>(token: CapabilityToken<T>): T;
+/** Like `useCapability`, but null while the token can't resolve (no plugin,
+ *  no document, or a document that isn't ready yet). */
+declare function useOptionalCapability<T>(token: CapabilityToken<T>): T | null;
+/**
+ * Subscribe to a selector over a (document-resolved) capability. Strict:
+ * while the token can't resolve, it throws the kernel's reason (`no
+ * document`, `document is loading`), for code that knows a document exists,
+ * such as anything inside a <DocumentGate>. `useOptionalSelector` is its
+ * total twin.
+ */
+declare function useSelector<C, R>(token: CapabilityToken<C>, select: (capability: C) => R, isEqual?: (left: R, right: R) => boolean): R;
+/**
+ * Null-safe `useSelector`: `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).
+ *
+ * The `select` guard also swallows reads through a capability whose document
+ * closed between the store notification and this render — that teardown race
+ * resolves to `fallback` for one frame, then re-renders against the new state.
+ */
+declare function useOptionalSelector<C, R>(token: CapabilityToken<C>, select: (capability: C) => R, fallback: R, isEqual?: (left: R, right: R) => boolean): R;
+/**
+ * Subscribe to a capability's {@link EventHook} for the mounted lifetime —
+ * `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`. Events
+ * carry occurrences, never state (a late subscriber that needs the current
+ * value uses `useSelector`). The handler rides a ref, so a fresh closure per
+ * render never resubscribes. Null-safe: no plugin/document → no subscription.
+ */
+declare function useCapabilityEvent<C, T>(token: CapabilityToken<C>, select: (capability: C) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The documents API: open, close, unlock, download, and the tabs. Inside a
+ * <DocumentScope>, the calls that leave out the document use that one, so
+ * `download()` without an id downloads the document in scope. The object
+ * never changes, so it's safe in effects and callbacks. What to show comes
+ * from `useDocument()` and `useDocumentsState()`.
+ */
+declare function useDocuments(): DocumentsCapability;
+/**
+ * The document this component talks to: the one its <DocumentScope> names, or
+ * else the active one. Its `id`, `name`, `status`, `pageCount`,
+ * `hasUnsavedChanges`, and why it's locked or failed. With no document, an
+ * empty one that reads as still opening. Takes a selector, and re-renders only
+ * when what it returns changes.
+ */
+declare function useDocument<Selected = DocumentInfo>(select?: (document: DocumentInfo) => Selected): Selected;
+/**
+ * Every open document, in tab order (loading, locked and failed ones too),
+ * and the active one's id. Takes a selector, and re-renders only when what it
+ * returns changes.
+ */
+declare function useDocumentsState<Selected = DocumentsState>(select?: (state: DocumentsState) => Selected): Selected;
+/** Subscribe to one documents event for the mounted lifetime: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+declare function useDocumentsEvent<T>(select: (documents: DocumentsCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The pages of the document this component talks to, in order: each with its
+ * `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail
+ * list or a page picker works anywhere. The same array until a page is added,
+ * removed, moved or rotated; empty with no document.
+ */
+declare function usePageList(): readonly PageInfo[];
+/**
+ * The viewer's own settings (`<Viewer identity scope accent page>`), or the
+ * value `select` picks from them: the accent every part without a color of its
+ * own follows, and how pages look. What paints a page or an accent reads it
+ * here, through `paint()` from `@embedpdf/web`, so a CSS variable still wins.
+ */
+declare function useViewerSettings<Selected = ViewerSettings>(select?: (settings: ViewerSettings) => Selected): Selected;
+interface ViewerProps {
+  /**
+   * The engine, as an instance or a thunk. Engines construct synchronously and
+   * boot lazily (`localEngine()` allocates nothing until first use), so
+   * ownership follows the shape of what you pass:
+   *
+   *   - An **instance** (`engine={engine}`) is borrowed: the Viewer uses it and
+   *     never destroys it, because you acquired it and therefore own it. The
+   *     common path — a module-scope `const engine = localEngine()` shared
+   *     across viewers and route changes. The Viewer warms up a local engine
+   *     on mount so the boot overlaps app initialization.
+   *   - A **thunk** (`engine={() => localEngine()}`) is viewer-owned: the
+   *     Viewer calls it on mount and `destroy()`s the result on unmount. Use it
+   *     for per-mount isolation (StrictMode/HMR-clean teardown, independent
+   *     multi-viewer engines).
+   *
+   * Init-only: captured on first render; later identity changes are ignored (dev warns).
+   */
+  engine: Engine | EngineFactory;
+  /** Init-only: captured on first render; later identity changes are ignored (dev warns). */
+  plugins: AnyPlugin[];
+  /** Documents to open on startup (with optional tab names). Init-only. */
+  initialDocuments?: InitialDocument[];
+  fallback?: React.ReactNode;
+  /** Rendered when kernel construction or `start()` fails. Without it a boot
+   *  failure renders nothing — but never a silent forever-fallback. */
+  renderError?: (error: unknown) => React.ReactNode;
+  /** Called once the kernel has started — before `children` mount and before
+   *  `initialDocuments` open. The imperative door for code outside React
+   *  (register commands, subscribe events). The `ref` carries the same kernel. */
+  onReady?: (kernel: Kernel) => void;
+  /**
+   * Who the user is, for every document opened without an `identity` of its
+   * own (which replaces this one). Documents opened after a change use the new
+   * value; open ones keep theirs. The local engine only: the cloud engine reads
+   * it from the document's token.
+   */
+  identity?: Identity;
+  /**
+   * What the user may do, as permissions, in every document opened without a
+   * `scope` of its own (which replaces this one). Left out, they may do
+   * everything. Changes reach the documents opened after them, as `identity`.
+   */
+  scope?: readonly string[];
+  /** The color every part without a color of its own follows. CSS `--epdf-accent` wins over it. */
+  accent?: string;
+  /** How pages look: `background` before the picture arrives, and the `shadow` under each page. */
+  page?: Partial<ViewerPageSettings>;
+  children?: React.ReactNode;
+}
+/**
+ * Owns the kernel as an effect-scoped resource: each effect setup creates and
+ * starts exactly one kernel; each cleanup destroys exactly that one. That is
+ * the contract StrictMode exercises (two kernels in dev, the first fully
+ * destroyed) — the kernel itself is never restarted after destroy.
+ *
+ * The kernel is published to context the moment it exists — before `start()`
+ * resolves — so the `fallback` can use workspace capabilities (i18n copy on a
+ * loading screen). The one exception is the very first render, which happens
+ * before the effect: it renders nothing. Children mount once `start()` resolves
+ * — which never touches the engine, so the shell is alive while WASM compiles
+ * or the transport connects. `initialDocuments` open in the background and
+ * stream into the registry (`useDocuments()` is reactive); per-document
+ * loading UI is the Stage's job, not a root gate.
+ *
+ * Engine ownership. When `engine` is a thunk, the Viewer owns it: each effect
+ * setup constructs one engine (construction is synchronous and inert — boot
+ * happens lazily inside the engine) and each cleanup destroys exactly that one
+ * — after the kernel, so handles close first. When `engine` is an instance it
+ * is borrowed and never destroyed here; the Viewer only warms up a local
+ * engine so the WASM boot overlaps plugin initialization. StrictMode's
+ * double-mount therefore constructs two independent thunk engines and tears
+ * the first fully down, matching the kernel's own effect-scoped lifecycle.
+ * That means dev-only double resource use (two worker spawns, two font
+ * fetches, briefly overlapping) — deliberate, because it is exactly the
+ * leak-detection contract StrictMode exists to exercise; production mounts
+ * once and boots once.
+ */
+declare const Viewer: React.ForwardRefExoticComponent<ViewerProps & React.RefAttributes<Kernel | null>>;
+declare const EmbedPDF: React.ForwardRefExoticComponent<ViewerProps & React.RefAttributes<Kernel | null>>;
+/**
+ * PageContext — the seam. A layer depends only on this, never on the Stage. So the
+ * same layer works inside a virtualized Stage and in a standalone <PageView>.
+ * Its members are documented on `PageContext` in `@embedpdf/web`.
+ */
+type PageContextValue = PageContext<PageTransform, PageViewDemand>;
+declare const PageProvider: React.Provider<PageContextValue | null>;
+declare function usePage(): PageContextValue;
+//#endregion
+export { usePageList as A, useDocumentsEvent as C, useOptionalCapability as D, useKernelValue as E, useViewerSettings as M, EpdfTheme$1 as N, useOptionalSelector as O, epdfTheme as P, useDocuments as S, useKernel as T, useCapability as _, EmbedPDF as a, useDocumentId as b, PageContextValue as c, ViewerProps as d, makePageContext as f, useActiveDocumentId as g, shallowArray as h, DocumentScopeProps as i, useSelector as j, usePage as k, PageProvider as l, saveFile as m, DocumentGateProps as n, KernelProvider as o, mountWebFont as p, DocumentScope as r, KernelProviderProps as s, DocumentGate as t, Viewer as u, useCapabilityEvent as v, useDocumentsState as w, useDocumentScope as x, useDocument as y };
+//# sourceMappingURL=runtime-DBEBlpQV.d.cts.map

package/dist/runtime-V3MVMb91.d.ts

@@ -0,0 +1,237 @@
+import { AnyPlugin, CapabilityToken, DocumentInfo, DocumentsCapability, DocumentsState, Engine, EngineFactory, EventHook, FailedDocumentInfo, Identity, InitialDocument, Kernel, LockedDocumentInfo, PageInfo, ViewerPageSettings, ViewerSettings } from "@embedpdf/core";
+import { EpdfTheme, EpdfTheme as EpdfTheme$1, PageContext, makePageContext as makePageContext$1, mountWebFont, saveFile } from "@embedpdf/web";
+import * as React$1 from "react";
+import { PageTransform } from "@embedpdf/core-geometry";
+import { PageViewDemand } from "@embedpdf/plugin-render/contract";
+//#region src/theme.d.ts
+/**
+ * The CSS variables of a theme, for a `style` prop: `<div style={epdfTheme({ accent })}>`.
+ * Everything inside the element follows them, and a CSS variable wins over any setting.
+ */
+declare function epdfTheme(theme: EpdfTheme): React$1.CSSProperties;
+//#endregion
+//#region src/runtime.d.ts
+declare function useKernel(): Kernel;
+interface KernelProviderProps {
+  kernel: Kernel;
+  children?: React$1.ReactNode;
+}
+/**
+ * Give a subtree a kernel someone else created and owns, so every hook in it
+ * works against that kernel. The full viewer's wrapper puts the children it
+ * slots into the viewer inside one. The provider never starts or destroys the
+ * kernel; `<Viewer>` is the component that owns one.
+ */
+declare function KernelProvider({ kernel, children }: KernelProviderProps): import("react/jsx-runtime").JSX.Element;
+declare const shallowArray: <T>(left: readonly T[], right: readonly T[]) => boolean;
+/** Read a value derived from the kernel, cached by equality (no tearing loop). */
+declare function useKernelValue<R>(select: (kernel: Kernel) => R, isEqual?: (left: R, right: R) => boolean): R;
+declare function useActiveDocumentId(): string | null;
+/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */
+declare function useDocumentId(): string | null;
+/**
+ * The document the nearest <DocumentScope> binds this subtree to, or null when
+ * it follows the active document. For resolvers that pass it to
+ * `kernel.tryCapability`, which reads the active document at call time; UI
+ * that needs the id itself uses {@link useDocumentId}.
+ */
+declare function useDocumentScope(): string | null;
+interface DocumentScopeProps {
+  id: string;
+  children: React$1.ReactNode;
+}
+/** Bind a subtree to a specific document (panes, comparison). */
+declare function DocumentScope({ id, children }: DocumentScopeProps): import("react/jsx-runtime").JSX.Element;
+interface DocumentGateProps {
+  /** Shown while this subtree has no document: none is open, or it's still opening. */
+  fallback?: React$1.ReactNode;
+  /** Shown while the document waits for its password; `fallback` without it. */
+  locked?: (document: LockedDocumentInfo) => React$1.ReactNode;
+  /** Shown when the document couldn't be opened, with why; `fallback` without it. */
+  error?: (document: FailedDocumentInfo) => React$1.ReactNode;
+  children?: React$1.ReactNode;
+}
+/**
+ * Render children only while this subtree has a ready document — the
+ * structural way to say "this UI is defined over a document". An empty
+ * workspace is a legitimate, designable state (the Viewer no longer blocks on
+ * documents so chrome can render at t≈0): workspace-scoped UI (toolbars,
+ * commands, i18n) lives outside the gate; document-scoped UI (Stage, panels,
+ * page chrome) lives inside it. A document that waits for its password, or
+ * failed, renders `locked` or `error` with it, or else `fallback`. Sibling of
+ * <DocumentScope>, which picks which document; this one handles whether.
+ */
+declare function DocumentGate({ fallback, locked, error, children }: DocumentGateProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Resolve a capability by token, binding document-scoped ones to this
+ * subtree's document. Resolution is a reactive read (`tryCapability` through
+ * the kernel's one change stream), not a memoized call — 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.
+ *
+ * Outside a document (none open, not ready yet, or none in scope), a document
+ * plugin resolves to its stand-in (`standInFor` from `@embedpdf/core`):
+ * rendering never fails, and a method called too early refuses with
+ * `not-ready` (a method that returns a promise rejects). A token no plugin
+ * provides still throws the kernel's reason, because that is a setup mistake.
+ */
+declare function useCapability<T>(token: CapabilityToken<T>): T;
+/** Like `useCapability`, but null while the token can't resolve (no plugin,
+ *  no document, or a document that isn't ready yet). */
+declare function useOptionalCapability<T>(token: CapabilityToken<T>): T | null;
+/**
+ * Subscribe to a selector over a (document-resolved) capability. Strict:
+ * while the token can't resolve, it throws the kernel's reason (`no
+ * document`, `document is loading`), for code that knows a document exists,
+ * such as anything inside a <DocumentGate>. `useOptionalSelector` is its
+ * total twin.
+ */
+declare function useSelector<C, R>(token: CapabilityToken<C>, select: (capability: C) => R, isEqual?: (left: R, right: R) => boolean): R;
+/**
+ * Null-safe `useSelector`: `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).
+ *
+ * The `select` guard also swallows reads through a capability whose document
+ * closed between the store notification and this render — that teardown race
+ * resolves to `fallback` for one frame, then re-renders against the new state.
+ */
+declare function useOptionalSelector<C, R>(token: CapabilityToken<C>, select: (capability: C) => R, fallback: R, isEqual?: (left: R, right: R) => boolean): R;
+/**
+ * Subscribe to a capability's {@link EventHook} for the mounted lifetime —
+ * `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`. Events
+ * carry occurrences, never state (a late subscriber that needs the current
+ * value uses `useSelector`). The handler rides a ref, so a fresh closure per
+ * render never resubscribes. Null-safe: no plugin/document → no subscription.
+ */
+declare function useCapabilityEvent<C, T>(token: CapabilityToken<C>, select: (capability: C) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The documents API: open, close, unlock, download, and the tabs. Inside a
+ * <DocumentScope>, the calls that leave out the document use that one, so
+ * `download()` without an id downloads the document in scope. The object
+ * never changes, so it's safe in effects and callbacks. What to show comes
+ * from `useDocument()` and `useDocumentsState()`.
+ */
+declare function useDocuments(): DocumentsCapability;
+/**
+ * The document this component talks to: the one its <DocumentScope> names, or
+ * else the active one. Its `id`, `name`, `status`, `pageCount`,
+ * `hasUnsavedChanges`, and why it's locked or failed. With no document, an
+ * empty one that reads as still opening. Takes a selector, and re-renders only
+ * when what it returns changes.
+ */
+declare function useDocument<Selected = DocumentInfo>(select?: (document: DocumentInfo) => Selected): Selected;
+/**
+ * Every open document, in tab order (loading, locked and failed ones too),
+ * and the active one's id. Takes a selector, and re-renders only when what it
+ * returns changes.
+ */
+declare function useDocumentsState<Selected = DocumentsState>(select?: (state: DocumentsState) => Selected): Selected;
+/** Subscribe to one documents event for the mounted lifetime: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+declare function useDocumentsEvent<T>(select: (documents: DocumentsCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The pages of the document this component talks to, in order: each with its
+ * `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail
+ * list or a page picker works anywhere. The same array until a page is added,
+ * removed, moved or rotated; empty with no document.
+ */
+declare function usePageList(): readonly PageInfo[];
+/**
+ * The viewer's own settings (`<Viewer identity scope accent page>`), or the
+ * value `select` picks from them: the accent every part without a color of its
+ * own follows, and how pages look. What paints a page or an accent reads it
+ * here, through `paint()` from `@embedpdf/web`, so a CSS variable still wins.
+ */
+declare function useViewerSettings<Selected = ViewerSettings>(select?: (settings: ViewerSettings) => Selected): Selected;
+interface ViewerProps {
+  /**
+   * The engine, as an instance or a thunk. Engines construct synchronously and
+   * boot lazily (`localEngine()` allocates nothing until first use), so
+   * ownership follows the shape of what you pass:
+   *
+   *   - An **instance** (`engine={engine}`) is borrowed: the Viewer uses it and
+   *     never destroys it, because you acquired it and therefore own it. The
+   *     common path — a module-scope `const engine = localEngine()` shared
+   *     across viewers and route changes. The Viewer warms up a local engine
+   *     on mount so the boot overlaps app initialization.
+   *   - A **thunk** (`engine={() => localEngine()}`) is viewer-owned: the
+   *     Viewer calls it on mount and `destroy()`s the result on unmount. Use it
+   *     for per-mount isolation (StrictMode/HMR-clean teardown, independent
+   *     multi-viewer engines).
+   *
+   * Init-only: captured on first render; later identity changes are ignored (dev warns).
+   */
+  engine: Engine | EngineFactory;
+  /** Init-only: captured on first render; later identity changes are ignored (dev warns). */
+  plugins: AnyPlugin[];
+  /** Documents to open on startup (with optional tab names). Init-only. */
+  initialDocuments?: InitialDocument[];
+  fallback?: React$1.ReactNode;
+  /** Rendered when kernel construction or `start()` fails. Without it a boot
+   *  failure renders nothing — but never a silent forever-fallback. */
+  renderError?: (error: unknown) => React$1.ReactNode;
+  /** Called once the kernel has started — before `children` mount and before
+   *  `initialDocuments` open. The imperative door for code outside React
+   *  (register commands, subscribe events). The `ref` carries the same kernel. */
+  onReady?: (kernel: Kernel) => void;
+  /**
+   * Who the user is, for every document opened without an `identity` of its
+   * own (which replaces this one). Documents opened after a change use the new
+   * value; open ones keep theirs. The local engine only: the cloud engine reads
+   * it from the document's token.
+   */
+  identity?: Identity;
+  /**
+   * What the user may do, as permissions, in every document opened without a
+   * `scope` of its own (which replaces this one). Left out, they may do
+   * everything. Changes reach the documents opened after them, as `identity`.
+   */
+  scope?: readonly string[];
+  /** The color every part without a color of its own follows. CSS `--epdf-accent` wins over it. */
+  accent?: string;
+  /** How pages look: `background` before the picture arrives, and the `shadow` under each page. */
+  page?: Partial<ViewerPageSettings>;
+  children?: React$1.ReactNode;
+}
+/**
+ * Owns the kernel as an effect-scoped resource: each effect setup creates and
+ * starts exactly one kernel; each cleanup destroys exactly that one. That is
+ * the contract StrictMode exercises (two kernels in dev, the first fully
+ * destroyed) — the kernel itself is never restarted after destroy.
+ *
+ * The kernel is published to context the moment it exists — before `start()`
+ * resolves — so the `fallback` can use workspace capabilities (i18n copy on a
+ * loading screen). The one exception is the very first render, which happens
+ * before the effect: it renders nothing. Children mount once `start()` resolves
+ * — which never touches the engine, so the shell is alive while WASM compiles
+ * or the transport connects. `initialDocuments` open in the background and
+ * stream into the registry (`useDocuments()` is reactive); per-document
+ * loading UI is the Stage's job, not a root gate.
+ *
+ * Engine ownership. When `engine` is a thunk, the Viewer owns it: each effect
+ * setup constructs one engine (construction is synchronous and inert — boot
+ * happens lazily inside the engine) and each cleanup destroys exactly that one
+ * — after the kernel, so handles close first. When `engine` is an instance it
+ * is borrowed and never destroyed here; the Viewer only warms up a local
+ * engine so the WASM boot overlaps plugin initialization. StrictMode's
+ * double-mount therefore constructs two independent thunk engines and tears
+ * the first fully down, matching the kernel's own effect-scoped lifecycle.
+ * That means dev-only double resource use (two worker spawns, two font
+ * fetches, briefly overlapping) — deliberate, because it is exactly the
+ * leak-detection contract StrictMode exists to exercise; production mounts
+ * once and boots once.
+ */
+declare const Viewer: React$1.ForwardRefExoticComponent<ViewerProps & React$1.RefAttributes<Kernel | null>>;
+declare const EmbedPDF: React$1.ForwardRefExoticComponent<ViewerProps & React$1.RefAttributes<Kernel | null>>;
+/**
+ * PageContext — the seam. A layer depends only on this, never on the Stage. So the
+ * same layer works inside a virtualized Stage and in a standalone <PageView>.
+ * Its members are documented on `PageContext` in `@embedpdf/web`.
+ */
+type PageContextValue = PageContext<PageTransform, PageViewDemand>;
+declare const PageProvider: React$1.Provider<PageContextValue | null>;
+declare function usePage(): PageContextValue;
+//#endregion
+export { usePageList as A, useDocumentsEvent as C, useOptionalCapability as D, useKernelValue as E, useViewerSettings as M, EpdfTheme$1 as N, useOptionalSelector as O, epdfTheme as P, useDocuments as S, useKernel as T, useCapability as _, EmbedPDF as a, useDocumentId as b, PageContextValue as c, ViewerProps as d, makePageContext$1 as f, useActiveDocumentId as g, shallowArray as h, DocumentScopeProps as i, useSelector as j, usePage as k, PageProvider as l, saveFile as m, DocumentGateProps as n, KernelProvider as o, mountWebFont as p, DocumentScope as r, KernelProviderProps as s, DocumentGate as t, Viewer as u, useCapabilityEvent as v, useDocumentsState as w, useDocumentScope as x, useDocument as y };
+//# sourceMappingURL=runtime-V3MVMb91.d.ts.map