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

package/dist/stage/props.d.ts

@@ -0,0 +1,71 @@
+/** The props of the Stage's components: `<Stage>` and `<Scrollbar>`. */
+import type { Snippet } from 'svelte';
+import type { PageContextValue } from '../runtime/page.js';
+import type { StageTokenProp } from './stage-scope.js';
+export interface StageProps {
+    /**
+     * Page-space content for each visible page (`<RenderLayer>`, annotations, markers): what you
+     * write between `<Stage>` and `</Stage>`, or `{#snippet children(page)}` when it needs the page.
+     * It's drawn inside the page's content frame, so it turns with the page, and positions are PDF
+     * points.
+     */
+    children: Snippet<[page: PageContextValue]>;
+    /**
+     * Box-space chrome for each visible page (a page number, a selection border, a per-page
+     * button), drawn into the outer box (content and the reserved `pageFrame`). It never turns,
+     * and the reserved bands are plain regions: `bottom: 0; height: page.frame.bottom`.
+     */
+    pageChrome?: Snippet<[page: PageContextValue]>;
+    /** Viewport-space UI (menus, controls, `<Scrollbar>`), drawn above the pages. */
+    overlay?: Snippet;
+    /**
+     * The active tool, two-way (`bind:tool`): while it's set, the interaction plugin's active tool
+     * follows it, and a tool chosen elsewhere is written back. Leave it out for the default
+     * (`useInteraction().activateTool()`).
+     */
+    tool?: string;
+    /** Called on every tool change of this stage's document. */
+    onToolChange?: (toolId: string) => void;
+    /**
+     * The current page's index, from 0, two-way (`bind:page`): the Stage writes it as the reader
+     * moves, and goes to the page when you change it.
+     */
+    page?: number;
+    /**
+     * The zoom level, two-way (`bind:zoom`): `1` is 100%. The Stage writes it as the zoom changes,
+     * and zooms to it when you change it.
+     */
+    zoom?: number;
+    /** The stage lens to drive: the nearest `<StageScope>`'s, else the main view. */
+    token?: StageTokenProp;
+    class?: string;
+    style?: string;
+}
+export type ScrollbarAxis = 'x' | 'y';
+export interface ScrollbarProps {
+    axis: ScrollbarAxis;
+    /** The stage lens to scroll: the nearest `<StageScope>` / `<Stage>`'s, else the main view. */
+    token?: StageTokenProp;
+    /**
+     * Hide `autoHide` milliseconds after the view stops moving (a drag or the pointer over it
+     * keeps it shown; a hidden bar ignores the pointer, like macOS). `false` always shows it.
+     * Published as `data-state="visible|hidden"`. Default 1200.
+     */
+    autoHide?: number | false;
+    /** The smallest thumb, in pixels, so it never vanishes on a long document. Default 24. */
+    minThumbSize?: number;
+    /**
+     * A press on the track: `'page'` steps 90% of a view toward the pointer and repeats while
+     * held, stopping at the pointer; `'jump'` centers the thumb at the pointer and drags from
+     * there. Default `'page'`.
+     */
+    trackPress?: 'page' | 'jump';
+    /**
+     * The track's class and style. The default style pins it to the right (y) or bottom (x) edge
+     * of the nearest positioned ancestor: the Stage, when it's in the overlay.
+     */
+    class?: string;
+    style?: string;
+    thumbClass?: string;
+    thumbStyle?: string;
+}

package/dist/stage/props.js

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

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

