@embedpdf/react 3.0.0-next.0

package/dist/redaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redaction.js","names":[],"sources":["../src/redaction.tsx"],"sourcesContent":["import { RedactionToken } from '@embedpdf/plugin-redaction';\nimport type {\n  RedactionApplyResult,\n  RedactionCapability,\n  RedactionPendingItem,\n} from '@embedpdf/plugin-redaction';\nimport { useCapability, useSelector } from './runtime';\n\n/**\n * Redaction for the surrounding `DocumentScope`: the pending-marks view plus\n * the destructive apply. Marking rides the annotation plane (the composed\n * `redact` tool); `useRedaction` surfaces the workflow around it.\n *\n *   const redaction = useRedaction();\n *   redaction.toggleRedact();\n *   await redaction.applyAll();          // irreversible — confirm first\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-redaction';\n\nexport function useRedaction(): RedactionCapability & {\n  applying: boolean;\n  lastApplyResult: RedactionApplyResult | null;\n} {\n  const cap = useCapability(RedactionToken);\n  const applying = useSelector(RedactionToken, (c) => c.isApplying());\n  const lastApplyResult = useSelector(RedactionToken, (c) => c.lastResult());\n  return { ...cap, applying, lastApplyResult };\n}\n\n/** The pending marks, reactive against the annotation plane. Note the view\n *  covers LOADED pages — call `preparePending()` (e.g. on panel open) to load\n *  the whole document. */\nexport function usePendingRedactions(): RedactionPendingItem[] {\n  return useSelector(RedactionToken, (c) => c.getPending(), pendingEqual);\n}\n\nconst pendingEqual = (a: RedactionPendingItem[], b: RedactionPendingItem[]): boolean =>\n  a.length === b.length &&\n  a.every((item, i) => item.id === b[i]!.id && item.overlayText === b[i]!.overlayText);\n"],"mappings":";;;;AAqBA,SAAgB,eAGd;CACA,MAAM,MAAM,cAAc,cAAc;CACxC,MAAM,WAAW,YAAY,iBAAiB,MAAM,EAAE,WAAW,CAAC;CAClE,MAAM,kBAAkB,YAAY,iBAAiB,MAAM,EAAE,WAAW,CAAC;CACzE,OAAO;EAAE,GAAG;EAAK;EAAU;CAAgB;AAC7C;;;;AAKA,SAAgB,uBAA+C;CAC7D,OAAO,YAAY,iBAAiB,MAAM,EAAE,WAAW,GAAG,YAAY;AACxE;AAEA,MAAM,gBAAgB,GAA2B,MAC/C,EAAE,WAAW,EAAE,UACf,EAAE,OAAO,MAAM,MAAM,KAAK,OAAO,EAAE,EAAE,CAAE,MAAM,KAAK,gBAAgB,EAAE,EAAE,CAAE,WAAW"}

package/dist/render.cjs

