@embedpdf/react 3.0.0-next.0

package/dist/runtime-DV98q7I0.d.ts

@@ -0,0 +1,195 @@
+import { AnyPlugin, CapabilityToken, Engine, EngineFactory, InitialDocument, Kernel } from "@embedpdf/core";
+import * as React from "react";
+import { PageFrame, PageTransform, Point, Rect } from "@embedpdf/core-geometry";
+import { PageViewDemand } from "@embedpdf/plugin-render";
+//#region src/runtime.d.ts
+declare function useKernel(): Kernel;
+declare const shallowArray: <T>(a: readonly T[], b: readonly T[]) => boolean;
+/** Read a value derived from the kernel, cached by equality (no tearing loop). */
+declare function useKernelValue<R>(select: (k: Kernel) => R, isEqual?: (a: R, b: 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;
+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 (empty workspace, docs still opening). */
+  fallback?: 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, or reads through `useOptionalSelector`.
+ * A `loading`/`locked`/`error` tab renders `fallback` — so the gate's
+ * fallback doubles as the per-tab boot state; richer chrome (a password
+ * prompt, an error pane) branches on `useDocumentStatus()` beside the gate.
+ * Sibling of <DocumentScope>, which picks WHICH document; this one handles
+ * WHETHER.
+ */
+declare function DocumentGate({ fallback, children }: DocumentGateProps): import("react/jsx-runtime").JSX.Element;
+/** Lifecycle status of this subtree's document (loading/locked/ready/error),
+ *  or null with no document. The password prompt and error panes key off it. */
+declare function useDocumentStatus(): import("@embedpdf/core").DocStatus | null;
+/**
+ * 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. Fail-fast: 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.
+ */
+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. */
+declare function useSelector<C, R>(token: CapabilityToken<C>, select: (cap: C) => R, isEqual?: (a: R, b: 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).
+ * `useSelector` stays strict (fail-fast) for code that KNOWS a document exists
+ * — e.g. anything inside a <DocumentGate>.
+ *
+ * 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: (cap: C) => R, fallback: R, isEqual?: (a: R, b: R) => boolean): R;
+/** The document registry (open/close/active/list), reactive. */
+declare function useDocuments(): {
+  docs: import("@embedpdf/core").DocInfo[];
+  activeId: string | null;
+  open: (input: import("@embedpdf/core").OpenSource, options?: import("@embedpdf/core").OpenDocumentOptions) => Promise<string>;
+  unlock: (id: string, input: {
+    password: string;
+  }) => Promise<void>;
+  close: (id: string) => Promise<void>;
+  setActive: (id: string) => void;
+  move: (id: string, toIndex: number) => void;
+  swap: (a: string, b: string) => void;
+  download: (id?: string, opts?: {
+    mode?: import("@embedpdf/core").PdfSaveMode;
+  }) => Promise<Uint8Array>;
+  downloadLayer: (id?: string) => Promise<Uint8Array>;
+};
+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 calls `engine.warmup?.()`
+   *     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;
+  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) exactly as before. 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 calls `warmup?.()` so
+ * the WASM/transport 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 function Viewer({ engine, plugins, initialDocuments, fallback, renderError, children }: ViewerProps): import("react/jsx-runtime").JSX.Element | null;
+declare const EmbedPDF: typeof Viewer;
+/**
+ * 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>.
+ */
+interface PageContextValue {
+  documentId: string;
+  /** Durable page identity (PDF object number) — use for keys / render / annotations. */
+  pon: number;
+  /** Display index (page N) — use for ordering / human-facing page numbers. */
+  pageIndex: number;
+  /**
+   * Reserved chrome bands around the page (screen px per side). The page-chrome
+   * slot renders into the outer box (content + frame); these thicknesses size
+   * the bands — a label in the bottom band is `bottom:0; height: frame.bottom`.
+   */
+  frame: PageFrame;
+  /**
+   * The single bridge between PDF points, view px, and device px for this page.
+   * Layers do ALL coordinate work through it — `pageToContent` to place content-
+   * space overlays, `renderScale`/`deviceWidth` to render, `contentWidth` for
+   * page-relative sizing. Never re-derive `x * scale` or `* dpr`.
+   */
+  transform: PageTransform;
+  /** Client (screen) point → PDF point — the one platform-bound hit-test. */
+  toPagePoint(clientX: number, clientY: number): Point;
+  /** PDF/content point → client (screen) px — the exact inverse of `toPagePoint`
+   *  (rotation applied). Lets viewport-space UI (e.g. a selection menu) anchor to a
+   *  page point WITHOUT a Stage camera, so it works the same in `<PageView>`. */
+  toClientPoint(p: Point): Point;
+  /** PDF/content rect → client (screen) px AABB. Rect analog of `toClientPoint`
+   *  for upright viewport-space UI that frames a selected page region. */
+  toClientRect(rect: Rect): Rect;
+  /**
+   * The page-view DEMAND for raster planning uses dependency inversion:
+   * plugin-render defines the shape; the host that CREATED this
+   * context fills it — as a PULL. The Stage host's getter closes over the
+   * stage capability and reads `VisiblePage.visibleRect` live at call time
+   * (visibility is the STAGE's data; adapters never re-derive camera math or
+   * cache a copy). Three states, three meanings: a real sub-rect (visible),
+   * a ZERO rect (stage host, page currently off-screen — want nothing), and
+   * an undefined getter (stage-less `<PageView>` — whole page visible, which
+   * a thumbnail-sized demand turns into "never engages" by arithmetic).
+   */
+  getViewDemand?: () => PageViewDemand;
+}
+declare const PageProvider: React.Provider<PageContextValue | null>;
+declare function usePage(): PageContextValue;
+declare function makePageContext(documentId: string, pon: number, pageIndex: number, frame: PageFrame, transform: PageTransform, getRect: () => DOMRect, getViewDemand?: () => PageViewDemand): PageContextValue;
+//#endregion
+export { useSelector as S, useKernel as _, EmbedPDF as a, useOptionalSelector as b, Viewer as c, shallowArray as d, useActiveDocumentId as f, useDocuments as g, useDocumentStatus as h, DocumentScopeProps as i, ViewerProps as l, useDocumentId as m, DocumentGateProps as n, PageContextValue as o, useCapability as p, DocumentScope as r, PageProvider as s, DocumentGate as t, makePageContext as u, useKernelValue as v, usePage as x, useOptionalCapability as y };
+//# sourceMappingURL=runtime-DV98q7I0.d.ts.map

package/dist/runtime.cjs

@@ -0,0 +1,314 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-DDXJien1.cjs");
+let react_jsx_runtime = require("react/jsx-runtime");
+let _embedpdf_core = require("@embedpdf/core");
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react, 1);
+//#region src/runtime.tsx
+const KernelCtx = (0, react.createContext)(null);
+/** The document a subtree is bound to. null => use the active document. */
+const DocumentScopeCtx = (0, react.createContext)(null);
+function useKernel() {
+	const k = (0, react.useContext)(KernelCtx);
+	if (!k) throw new Error("useKernel must be used within <Viewer>/<EmbedPDF>");
+	return k;
+}
+const shallowArray = (a, b) => a === b || a.length === b.length && a.every((x, i) => x === b[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 = (0, react.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 (0, react.useSyncExternalStore)(kernel.subscribe, get, get);
+}
+function useActiveDocumentId() {
+	return useKernelValue((k) => k.documents.activeId());
+}
+/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */
+function useDocumentId() {
+	const scoped = (0, react.useContext)(DocumentScopeCtx);
+	const active = useActiveDocumentId();
+	return scoped ?? active;
+}
+/** Bind a subtree to a specific document (panes, comparison). */
+function DocumentScope({ id, children }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.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, or reads through `useOptionalSelector`.
+* A `loading`/`locked`/`error` tab renders `fallback` — so the gate's
+* fallback doubles as the per-tab boot state; richer chrome (a password
+* prompt, an error pane) branches on `useDocumentStatus()` beside the gate.
+* Sibling of <DocumentScope>, which picks WHICH document; this one handles
+* WHETHER.
+*/
+function DocumentGate({ fallback = null, children }) {
+	const docId = useDocumentId();
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: useKernelValue((k) => docId ? k.documents.get(docId)?.status === "ready" : false) ? children : fallback });
+}
+/** Lifecycle status of this subtree's document (loading/locked/ready/error),
+*  or null with no document. The password prompt and error panes key off it. */
+function useDocumentStatus() {
+	const docId = useDocumentId();
+	return useKernelValue((k) => docId ? k.documents.get(docId)?.status ?? null : null);
+}
+/**
+* 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. Fail-fast: 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 useCapability(token) {
+	const kernel = useKernel();
+	const scoped = (0, react.useContext)(DocumentScopeCtx);
+	return useKernelValue((k) => k.tryCapability(token, scoped ?? void 0)) ?? kernel.capability(token, scoped ?? void 0);
+}
+/** 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 = (0, react.useContext)(DocumentScopeCtx);
+	return useKernelValue((k) => k.tryCapability(token, scoped ?? void 0));
+}
+/** Subscribe to a selector over a (document-resolved) capability. */
+function useSelector(token, select, isEqual = Object.is) {
+	const kernel = useKernel();
+	const cap = useCapability(token);
+	const last = (0, react.useRef)(null);
+	const get = () => {
+		const next = select(cap);
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return (0, react.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).
+* `useSelector` stays strict (fail-fast) for code that KNOWS a document exists
+* — e.g. anything inside a <DocumentGate>.
+*
+* 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 cap = useOptionalCapability(token);
+	const last = (0, react.useRef)(null);
+	const get = () => {
+		let next;
+		if (cap === null) next = fallback;
+		else try {
+			next = select(cap);
+		} catch {
+			next = fallback;
+		}
+		if (last.current && isEqual(last.current.v, next)) return last.current.v;
+		last.current = { v: next };
+		return next;
+	};
+	return (0, react.useSyncExternalStore)(kernel.subscribe, get, get);
+}
+/** The document registry (open/close/active/list), reactive. */
+function useDocuments() {
+	const kernel = useKernel();
+	return {
+		docs: useKernelValue((k) => k.documents.list(), _embedpdf_core.docInfoListEquals),
+		activeId: useActiveDocumentId(),
+		open: kernel.documents.open,
+		unlock: kernel.documents.unlock,
+		close: kernel.documents.close,
+		setActive: kernel.documents.setActive,
+		move: kernel.documents.move,
+		swap: kernel.documents.swap,
+		download: kernel.documents.download,
+		downloadLayer: kernel.documents.downloadLayer
+	};
+}
+/**
+* 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) exactly as before. 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 calls `warmup?.()` so
+* the WASM/transport 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.
+*/
+function Viewer({ engine, plugins, initialDocuments, fallback, renderError, children }) {
+	const initial = (0, react.useRef)({
+		engine,
+		plugins,
+		initialDocuments
+	});
+	const warned = (0, react.useRef)(false);
+	if (process.env.NODE_ENV !== "production" && !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] = (0, react.useState)({
+		phase: "booting",
+		kernel: null
+	});
+	(0, react.useEffect)(() => {
+		const captured = initial.current;
+		const ownsEngine = typeof captured.engine === "function";
+		const engine = ownsEngine ? captured.engine() : captured.engine;
+		engine.warmup?.();
+		let kernel;
+		try {
+			kernel = (0, _embedpdf_core.createKernel)({
+				engine,
+				plugins: captured.plugins
+			});
+		} catch (error) {
+			setBoot({
+				phase: "error",
+				error
+			});
+			if (ownsEngine) engine.destroy();
+			return;
+		}
+		let alive = true;
+		setBoot({
+			phase: "booting",
+			kernel
+		});
+		kernel.start().then(() => {
+			if (!alive) return;
+			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();
+			});
+		};
+	}, []);
+	if (boot.phase === "error") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: renderError ? renderError(boot.error) : null });
+	if (!boot.kernel) return null;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(KernelCtx.Provider, {
+		value: boot.kernel,
+		children: boot.phase === "ready" ? children : fallback ?? null
+	});
+}
+const EmbedPDF = Viewer;
+const PageCtx = (0, react.createContext)(null);
+const PageProvider = PageCtx.Provider;
+function usePage() {
+	const c = (0, react.useContext)(PageCtx);
+	if (!c) throw new Error("usePage must be used inside <PageView> or a <Stage> page");
+	return c;
+}
+function makePageContext(documentId, pon, pageIndex, frame, transform, getRect, getViewDemand) {
+	return {
+		documentId,
+		pon,
+		pageIndex,
+		frame,
+		transform,
+		...getViewDemand ? { getViewDemand } : {},
+		toPagePoint: (cx, cy) => {
+			const r = getRect();
+			return transform.viewToPage({
+				x: cx - r.left,
+				y: cy - r.top
+			});
+		},
+		toClientPoint: (p) => {
+			const r = getRect();
+			const v = transform.pageToView(p);
+			return {
+				x: r.left + v.x,
+				y: r.top + v.y
+			};
+		},
+		toClientRect: (rect) => {
+			const r = getRect();
+			const v = transform.pageToViewRect(rect);
+			return {
+				x: r.left + v.x,
+				y: r.top + v.y,
+				width: v.width,
+				height: v.height
+			};
+		}
+	};
+}
+//#endregion
+exports.DocumentGate = DocumentGate;
+exports.DocumentScope = DocumentScope;
+exports.EmbedPDF = EmbedPDF;
+exports.PageProvider = PageProvider;
+exports.Viewer = Viewer;
+exports.makePageContext = makePageContext;
+exports.shallowArray = shallowArray;
+exports.useActiveDocumentId = useActiveDocumentId;
+exports.useCapability = useCapability;
+exports.useDocumentId = useDocumentId;
+exports.useDocumentStatus = useDocumentStatus;
+exports.useDocuments = useDocuments;
+exports.useKernel = useKernel;
+exports.useKernelValue = useKernelValue;
+exports.useOptionalCapability = useOptionalCapability;
+exports.useOptionalSelector = useOptionalSelector;
+exports.usePage = usePage;
+exports.useSelector = useSelector;
+Object.keys(_embedpdf_core).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _embedpdf_core[k];
+		}
+	});
+});
+
+//# sourceMappingURL=runtime.cjs.map