@@ -0,0 +1,39 @@
+import type { CapabilityToken, EventHook } from '@embedpdf/core';
+import { stageState } from '@embedpdf/plugin-stage';
+import type { StageCapability, StageSettings } from '@embedpdf/plugin-stage';
+import type { ScrollMetrics, StageHostCapability } from '@embedpdf/plugin-stage/contract/host';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+import { type StageTokenProp } from './stage-scope.js';
+/** What `useStageState()` gives: the Stage page's State table. */
+export type StageStateValue = (typeof stageState)['empty'];
+/** A lens argument: a token, a function that returns one, or none (the scope's, else the main view). */
+type LensArgument = MaybeGetter<StageTokenProp | undefined>;
+/** The Stage's API (zoom, navigation, reveal, settings), for app chrome. */
+export declare function useStage(token?: LensArgument): StageCapability;
+/** Subscribe to one stage event while the component lives: `useStageEvent((stage) => stage.onZoomChanged, handler)`. */
+export declare function useStageEvent<T>(select: (stage: StageCapability) => EventHook<T>, handler: (event: T) => void, token?: LensArgument): void;
+/**
+ * The view's state: the zoom, the current page, the page count, the view rotation and the
+ * responsive rules that apply (declared once in `stageState`), as a reactive object
+ * (`state.zoomLevel`). With a selector, the value it picks as `{ current }`. Without a document
+ * it is `stageState.empty`.
+ */
+export declare function useStageState(token?: StageTokenProp): Readonly<StageStateValue>;
+export declare function useStageState<Selected>(select: (state: StageStateValue) => Selected, token?: LensArgument): CurrentValue<Selected>;
+/**
+ * The view's settings, as a reactive object, or the value a selector picks as `{ current }`. They
+ * belong to the view, so without a document there is none yet and this reads the defaults.
+ * Change them with `useStage().updateSettings()`.
+ */
+export declare function useStageSettings(token?: StageTokenProp): Readonly<StageSettings>;
+export declare function useStageSettings<Selected>(select: (settings: StageSettings) => Selected, token?: LensArgument): CurrentValue<Selected>;
+export declare const asHost: (token: CapabilityToken<StageCapability>) => CapabilityToken<StageHostCapability>;
+/**
+ * The view's scroll position as a scrolling element has it: `scrollTop`, `scrollHeight`,
+ * `clientHeight` and their horizontal twins, in screen pixels, as a reactive object. The raw
+ * material for scroll UI of your own; all zero without a document.
+ */
+export declare function useScrollMetrics(token?: LensArgument): Readonly<ScrollMetrics>;
+/** {@link useScrollMetrics} for the lens `lens()` names now, for a component whose token is a prop. */
+export declare function scrollMetricsOf(lens: () => StageTokenProp): Readonly<ScrollMetrics>;
+export {};

package/dist/stage/readers.svelte.js