@@ -0,0 +1,142 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-DDXJien1.cjs");
+const require_runtime = require("./runtime.cjs");
+let react_jsx_runtime = require("react/jsx-runtime");
+let react = require("react");
+react = require_rolldown_runtime.__toESM(react, 1);
+let _embedpdf_plugin_render = require("@embedpdf/plugin-render");
+//#region src/render.tsx
+function RenderLayer({ annotations = true } = {}) {
+	const page = require_runtime.usePage();
+	const render = require_runtime.useCapability(_embedpdf_plugin_render.RenderToken);
+	const ref = (0, react.useRef)(null);
+	const sourceKey = require_runtime.useSelector(_embedpdf_plugin_render.RenderToken, (c) => c.renderSourceKey(page.pon, {
+		scale: page.transform.renderScale,
+		includeAnnotations: annotations
+	}));
+	(0, react.useEffect)(() => {
+		const controller = new AbortController();
+		let revoke;
+		(async () => {
+			try {
+				const obj = await (await render.renderPage(page.pon, {
+					scale: page.transform.renderScale,
+					includeAnnotations: annotations,
+					signal: controller.signal
+				})).objectUrl(controller.signal);
+				if (controller.signal.aborted) {
+					obj.revoke();
+					return;
+				}
+				revoke = obj.revoke;
+				if (ref.current) ref.current.src = obj.url;
+			} catch {}
+		})();
+		return () => {
+			controller.abort();
+			revoke?.();
+		};
+	}, [
+		render,
+		page.pon,
+		sourceKey
+	]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("img", {
+		ref,
+		alt: "",
+		draggable: false,
+		style: {
+			position: "absolute",
+			inset: 0,
+			width: "100%",
+			height: "100%",
+			pointerEvents: "none"
+		}
+	});
+}
+/**
+* TileLayer — the sharp plane above the base rung.
+*
+* Mounting it is the per-lens OPT-IN; whether it spends anything is demand
+* arithmetic (a thumbnail rail's demand never engages). The paint list is the
+* plugin's retention-safe plan: keyed <img>s inside ONE container that carries
+* the page scale as a single transform (one rounding context — no tile seams),
+* with `onLoad` reporting the decode boundary back so retained coarser
+* generations release only when their replacement is truly on screen.
+*/
+function TileLayer({ annotations = true } = {}) {
+	const page = require_runtime.usePage();
+	const render = require_runtime.useCapability(_embedpdf_plugin_render.RenderToken);
+	const demand = page.getViewDemand?.() ?? { desiredDeviceWidth: page.transform.deviceWidth };
+	const plan = require_runtime.useSelector(_embedpdf_plugin_render.RenderToken, (c) => c.tilePlan(page.pon, demand, { includeAnnotations: annotations }));
+	(0, react.useEffect)(() => () => render.releaseTiles(page.pon), [render, page.pon]);
+	if (plan.paint.length === 0) return null;
+	const t = page.transform;
+	const scale = t.viewScale;
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+		style: {
+			position: "absolute",
+			left: 0,
+			top: 0,
+			width: t.contentWidth / scale,
+			height: t.contentHeight / scale,
+			transform: `scale(${scale})`,
+			transformOrigin: "0 0",
+			pointerEvents: "none"
+		},
+		children: plan.paint.map((source) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TileImg, {
+			source,
+			onPainted: () => render.tilePainted(page.pon, source.key)
+		}, source.key))
+	});
+}
+/** One tile: object-URL lifecycle + the painted (decode-boundary) report. */
+function TileImg({ source, onPainted }) {
+	const ref = (0, react.useRef)(null);
+	(0, react.useEffect)(() => {
+		const controller = new AbortController();
+		let revoke;
+		(async () => {
+			try {
+				const obj = await source.handle.objectUrl(controller.signal);
+				if (controller.signal.aborted) {
+					obj.revoke();
+					return;
+				}
+				revoke = obj.revoke;
+				if (ref.current) ref.current.src = obj.url;
+			} catch {}
+		})();
+		return () => {
+			controller.abort();
+			revoke?.();
+		};
+	}, [source.handle]);
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("img", {
+		ref,
+		alt: "",
+		draggable: false,
+		onLoad: onPainted,
+		style: {
+			position: "absolute",
+			left: source.rect.x,
+			top: source.rect.y,
+			width: source.rect.width,
+			height: source.rect.height,
+			zIndex: source.z
+		}
+	});
+}
+//#endregion
+exports.RenderLayer = RenderLayer;
+exports.TileLayer = TileLayer;
+Object.keys(_embedpdf_plugin_render).forEach(function(k) {
+	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function() {
+			return _embedpdf_plugin_render[k];
+		}
+	});
+});
+
+//# sourceMappingURL=render.cjs.map

