@embedpdf/svelte 0.0.0-stage → 3.0.0-next.15

package/dist/link/props.d.ts

@@ -0,0 +1,17 @@
+/** The props of `<LinkLayer>`. */
+import type { Snippet } from 'svelte';
+import type { Link } from '@embedpdf/plugin-link';
+/** What the `link` snippet receives for each link. */
+export interface LinkRenderProps {
+    /** The link: its `id`, its `bounds` on the page and its `target`. */
+    link: Link;
+    /** The layer's own clickable area, `{@render native()}`: wrap it to keep what a click does. */
+    native: Snippet;
+}
+export interface LinkLayerProps {
+    /**
+     * Draw each link yourself, usually around `{@render native()}`. To leave a link as it is,
+     * render only `native` for it.
+     */
+    link?: Snippet<[props: LinkRenderProps]>;
+}

package/dist/link/props.js

@@ -0,0 +1 @@
+export {};

package/dist/link/readers.svelte.d.ts

@@ -0,0 +1,18 @@
+import type { EventHook } from '@embedpdf/core';
+import type { LinkCapability } from '@embedpdf/plugin-link';
+/**
+ * Hand the link plugin this binding's website opener (`openExternalUri`) while the component
+ * lives: an allowed address opens in a new tab, anything else is refused and the plugin reports
+ * it. Registered again for each document.
+ */
+export declare function useUriOpener(): void;
+/**
+ * The link API (`listLinks()`, `activate()`, …) for app code. While a component uses it,
+ * `activate()` opens a website in a new tab.
+ */
+export declare function useLink(): LinkCapability;
+/**
+ * Subscribe to one link event while the component lives:
+ * `useLinkEvent((link) => link.onActivated, handler)`.
+ */
+export declare function useLinkEvent<T>(select: (link: LinkCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/link/readers.svelte.js

@@ -0,0 +1,38 @@
+/**
+ * The link plugin's readers: `useLink()` (the API) and `useLinkEvent()`, and the website opener
+ * this binding hands the plugin while a link component is mounted.
+ */
+import { untrack } from 'svelte';
+import { LinkToken } from '@embedpdf/plugin-link';
+import { LinkToken as LinkHostToken } from '@embedpdf/plugin-link/contract/host';
+import { openExternalUri } from '@embedpdf/web';
+import { useCapability, useCapabilityEvent, useOptionalCapability, } from '../runtime/readers.svelte.js';
+/**
+ * Hand the link plugin this binding's website opener (`openExternalUri`) while the component
+ * lives: an allowed address opens in a new tab, anything else is refused and the plugin reports
+ * it. Registered again for each document.
+ */
+export function useUriOpener() {
+    const host = useOptionalCapability(LinkHostToken);
+    $effect(() => {
+        const current = host.current;
+        if (!current)
+            return;
+        return untrack(() => current.registerUriOpener(openExternalUri));
+    });
+}
+/**
+ * The link API (`listLinks()`, `activate()`, …) for app code. While a component uses it,
+ * `activate()` opens a website in a new tab.
+ */
+export function useLink() {
+    useUriOpener();
+    return useCapability(LinkToken);
+}
+/**
+ * Subscribe to one link event while the component lives:
+ * `useLinkEvent((link) => link.onActivated, handler)`.
+ */
+export function useLinkEvent(select, handler) {
+    useCapabilityEvent(LinkToken, select, handler);
+}

package/dist/link.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/svelte/link — following links.
+ *
+ * `<LinkLayer>` puts a real anchor over each link on a page (draw around it with its `link`
+ * snippet); `useLink()` is the plugin's API and opens websites while it's in use, and
+ * `useLinkEvent()` its events.
+ */
+export * from '@embedpdf/plugin-link';
+export { default as LinkLayer } from './link/LinkLayer.svelte';
+export type { LinkLayerProps, LinkRenderProps } from './link/props.js';
+export { useLink, useLinkEvent } from './link/readers.svelte.js';

package/dist/link.js

@@ -0,0 +1,11 @@
+/**
+ * @embedpdf/svelte/link — following links.
+ *
+ * `<LinkLayer>` puts a real anchor over each link on a page (draw around it with its `link`
+ * snippet); `useLink()` is the plugin's API and opens websites while it's in use, and
+ * `useLinkEvent()` its events.
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-link';
+export { default as LinkLayer } from './link/LinkLayer.svelte';
+export { useLink, useLinkEvent } from './link/readers.svelte.js';

package/dist/measurement/readers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The measurement plugin's readers: `useMeasurement()` (the API), `useMeasurementState()`,
+ * `useMeasurementSettings()`, `useMeasurementEvent()`, and one per page scale and one per
+ * measurement, so a template updates only for its own page or measurement. Every one works before
+ * a document opens.
+ */
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { AnnotationRef, MeasurementCapability, MeasurementReadout, MeasurementUnavailable, PageScale } from '@embedpdf/plugin-measurement';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document every method throws
+ * `not-ready`.
+ */
+export declare function useMeasurement(): MeasurementCapability;
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export declare function useMeasurementEvent<T>(select: (measurement: MeasurementCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The measurement state: whether a scale change runs, the calibration request waiting for its
+ * length, and the last change's reports (the page's State table, declared once in
+ * `measurementState`), as a reactive object (`state.calibrationRequest`). With a selector, the
+ * value it picks as `{ current }`. Empty without a document.
+ */
+export declare const useMeasurementState: import("../index.js").StateReader<{
+    busy: boolean;
+    calibrationRequest: import("@embedpdf/plugin-measurement").CalibrationRequest | null;
+    lastReports: readonly import("@embedpdf/plugin-measurement").ScaleChangeReport[];
+}>;
+/** The measurement settings (`defaultScale`, `presets`), with or without a document. */
+export declare const useMeasurementSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-measurement").MeasurementSettings & object>;
+/**
+ * A page's measurement scale (its ref or its index; a function to follow a prop) as
+ * `{ current }`: for a scale bar or a "1:100" badge. Accepts `null` (no current page) and answers
+ * `null` then, so chrome can stay mounted without inventing a page.
+ */
+export declare function usePageScale(page: MaybeGetter<PageRef | number>): CurrentValue<PageScale>;
+export declare function usePageScale(page: MaybeGetter<PageRef | number | null>): CurrentValue<PageScale | null>;
+/**
+ * A measurement's `{ kind, value, label }` as `{ current }`, or `{ unavailable }` with why there's
+ * none. A measurement that changes is a function: `useMeasurementReadout(() => annotation)`.
+ * Readouts are reference-stable in the plugin, so the value changes only when the measurement's
+ * does.
+ */
+export declare function useMeasurementReadout(ref: MaybeGetter<AnnotationRef>): CurrentValue<MeasurementReadout | MeasurementUnavailable>;

package/dist/measurement/readers.js

@@ -0,0 +1,46 @@
+import { MeasurementToken, measurementState, NO_PAGE_SCALE, NO_READOUT, } from '@embedpdf/plugin-measurement';
+import { documentScopeOf } from '../runtime/binding.svelte.js';
+import { useCapability, useCapabilityEvent, useKernelValue, useOptionalSelector, } from '../runtime/readers.svelte.js';
+import { settingsReader, stateReader } from '../runtime/state.svelte.js';
+import { valueOf } from '../runtime/values.svelte.js';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document every method throws
+ * `not-ready`.
+ */
+export function useMeasurement() {
+    return useCapability(MeasurementToken);
+}
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export function useMeasurementEvent(select, handler) {
+    useCapabilityEvent(MeasurementToken, select, handler);
+}
+/**
+ * The measurement state: whether a scale change runs, the calibration request waiting for its
+ * length, and the last change's reports (the page's State table, declared once in
+ * `measurementState`), as a reactive object (`state.calibrationRequest`). With a selector, the
+ * value it picks as `{ current }`. Empty without a document.
+ */
+export const useMeasurementState = stateReader(measurementState);
+/** The measurement settings (`defaultScale`, `presets`), with or without a document. */
+export const useMeasurementSettings = settingsReader(MeasurementToken);
+export function usePageScale(page) {
+    const scoped = documentScopeOf();
+    // Scales are reference-stable in the plugin, so the value changes only when this page's does.
+    return useKernelValue((kernel) => {
+        const wanted = valueOf(page);
+        if (wanted === null)
+            return null;
+        return (kernel.tryCapability(MeasurementToken, scoped() ?? undefined)?.getPageScale(wanted) ??
+            NO_PAGE_SCALE);
+    });
+}
+/**
+ * A measurement's `{ kind, value, label }` as `{ current }`, or `{ unavailable }` with why there's
+ * none. A measurement that changes is a function: `useMeasurementReadout(() => annotation)`.
+ * Readouts are reference-stable in the plugin, so the value changes only when the measurement's
+ * does.
+ */
+export function useMeasurementReadout(ref) {
+    return useOptionalSelector(MeasurementToken, (measurement) => measurement.getReadout(valueOf(ref)), NO_READOUT);
+}

package/dist/measurement.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/measurement — distances, perimeters and areas in the page's scale.
+ *
+ * Measuring rides the annotation plugin (the `distance`, `perimeter` and `area` tools draw on its
+ * `<AnnotationLayer>`); these readers surface the scale, the calibration and the readouts:
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // scale.current: the cover's
+ *   const readout = useMeasurementReadout(() => annotation); // readout.current.label
+ */
+export * from '@embedpdf/plugin-measurement';
+export { useMeasurement, useMeasurementEvent, useMeasurementReadout, useMeasurementSettings, useMeasurementState, usePageScale, } from './measurement/readers.js';

package/dist/measurement.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/measurement — distances, perimeters and areas in the page's scale.
+ *
+ * Measuring rides the annotation plugin (the `distance`, `perimeter` and `area` tools draw on its
+ * `<AnnotationLayer>`); these readers surface the scale, the calibration and the readouts:
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // scale.current: the cover's
+ *   const readout = useMeasurementReadout(() => annotation); // readout.current.label
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-measurement';
+export { useMeasurement, useMeasurementEvent, useMeasurementReadout, useMeasurementSettings, useMeasurementState, usePageScale, } from './measurement/readers.js';

package/dist/metadata/readers.d.ts

@@ -0,0 +1,22 @@
+/** The metadata's readers: the API, the state declared once in `metadataState`, and its events. */
+import type { EventHook } from '@embedpdf/core';
+import type { MetadataCapability } from '@embedpdf/plugin-metadata';
+/**
+ * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canUpdate()` is a read, so `disabled={!metadata.canUpdate()}` updates by
+ * itself.
+ */
+export declare function useMetadata(): MetadataCapability;
+/**
+ * The standard fields, your own fields and their load state (the page's State table, declared
+ * once in `metadataState`), as a reactive object: `state.metadata?.title`. With a selector, the
+ * value it picks as `{ current }`, which changes only when that value does.
+ */
+export declare const useMetadataState: import("../index.js").StateReader<{
+    metadata: import("@embedpdf/core").DocumentMetadata | null;
+    custom: import("@embedpdf/core").CustomMetadata | null;
+    status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+export declare function useMetadataEvent<T>(select: (metadata: MetadataCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/metadata/readers.js

@@ -0,0 +1,22 @@
+import { MetadataToken, metadataState } from '@embedpdf/plugin-metadata';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.svelte.js';
+/**
+ * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canUpdate()` is a read, so `disabled={!metadata.canUpdate()}` updates by
+ * itself.
+ */
+export function useMetadata() {
+    return useCapability(MetadataToken);
+}
+/**
+ * The standard fields, your own fields and their load state (the page's State table, declared
+ * once in `metadataState`), as a reactive object: `state.metadata?.title`. With a selector, the
+ * value it picks as `{ current }`, which changes only when that value does.
+ */
+export const useMetadataState = stateReader(metadataState);
+/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+export function useMetadataEvent(select, handler) {
+    useCapabilityEvent(MetadataToken, select, handler);
+}

package/dist/metadata.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/metadata — the document's properties and your own fields.
+ *
+ * The plugin keeps the metadata live off the document's event stream, so the state follows your
+ * own edits and other sessions':
+ *
+ *   const metadata = useMetadata();
+ *   const state = useMetadataState(); // state.metadata, state.custom, state.status
+ *   await metadata.update({ title: 'New title' }); // resolves once the state shows it
+ */
+export * from '@embedpdf/plugin-metadata';
+export { useMetadata, useMetadataEvent, useMetadataState } from './metadata/readers.js';

package/dist/metadata.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/metadata — the document's properties and your own fields.
+ *
+ * The plugin keeps the metadata live off the document's event stream, so the state follows your
+ * own edits and other sessions':
+ *
+ *   const metadata = useMetadata();
+ *   const state = useMetadataState(); // state.metadata, state.custom, state.status
+ *   await metadata.update({ title: 'New title' }); // resolves once the state shows it
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-metadata';
+export { useMetadata, useMetadataEvent, useMetadataState } from './metadata/readers.js';

package/dist/page-edit/readers.d.ts

@@ -0,0 +1,7 @@
+import type { PageEditCapability } from '@embedpdf/plugin-page-edit';
+/**
+ * The page edits of the nearest `<DocumentScope>`'s document, else the active one. Outside a
+ * ready document, every method throws `not-ready`. `canEdit()` and `canExtract()` are reads, so
+ * `disabled={!pageEdit.canEdit()}` updates by itself.
+ */
+export declare function usePageEdit(): PageEditCapability;

package/dist/page-edit/readers.js

@@ -0,0 +1,11 @@
+/** The page edits' reader: the API. The plugin has no state of its own; the pages are the document's. */
+import { PageEditToken } from '@embedpdf/plugin-page-edit';
+import { useCapability } from '../runtime/readers.svelte.js';
+/**
+ * The page edits of the nearest `<DocumentScope>`'s document, else the active one. Outside a
+ * ready document, every method throws `not-ready`. `canEdit()` and `canExtract()` are reads, so
+ * `disabled={!pageEdit.canEdit()}` updates by itself.
+ */
+export function usePageEdit() {
+    return useCapability(PageEditToken);
+}

package/dist/page-edit.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/page-edit — rotate, move, insert, delete and extract pages.
+ *
+ * The plugin turns a page relative to its rotation and resolves placements, so this is binding
+ * only. The pages themselves come from `usePageList()` (`@embedpdf/svelte/runtime`), which
+ * follows every edit:
+ *
+ *   const pageEdit = usePageEdit();
+ *   await pageEdit.rotateBy([page.ref], 90);
+ */
+export * from '@embedpdf/plugin-page-edit';
+export { usePageEdit } from './page-edit/readers.js';

package/dist/page-edit.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/page-edit — rotate, move, insert, delete and extract pages.
+ *
+ * The plugin turns a page relative to its rotation and resolves placements, so this is binding
+ * only. The pages themselves come from `usePageList()` (`@embedpdf/svelte/runtime`), which
+ * follows every edit:
+ *
+ *   const pageEdit = usePageEdit();
+ *   await pageEdit.rotateBy([page.ref], 90);
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-page-edit';
+export { usePageEdit } from './page-edit/readers.js';

package/dist/page-view/PageView.svelte

@@ -0,0 +1,192 @@
+<!--
+  One page on its own, with no Stage: the same layers, rotation and chrome frame as a `<Stage>`
+  page, but no camera, scrolling or zoom, and no need for the stage plugin.
+
+  It builds the page's transform from a width, and provides the same page context a Stage page
+  does, so every layer (`<RenderLayer>`, the selection, search matches) works here unchanged. It
+  provides a projection too, measured from the page element in client space, so anchored UI (a
+  selection menu) works here as well: it sits on `<body>`, where no card or scrolling list clips it.
+-->
+<script lang="ts">
+  import { toPageRef } from '@embedpdf/core';
+  import { pageTransform, type PageFrame } from '@embedpdf/core-geometry';
+  import {
+    clientPageProjector,
+    livePageContext,
+    makePageContext,
+    observeClientGeometry,
+    pageSurfaceLayout,
+    pageViewTransformInput,
+    paint,
+  } from '@embedpdf/web';
+  import {
+    setProjectorBinding,
+    setShownPages,
+    type ProjectorBinding,
+    type ShownPages,
+  } from '../anchored/context.js';
+  import { InteractionToken as InteractionHostToken } from '@embedpdf/plugin-interaction/contract/host';
+  import PagePointerSource from '../interaction/PagePointerSource.svelte';
+  import DocumentScope from '../runtime/DocumentScope.svelte';
+  import { useViewerSettings } from '../runtime/documents.svelte.js';
+  import { setPageContext } from '../runtime/page.js';
+  import { useDocumentId, useKernelValue, useOptionalCapability } from '../runtime/readers.svelte.js';
+  import type { PageViewProps } from './props.js';
+
+  let {
+    page: wanted,
+    documentId,
+    fallback,
+    width = 240,
+    pageFrame: framePatch,
+    children,
+    pageChrome,
+    class: className,
+    style,
+  }: PageViewProps = $props();
+
+  // The document a <DocumentScope> around it names, else the active one.
+  const inScope = useDocumentId();
+  const docId = $derived(documentId ?? inScope.current);
+  // With the interaction plugin registered, the page view is the page's pointer surface.
+  const interaction = useOptionalCapability(InteractionHostToken);
+
+  // The page asked for: by its ref (which follows it when pages move) or by its index.
+  const wantedObjectNumber = $derived(typeof wanted === 'number' ? null : wanted.objectNumber);
+  const wantedIndex = $derived(typeof wanted === 'number' ? wanted : null);
+
+  // The page's entry in the document's page list, subscribed: a rotation or a move redraws this
+  // surface as it redraws a Stage page. Entries keep their identity until the page changes.
+  const base = useKernelValue((kernel) => {
+    if (!docId) return null;
+    const pages = kernel.documents.listPages(docId);
+    const found =
+      wantedObjectNumber !== null
+        ? pages.find((info) => info.ref.objectNumber === wantedObjectNumber)
+        : pages[wantedIndex ?? 0];
+    return found ?? null;
+  });
+
+  const pageIndex = $derived(base.current?.index ?? wantedIndex ?? 0);
+  // The page's address is the document's; a stand-in (object number = index + 1) only until the
+  // page list is known, and the fallback shows until then anyway. Derived from the number, so
+  // the context's `ref` keeps its identity while the number stays (layers key work on it).
+  const pageObjectNumber = $derived(
+    base.current?.ref.objectNumber ?? wantedObjectNumber ?? pageIndex + 1,
+  );
+  const pageRef = $derived(toPageRef(pageObjectNumber));
+
+  // The sides left out reserve nothing; built from the four numbers, so an equal frame passed
+  // again as a new object changes nothing.
+  const frameTop = $derived(framePatch?.top ?? 0);
+  const frameRight = $derived(framePatch?.right ?? 0);
+  const frameBottom = $derived(framePatch?.bottom ?? 0);
+  const frameLeft = $derived(framePatch?.left ?? 0);
+  const frame: PageFrame = $derived({
+    top: frameTop,
+    right: frameRight,
+    bottom: frameBottom,
+    left: frameLeft,
+  });
+
+  // What the transform depends on, each a value of its own, so an entry that changed something
+  // else keeps the transform.
+  const pageWidth = $derived(base.current?.size.width ?? null);
+  const pageHeight = $derived(base.current?.size.height ?? null);
+  const userUnit = $derived(base.current?.userUnit ?? 1);
+  const rotation = $derived(base.current?.rotation ?? 0);
+
+  // No camera: the transform comes from the width asked for (`pageViewTransformInput` from
+  // `@embedpdf/web`, the same in every framework).
+  const transform = $derived(
+    pageTransform(
+      pageViewTransformInput(
+        pageWidth !== null && pageHeight !== null
+          ? { size: { width: pageWidth, height: pageHeight }, rotation, userUnit }
+          : null,
+        width,
+        typeof window !== 'undefined' ? window.devicePixelRatio || 1 : 1,
+      ),
+    ),
+  );
+
+  // The page content box, once it's in the DOM: the client conversions measure it, and the
+  // projection answers nothing until it's there.
+  let contentElement = $state<HTMLDivElement | null>(null);
+
+  // This instance's view identity: two page views of one page (a compare strip) plan their
+  // rasters apart, as two stage lenses do.
+  const viewId = $props.id();
+  const context = $derived(
+    makePageContext(docId ?? '', `page-view:${viewId}`, pageRef, pageIndex, frame, transform, () =>
+      contentElement!.getBoundingClientRect(),
+    ),
+  );
+  const live = livePageContext(() => context);
+  setPageContext(live);
+
+  // The projection: no camera, so anchored UI is placed by measuring the page element in client
+  // space. `mounted` reads the element, a state value, so a placement computed before the
+  // element existed is computed again once it does. A new context (a new transform or page) is
+  // the binding's revision; `observeClientGeometry` reports what no state announces (the
+  // document scrolled, the window resized).
+  const projectorBinding: ProjectorBinding = $derived({
+    projector: clientPageProjector(context, () => contentElement !== null),
+    revision: context,
+    subscribe: observeClientGeometry,
+  });
+  setProjectorBinding(() => projectorBinding);
+  // A page view shows its one page.
+  const shownPages: ShownPages = $derived(new Set([pageObjectNumber]));
+  setShownPages(() => shownPages);
+
+  // The viewer's `page` settings; `--epdf-page-*` CSS variables win over them.
+  const look = useViewerSettings((settings) => settings.page);
+
+  // The outer box, the shadow at the footprint, and the content box centred on it and turned
+  // about its centre, as on a Stage page.
+  const layout = $derived(pageSurfaceLayout(transform, frame));
+</script>
+
+{#if docId && base.current}
+  <DocumentScope id={docId}>
+    <div
+      class={className}
+      style="position: relative; width: {layout.outer.width}px; height: {layout.outer
+        .height}px;{style ? ` ${style}` : ''}"
+    >
+      <!-- The drop shadow only: at the footprint, with no fill, so it never shows behind the
+           picture, and it stays put while the page turns. -->
+      <div
+        style:position="absolute"
+        style:left="{layout.shadow.left}px"
+        style:top="{layout.shadow.top}px"
+        style:width="{layout.shadow.width}px"
+        style:height="{layout.shadow.height}px"
+        style:box-shadow={paint('page-shadow', look.current.shadow)}
+      ></div>
+      <!-- The page: its background and its layers as one box, the only thing the rotation turns.
+           Native text and image selection is off: the selection layer draws its own. -->
+      <div
+        bind:this={contentElement}
+        style="user-select: none; -webkit-user-select: none"
+        style:position="absolute"
+        style:left="{layout.content.left}px"
+        style:top="{layout.content.top}px"
+        style:width="{layout.content.width}px"
+        style:height="{layout.content.height}px"
+        style:background={paint('page-background', look.current.background)}
+        style:transform={layout.turn ?? undefined}
+      >
+        <!-- The page's pointer surface, below the layers, like the Stage's own listener: a press
+             on a layer that lets the pointer through reaches the tools, a link keeps its own. -->
+        {#if interaction.current}<PagePointerSource />{/if}
+        {@render children(live)}
+      </div>
+      <!-- The page chrome fills the outer box and never turns. -->
+      {@render pageChrome?.(live)}
+    </div>
+  </DocumentScope>
+{:else}
+  {@render fallback?.()}
+{/if}

package/dist/page-view/PageView.svelte.d.ts

@@ -0,0 +1,4 @@
+import type { PageViewProps } from './props.js';
+declare const PageView: import("svelte").Component<PageViewProps, {}, "">;
+type PageView = ReturnType<typeof PageView>;
+export default PageView;

package/dist/page-view/props.d.ts

@@ -0,0 +1,32 @@
+/** The props of `<PageView>`. */
+import type { Snippet } from 'svelte';
+import type { PageRef } from '@embedpdf/core';
+import type { PageFrame } from '@embedpdf/core-geometry';
+import type { PageContextValue } from '../runtime/page.js';
+export interface PageViewProps {
+    /** The page: its `ref`, which follows it when pages move, or its index, from 0. */
+    page: PageRef | number;
+    /** Which document to show. Defaults to the active document. */
+    documentId?: string;
+    /** Shown while the document or the page is not available yet (default: nothing). */
+    fallback?: Snippet;
+    /** The width of the page upright, in pixels: a page turned a quarter is that tall. Default 240. */
+    width?: number;
+    /** Space reserved around the page for your own labels, in pixels per side; the sides left out are 0. */
+    pageFrame?: Partial<PageFrame>;
+    /**
+     * Page-space content (`<RenderLayer>`, the selection, search matches): what you write between
+     * `<PageView>` and `</PageView>`, or `{#snippet children(page)}` when it needs the page. It turns
+     * with the page, and positions are PDF points.
+     */
+    children: Snippet<[page: PageContextValue]>;
+    /**
+     * Box-space chrome (a label, a border) drawn into the outer box, page and `pageFrame`. It never
+     * turns, like `<Stage>`'s `pageChrome`.
+     */
+    pageChrome?: Snippet<[page: PageContextValue]>;
+    /** On the outer box, after its own. */
+    class?: string;
+    /** On the outer box, after its own. */
+    style?: string;
+}

package/dist/page-view/props.js

@@ -0,0 +1 @@
+export {};

package/dist/page-view.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @embedpdf/svelte/page-view — one page on its own, with no Stage.
+ *
+ * `<PageView>` shows a page anywhere in an app (a preview in a card, a page picker) with the same
+ * layers, rotation and chrome frame as a Stage page, and anchored UI that works inside it.
+ */
+export { default as PageView } from './page-view/PageView.svelte';
+export type { PageViewProps } from './page-view/props.js';

package/dist/page-view.js

@@ -0,0 +1,7 @@
+/**
+ * @embedpdf/svelte/page-view — one page on its own, with no Stage.
+ *
+ * `<PageView>` shows a page anywhere in an app (a preview in a card, a page picker) with the same
+ * layers, rotation and chrome frame as a Stage page, and anchored UI that works inside it.
+ */
+export { default as PageView } from './page-view/PageView.svelte';

package/dist/redaction/readers.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The redaction plugin's readers: `useRedaction()` (the API), `useRedactionState()`,
+ * `useRedactionSettings()`, `useRedactionEvent()`, and `usePendingRedactions()` for a list of the
+ * marks waiting to be applied.
+ */
+import type { EventHook } from '@embedpdf/core';
+import { redactionState } from '@embedpdf/plugin-redaction';
+import type { RedactionCapability, RedactionMark, RedactionMarkFilter } from '@embedpdf/plugin-redaction';
+import { type StateReader } from '../runtime/state.svelte.js';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+/**
+ * The redaction API (marking, the pending marks, applying them) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document every method throws
+ * `not-ready`.
+ */
+export declare function useRedaction(): RedactionCapability;
+/** Subscribe to one redaction event while the component lives: `useRedactionEvent((redaction) => redaction.onApplied, handler)`. */
+export declare function useRedactionEvent<T>(select: (redaction: RedactionCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The redaction state: how many marks wait, whether marks are being applied, and the last apply's
+ * result (the page's State table, declared once in `redactionState`), as a reactive object
+ * (`state.pendingCount`). With a selector, the value it picks as `{ current }`. Empty without a
+ * document.
+ *
+ * Typed through the declaration, so the published types name it from `@embedpdf/plugin-redaction`, a
+ * dependency of this package, and not from the engine package `lastResult`'s type comes from, which
+ * isn't one.
+ */
+export declare const useRedactionState: StateReader<ReturnType<typeof redactionState.read>>;
+/** The redaction settings (`overlay`), with or without a document. */
+export declare const useRedactionSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-redaction").RedactionSettings & object>;
+/**
+ * The marks waiting to be applied, in page order, or one page's (its ref or its index; a function
+ * to follow a prop), as `{ current }`. The plugin's lists keep their identity until the marks
+ * change, so a list redraws only then. Empty without a document.
+ */
+export declare function usePendingRedactions(filter?: MaybeGetter<RedactionMarkFilter | undefined>): CurrentValue<readonly RedactionMark[]>;