@@ -0,0 +1,84 @@
+/**
+ * The Stage's readers: `useStage()` (the API), `useStageState()`, `useStageSettings()`,
+ * `useStageEvent()` and `useScrollMetrics()`. Each takes an optional token; without one it binds
+ * to the nearest `<StageScope>` / `<Stage>`, else the main view. A token that changes (a prop) is
+ * passed as a function: `useStage(() => token)`, and after a selector,
+ * `useStageState((state) => state.zoomLevel, () => token)`.
+ */
+import { shallowEqual } from '@embedpdf/core';
+import { DEFAULT_SETTINGS, stageState } from '@embedpdf/plugin-stage';
+import { documentScopeOf, useKernelBinding } from '../runtime/binding.svelte.js';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { declaredState, readRecord } from '../runtime/state.svelte.js';
+import { derivedValue, valueOf, } from '../runtime/values.svelte.js';
+import { stageTokenOf } from './stage-scope.js';
+/** The lens a reader with this argument binds to, read on every use. */
+const lensOf = (token) => stageTokenOf(() => valueOf(token));
+/** The Stage's API (zoom, navigation, reveal, settings), for app chrome. */
+export function useStage(token) {
+    return useCapability(lensOf(token));
+}
+/** Subscribe to one stage event while the component lives: `useStageEvent((stage) => stage.onZoomChanged, handler)`. */
+export function useStageEvent(select, handler, token) {
+    useCapabilityEvent(lensOf(token), select, handler);
+}
+/**
+ * A reader's arguments: a selector, then an optional lens; or just a token. A function first is
+ * always the selector, so a token that changes goes second, as a function.
+ */
+function selectorAndLens(first, second) {
+    return typeof first === 'function' ? [first, second] : [undefined, first ?? second];
+}
+export function useStageState(first, second) {
+    const [select, token] = selectorAndLens(first, second);
+    const binding = useKernelBinding();
+    const lens = lensOf(token);
+    const whole = declaredState(binding, lens, stageState.read, stageState.empty);
+    return readRecord(whole, Object.keys(stageState.empty), select);
+}
+export function useStageSettings(first, second) {
+    const [select, token] = selectorAndLens(first, second);
+    const binding = useKernelBinding();
+    const lens = lensOf(token);
+    const scoped = documentScopeOf();
+    const whole = derivedValue(() => {
+        binding.track();
+        const stage = binding.kernel.tryCapability(lens(), scoped() ?? undefined);
+        return stage?.getSettings() ?? DEFAULT_SETTINGS;
+    }, shallowEqual);
+    return readRecord(whole, Object.keys(DEFAULT_SETTINGS), select);
+}
+/** What a view with nothing to scroll measures: no document, or not placed yet. */
+const NO_SCROLL = Object.freeze({
+    scrollLeft: 0,
+    scrollTop: 0,
+    scrollWidth: 0,
+    scrollHeight: 0,
+    clientWidth: 0,
+    clientHeight: 0,
+    scrollableX: false,
+    scrollableY: false,
+});
+// Scroll metrics live on the host lens (the same runtime token, typed wider): a scrollbar is
+// chrome that drives the camera, not a document-level consumer.
+export const asHost = (token) => token;
+/**
+ * The view's scroll position as a scrolling element has it: `scrollTop`, `scrollHeight`,
+ * `clientHeight` and their horizontal twins, in screen pixels, as a reactive object. The raw
+ * material for scroll UI of your own; all zero without a document.
+ */
+export function useScrollMetrics(token) {
+    return scrollMetricsOf(lensOf(token));
+}
+/** {@link useScrollMetrics} for the lens `lens()` names now, for a component whose token is a prop. */
+export function scrollMetricsOf(lens) {
+    const binding = useKernelBinding();
+    const scoped = documentScopeOf();
+    // The capability keeps the same metrics object until a number moves.
+    const whole = derivedValue(() => {
+        binding.track();
+        const stage = binding.kernel.tryCapability(asHost(lens()), scoped() ?? undefined);
+        return stage?.getScrollMetrics() ?? NO_SCROLL;
+    });
+    return readRecord(whole, Object.keys(NO_SCROLL), undefined);
+}

package/dist/stage/stage-scope.d.ts

@@ -0,0 +1,18 @@
+import type { CapabilityToken } from '@embedpdf/core';
+import type { StageCapability } from '@embedpdf/plugin-stage/contract';
+/** Which stage lens to bind to: the main `StageToken`, or a second view's own token. */
+export type StageTokenProp = CapabilityToken<StageCapability>;
+/** For `<Stage>` and `<StageScope>`: bind everything inside to the lens `token()` names. */
+export declare function setStageToken(token: () => StageTokenProp): void;
+/**
+ * The lens a stage reader binds to, as a function read on every use: the explicit token, else
+ * the nearest `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export declare function stageTokenOf(explicit?: () => StageTokenProp | undefined): () => StageTokenProp;
+/**
+ * The lens stage chrome of your own binds to, as `{ current }`: `token`, else the nearest
+ * `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export declare function useStageToken(token?: StageTokenProp): {
+    readonly current: StageTokenProp;
+};

package/dist/stage/stage-scope.js

@@ -0,0 +1,35 @@
+/**
+ * The stage lens a subtree binds to, so the stage readers and the stage-bound chrome
+ * (`<Scrollbar>`, `<SelectionHandles>`) need no token. `<Stage>` provides its own lens to its
+ * pages and overlay; an app wraps a second lens (a thumbnail rail) in `<StageScope token>`. An
+ * explicit token still wins everywhere.
+ *
+ * Apart from `./Stage.svelte`, so entries that only need the scope never pull the stage surface.
+ */
+import { getContext, hasContext, setContext } from 'svelte';
+import { StageToken } from '@embedpdf/plugin-stage/contract';
+const STAGE_TOKEN = Symbol('embedpdf.stage-token');
+/** For `<Stage>` and `<StageScope>`: bind everything inside to the lens `token()` names. */
+export function setStageToken(token) {
+    setContext(STAGE_TOKEN, token);
+}
+/**
+ * The lens a stage reader binds to, as a function read on every use: the explicit token, else
+ * the nearest `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export function stageTokenOf(explicit) {
+    const scoped = hasContext(STAGE_TOKEN) ? getContext(STAGE_TOKEN) : null;
+    return () => explicit?.() ?? scoped?.() ?? StageToken;
+}
+/**
+ * The lens stage chrome of your own binds to, as `{ current }`: `token`, else the nearest
+ * `<StageScope>` / `<Stage>`, else the main lens.
+ */
+export function useStageToken(token) {
+    const lens = stageTokenOf(() => token);
+    return {
+        get current() {
+            return lens();
+        },
+    };
+}