package/dist/runtime.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.cjs","names":["docInfoListEquals"],"sources":["../src/runtime.tsx"],"sourcesContent":["/**\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), and provides the page coordinate context. Every plugin and layer rides\n * on this — there is no per-plugin framework code.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/core';\nimport * as React from 'react';\nimport {\n  createContext,\n  useContext,\n  useEffect,\n  useRef,\n  useState,\n  useSyncExternalStore,\n} from 'react';\nimport { createKernel, docInfoListEquals } from '@embedpdf/core';\nimport type {\n  AnyPlugin,\n  CapabilityToken,\n  Engine,\n  EngineFactory,\n  InitialDocument,\n  Kernel,\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 { PageFrame, PageTransform, Point, Rect } from '@embedpdf/core-geometry';\nimport type { PageViewDemand } from '@embedpdf/plugin-render';\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 k = useContext(KernelCtx);\n  if (!k) throw new Error('useKernel must be used within <Viewer>/<EmbedPDF>');\n  return k;\n}\n\nexport const shallowArray = <T,>(a: readonly T[], b: readonly T[]): boolean =>\n  a === b || (a.length === b.length && a.every((x, i) => x === b[i]));\n\n/** Read a value derived from the kernel, cached by equality (no tearing loop). */\nexport function useKernelValue<R>(\n  select: (k: Kernel) => R,\n  isEqual: (a: R, b: 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((k) => k.documents.activeId());\n}\n\n/** The document id for this subtree: the nearest <DocumentScope>, else the active doc. */\nexport function useDocumentId(): string | null {\n  const scoped = useContext(DocumentScopeCtx);\n  const active = useActiveDocumentId();\n  return scoped ?? active;\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 (empty workspace, docs still opening). */\n  fallback?: 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, or reads through `useOptionalSelector`.\n * A `loading`/`locked`/`error` tab renders `fallback` — so the gate's\n * fallback doubles as the per-tab boot state; richer chrome (a password\n * prompt, an error pane) branches on `useDocumentStatus()` beside the gate.\n * Sibling of <DocumentScope>, which picks WHICH document; this one handles\n * WHETHER.\n */\nexport function DocumentGate({ fallback = null, children }: DocumentGateProps) {\n  const docId = useDocumentId();\n  const ready = useKernelValue((k) => (docId ? k.documents.get(docId)?.status === 'ready' : false));\n  return <>{ready ? children : fallback}</>;\n}\n\n/** Lifecycle status of this subtree's document (loading/locked/ready/error),\n *  or null with no document. The password prompt and error panes key off it. */\nexport function useDocumentStatus() {\n  const docId = useDocumentId();\n  return useKernelValue((k) => (docId ? (k.documents.get(docId)?.status ?? null) : null));\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. Fail-fast: while unresolvable, this re-runs the\n * strict resolver so the kernel's truthful reason (`no capability` / `no\n * document` / `document is loading|locked`) is what throws.\n */\nexport function useCapability<T>(token: CapabilityToken<T>): T {\n  const kernel = useKernel();\n  const scoped = useContext(DocumentScopeCtx);\n  const cap = useKernelValue((k) => k.tryCapability(token, scoped ?? undefined));\n  return cap ?? kernel.capability(token, scoped ?? undefined);\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 = useContext(DocumentScopeCtx);\n  return useKernelValue((k) => k.tryCapability(token, scoped ?? undefined));\n}\n\n/** Subscribe to a selector over a (document-resolved) capability. */\nexport function useSelector<C, R>(\n  token: CapabilityToken<C>,\n  select: (cap: C) => R,\n  isEqual: (a: R, b: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const cap = useCapability(token);\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    const next = select(cap);\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 * `useSelector` stays strict (fail-fast) for code that KNOWS a document exists\n * — e.g. anything inside a <DocumentGate>.\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: (cap: C) => R,\n  fallback: R,\n  isEqual: (a: R, b: R) => boolean = Object.is,\n): R {\n  const kernel = useKernel();\n  const cap = useOptionalCapability(token);\n  const last = useRef<{ v: R } | null>(null);\n  const get = () => {\n    let next: R;\n    if (cap === null) {\n      next = fallback;\n    } else {\n      try {\n        next = select(cap);\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/** The document registry (open/close/active/list), reactive. */\nexport function useDocuments() {\n  const kernel = useKernel();\n  const docs = useKernelValue((k) => k.documents.list(), docInfoListEquals);\n  const activeId = useActiveDocumentId();\n  return {\n    docs,\n    activeId,\n    open: kernel.documents.open,\n    unlock: kernel.documents.unlock,\n    close: kernel.documents.close,\n    setActive: kernel.documents.setActive,\n    move: kernel.documents.move,\n    swap: kernel.documents.swap,\n    download: kernel.documents.download,\n    downloadLayer: kernel.documents.downloadLayer,\n  };\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 calls `engine.warmup?.()`\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  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) exactly as before. The one exception is the very first\n * render, which happens before the effect: it renders nothing. Children mount\n * once `start()` resolves — which never touches the engine, so the shell is\n * alive while WASM compiles or the transport connects. `initialDocuments`\n * open in the BACKGROUND and stream into the registry (`useDocuments()` is\n * reactive); per-document 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 calls `warmup?.()` so\n * the WASM/transport 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 function Viewer({\n  engine,\n  plugins,\n  initialDocuments,\n  fallback,\n  renderError,\n  children,\n}: ViewerProps) {\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  const warned = useRef(false);\n  if (process.env.NODE_ENV !== 'production' && !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  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 kick `warmup()`\n    // to overlap the WASM/transport 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    engine.warmup?.();\n    let kernel: Kernel;\n    try {\n      kernel = createKernel({ engine, plugins: captured.plugins });\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        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  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 */\nexport interface PageContextValue {\n  documentId: string;\n  /** Durable page identity (PDF object number) — use for keys / render / annotations. */\n  pon: number;\n  /** Display index (page N) — use for ordering / human-facing page numbers. */\n  pageIndex: number;\n  /**\n   * Reserved chrome bands around the page (screen px per side). The page-chrome\n   * slot renders into the outer box (content + frame); these thicknesses size\n   * the bands — a label in the bottom band is `bottom:0; height: frame.bottom`.\n   */\n  frame: PageFrame;\n  /**\n   * The single bridge between PDF points, view px, and device px for this page.\n   * Layers do ALL coordinate work through it — `pageToContent` to place content-\n   * space overlays, `renderScale`/`deviceWidth` to render, `contentWidth` for\n   * page-relative sizing. Never re-derive `x * scale` or `* dpr`.\n   */\n  transform: PageTransform;\n  /** Client (screen) point → PDF point — the one platform-bound hit-test. */\n  toPagePoint(clientX: number, clientY: number): Point;\n  /** PDF/content point → client (screen) px — the exact inverse of `toPagePoint`\n   *  (rotation applied). Lets viewport-space UI (e.g. a selection menu) anchor to a\n   *  page point WITHOUT a Stage camera, so it works the same in `<PageView>`. */\n  toClientPoint(p: Point): Point;\n  /** PDF/content rect → client (screen) px AABB. Rect analog of `toClientPoint`\n   *  for upright viewport-space UI that frames a selected page region. */\n  toClientRect(rect: Rect): Rect;\n  /**\n   * The page-view DEMAND for raster planning uses dependency inversion:\n   * plugin-render defines the shape; the host that CREATED this\n   * context fills it — as a PULL. The Stage host's getter closes over the\n   * stage capability and reads `VisiblePage.visibleRect` live at call time\n   * (visibility is the STAGE's data; adapters never re-derive camera math or\n   * cache a copy). Three states, three meanings: a real sub-rect (visible),\n   * a ZERO rect (stage host, page currently off-screen — want nothing), and\n   * an undefined getter (stage-less `<PageView>` — whole page visible, which\n   * a thumbnail-sized demand turns into \"never engages\" by arithmetic).\n   */\n  getViewDemand?: () => PageViewDemand;\n}\n\nconst PageCtx = createContext<PageContextValue | null>(null);\nexport const PageProvider = PageCtx.Provider;\n\nexport function usePage(): PageContextValue {\n  const c = useContext(PageCtx);\n  if (!c) throw new Error('usePage must be used inside <PageView> or a <Stage> page');\n  return c;\n}\n\nexport function makePageContext(\n  documentId: string,\n  pon: number,\n  pageIndex: number,\n  frame: PageFrame,\n  transform: PageTransform,\n  getRect: () => DOMRect,\n  getViewDemand?: () => PageViewDemand,\n): PageContextValue {\n  return {\n    documentId,\n    pon,\n    pageIndex,\n    frame,\n    transform,\n    ...(getViewDemand ? { getViewDemand } : {}),\n    toPagePoint: (cx, cy) => {\n      // `getRect()` is the rotated content wrapper's axis-aligned bounding box =\n      // the page's DISPLAY box on screen. Convert client → box-local view px,\n      // then invert rotation + scale via the transform (verified once in geometry,\n      // not re-derived per framework adapter).\n      const r = getRect();\n      return transform.viewToPage({ x: cx - r.left, y: cy - r.top });\n    },\n    toClientPoint: (p) => {\n      // Exact inverse of `toPagePoint`: page/content point → display-box view px\n      // (rotation applied by the transform), offset by the same live display-box\n      // origin. So the two can never drift, in either <Stage> or <PageView>.\n      const r = getRect();\n      const v = transform.pageToView(p);\n      return { x: r.left + v.x, y: r.top + v.y };\n    },\n    toClientRect: (rect) => {\n      const r = getRect();\n      const v = transform.pageToViewRect(rect);\n      return { x: r.left + v.x, y: r.top + v.y, width: v.width, height: v.height };\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/runtime.d.cts

@@ -0,0 +1,3 @@
+import { S as useSelector, _ as useKernel, a as EmbedPDF, b as useOptionalSelector, c as Viewer, d as shallowArray, f as useActiveDocumentId, g as useDocuments, h as useDocumentStatus, i as DocumentScopeProps, l as ViewerProps, m as useDocumentId, n as DocumentGateProps, o as PageContextValue, p as useCapability, r as DocumentScope, s as PageProvider, t as DocumentGate, u as makePageContext, v as useKernelValue, x as usePage, y as useOptionalCapability } from "./runtime-CMxIuF2O.cjs";
+export * from "@embedpdf/core";
+export { DocumentGate, DocumentGateProps, DocumentScope, DocumentScopeProps, EmbedPDF, PageContextValue, PageProvider, Viewer, ViewerProps, makePageContext, shallowArray, useActiveDocumentId, useCapability, useDocumentId, useDocumentStatus, useDocuments, useKernel, useKernelValue, useOptionalCapability, useOptionalSelector, usePage, useSelector };

package/dist/runtime.d.ts

@@ -0,0 +1,3 @@
+import { S as useSelector, _ as useKernel, a as EmbedPDF, b as useOptionalSelector, c as Viewer, d as shallowArray, f as useActiveDocumentId, g as useDocuments, h as useDocumentStatus, i as DocumentScopeProps, l as ViewerProps, m as useDocumentId, n as DocumentGateProps, o as PageContextValue, p as useCapability, r as DocumentScope, s as PageProvider, t as DocumentGate, u as makePageContext, v as useKernelValue, x as usePage, y as useOptionalCapability } from "./runtime-DV98q7I0.js";
+export * from "@embedpdf/core";
+export { DocumentGate, DocumentGateProps, DocumentScope, DocumentScopeProps, EmbedPDF, PageContextValue, PageProvider, Viewer, ViewerProps, makePageContext, shallowArray, useActiveDocumentId, useCapability, useDocumentId, useDocumentStatus, useDocuments, useKernel, useKernelValue, useOptionalCapability, useOptionalSelector, usePage, useSelector };