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

package/dist/runtime-B6xcPsEb.js

@@ -0,0 +1,398 @@
+import { Fragment, jsx } from "react/jsx-runtime";
+import { DocumentsToken, createKernel, documentState, documentsState, isLocalEngine, shallowEqual, standInFor, viewerSettingsOf } from "@embedpdf/core";
+import { browserClock, epdfThemeVariables, makePageContext as makePageContext$1, mountWebFont, saveFile } from "@embedpdf/web";
+import { createContext, forwardRef, useContext, useEffect, useImperativeHandle, useRef, useState, useSyncExternalStore } from "react";
+//#region src/theme.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.
+*/
+function epdfTheme(theme) {
+	return epdfThemeVariables(theme);
+}
+//#endregion
+//#region src/dev.ts
+/**
+* Development-time guardrails. Every warning fires once per process (keyed),
+* says what is wrong and what to do instead, and compiles out of production
+* builds ({@link isDev}).
+*/
+const warned = /* @__PURE__ */ new Set();
+/**
+* Whether this is a development build, as the app's bundler says: every bundler replaces
+* `process.env.NODE_ENV`, with `"production"` in a production build, so there this is `false`
+* and the warnings behind it compile out. A page with no bundler has no `process` at all, and
+* counts as development: the warnings help most while you try the package out.
+*/
+function isDev() {
+	try {
+		return process.env.NODE_ENV !== "production";
+	} catch {
+		return true;
+	}
+}
+/** Warn once per key. No-op in production. */
+function devWarn(key, message) {
+	if (!isDev() || warned.has(key)) return;
+	warned.add(key);
+	console.warn(`[embedpdf] ${message}`);
+}
+//#endregion
+//#region src/runtime.tsx
+const KernelCtx = createContext(null);
+/** The document a subtree is bound to. null => use the active document. */
+const DocumentScopeCtx = createContext(null);
+function useKernel() {
+	const kernel = useContext(KernelCtx);
+	if (!kernel) throw new Error("useKernel must be used within <Viewer>/<EmbedPDF>");
+	return kernel;
+}
+/**
+* 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.
+*/
+function KernelProvider({ kernel, children }) {
+	return /* @__PURE__ */ jsx(KernelCtx.Provider, {
+		value: kernel,
+		children
+	});
+}
+const shallowArray = (left, right) => left === right || left.length === right.length && left.every((item, i) => item === right[i]);
+/** Read a value derived from the kernel, cached by equality (no tearing loop). */
+function useKernelValue(select, isEqual = Object.is) {
+	const kernel = useKernel();
+	const last = useRef(null);
+	const get = () => {
+		const next = select(kernel);
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return useSyncExternalStore(kernel.subscribe, get, get);
+}
+function useActiveDocumentId() {
+	return useKernelValue((kernel) => kernel.documents.getActiveId());
+}
+/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */
+function useDocumentId() {
+	const scoped = useDocumentScope();
+	const active = useActiveDocumentId();
+	return scoped ?? active;
+}
+/**
+* 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}.
+*/
+function useDocumentScope() {
+	return useContext(DocumentScopeCtx);
+}
+/** Bind a subtree to a specific document (panes, comparison). */
+function DocumentScope({ id, children }) {
+	return /* @__PURE__ */ jsx(DocumentScopeCtx.Provider, {
+		value: id,
+		children
+	});
+}
+/**
+* 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.
+*/
+function DocumentGate({ fallback = null, locked, error, children }) {
+	const document = useDocument();
+	if (document.status === "ready") return /* @__PURE__ */ jsx(Fragment, { children });
+	if (document.status === "locked" && locked) return /* @__PURE__ */ jsx(Fragment, { children: locked(document) });
+	if (document.status === "error" && error) return /* @__PURE__ */ jsx(Fragment, { children: error(document) });
+	return /* @__PURE__ */ jsx(Fragment, { children: fallback });
+}
+/**
+* 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.
+*/
+function useCapability(token) {
+	const kernel = useKernel();
+	const capability = useOptionalCapability(token);
+	if (capability) return capability;
+	if (kernel.scopeOf(token) === "document") return standInFor(kernel, token);
+	return kernel.capability(token);
+}
+/** Like `useCapability`, but null while the token can't resolve (no plugin,
+*  no document, or a document that isn't ready yet). */
+function useOptionalCapability(token) {
+	const scoped = useDocumentScope();
+	return useKernelValue((kernel) => kernel.tryCapability(token, scoped ?? void 0));
+}
+/**
+* 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.
+*/
+function useSelector(token, select, isEqual = Object.is) {
+	const kernel = useKernel();
+	const scoped = useDocumentScope();
+	const capability = useOptionalCapability(token) ?? kernel.capability(token, scoped ?? void 0);
+	const last = useRef(null);
+	const get = () => {
+		const next = select(capability);
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return useSyncExternalStore(kernel.subscribe, get, get);
+}
+/**
+* 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.
+*/
+function useOptionalSelector(token, select, fallback, isEqual = Object.is) {
+	const kernel = useKernel();
+	const capability = useOptionalCapability(token);
+	const last = useRef(null);
+	const get = () => {
+		let next;
+		if (capability === null) next = fallback;
+		else try {
+			next = select(capability);
+		} catch {
+			next = fallback;
+		}
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return useSyncExternalStore(kernel.subscribe, get, get);
+}
+/**
+* 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.
+*/
+function useCapabilityEvent(token, select, handler) {
+	const capability = useOptionalCapability(token);
+	const handlerRef = useRef(handler);
+	handlerRef.current = handler;
+	const selectRef = useRef(select);
+	selectRef.current = select;
+	useEffect(() => {
+		if (!capability) return;
+		return selectRef.current(capability)((event) => handlerRef.current(event));
+	}, [capability]);
+}
+/**
+* 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()`.
+*/
+function useDocuments() {
+	return useCapability(DocumentsToken);
+}
+/** Read a state declaration's value through the kernel, or the value `select` picks from it. */
+function useDeclared(token, read, empty, select) {
+	const scoped = useDocumentScope();
+	return useKernelValue((kernel) => {
+		const capability = kernel.tryCapability(token, scoped ?? void 0);
+		const state = capability ? read(capability) : empty;
+		return select ? select(state) : state;
+	}, shallowEqual);
+}
+/**
+* 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.
+*/
+function useDocument(select) {
+	return useDeclared(DocumentsToken, documentState.read, documentState.empty, select);
+}
+/**
+* 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.
+*/
+function useDocumentsState(select) {
+	return useDeclared(DocumentsToken, documentsState.read, documentsState.empty, select);
+}
+/** Subscribe to one documents event for the mounted lifetime: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */
+function useDocumentsEvent(select, handler) {
+	useCapabilityEvent(DocumentsToken, select, handler);
+}
+const NO_PAGES = Object.freeze([]);
+/**
+* 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.
+*/
+function usePageList() {
+	const documentId = useDocumentId();
+	return useKernelValue((kernel) => documentId ? kernel.documents.listPages(documentId) : NO_PAGES);
+}
+/**
+* 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.
+*/
+function useViewerSettings(select) {
+	return useKernelValue((kernel) => {
+		const settings = kernel.getSettings();
+		return select ? select(settings) : settings;
+	}, shallowEqual);
+}
+/**
+* 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.
+*/
+const Viewer = forwardRef(function Viewer({ engine, plugins, initialDocuments, fallback, renderError, onReady, identity, scope, accent, page, children }, ref) {
+	const initial = useRef({
+		engine,
+		plugins,
+		initialDocuments
+	});
+	const settings = viewerSettingsOf({
+		identity,
+		scope,
+		accent,
+		page
+	});
+	const latestSettings = useRef(settings);
+	latestSettings.current = settings;
+	const warned = useRef(false);
+	if (isDev() && !warned.current) {
+		if (initial.current.engine !== engine || initial.current.plugins !== plugins) {
+			warned.current = true;
+			console.warn("[embedpdf] <Viewer> engine/plugins are init-only. A changed identity is ignored — pass stable references (module scope, useState, or useMemo). An inline `plugins={[...]}` array recreates its identity every render.");
+		}
+	}
+	const [boot, setBoot] = useState({
+		phase: "booting",
+		kernel: null
+	});
+	const onReadyRef = useRef(onReady);
+	onReadyRef.current = onReady;
+	useImperativeHandle(ref, () => boot.phase === "ready" ? boot.kernel : null, [boot]);
+	useEffect(() => {
+		const captured = initial.current;
+		const ownsEngine = typeof captured.engine === "function";
+		const engine = ownsEngine ? captured.engine() : captured.engine;
+		if (isLocalEngine(engine)) engine.warmup();
+		let kernel;
+		try {
+			kernel = createKernel({
+				engine,
+				plugins: captured.plugins,
+				settings: latestSettings.current,
+				clock: browserClock()
+			});
+		} catch (error) {
+			setBoot({
+				phase: "error",
+				error
+			});
+			if (ownsEngine) engine.destroy();
+			return;
+		}
+		let alive = true;
+		setBoot({
+			phase: "booting",
+			kernel
+		});
+		kernel.start().then(() => {
+			if (!alive) return;
+			onReadyRef.current?.(kernel);
+			setBoot({
+				phase: "ready",
+				kernel
+			});
+			kernel.documents.openAll(captured.initialDocuments ?? []);
+		}, (error) => {
+			if (alive) setBoot({
+				phase: "error",
+				error
+			});
+		});
+		return () => {
+			alive = false;
+			kernel.destroy().then(() => {
+				if (ownsEngine) engine.destroy();
+			});
+		};
+	}, []);
+	const liveKernel = boot.phase === "error" ? null : boot.kernel;
+	useEffect(() => {
+		liveKernel?.updateSettings(latestSettings.current);
+	});
+	if (boot.phase === "error") return /* @__PURE__ */ jsx(Fragment, { children: renderError ? renderError(boot.error) : null });
+	if (!boot.kernel) return null;
+	return /* @__PURE__ */ jsx(KernelCtx.Provider, {
+		value: boot.kernel,
+		children: boot.phase === "ready" ? children : fallback ?? null
+	});
+});
+const EmbedPDF = Viewer;
+const PageCtx = createContext(null);
+const PageProvider = PageCtx.Provider;
+function usePage() {
+	const context = useContext(PageCtx);
+	if (!context) throw new Error("usePage must be used inside <PageView> or a <Stage> page");
+	return context;
+}
+//#endregion
+export { useOptionalSelector as C, useViewerSettings as D, useSelector as E, devWarn as O, useOptionalCapability as S, usePageList as T, useDocuments as _, PageProvider as a, useKernel as b, mountWebFont as c, useActiveDocumentId as d, useCapability as f, useDocumentScope as g, useDocumentId as h, KernelProvider as i, epdfTheme as k, saveFile as l, useDocument as m, DocumentScope as n, Viewer as o, useCapabilityEvent as p, EmbedPDF as r, makePageContext$1 as s, DocumentGate as t, shallowArray as u, useDocumentsEvent as v, usePage as w, useKernelValue as x, useDocumentsState as y };
+
+//# sourceMappingURL=runtime-B6xcPsEb.js.map

package/dist/runtime-B6xcPsEb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-B6xcPsEb.js","names":[],"sources":["../src/theme.ts","../src/dev.ts","../src/runtime.tsx"],"sourcesContent":["/**\n * `epdfTheme()`: a theme written with setting names, as a style for the\n * element around your viewer. The variables and their lookup are framework-free\n * (`@embedpdf/web`); this only types the result as React's style.\n */\nimport type * as React from 'react';\nimport { epdfThemeVariables, type EpdfTheme } from '@embedpdf/web';\n\nexport type { EpdfTheme } from '@embedpdf/web';\n\n/**\n * The CSS variables of a theme, for a `style` prop: `<div style={epdfTheme({ accent })}>`.\n * Everything inside the element follows them, and a CSS variable wins over any setting.\n */\nexport function epdfTheme(theme: EpdfTheme): React.CSSProperties {\n  return epdfThemeVariables(theme) as React.CSSProperties;\n}\n","/**\n * Development-time guardrails. Every warning fires once per process (keyed),\n * says what is wrong and what to do instead, and compiles out of production\n * builds ({@link isDev}).\n */\nconst warned = new Set<string>();\n\n/**\n * Whether this is a development build, as the app's bundler says: every bundler replaces\n * `process.env.NODE_ENV`, with `\"production\"` in a production build, so there this is `false`\n * and the warnings behind it compile out. A page with no bundler has no `process` at all, and\n * counts as development: the warnings help most while you try the package out.\n */\nexport function isDev(): boolean {\n  try {\n    return process.env.NODE_ENV !== 'production';\n  } catch {\n    return true;\n  }\n}\n\n/** Warn once per key. No-op in production. */\nexport function devWarn(key: string, message: string): void {\n  if (!isDev() || warned.has(key)) return;\n  warned.add(key);\n  console.warn(`[embedpdf] ${message}`);\n}\n\n/** Test seam: forget every warning so a suite can assert one fires again. */\nexport function resetDevWarnings(): void {\n  warned.clear();\n}\n","/**\n * @embedpdf/react — the generic binding.\n *\n * Binds the kernel's one change stream to React (useSyncExternalStore), resolves\n * capabilities (document-scoped ones against the active or `<DocumentScope>`-given\n * document, with a stand-in while there is none), and provides the page\n * coordinate context. Every plugin and layer rides on this — there is no\n * per-plugin framework code.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/core';\n// What a page with a viewer needs from the browser: handing bytes to the user as a download,\n// and a font the engine draws with, for text you draw yourself.\nexport { mountWebFont, saveFile } from '@embedpdf/web';\n// The page context every layer draws through; its conversions are shared with every framework.\nexport { makePageContext } from '@embedpdf/web';\n// A theme written with setting names, as the style for the element around a viewer.\nexport { epdfTheme } from './theme';\nexport type { EpdfTheme } from './theme';\nimport * as React from 'react';\nimport {\n  createContext,\n  forwardRef,\n  useContext,\n  useEffect,\n  useImperativeHandle,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react';\nimport {\n  DocumentsToken,\n  createKernel,\n  documentState,\n  documentsState,\n  isLocalEngine,\n  shallowEqual,\n  standInFor,\n  viewerSettingsOf,\n} from '@embedpdf/core';\nimport type {\n  AnyPlugin,\n  CapabilityToken,\n  DocumentInfo,\n  DocumentsCapability,\n  DocumentsState,\n  Engine,\n  EngineFactory,\n  EventHook,\n  FailedDocumentInfo,\n  Identity,\n  InitialDocument,\n  Kernel,\n  LockedDocumentInfo,\n  PageInfo,\n  ViewerPageSettings,\n  ViewerSettings,\n} from '@embedpdf/core';\n// Pure coordinate math from the geometry base — not from stage-core. The\n// PageContext seam stays stage-agnostic (it must also serve standalone PageView).\nimport type { PageTransform } from '@embedpdf/core-geometry';\nimport type { PageViewDemand } from '@embedpdf/plugin-render/contract';\nimport { browserClock } from '@embedpdf/web';\nimport type { PageContext } from '@embedpdf/web';\n\nimport { isDev } from './dev';\n\nconst KernelCtx = createContext<Kernel | null>(null);\n/** The document a subtree is bound to. null => use the active document. */\nconst DocumentScopeCtx = createContext<string | null>(null);\n\nexport function useKernel(): Kernel {\n  const kernel = useContext(KernelCtx);\n  if (!kernel) throw new Error('useKernel must be used within <Viewer>/<EmbedPDF>');\n  return kernel;\n}\n\nexport interface KernelProviderProps {\n  kernel: Kernel;\n  children?: React.ReactNode;\n}\n/**\n * Give a subtree a kernel someone else created and owns, so every hook in it\n * works against that kernel. The full viewer's wrapper puts the children it\n * slots into the viewer inside one. The provider never starts or destroys the\n * kernel; `<Viewer>` is the component that owns one.\n */\nexport function KernelProvider({ kernel, children }: KernelProviderProps) {\n  return <KernelCtx.Provider value={kernel}>{children}</KernelCtx.Provider>;\n}\n\nexport const shallowArray = <T,>(left: readonly T[], right: readonly T[]): boolean =>\n  left === right || (left.length === right.length && left.every((item, i) => item === right[i]));\n\n/** Read a value derived from the kernel, cached by equality (no tearing loop). */\nexport function useKernelValue<R>(\n  select: (kernel: Kernel) => R,\n  isEqual: (left: R, right: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    const next = select(kernel);\n    if (last.current && isEqual(last.current.v, next)) return last.current.v;\n    last.current = { v: next };\n    return next;\n  };\n  return useSyncExternalStore(kernel.subscribe, get, get);\n}\n\nexport function useActiveDocumentId(): string | null {\n  return useKernelValue((kernel) => kernel.documents.getActiveId());\n}\n\n/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */\nexport function useDocumentId(): string | null {\n  const scoped = useDocumentScope();\n  const active = useActiveDocumentId();\n  return scoped ?? active;\n}\n\n/**\n * The document the nearest <DocumentScope> binds this subtree to, or null when\n * it follows the active document. For resolvers that pass it to\n * `kernel.tryCapability`, which reads the active document at call time; UI\n * that needs the id itself uses {@link useDocumentId}.\n */\nexport function useDocumentScope(): string | null {\n  return useContext(DocumentScopeCtx);\n}\n\nexport interface DocumentScopeProps {\n  id: string;\n  children: React.ReactNode;\n}\n/** Bind a subtree to a specific document (panes, comparison). */\nexport function DocumentScope({ id, children }: DocumentScopeProps) {\n  return <DocumentScopeCtx.Provider value={id}>{children}</DocumentScopeCtx.Provider>;\n}\n\nexport interface DocumentGateProps {\n  /** Shown while this subtree has no document: none is open, or it's still opening. */\n  fallback?: React.ReactNode;\n  /** Shown while the document waits for its password; `fallback` without it. */\n  locked?: (document: LockedDocumentInfo) => React.ReactNode;\n  /** Shown when the document couldn't be opened, with why; `fallback` without it. */\n  error?: (document: FailedDocumentInfo) => React.ReactNode;\n  children?: React.ReactNode;\n}\n/**\n * Render children only while this subtree has a ready document — the\n * structural way to say \"this UI is defined over a document\". An empty\n * workspace is a legitimate, designable state (the Viewer no longer blocks on\n * documents so chrome can render at t≈0): workspace-scoped UI (toolbars,\n * commands, i18n) lives outside the gate; document-scoped UI (Stage, panels,\n * page chrome) lives inside it. A document that waits for its password, or\n * failed, renders `locked` or `error` with it, or else `fallback`. Sibling of\n * <DocumentScope>, which picks which document; this one handles whether.\n */\nexport function DocumentGate({ fallback = null, locked, error, children }: DocumentGateProps) {\n  const document = useDocument();\n  if (document.status === 'ready') return <>{children}</>;\n  if (document.status === 'locked' && locked) {\n    return <>{locked(document as LockedDocumentInfo)}</>;\n  }\n  if (document.status === 'error' && error) return <>{error(document as FailedDocumentInfo)}</>;\n  return <>{fallback}</>;\n}\n\n/**\n * Resolve a capability by token, binding document-scoped ones to this\n * subtree's document. Resolution is a reactive read (`tryCapability` through\n * the kernel's one change stream), not a memoized call — under the\n * request-time lifecycle a document can become resolvable while its id stays\n * the same, so any id-keyed cache goes stale; subscribing makes staleness\n * structurally impossible.\n *\n * Outside a document (none open, not ready yet, or none in scope), a document\n * plugin resolves to its stand-in (`standInFor` from `@embedpdf/core`):\n * rendering never fails, and a method called too early refuses with\n * `not-ready` (a method that returns a promise rejects). A token no plugin\n * provides still throws the kernel's reason, because that is a setup mistake.\n */\nexport function useCapability<T>(token: CapabilityToken<T>): T {\n  const kernel = useKernel();\n  const capability = useOptionalCapability(token);\n  if (capability) return capability;\n  if (kernel.scopeOf(token) === 'document') return standInFor(kernel, token);\n  return kernel.capability(token);\n}\n\n/** Like `useCapability`, but null while the token can't resolve (no plugin,\n *  no document, or a document that isn't ready yet). */\nexport function useOptionalCapability<T>(token: CapabilityToken<T>): T | null {\n  const scoped = useDocumentScope();\n  return useKernelValue((kernel) => kernel.tryCapability(token, scoped ?? undefined));\n}\n\n/**\n * Subscribe to a selector over a (document-resolved) capability. Strict:\n * while the token can't resolve, it throws the kernel's reason (`no\n * document`, `document is loading`), for code that knows a document exists,\n * such as anything inside a <DocumentGate>. `useOptionalSelector` is its\n * total twin.\n */\nexport function useSelector<C, R>(\n  token: CapabilityToken<C>,\n  select: (capability: C) => R,\n  isEqual: (left: R, right: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const scoped = useDocumentScope();\n  const capability = useOptionalCapability(token) ?? kernel.capability(token, scoped ?? undefined);\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    const next = select(capability);\n    if (last.current && isEqual(last.current.v, next)) return last.current.v;\n    last.current = { v: next };\n    return next;\n  };\n  return useSyncExternalStore(kernel.subscribe, get, get);\n}\n\n/**\n * Null-safe `useSelector`: `fallback` whenever the token can't resolve — no\n * provider, or a document-scoped token with no document. For chrome that stays\n * mounted across the empty-workspace state (a zoom readout, a mode band).\n *\n * The `select` guard also swallows reads through a capability whose document\n * closed between the store notification and this render — that teardown race\n * resolves to `fallback` for one frame, then re-renders against the new state.\n */\nexport function useOptionalSelector<C, R>(\n  token: CapabilityToken<C>,\n  select: (capability: C) => R,\n  fallback: R,\n  isEqual: (left: R, right: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const capability = useOptionalCapability(token);\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    let next: R;\n    if (capability === null) {\n      next = fallback;\n    } else {\n      try {\n        next = select(capability);\n      } catch {\n        next = fallback;\n      }\n    }\n    if (last.current && isEqual(last.current.v, next)) return last.current.v;\n    last.current = { v: next };\n    return next;\n  };\n  return useSyncExternalStore(kernel.subscribe, get, get);\n}\n\n/**\n * Subscribe to a capability's {@link EventHook} for the mounted lifetime —\n * `useCapabilityEvent(ActionsToken, (actions) => actions.onExecuted, handler)`. Events\n * carry occurrences, never state (a late subscriber that needs the current\n * value uses `useSelector`). The handler rides a ref, so a fresh closure per\n * render never resubscribes. Null-safe: no plugin/document → no subscription.\n */\nexport function useCapabilityEvent<C, T>(\n  token: CapabilityToken<C>,\n  select: (capability: C) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  const capability = useOptionalCapability(token);\n  const handlerRef = useRef(handler);\n  handlerRef.current = handler;\n  const selectRef = useRef(select);\n  selectRef.current = select;\n  useEffect(() => {\n    if (!capability) return;\n    return selectRef.current(capability)((event) => handlerRef.current(event));\n  }, [capability]);\n}\n\n/**\n * The documents API: open, close, unlock, download, and the tabs. Inside a\n * <DocumentScope>, the calls that leave out the document use that one, so\n * `download()` without an id downloads the document in scope. The object\n * never changes, so it's safe in effects and callbacks. What to show comes\n * from `useDocument()` and `useDocumentsState()`.\n */\nexport function useDocuments(): DocumentsCapability {\n  return useCapability(DocumentsToken);\n}\n\n/** Read a state declaration's value through the kernel, or the value `select` picks from it. */\nfunction useDeclared<Capability, State extends object, Selected>(\n  token: CapabilityToken<Capability>,\n  read: (capability: Capability) => State,\n  empty: State,\n  select: ((state: State) => Selected) | undefined,\n): Selected {\n  const scoped = useDocumentScope();\n  return useKernelValue((kernel) => {\n    const capability = kernel.tryCapability(token, scoped ?? undefined);\n    const state = capability ? read(capability) : empty;\n    return select ? select(state) : (state as unknown as Selected);\n  }, shallowEqual);\n}\n\n/**\n * The document this component talks to: the one its <DocumentScope> names, or\n * else the active one. Its `id`, `name`, `status`, `pageCount`,\n * `hasUnsavedChanges`, and why it's locked or failed. With no document, an\n * empty one that reads as still opening. Takes a selector, and re-renders only\n * when what it returns changes.\n */\nexport function useDocument<Selected = DocumentInfo>(\n  select?: (document: DocumentInfo) => Selected,\n): Selected {\n  return useDeclared(DocumentsToken, documentState.read, documentState.empty, select);\n}\n\n/**\n * Every open document, in tab order (loading, locked and failed ones too),\n * and the active one's id. Takes a selector, and re-renders only when what it\n * returns changes.\n */\nexport function useDocumentsState<Selected = DocumentsState>(\n  select?: (state: DocumentsState) => Selected,\n): Selected {\n  return useDeclared(DocumentsToken, documentsState.read, documentsState.empty, select);\n}\n\n/** Subscribe to one documents event for the mounted lifetime: `useDocumentsEvent((documents) => documents.onOpened, handler)`. */\nexport function useDocumentsEvent<T>(\n  select: (documents: DocumentsCapability) => EventHook<T>,\n  handler: (event: T) => void,\n): void {\n  useCapabilityEvent(DocumentsToken, select, handler);\n}\n\nconst NO_PAGES: readonly PageInfo[] = Object.freeze([]);\n\n/**\n * The pages of the document this component talks to, in order: each with its\n * `ref`, `index`, `label`, size and rotation. Needs no Stage, so a thumbnail\n * list or a page picker works anywhere. The same array until a page is added,\n * removed, moved or rotated; empty with no document.\n */\nexport function usePageList(): readonly PageInfo[] {\n  const documentId = useDocumentId();\n  return useKernelValue((kernel) =>\n    documentId ? kernel.documents.listPages(documentId) : NO_PAGES,\n  );\n}\n\n/**\n * The viewer's own settings (`<Viewer identity scope accent page>`), or the\n * value `select` picks from them: the accent every part without a color of its\n * own follows, and how pages look. What paints a page or an accent reads it\n * here, through `paint()` from `@embedpdf/web`, so a CSS variable still wins.\n */\nexport function useViewerSettings<Selected = ViewerSettings>(\n  select?: (settings: ViewerSettings) => Selected,\n): Selected {\n  return useKernelValue((kernel) => {\n    const settings = kernel.getSettings();\n    return select ? select(settings) : (settings as unknown as Selected);\n  }, shallowEqual);\n}\n\n// `InitialDocument` is the kernel's type (re-exported via `export * from\n// '@embedpdf/core'` above) — one shared shape for every adapter.\n\nexport interface ViewerProps {\n  /**\n   * The engine, as an instance or a thunk. Engines construct synchronously and\n   * boot lazily (`localEngine()` allocates nothing until first use), so\n   * ownership follows the shape of what you pass:\n   *\n   *   - An **instance** (`engine={engine}`) is borrowed: the Viewer uses it and\n   *     never destroys it, because you acquired it and therefore own it. The\n   *     common path — a module-scope `const engine = localEngine()` shared\n   *     across viewers and route changes. The Viewer warms up a local engine\n   *     on mount so the boot overlaps app initialization.\n   *   - A **thunk** (`engine={() => localEngine()}`) is viewer-owned: the\n   *     Viewer calls it on mount and `destroy()`s the result on unmount. Use it\n   *     for per-mount isolation (StrictMode/HMR-clean teardown, independent\n   *     multi-viewer engines).\n   *\n   * Init-only: captured on first render; later identity changes are ignored (dev warns).\n   */\n  engine: Engine | EngineFactory;\n  /** Init-only: captured on first render; later identity changes are ignored (dev warns). */\n  plugins: AnyPlugin[];\n  /** Documents to open on startup (with optional tab names). Init-only. */\n  initialDocuments?: InitialDocument[];\n  fallback?: React.ReactNode;\n  /** Rendered when kernel construction or `start()` fails. Without it a boot\n   *  failure renders nothing — but never a silent forever-fallback. */\n  renderError?: (error: unknown) => React.ReactNode;\n  /** Called once the kernel has started — before `children` mount and before\n   *  `initialDocuments` open. The imperative door for code outside React\n   *  (register commands, subscribe events). The `ref` carries the same kernel. */\n  onReady?: (kernel: Kernel) => void;\n  /**\n   * Who the user is, for every document opened without an `identity` of its\n   * own (which replaces this one). Documents opened after a change use the new\n   * value; open ones keep theirs. The local engine only: the cloud engine reads\n   * it from the document's token.\n   */\n  identity?: Identity;\n  /**\n   * What the user may do, as permissions, in every document opened without a\n   * `scope` of its own (which replaces this one). Left out, they may do\n   * everything. Changes reach the documents opened after them, as `identity`.\n   */\n  scope?: readonly string[];\n  /** The color every part without a color of its own follows. CSS `--epdf-accent` wins over it. */\n  accent?: string;\n  /** How pages look: `background` before the picture arrives, and the `shadow` under each page. */\n  page?: Partial<ViewerPageSettings>;\n  children?: React.ReactNode;\n}\n\ntype BootState =\n  | { phase: 'booting'; kernel: Kernel | null }\n  | { phase: 'ready'; kernel: Kernel }\n  | { phase: 'error'; error: unknown };\n\n/**\n * Owns the kernel as an effect-scoped resource: each effect setup creates and\n * starts exactly one kernel; each cleanup destroys exactly that one. That is\n * the contract StrictMode exercises (two kernels in dev, the first fully\n * destroyed) — the kernel itself is never restarted after destroy.\n *\n * The kernel is published to context the moment it exists — before `start()`\n * resolves — so the `fallback` can use workspace capabilities (i18n copy on a\n * loading screen). The one exception is the very first render, which happens\n * before the effect: it renders nothing. Children mount once `start()` resolves\n * — which never touches the engine, so the shell is alive while WASM compiles\n * or the transport connects. `initialDocuments` open in the background and\n * stream into the registry (`useDocuments()` is reactive); per-document\n * loading UI is the Stage's job, not a root gate.\n *\n * Engine ownership. When `engine` is a thunk, the Viewer owns it: each effect\n * setup constructs one engine (construction is synchronous and inert — boot\n * happens lazily inside the engine) and each cleanup destroys exactly that one\n * — after the kernel, so handles close first. When `engine` is an instance it\n * is borrowed and never destroyed here; the Viewer only warms up a local\n * engine so the WASM boot overlaps plugin initialization. StrictMode's\n * double-mount therefore constructs two independent thunk engines and tears\n * the first fully down, matching the kernel's own effect-scoped lifecycle.\n * That means dev-only double resource use (two worker spawns, two font\n * fetches, briefly overlapping) — deliberate, because it is exactly the\n * leak-detection contract StrictMode exists to exercise; production mounts\n * once and boots once.\n */\nexport const Viewer = forwardRef<Kernel | null, ViewerProps>(function Viewer(\n  {\n    engine,\n    plugins,\n    initialDocuments,\n    fallback,\n    renderError,\n    onReady,\n    identity,\n    scope,\n    accent,\n    page,\n    children,\n  }: ViewerProps,\n  ref,\n) {\n  // Init-only inputs: the kernel's lifetime is the component's lifetime, so a\n  // changed engine/plugins identity cannot mean \"rebuild the workspace\" —\n  // that would silently drop every open document. Capture once, warn in dev.\n  const initial = useRef({ engine, plugins, initialDocuments });\n  // The viewer's settings follow the props. The first ones go to the kernel when it's\n  // created, so the initial documents open with them; later ones as they change.\n  const settings = viewerSettingsOf({ identity, scope, accent, page });\n  const latestSettings = useRef(settings);\n  latestSettings.current = settings;\n  const warned = useRef(false);\n  if (isDev() && !warned.current) {\n    if (initial.current.engine !== engine || initial.current.plugins !== plugins) {\n      warned.current = true;\n      console.warn(\n        '[embedpdf] <Viewer> engine/plugins are init-only. A changed identity is ignored — ' +\n          'pass stable references (module scope, useState, or useMemo). ' +\n          'An inline `plugins={[...]}` array recreates its identity every render.',\n      );\n    }\n  }\n\n  const [boot, setBoot] = useState<BootState>({ phase: 'booting', kernel: null });\n  const onReadyRef = useRef(onReady);\n  onReadyRef.current = onReady;\n  // The ref is the started kernel (null before boot and after an error).\n  useImperativeHandle<Kernel | null, Kernel | null>(\n    ref,\n    () => (boot.phase === 'ready' ? boot.kernel : null),\n    [boot],\n  );\n  useEffect(() => {\n    const captured = initial.current;\n    // A thunk is viewer-owned: call it now, destroy on unmount. An instance is\n    // borrowed: use as-is, never destroy. Construction is synchronous and inert\n    // either way — the engine boots lazily on first use — so a local engine's\n    // `warmup()` overlaps the WASM boot with plugin initialization.\n    const ownsEngine = typeof captured.engine === 'function';\n    const engine: Engine = ownsEngine\n      ? (captured.engine as EngineFactory)()\n      : (captured.engine as Engine);\n    if (isLocalEngine(engine)) engine.warmup();\n    let kernel: Kernel;\n    try {\n      kernel = createKernel({\n        engine,\n        plugins: captured.plugins,\n        settings: latestSettings.current,\n        clock: browserClock(),\n      });\n    } catch (error) {\n      setBoot({ phase: 'error', error }); // plan/graph errors surface, not throw mid-render\n      if (ownsEngine) void engine.destroy();\n      return;\n    }\n    let alive = true;\n    setBoot({ phase: 'booting', kernel }); // context carries the kernel from this frame on\n    kernel.start().then(\n      () => {\n        if (!alive) return; // unmounted mid-boot — don't open anything\n        onReadyRef.current?.(kernel);\n        setBoot({ phase: 'ready', kernel });\n        // Kernel-owned boot policy: all tabs appear immediately in array\n        // order; the `active` entry (else the first) is selected; failures\n        // surface as tab status. See DocumentsCapability.openAll.\n        kernel.documents.openAll(captured.initialDocuments ?? []);\n      },\n      (error) => {\n        if (alive) setBoot({ phase: 'error', error });\n      },\n    );\n    return () => {\n      alive = false;\n      // Kernel first (closes every document handle), then the engine we own —\n      // ownership follows acquisition. `engine.destroy()` joins an in-flight\n      // boot (or no-ops if it never started), so an unmount mid-boot is safe.\n      void kernel.destroy().then(() => {\n        if (ownsEngine) void engine.destroy();\n      });\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  // After every render: props compare by value (an inline `page={{ shadow: 'none' }}` is a new\n  // object each time), and settings that didn't change change nothing.\n  const liveKernel = boot.phase === 'error' ? null : boot.kernel;\n  useEffect(() => {\n    liveKernel?.updateSettings(latestSettings.current);\n  });\n\n  if (boot.phase === 'error') {\n    return <>{renderError ? renderError(boot.error) : null}</>;\n  }\n  if (!boot.kernel) return null; // pre-effect first render only\n  return (\n    <KernelCtx.Provider value={boot.kernel}>\n      {boot.phase === 'ready' ? children : (fallback ?? null)}\n    </KernelCtx.Provider>\n  );\n});\nexport const EmbedPDF = Viewer;\n\n/**\n * PageContext — the seam. A layer depends only on this, never on the Stage. So the\n * same layer works inside a virtualized Stage and in a standalone <PageView>.\n * Its members are documented on `PageContext` in `@embedpdf/web`.\n */\nexport type PageContextValue = PageContext<PageTransform, PageViewDemand>;\n\nconst PageCtx = createContext<PageContextValue | null>(null);\nexport const PageProvider = PageCtx.Provider;\n\nexport function usePage(): PageContextValue {\n  const context = useContext(PageCtx);\n  if (!context) throw new Error('usePage must be used inside <PageView> or a <Stage> page');\n  return context;\n}\n"],"mappings":"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"}