package/dist/stage/two-way.svelte.d.ts

@@ -0,0 +1,13 @@
+export interface TwoWayValue<T> {
+    /** The Stage's value now. */
+    stage: () => T;
+    /** The bound prop now; undefined while the owner gives none. */
+    bound: () => T | undefined;
+    /** Whether the Stage can take a value yet (it has a document). */
+    ready: () => boolean;
+    /** Write the Stage's value to the bound prop. */
+    write: (value: T) => void;
+    /** Move the Stage to the owner's value. */
+    apply: (value: T) => void;
+}
+export declare function syncTwoWay<T>(value: TwoWayValue<T>): void;

package/dist/stage/two-way.svelte.js

@@ -0,0 +1,26 @@
+/**
+ * A value the Stage and its owner both write, for `bind:page` and `bind:zoom`: the owner's
+ * value goes in when it differs from the Stage's, and the Stage's goes out when it changes.
+ */
+import { untrack } from 'svelte';
+export function syncTwoWay(value) {
+    // In first: on mount, the owner's value is where the Stage goes, and only then does the
+    // Stage's own value come back out.
+    $effect(() => {
+        const wanted = value.bound();
+        if (wanted === undefined || !value.ready())
+            return;
+        untrack(() => {
+            if (!Object.is(wanted, value.stage()))
+                value.apply(wanted);
+        });
+    });
+    let last = untrack(value.stage);
+    $effect(() => {
+        const current = value.stage();
+        if (Object.is(current, last))
+            return;
+        last = current;
+        untrack(() => value.write(current));
+    });
+}

package/dist/stage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @embedpdf/svelte/stage — the Stage and its readers.
+ *
+ * `<Stage>` lays out and positions the visible pages by the camera, and hands each one to its
+ * content: you bring the layers. The readers are the plugin's four, `useStage()` (the API),
+ * `useStageState()`, `useStageSettings()` and `useStageEvent()`; `<Scrollbar>` and
+ * `useScrollMetrics()` are the Stage's too.
+ */
+export * from '@embedpdf/plugin-stage';
+export { default as Stage } from './stage/Stage.svelte';
+export { default as StageScope } from './stage/StageScope.svelte';
+export { default as Scrollbar } from './stage/Scrollbar.svelte';
+export type { ScrollbarAxis, ScrollbarProps, StageProps } from './stage/props.js';
+export { useStageToken } from './stage/stage-scope.js';
+export type { StageTokenProp } from './stage/stage-scope.js';
+export { useScrollMetrics, useStage, useStageEvent, useStageSettings, useStageState, } from './stage/readers.svelte.js';
+export type { StageStateValue } from './stage/readers.svelte.js';