package/dist/render.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.cjs","names":["usePage","useCapability","RenderToken","useSelector"],"sources":["../src/render.tsx"],"sourcesContent":["/**\n * RenderLayer + TileLayer — the React views of @embedpdf/plugin-render.\n *\n * RenderLayer paints the BASE rung to an <img> from the engine's ENCODED\n * image() (identical for local & cloud). TileLayer paints the tile paint-plan\n * ABOVE it when the deployment lattice caps the base below the demand — mount\n * it per lens (the main stage yes, a thumbnail rail no); where the demand is\n * small it engages nothing. Both are dumb painters: every decision (policy\n * conformance, want sets, retention, release) is plugin-render's.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-render';\nimport * as React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { RenderToken } from '@embedpdf/plugin-render';\nimport type { PageViewDemand, TilePaintSource } from '@embedpdf/plugin-render';\nimport { useCapability, usePage, useSelector } from './runtime';\n\nexport interface RenderLayerProps {\n  /**\n   * Bake annotations into the page bitmap (default true). Pass false when an\n   * <AnnotationLayer> owns annotation rendering, so they aren't drawn twice.\n   */\n  annotations?: boolean;\n}\n\nexport function RenderLayer({ annotations = true }: RenderLayerProps = {}) {\n  const page = usePage();\n  const render = useCapability(RenderToken);\n  const ref = useRef<HTMLImageElement>(null);\n  // ONE dependency: the raster's canonical identity — conformed viewport +\n  // annotations flag + epoch. Inside a lattice\n  // rung, zoom changes don't move it: no refetch, no DOM churn — the stage's\n  // CSS transform does the scaling. It changes exactly at rung crossings and\n  // on CONFIRMED mutations (epoch bumps at commit, never mid-gesture). Under\n  // `continuous` it embeds the exact scale — v2 behavior byte-for-byte. The\n  // policy behind it is a document fact the kernel materialized before\n  // publish, so the key is always computable.\n  const sourceKey = useSelector(RenderToken, (c) =>\n    c.renderSourceKey(page.pon, {\n      scale: page.transform.renderScale,\n      includeAnnotations: annotations,\n    }),\n  );\n  useEffect(() => {\n    const controller = new AbortController();\n    let revoke: (() => void) | undefined;\n    (async () => {\n      try {\n        // The capability conforms this to the policy (lattice → ladder width,\n        // continuous → this exact scale) and collapses same-key asks in its\n        // raster store. A stale-closure scale is harmless by construction:\n        // any scale in this rung produces this key's canonical request.\n        const image = await render.renderPage(page.pon, {\n          scale: page.transform.renderScale,\n          includeAnnotations: annotations,\n          signal: controller.signal,\n        });\n        const obj = await image.objectUrl(controller.signal);\n        if (controller.signal.aborted) {\n          obj.revoke();\n          return;\n        }\n        revoke = obj.revoke;\n        if (ref.current) ref.current.src = obj.url;\n      } catch {\n        /* aborted (camera moved / unmounted) or render failed */\n      }\n    })();\n    return () => {\n      controller.abort();\n      revoke?.();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- sourceKey IS the\n    // render identity; scale/annotations/epoch are folded into it upstream.\n  }, [render, page.pon, sourceKey]);\n  return (\n    <img\n      ref={ref}\n      alt=\"\"\n      draggable={false}\n      style={{\n        position: 'absolute',\n        inset: 0,\n        width: '100%',\n        height: '100%',\n        pointerEvents: 'none',\n      }}\n    />\n  );\n}\n\nexport interface TileLayerProps {\n  /**\n   * Bake annotations into tile bitmaps (default true). Pass false when an\n   * <AnnotationLayer> owns annotation rendering — the composition that keeps\n   * tile artifacts annotation-version-free (CDN-stable across edits).\n   */\n  annotations?: boolean;\n}\n\n/**\n * TileLayer — the sharp plane above the base rung.\n *\n * Mounting it is the per-lens OPT-IN; whether it spends anything is demand\n * arithmetic (a thumbnail rail's demand never engages). The paint list is the\n * plugin's retention-safe plan: keyed <img>s inside ONE container that carries\n * the page scale as a single transform (one rounding context — no tile seams),\n * with `onLoad` reporting the decode boundary back so retained coarser\n * generations release only when their replacement is truly on screen.\n */\nexport function TileLayer({ annotations = true }: TileLayerProps = {}) {\n  const page = usePage();\n  const render = useCapability(RenderToken);\n  // Demand: the host's live camera view (Stage) or whole-page (PageView).\n  const demand: PageViewDemand = page.getViewDemand?.() ?? {\n    desiredDeviceWidth: page.transform.deviceWidth,\n  };\n  const plan = useSelector(RenderToken, (c) =>\n    c.tilePlan(page.pon, demand, { includeAnnotations: annotations }),\n  );\n  // Lens unmounted: stop in-flight tile fetches; resolved bytes stay cached.\n  useEffect(() => () => render.releaseTiles(page.pon), [render, page.pon]);\n  if (plan.paint.length === 0) return null;\n  const t = page.transform;\n  const scale = t.viewScale;\n  return (\n    <div\n      style={{\n        position: 'absolute',\n        left: 0,\n        top: 0,\n        width: t.contentWidth / scale,\n        height: t.contentHeight / scale,\n        transform: `scale(${scale})`,\n        transformOrigin: '0 0',\n        pointerEvents: 'none',\n      }}\n    >\n      {plan.paint.map((source) => (\n        <TileImg\n          key={source.key}\n          source={source}\n          onPainted={() => render.tilePainted(page.pon, source.key)}\n        />\n      ))}\n    </div>\n  );\n}\n\n/** One tile: object-URL lifecycle + the painted (decode-boundary) report. */\nfunction TileImg({ source, onPainted }: { source: TilePaintSource; onPainted: () => void }) {\n  const ref = useRef<HTMLImageElement>(null);\n  useEffect(() => {\n    const controller = new AbortController();\n    let revoke: (() => void) | undefined;\n    (async () => {\n      try {\n        const obj = await source.handle.objectUrl(controller.signal);\n        if (controller.signal.aborted) {\n          obj.revoke();\n          return;\n        }\n        revoke = obj.revoke;\n        if (ref.current) ref.current.src = obj.url;\n      } catch {\n        /* aborted (plan moved on) */\n      }\n    })();\n    return () => {\n      controller.abort();\n      revoke?.();\n    };\n  }, [source.handle]);\n  return (\n    <img\n      ref={ref}\n      alt=\"\"\n      draggable={false}\n      onLoad={onPainted}\n      style={{\n        position: 'absolute',\n        left: source.rect.x,\n        top: source.rect.y,\n        width: source.rect.width,\n        height: source.rect.height,\n        zIndex: source.z,\n      }}\n    />\n  );\n}\n"],"mappings":"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"}

package/dist/render.d.cts

@@ -0,0 +1,32 @@
+export * from "@embedpdf/plugin-render";
+//#region src/render.d.ts
+interface RenderLayerProps {
+  /**
+   * Bake annotations into the page bitmap (default true). Pass false when an
+   * <AnnotationLayer> owns annotation rendering, so they aren't drawn twice.
+   */
+  annotations?: boolean;
+}
+declare function RenderLayer({ annotations }?: RenderLayerProps): import("react/jsx-runtime").JSX.Element;
+interface TileLayerProps {
+  /**
+   * Bake annotations into tile bitmaps (default true). Pass false when an
+   * <AnnotationLayer> owns annotation rendering — the composition that keeps
+   * tile artifacts annotation-version-free (CDN-stable across edits).
+   */
+  annotations?: boolean;
+}
+/**
+ * TileLayer — the sharp plane above the base rung.
+ *
+ * Mounting it is the per-lens OPT-IN; whether it spends anything is demand
+ * arithmetic (a thumbnail rail's demand never engages). The paint list is the
+ * plugin's retention-safe plan: keyed <img>s inside ONE container that carries
+ * the page scale as a single transform (one rounding context — no tile seams),
+ * with `onLoad` reporting the decode boundary back so retained coarser
+ * generations release only when their replacement is truly on screen.
+ */
+declare function TileLayer({ annotations }?: TileLayerProps): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+export { RenderLayer, RenderLayerProps, TileLayer, TileLayerProps };
+//# sourceMappingURL=render.d.cts.map

package/dist/render.d.ts

@@ -0,0 +1,32 @@
+export * from "@embedpdf/plugin-render";
+//#region src/render.d.ts
+interface RenderLayerProps {
+  /**
+   * Bake annotations into the page bitmap (default true). Pass false when an
+   * <AnnotationLayer> owns annotation rendering, so they aren't drawn twice.
+   */
+  annotations?: boolean;
+}
+declare function RenderLayer({ annotations }?: RenderLayerProps): import("react/jsx-runtime").JSX.Element;
+interface TileLayerProps {
+  /**
+   * Bake annotations into tile bitmaps (default true). Pass false when an
+   * <AnnotationLayer> owns annotation rendering — the composition that keeps
+   * tile artifacts annotation-version-free (CDN-stable across edits).
+   */
+  annotations?: boolean;
+}
+/**
+ * TileLayer — the sharp plane above the base rung.
+ *
+ * Mounting it is the per-lens OPT-IN; whether it spends anything is demand
+ * arithmetic (a thumbnail rail's demand never engages). The paint list is the
+ * plugin's retention-safe plan: keyed <img>s inside ONE container that carries
+ * the page scale as a single transform (one rounding context — no tile seams),
+ * with `onLoad` reporting the decode boundary back so retained coarser
+ * generations release only when their replacement is truly on screen.
+ */
+declare function TileLayer({ annotations }?: TileLayerProps): import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+export { RenderLayer, RenderLayerProps, TileLayer, TileLayerProps };
+//# sourceMappingURL=render.d.ts.map

package/dist/render.js

@@ -0,0 +1,131 @@
+import { useCapability, usePage, useSelector } from "./runtime.js";
+import { jsx } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { RenderToken } from "@embedpdf/plugin-render";
+export * from "@embedpdf/plugin-render";
+//#region src/render.tsx
+function RenderLayer({ annotations = true } = {}) {
+	const page = usePage();
+	const render = useCapability(RenderToken);
+	const ref = useRef(null);
+	const sourceKey = useSelector(RenderToken, (c) => c.renderSourceKey(page.pon, {
+		scale: page.transform.renderScale,
+		includeAnnotations: annotations
+	}));
+	useEffect(() => {
+		const controller = new AbortController();
+		let revoke;
+		(async () => {
+			try {
+				const obj = await (await render.renderPage(page.pon, {
+					scale: page.transform.renderScale,
+					includeAnnotations: annotations,
+					signal: controller.signal
+				})).objectUrl(controller.signal);
+				if (controller.signal.aborted) {
+					obj.revoke();
+					return;
+				}
+				revoke = obj.revoke;
+				if (ref.current) ref.current.src = obj.url;
+			} catch {}
+		})();
+		return () => {
+			controller.abort();
+			revoke?.();
+		};
+	}, [
+		render,
+		page.pon,
+		sourceKey
+	]);
+	return /* @__PURE__ */ jsx("img", {
+		ref,
+		alt: "",
+		draggable: false,
+		style: {
+			position: "absolute",
+			inset: 0,
+			width: "100%",
+			height: "100%",
+			pointerEvents: "none"
+		}
+	});
+}
+/**
+* TileLayer — the sharp plane above the base rung.
+*
+* Mounting it is the per-lens OPT-IN; whether it spends anything is demand
+* arithmetic (a thumbnail rail's demand never engages). The paint list is the
+* plugin's retention-safe plan: keyed <img>s inside ONE container that carries
+* the page scale as a single transform (one rounding context — no tile seams),
+* with `onLoad` reporting the decode boundary back so retained coarser
+* generations release only when their replacement is truly on screen.
+*/
+function TileLayer({ annotations = true } = {}) {
+	const page = usePage();
+	const render = useCapability(RenderToken);
+	const demand = page.getViewDemand?.() ?? { desiredDeviceWidth: page.transform.deviceWidth };
+	const plan = useSelector(RenderToken, (c) => c.tilePlan(page.pon, demand, { includeAnnotations: annotations }));
+	useEffect(() => () => render.releaseTiles(page.pon), [render, page.pon]);
+	if (plan.paint.length === 0) return null;
+	const t = page.transform;
+	const scale = t.viewScale;
+	return /* @__PURE__ */ jsx("div", {
+		style: {
+			position: "absolute",
+			left: 0,
+			top: 0,
+			width: t.contentWidth / scale,
+			height: t.contentHeight / scale,
+			transform: `scale(${scale})`,
+			transformOrigin: "0 0",
+			pointerEvents: "none"
+		},
+		children: plan.paint.map((source) => /* @__PURE__ */ jsx(TileImg, {
+			source,
+			onPainted: () => render.tilePainted(page.pon, source.key)
+		}, source.key))
+	});
+}
+/** One tile: object-URL lifecycle + the painted (decode-boundary) report. */
+function TileImg({ source, onPainted }) {
+	const ref = useRef(null);
+	useEffect(() => {
+		const controller = new AbortController();
+		let revoke;
+		(async () => {
+			try {
+				const obj = await source.handle.objectUrl(controller.signal);
+				if (controller.signal.aborted) {
+					obj.revoke();
+					return;
+				}
+				revoke = obj.revoke;
+				if (ref.current) ref.current.src = obj.url;
+			} catch {}
+		})();
+		return () => {
+			controller.abort();
+			revoke?.();
+		};
+	}, [source.handle]);
+	return /* @__PURE__ */ jsx("img", {
+		ref,
+		alt: "",
+		draggable: false,
+		onLoad: onPainted,
+		style: {
+			position: "absolute",
+			left: source.rect.x,
+			top: source.rect.y,
+			width: source.rect.width,
+			height: source.rect.height,
+			zIndex: source.z
+		}
+	});
+}
+//#endregion
+export { RenderLayer, TileLayer };
+
+//# sourceMappingURL=render.js.map

package/dist/render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.js","names":[],"sources":["../src/render.tsx"],"sourcesContent":["/**\n * RenderLayer + TileLayer — the React views of @embedpdf/plugin-render.\n *\n * RenderLayer paints the BASE rung to an <img> from the engine's ENCODED\n * image() (identical for local & cloud). TileLayer paints the tile paint-plan\n * ABOVE it when the deployment lattice caps the base below the demand — mount\n * it per lens (the main stage yes, a thumbnail rail no); where the demand is\n * small it engages nothing. Both are dumb painters: every decision (policy\n * conformance, want sets, retention, release) is plugin-render's.\n */\n\n// One-line-per-feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-render';\nimport * as React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { RenderToken } from '@embedpdf/plugin-render';\nimport type { PageViewDemand, TilePaintSource } from '@embedpdf/plugin-render';\nimport { useCapability, usePage, useSelector } from './runtime';\n\nexport interface RenderLayerProps {\n  /**\n   * Bake annotations into the page bitmap (default true). Pass false when an\n   * <AnnotationLayer> owns annotation rendering, so they aren't drawn twice.\n   */\n  annotations?: boolean;\n}\n\nexport function RenderLayer({ annotations = true }: RenderLayerProps = {}) {\n  const page = usePage();\n  const render = useCapability(RenderToken);\n  const ref = useRef<HTMLImageElement>(null);\n  // ONE dependency: the raster's canonical identity — conformed viewport +\n  // annotations flag + epoch. Inside a lattice\n  // rung, zoom changes don't move it: no refetch, no DOM churn — the stage's\n  // CSS transform does the scaling. It changes exactly at rung crossings and\n  // on CONFIRMED mutations (epoch bumps at commit, never mid-gesture). Under\n  // `continuous` it embeds the exact scale — v2 behavior byte-for-byte. The\n  // policy behind it is a document fact the kernel materialized before\n  // publish, so the key is always computable.\n  const sourceKey = useSelector(RenderToken, (c) =>\n    c.renderSourceKey(page.pon, {\n      scale: page.transform.renderScale,\n      includeAnnotations: annotations,\n    }),\n  );\n  useEffect(() => {\n    const controller = new AbortController();\n    let revoke: (() => void) | undefined;\n    (async () => {\n      try {\n        // The capability conforms this to the policy (lattice → ladder width,\n        // continuous → this exact scale) and collapses same-key asks in its\n        // raster store. A stale-closure scale is harmless by construction:\n        // any scale in this rung produces this key's canonical request.\n        const image = await render.renderPage(page.pon, {\n          scale: page.transform.renderScale,\n          includeAnnotations: annotations,\n          signal: controller.signal,\n        });\n        const obj = await image.objectUrl(controller.signal);\n        if (controller.signal.aborted) {\n          obj.revoke();\n          return;\n        }\n        revoke = obj.revoke;\n        if (ref.current) ref.current.src = obj.url;\n      } catch {\n        /* aborted (camera moved / unmounted) or render failed */\n      }\n    })();\n    return () => {\n      controller.abort();\n      revoke?.();\n    };\n    // eslint-disable-next-line react-hooks/exhaustive-deps -- sourceKey IS the\n    // render identity; scale/annotations/epoch are folded into it upstream.\n  }, [render, page.pon, sourceKey]);\n  return (\n    <img\n      ref={ref}\n      alt=\"\"\n      draggable={false}\n      style={{\n        position: 'absolute',\n        inset: 0,\n        width: '100%',\n        height: '100%',\n        pointerEvents: 'none',\n      }}\n    />\n  );\n}\n\nexport interface TileLayerProps {\n  /**\n   * Bake annotations into tile bitmaps (default true). Pass false when an\n   * <AnnotationLayer> owns annotation rendering — the composition that keeps\n   * tile artifacts annotation-version-free (CDN-stable across edits).\n   */\n  annotations?: boolean;\n}\n\n/**\n * TileLayer — the sharp plane above the base rung.\n *\n * Mounting it is the per-lens OPT-IN; whether it spends anything is demand\n * arithmetic (a thumbnail rail's demand never engages). The paint list is the\n * plugin's retention-safe plan: keyed <img>s inside ONE container that carries\n * the page scale as a single transform (one rounding context — no tile seams),\n * with `onLoad` reporting the decode boundary back so retained coarser\n * generations release only when their replacement is truly on screen.\n */\nexport function TileLayer({ annotations = true }: TileLayerProps = {}) {\n  const page = usePage();\n  const render = useCapability(RenderToken);\n  // Demand: the host's live camera view (Stage) or whole-page (PageView).\n  const demand: PageViewDemand = page.getViewDemand?.() ?? {\n    desiredDeviceWidth: page.transform.deviceWidth,\n  };\n  const plan = useSelector(RenderToken, (c) =>\n    c.tilePlan(page.pon, demand, { includeAnnotations: annotations }),\n  );\n  // Lens unmounted: stop in-flight tile fetches; resolved bytes stay cached.\n  useEffect(() => () => render.releaseTiles(page.pon), [render, page.pon]);\n  if (plan.paint.length === 0) return null;\n  const t = page.transform;\n  const scale = t.viewScale;\n  return (\n    <div\n      style={{\n        position: 'absolute',\n        left: 0,\n        top: 0,\n        width: t.contentWidth / scale,\n        height: t.contentHeight / scale,\n        transform: `scale(${scale})`,\n        transformOrigin: '0 0',\n        pointerEvents: 'none',\n      }}\n    >\n      {plan.paint.map((source) => (\n        <TileImg\n          key={source.key}\n          source={source}\n          onPainted={() => render.tilePainted(page.pon, source.key)}\n        />\n      ))}\n    </div>\n  );\n}\n\n/** One tile: object-URL lifecycle + the painted (decode-boundary) report. */\nfunction TileImg({ source, onPainted }: { source: TilePaintSource; onPainted: () => void }) {\n  const ref = useRef<HTMLImageElement>(null);\n  useEffect(() => {\n    const controller = new AbortController();\n    let revoke: (() => void) | undefined;\n    (async () => {\n      try {\n        const obj = await source.handle.objectUrl(controller.signal);\n        if (controller.signal.aborted) {\n          obj.revoke();\n          return;\n        }\n        revoke = obj.revoke;\n        if (ref.current) ref.current.src = obj.url;\n      } catch {\n        /* aborted (plan moved on) */\n      }\n    })();\n    return () => {\n      controller.abort();\n      revoke?.();\n    };\n  }, [source.handle]);\n  return (\n    <img\n      ref={ref}\n      alt=\"\"\n      draggable={false}\n      onLoad={onPainted}\n      style={{\n        position: 'absolute',\n        left: source.rect.x,\n        top: source.rect.y,\n        width: source.rect.width,\n        height: source.rect.height,\n        zIndex: source.z,\n      }}\n    />\n  );\n}\n"],"mappings":"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"}

package/dist/rolldown-runtime-DDXJien1.cjs

@@ -0,0 +1,50 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__reExport", {
+	enumerable: true,
+	get: function() {
+		return __reExport;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/runtime-CMxIuF2O.d.cts

@@ -0,0 +1,195 @@
+import * as React from "react";
+import { AnyPlugin, CapabilityToken, Engine, EngineFactory, InitialDocument, Kernel } from "@embedpdf/core";
+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-CMxIuF2O.d.cts.map