package/dist/stage.js

@@ -0,0 +1,15 @@
+/**
+ * @embedpdf/svelte/stage — the Stage and its readers.
+ *
+ * `<Stage>` lays out and positions the visible pages by the camera, and hands each one to its
+ * content: you bring the layers. The readers are the plugin's four, `useStage()` (the API),
+ * `useStageState()`, `useStageSettings()` and `useStageEvent()`; `<Scrollbar>` and
+ * `useScrollMetrics()` are the Stage's too.
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-stage';
+export { default as Stage } from './stage/Stage.svelte';
+export { default as StageScope } from './stage/StageScope.svelte';
+export { default as Scrollbar } from './stage/Scrollbar.svelte';
+export { useStageToken } from './stage/stage-scope.js';
+export { useScrollMetrics, useStage, useStageEvent, useStageSettings, useStageState, } from './stage/readers.svelte.js';

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

@@ -0,0 +1,50 @@
+/**
+ * The stamp plugin's readers: `useStamp()` (the API), `useStampState()`, `useStampSettings()`,
+ * `useStampEvent()`, and the three a picker is built from: `useStampLibraries()`,
+ * `useStampAssets()` and `useStampAssetPreviewUrl()`.
+ *
+ * The plugin owns the libraries, their stamps and the cached previews; the one thing made here is
+ * the DOM resource a picker shows, the object URL of a stamp's preview.
+ */
+import type { EventHook } from '@embedpdf/core';
+import type { StampAsset, StampAssetFilter, StampCapability, StampLibrary, StampLibraryFilter } from '@embedpdf/plugin-stamp';
+import { type CurrentValue, type MaybeGetter } from '../runtime/values.svelte.js';
+/**
+ * The stamp API. Libraries are shared by every document; the placing verbs (`armAsset`,
+ * `placeAsset`, …) act on the nearest `<DocumentScope>`'s document, else the active one. A handle:
+ * keep it whole and call through it, `stamp.armAsset(id)`.
+ */
+export declare function useStamp(): StampCapability;
+/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */
+export declare function useStampEvent<T>(select: (stamp: StampCapability) => EventHook<T>, handler: (event: T) => void): void;
+/**
+ * The stamps' state for this component's document: the armed stamp (the page's State table,
+ * declared once in `stampState`), as a reactive object (`stampState.armedAsset`). With a
+ * selector, the value it picks as `{ current }`.
+ */
+export declare const useStampState: import("../index.js").StateReader<{
+    armedAsset: StampAsset | null;
+}>;
+/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document. */
+export declare const useStampSettings: import("../index.js").SettingsReader<import("@embedpdf/plugin-stamp").StampSettings & object>;
+/**
+ * The libraries as `{ current }`, optionally of one kind or several (`{ kind: 'stamps' }`,
+ * `{ kind: ['stamps', 'legal-seals'] }`; a function to follow a prop). Every read is a new array,
+ * compared item by item, so the value changes only when a library is added, renamed or removed.
+ */
+export declare function useStampLibraries(filter?: MaybeGetter<StampLibraryFilter | undefined>): CurrentValue<readonly StampLibrary[]>;
+/**
+ * The stamps as `{ current }`: one library's (`{ libraryId }`), one kind's or category's, or every
+ * stamp, in the order a picker shows them. A filter that changes is a function:
+ * `useStampAssets(() => ({ libraryId }))`.
+ */
+export declare function useStampAssets(filter?: MaybeGetter<StampAssetFilter | undefined>): CurrentValue<readonly StampAsset[]>;
+/**
+ * An image URL for a stamp's cached preview (a gallery thumbnail) as `{ current }`, or null while
+ * there is none. An id that changes is a function: `useStampAssetPreviewUrl(() => assetId)`.
+ *
+ * The plugin holds the preview's bytes; the URL is a DOM resource, so it is made here and revoked
+ * when the preview changes or the component goes away, the rule `<AnnotationLayer>` follows for
+ * the pictures it shows.
+ */
+export declare function useStampAssetPreviewUrl(assetId: MaybeGetter<string | null>): CurrentValue<string | null>;

package/dist/stamp/readers.svelte.js

@@ -0,0 +1,76 @@
+import { StampToken, stampState } from '@embedpdf/plugin-stamp';
+import { objectUrlOf } from '@embedpdf/web';
+import { shallowArray, useCapability, useCapabilityEvent, useOptionalSelector, useSelector, } from '../runtime/readers.svelte.js';
+import { settingsReader, stateReader } from '../runtime/state.svelte.js';
+import { valueOf } from '../runtime/values.svelte.js';
+/**
+ * The stamp API. Libraries are shared by every document; the placing verbs (`armAsset`,
+ * `placeAsset`, …) act on the nearest `<DocumentScope>`'s document, else the active one. A handle:
+ * keep it whole and call through it, `stamp.armAsset(id)`.
+ */
+export function useStamp() {
+    return useCapability(StampToken);
+}
+/** Subscribe to one stamp event while the component lives: `useStampEvent((stamp) => stamp.onLibraryChanged, handler)`. */
+export function useStampEvent(select, handler) {
+    useCapabilityEvent(StampToken, select, handler);
+}
+/**
+ * The stamps' state for this component's document: the armed stamp (the page's State table,
+ * declared once in `stampState`), as a reactive object (`stampState.armedAsset`). With a
+ * selector, the value it picks as `{ current }`.
+ */
+export const useStampState = stateReader(stampState);
+/** The stamp settings (`assetEngine`, `previewWidth`, `dynamic`), with or without a document. */
+export const useStampSettings = settingsReader(StampToken);
+/**
+ * The libraries as `{ current }`, optionally of one kind or several (`{ kind: 'stamps' }`,
+ * `{ kind: ['stamps', 'legal-seals'] }`; a function to follow a prop). Every read is a new array,
+ * compared item by item, so the value changes only when a library is added, renamed or removed.
+ */
+export function useStampLibraries(filter) {
+    return useSelector(StampToken, (stamp) => stamp.listLibraries(valueOf(filter)), shallowArray);
+}
+/**
+ * The stamps as `{ current }`: one library's (`{ libraryId }`), one kind's or category's, or every
+ * stamp, in the order a picker shows them. A filter that changes is a function:
+ * `useStampAssets(() => ({ libraryId }))`.
+ */
+export function useStampAssets(filter) {
+    return useSelector(StampToken, (stamp) => stamp.listAssets(valueOf(filter)), shallowArray);
+}
+/**
+ * An image URL for a stamp's cached preview (a gallery thumbnail) as `{ current }`, or null while
+ * there is none. An id that changes is a function: `useStampAssetPreviewUrl(() => assetId)`.
+ *
+ * The plugin holds the preview's bytes; the URL is a DOM resource, so it is made here and revoked
+ * when the preview changes or the component goes away, the rule `<AnnotationLayer>` follows for
+ * the pictures it shows.
+ */
+export function useStampAssetPreviewUrl(assetId) {
+    // The preview itself, read on every change: it follows the id, and a preview that arrives
+    // after the stamp does.
+    const preview = useOptionalSelector(StampToken, (stamp) => {
+        const id = valueOf(assetId);
+        return id ? stamp.getAssetPreview(id) : null;
+    }, null);
+    let url = $state(null);
+    $effect(() => {
+        const current = preview.current;
+        if (!current) {
+            url = null;
+            return;
+        }
+        const objectUrl = objectUrlOf(current);
+        url = objectUrl.url;
+        return () => {
+            objectUrl.revoke();
+            url = null;
+        };
+    });
+    return {
+        get current() {
+            return url;
+        },
+    };
+}

package/dist/stamp.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @embedpdf/svelte/stamp — stamps: libraries of marks you pick from and place.
+ *
+ * Thin by design: the plugin owns the libraries, their stamps and the cached previews. Placing
+ * needs no component here: an armed stamp rides the annotation plugin, whose `<AnnotationLayer>`
+ * draws the ghost under the pointer.
+ *
+ *   const stamp = useStamp();
+ *   const assets = useStampAssets(() => ({ libraryId })); // assets.current
+ *   const stampState = useStampState(); // stampState.armedAsset
+ *   await stamp.armAsset(assetId); // the next click places it
+ */
+export * from '@embedpdf/plugin-stamp';
+export { indexedDbByteStore } from '@embedpdf/web';
+export type { ByteStore } from '@embedpdf/web';
+export { useStamp, useStampAssetPreviewUrl, useStampAssets, useStampEvent, useStampLibraries, useStampSettings, useStampState, } from './stamp/readers.svelte.js';

package/dist/stamp.js

@@ -0,0 +1,18 @@
+/**
+ * @embedpdf/svelte/stamp — stamps: libraries of marks you pick from and place.
+ *
+ * Thin by design: the plugin owns the libraries, their stamps and the cached previews. Placing
+ * needs no component here: an armed stamp rides the annotation plugin, whose `<AnnotationLayer>`
+ * draws the ghost under the pointer.
+ *
+ *   const stamp = useStamp();
+ *   const assets = useStampAssets(() => ({ libraryId })); // assets.current
+ *   const stampState = useStampState(); // stampState.armedAsset
+ *   await stamp.armAsset(assetId); // the next click places it
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-stamp';
+// The browser store for `persistStampLibraries` / `restoreStampLibraries` (structurally the
+// plugin's `StampLibraryStore`), written once in `@embedpdf/web`.
+export { indexedDbByteStore } from '@embedpdf/web';
+export { useStamp, useStampAssetPreviewUrl, useStampAssets, useStampEvent, useStampLibraries, useStampSettings, useStampState, } from './stamp/readers.svelte.js';

package/dist/toolbar/DefaultCollapsed.svelte

@@ -0,0 +1,39 @@
+<!--
+  The default folded group: a <select> for `collapse: 'select'`, else a "More"-style button with a
+  menu of the group's commands.
+-->
+<script lang="ts">
+  import DefaultOverflowMenu from './DefaultOverflowMenu.svelte';
+  import DefaultOverflowTrigger from './DefaultOverflowTrigger.svelte';
+  import { groupMenuView } from '@embedpdf/core-ui';
+  import type { Orientation } from '@embedpdf/web';
+  import type { CollapsedGroupView } from './views.js';
+  import { BORDER, SURFACE } from './paint.js';
+
+  let { view, orientation }: { view: CollapsedGroupView; orientation: Orientation } = $props();
+
+  let isOpen = $state(false);
+  const active = $derived(view.commands.find((command) => command.active)?.id ?? '');
+  const menu = $derived(groupMenuView(view, isOpen, () => (isOpen = false)));
+</script>
+
+{#if view.collapse === 'select'}
+  <select
+    value={active}
+    onchange={(event) => view.execute(event.currentTarget.value)}
+    style:padding="4px 6px"
+    style:font="inherit"
+    style:border-radius="4px"
+    style:border="1px solid {BORDER}"
+    style:background={SURFACE}
+  >
+    {#each view.commands as command (command.id)}
+      <option value={command.id} disabled={!command.enabled}>{command.label}</option>
+    {/each}
+  </select>
+{:else}
+  <span style="position: relative; display: inline-flex">
+    <DefaultOverflowTrigger {isOpen} toggle={() => (isOpen = !isOpen)} />
+    <DefaultOverflowMenu view={menu} {orientation} />
+  </span>
+{/if}

package/dist/toolbar/DefaultCollapsed.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Orientation } from '@embedpdf/web';
+import type { CollapsedGroupView } from './views.js';
+type $$ComponentProps = {
+    view: CollapsedGroupView;
+    orientation: Orientation;
+};
+declare const DefaultCollapsed: import("svelte").Component<$$ComponentProps, {}, "">;
+type DefaultCollapsed = ReturnType<typeof DefaultCollapsed>;
+export default DefaultCollapsed;

package/dist/toolbar/DefaultCommand.svelte

@@ -0,0 +1,33 @@
+<!--
+  The default command button: the command's label in every variant (icons are the app's), pressed
+  when the command is active.
+-->
+<script lang="ts">
+  import type { ResolvedCommand } from '@embedpdf/plugin-commands/contract';
+  import { ACTIVE, BORDER } from './paint.js';
+
+  let { command, run }: { command: ResolvedCommand; run: () => void } = $props();
+</script>
+
+<button
+  type="button"
+  onclick={run}
+  disabled={!command.enabled}
+  aria-pressed={command.active || undefined}
+  aria-haspopup={command.menu ? 'menu' : undefined}
+  title={command.label}
+  style:display="inline-flex"
+  style:align-items="center"
+  style:gap="4px"
+  style:padding="4px 8px"
+  style:white-space="nowrap"
+  style:color="inherit"
+  style:font="inherit"
+  style:background={command.active ? ACTIVE : 'transparent'}
+  style:border="1px solid {BORDER}"
+  style:border-radius="4px"
+  style:cursor={command.enabled ? 'pointer' : 'default'}
+  style:opacity={command.enabled ? 1 : 0.4}
+>
+  {command.label}
+</button>

package/dist/toolbar/DefaultCommand.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedCommand } from '@embedpdf/plugin-commands/contract';
+type $$ComponentProps = {
+    command: ResolvedCommand;
+    run: () => void;
+};
+declare const DefaultCommand: import("svelte").Component<$$ComponentProps, {}, "">;
+type DefaultCommand = ReturnType<typeof DefaultCommand>;
+export default DefaultCommand;

package/dist/toolbar/DefaultGroupTrigger.svelte

@@ -0,0 +1,39 @@
+<!--
+  The default button of a group that shed items: a chevron opening a menu of what it shed, lit
+  while the active item is in there.
+-->
+<script lang="ts">
+  import DefaultOverflowMenu from './DefaultOverflowMenu.svelte';
+  import { groupMenuView } from '@embedpdf/core-ui';
+  import type { Orientation } from '@embedpdf/web';
+  import type { GroupDisclosureView } from './views.js';
+  import { ACTIVE, BORDER } from './paint.js';
+
+  let { view, orientation }: { view: GroupDisclosureView; orientation: Orientation } = $props();
+
+  let isOpen = $state(false);
+  const someActive = $derived(view.commands.some((command) => command.active));
+  const menu = $derived(groupMenuView(view, isOpen, () => (isOpen = false)));
+</script>
+
+<span style="position: relative; display: inline-flex">
+  <button
+    type="button"
+    onclick={() => (isOpen = !isOpen)}
+    aria-haspopup="menu"
+    aria-expanded={isOpen}
+    title="More"
+    style:display="inline-flex"
+    style:align-items="center"
+    style:padding="4px 6px"
+    style:color="inherit"
+    style:font="inherit"
+    style:border="1px solid {BORDER}"
+    style:border-radius="4px"
+    style:background={isOpen || someActive ? ACTIVE : 'transparent'}
+    style:cursor="pointer"
+  >
+    ▾
+  </button>
+  <DefaultOverflowMenu view={menu} {orientation} />
+</span>

package/dist/toolbar/DefaultGroupTrigger.svelte.d.ts

@@ -0,0 +1,9 @@
+import type { Orientation } from '@embedpdf/web';
+import type { GroupDisclosureView } from './views.js';
+type $$ComponentProps = {
+    view: GroupDisclosureView;
+    orientation: Orientation;
+};
+declare const DefaultGroupTrigger: import("svelte").Component<$$ComponentProps, {}, "">;
+type DefaultGroupTrigger = ReturnType<typeof DefaultGroupTrigger>;
+export default DefaultGroupTrigger;