@embedpdf/svelte 3.0.0-next.15 → 3.0.0-next.16

package/dist/annotation/FreeTextBox.svelte

@@ -7,49 +7,45 @@
 -->
 <script lang="ts">
   import type { TextItem } from '@embedpdf/plugin-annotation';
-  import { textBoxStyleOf, textPlateInPixels } from '@embedpdf/web';
+  import { freeTextBoxOf } from '@embedpdf/web';
   import type { PageContextValue } from '../runtime/page.js';
   import { useChromePaint } from './chrome-paint.svelte.js';
   import { textBoxEditor } from './text-box.svelte.js';
 
   let { item, page }: { item: TextItem; page: PageContextValue } = $props();
 
-  const plate = $derived(textPlateInPixels(item, page.transform));
-  const text = $derived(textBoxStyleOf(item.css, plate.scale));
   const paint = useChromePaint();
+  // On the engine's text plate (the box inset by its padding), laid out at a legible size.
+  const box = $derived(freeTextBoxOf(item, page.transform, paint.css.textOutline));
   const editor = textBoxEditor(
     () => item,
-    () => plate.scale,
+    () => box.scale,
   );
 </script>
 
-<!-- Fixed to the plate: the box never grows with its text; it scrolls while typing and clips
-     otherwise, where the baked appearance clips. Its fill and border are the scene's, under this
-     layer. A plain text box turns about its centre, as the baked appearance does. Not typing,
-     presses fall through to the shapes (select, move, resize). -->
 <div
   {@attach editor}
-  style:position="absolute"
-  style:left="{plate.left}px"
-  style:top="{plate.top}px"
-  style:width="{plate.width}px"
-  style:height="{plate.height}px"
-  style:font-family={text.fontFamily}
-  style:font-size={text.fontSize}
-  style:color={text.color}
-  style:font-weight={text.fontWeight}
-  style:font-style={text.fontStyle}
-  style:text-decoration={text.textDecoration}
-  style:text-align={text.textAlign}
-  style:box-sizing="border-box"
-  style:background="transparent"
-  style:white-space="pre-wrap"
-  style:overflow-wrap="break-word"
-  style:overflow-y={item.editing ? 'auto' : 'hidden'}
-  style:overflow-x="hidden"
-  style:outline={item.editing ? `1px solid ${paint.css.textOutline}` : 'none'}
-  style:cursor={item.editing ? 'text' : 'default'}
-  style:transform={item.rot ? `rotate(${item.rot}deg)` : undefined}
-  style:transform-origin={item.rot ? 'center' : undefined}
-  style:pointer-events={item.editing ? 'auto' : 'none'}
+  style:position={box.style.position}
+  style:left={box.style.left}
+  style:top={box.style.top}
+  style:width={box.style.width}
+  style:height={box.style.height}
+  style:font-family={box.style.fontFamily}
+  style:font-size={box.style.fontSize}
+  style:color={box.style.color}
+  style:font-weight={box.style.fontWeight}
+  style:font-style={box.style.fontStyle}
+  style:text-decoration={box.style.textDecoration}
+  style:text-align={box.style.textAlign}
+  style:box-sizing={box.style.boxSizing}
+  style:background={box.style.background}
+  style:white-space={box.style.whiteSpace}
+  style:overflow-wrap={box.style.overflowWrap}
+  style:overflow-x={box.style.overflowX}
+  style:overflow-y={box.style.overflowY}
+  style:outline={box.style.outline}
+  style:cursor={box.style.cursor}
+  style:transform={box.style.transform}
+  style:transform-origin={box.style.transformOrigin}
+  style:pointer-events={box.style.pointerEvents}
 ></div>

package/dist/annotation/text-box.svelte.d.ts

@@ -22,6 +22,7 @@ export declare function setLookScale(scale: () => number): void;
  * ```
  *
  * `attach` goes on your element (render nothing inside it: the editor owns what's in it); `style`
- * and `editing` follow the box.
+ * and `editing` follow the box. `style` fills the element's parent at a legible size: draw the
+ * box's frame on the parent.
  */
 export declare function useRichTextEditor(annotation: MaybeGetter<Annotation>): RichTextEditor;

package/dist/annotation/text-box.svelte.js

@@ -7,10 +7,9 @@
  * that draws its text box itself.
  */
 import { getContext, hasContext, setContext, untrack } from 'svelte';
-import { annotationKey } from '@embedpdf/core';
 // Typing reaches the plugin through its host lens (drafts, the text selection).
 import { AnnotationToken as AnnotationHostToken } from '@embedpdf/plugin-annotation/contract/host';
-import { createTextBoxEditorFollower, cssText, textBoxEditorScaleOf, textBoxStyleOf, } from '@embedpdf/web';
+import { createTextBoxEditorFollower, cssText, ownTextBoxOf, textBoxEditorScaleOf, } from '@embedpdf/web';
 import { usePage } from '../runtime/page.js';
 import { useOptionalCapability, useOptionalSelector } from '../runtime/readers.svelte.js';
 import { valueOf } from '../runtime/values.svelte.js';
@@ -56,32 +55,26 @@ function lookScaleOf() {
  * ```
  *
  * `attach` goes on your element (render nothing inside it: the editor owns what's in it); `style`
- * and `editing` follow the box.
+ * and `editing` follow the box. `style` fills the element's parent at a legible size: draw the
+ * box's frame on the parent.
  */
 export function useRichTextEditor(annotation) {
     const page = usePage();
     const lookScale = lookScaleOf();
+    // Saved and idle too: your element draws its text, no engine picture does.
     const item = useOptionalSelector(AnnotationHostToken, (host) => {
-        const key = annotationKey(valueOf(annotation).ref);
         const { transform } = page;
-        return (host
-            .listTextItems(page.ref, { zoom: transform.zoom, rotation: transform.rotation })
-            .find((text) => text.ref !== null && annotationKey(text.ref) === key) ?? null);
+        return host.getTextItem(valueOf(annotation).ref, {
+            zoom: transform.zoom,
+            rotation: transform.rotation,
+        });
     }, null);
     // Pixels per point where the element is: inside a scaled look, at the annotation's 100% size;
     // the look's scale does the rest.
     const scale = $derived(textBoxEditorScaleOf(item.current, page.transform, lookScale()));
-    // While typing, the element takes the pointer (the caret, a drag over words).
-    const style = $derived.by(() => {
-        const text = item.current;
-        if (!text)
-            return '';
-        return cssText({
-            ...textBoxStyleOf(text.css, scale),
-            ...(text.editing ? { pointerEvents: 'auto' } : {}),
-        });
-    });
-    const attach = textBoxEditor(() => item.current, () => scale);
+    const own = $derived(item.current ? ownTextBoxOf(item.current, scale) : null);
+    const style = $derived(own ? cssText(own.style) : '');
+    const attach = textBoxEditor(() => item.current, () => own?.scale ?? scale);
     return {
         attach,
         get style() {

package/dist/attachment/readers.d.ts

@@ -0,0 +1,23 @@
+/** The attachments' readers: the API, the state declared once in `attachmentState`, and its events. */
+import type { EventHook } from '@embedpdf/core';
+import type { AttachmentCapability } from '@embedpdf/plugin-attachment';
+/**
+ * The attachment API (add, remove, download, reveal) of the nearest `<DocumentScope>`'s document,
+ * else the active one. Outside a ready document, every method throws `not-ready`. `canAdd()` is a
+ * read, so `disabled={!attachment.canAdd()}` updates by itself.
+ */
+export declare function useAttachment(): AttachmentCapability;
+/**
+ * The files the document carries, the load state, and whether you may add and save files (the
+ * page's State table, declared once in `attachmentState`), as a reactive object: `state.files`.
+ * With a selector, the value it picks as `{ current }`, which changes only when that value does.
+ */
+export declare const useAttachmentState: import("../index.js").StateReader<{
+    files: readonly import("@embedpdf/plugin-attachment").AttachedFile[];
+    selected: readonly import("@embedpdf/plugin-attachment").AttachedFile[];
+    status: import("@embedpdf/core").ResourceStatus;
+    canAdd: boolean;
+    canDownload: boolean;
+}>;
+/** Subscribe to one attachment event while the component lives: `useAttachmentEvent((attachment) => attachment.onChanged, handler)`. */
+export declare function useAttachmentEvent<T>(select: (attachment: AttachmentCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/attachment/readers.js

@@ -0,0 +1,21 @@
+import { AttachmentToken, attachmentState } from '@embedpdf/plugin-attachment';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.svelte.js';
+/**
+ * The attachment API (add, remove, download, reveal) of the nearest `<DocumentScope>`'s document,
+ * else the active one. Outside a ready document, every method throws `not-ready`. `canAdd()` is a
+ * read, so `disabled={!attachment.canAdd()}` updates by itself.
+ */
+export function useAttachment() {
+    return useCapability(AttachmentToken);
+}
+/**
+ * The files the document carries, the load state, and whether you may add and save files (the
+ * page's State table, declared once in `attachmentState`), as a reactive object: `state.files`.
+ * With a selector, the value it picks as `{ current }`, which changes only when that value does.
+ */
+export const useAttachmentState = stateReader(attachmentState);
+/** Subscribe to one attachment event while the component lives: `useAttachmentEvent((attachment) => attachment.onChanged, handler)`. */
+export function useAttachmentEvent(select, handler) {
+    useCapabilityEvent(AttachmentToken, select, handler);
+}

package/dist/attachment.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/attachment — the files a document carries.
+ *
+ * Reading the state reads the document's attachments; the plugin keeps them live off the
+ * document's event stream, lists the pages' files with them, and shows your own adds and removes
+ * at once:
+ *
+ *   const attachment = useAttachment();
+ *   const state = useAttachmentState(); // state.files, state.canAdd
+ *   const { bytes, name, mimeType } = await attachment.download(file);
+ */
+export * from '@embedpdf/plugin-attachment';
+export { useAttachment, useAttachmentEvent, useAttachmentState } from './attachment/readers.js';

package/dist/attachment.js

@@ -0,0 +1,14 @@
+/**
+ * @embedpdf/svelte/attachment — the files a document carries.
+ *
+ * Reading the state reads the document's attachments; the plugin keeps them live off the
+ * document's event stream, lists the pages' files with them, and shows your own adds and removes
+ * at once:
+ *
+ *   const attachment = useAttachment();
+ *   const state = useAttachmentState(); // state.files, state.canAdd
+ *   const { bytes, name, mimeType } = await attachment.download(file);
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-attachment';
+export { useAttachment, useAttachmentEvent, useAttachmentState } from './attachment/readers.js';

package/dist/index.d.ts

@@ -19,6 +19,8 @@ export * from './actions.js';
 export * from './view-manager.js';
 export * from './page-edit.js';
 export * from './metadata.js';
+export * from './outline.js';
+export * from './attachment.js';
 export * from './history.js';
 export * from './annotation.js';
 export * from './redaction.js';

package/dist/index.js

@@ -19,6 +19,8 @@ export * from './actions.js';
 export * from './view-manager.js';
 export * from './page-edit.js';
 export * from './metadata.js';
+export * from './outline.js';
+export * from './attachment.js';
 export * from './history.js';
 export * from './annotation.js';
 export * from './redaction.js';

package/dist/outline/readers.d.ts

@@ -0,0 +1,26 @@
+/** The outline's readers: the API, the state declared once in `outlineState`, and its events. */
+import type { EventHook } from '@embedpdf/core';
+import type { OutlineCapability } from '@embedpdf/plugin-outline';
+/**
+ * The outline API (expand, select, activate, create, update, move, delete) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canEdit()` is a read, so `disabled={!outline.canEdit()}` updates by itself.
+ */
+export declare function useOutline(): OutlineCapability;
+/**
+ * The outline's items, the rows a tree view shows, the item for where the view is reading, the
+ * selection, the load state and whether you may edit it (the page's State table, declared once in
+ * `outlineState`), as a reactive object: `state.rows`. With a selector, the value it picks as
+ * `{ current }`, which changes only when that value does.
+ */
+export declare const useOutlineState: import("../index.js").StateReader<{
+    items: readonly import("@embedpdf/plugin-outline").OutlineItem<import("@embedpdf/core").PageDestination>[];
+    rows: readonly import("@embedpdf/plugin-outline").OutlineRow[];
+    current: import("@embedpdf/plugin-outline").OutlineItemRef | null;
+    selected: readonly import("@embedpdf/plugin-outline").OutlineItemRef[];
+    status: import("@embedpdf/core").ResourceStatus;
+    incomplete: boolean;
+    canEdit: boolean;
+}>;
+/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+export declare function useOutlineEvent<T>(select: (outline: OutlineCapability) => EventHook<T>, handler: (event: T) => void): void;

package/dist/outline/readers.js

@@ -0,0 +1,22 @@
+import { OutlineToken, outlineState } from '@embedpdf/plugin-outline';
+import { useCapability, useCapabilityEvent } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.svelte.js';
+/**
+ * The outline API (expand, select, activate, create, update, move, delete) of the nearest
+ * `<DocumentScope>`'s document, else the active one. Outside a ready document, every method
+ * throws `not-ready`. `canEdit()` is a read, so `disabled={!outline.canEdit()}` updates by itself.
+ */
+export function useOutline() {
+    return useCapability(OutlineToken);
+}
+/**
+ * The outline's items, the rows a tree view shows, the item for where the view is reading, the
+ * selection, the load state and whether you may edit it (the page's State table, declared once in
+ * `outlineState`), as a reactive object: `state.rows`. With a selector, the value it picks as
+ * `{ current }`, which changes only when that value does.
+ */
+export const useOutlineState = stateReader(outlineState);
+/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+export function useOutlineEvent(select, handler) {
+    useCapabilityEvent(OutlineToken, select, handler);
+}

package/dist/outline.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @embedpdf/svelte/outline — the document's outline (its bookmarks).
+ *
+ * Reading the state reads the outline; the plugin keeps it live off the document's event stream,
+ * and shows your own edits at once:
+ *
+ *   const outline = useOutline();
+ *   const state = useOutlineState(); // state.rows, state.current, state.canEdit
+ *   outline.activate(row.item.ref); // goes where the item goes, as a click does
+ */
+export * from '@embedpdf/plugin-outline';
+export { useOutline, useOutlineEvent, useOutlineState } from './outline/readers.js';

package/dist/outline.js

@@ -0,0 +1,13 @@
+/**
+ * @embedpdf/svelte/outline — the document's outline (its bookmarks).
+ *
+ * Reading the state reads the outline; the plugin keeps it live off the document's event stream,
+ * and shows your own edits at once:
+ *
+ *   const outline = useOutline();
+ *   const state = useOutlineState(); // state.rows, state.current, state.canEdit
+ *   outline.activate(row.item.ref); // goes where the item goes, as a click does
+ */
+// Registration travels with the UI.
+export * from '@embedpdf/plugin-outline';
+export { useOutline, useOutlineEvent, useOutlineState } from './outline/readers.js';

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

@@ -5,3 +5,13 @@ import type { PageEditCapability } from '@embedpdf/plugin-page-edit';
  * `disabled={!pageEdit.canEdit()}` updates by itself.
  */
 export declare function usePageEdit(): PageEditCapability;
+/**
+ * The selected pages and whether you may edit and copy pages (the page's State table, declared
+ * once in `pageEditState`), as a reactive object: `state.selected`. With a selector, the value it
+ * picks as `{ current }`, which changes only when that value does.
+ */
+export declare const usePageEditState: import("../index.js").StateReader<{
+    selected: readonly import("@embedpdf/core").PageRef[];
+    canEdit: boolean;
+    canExtract: boolean;
+}>;

package/dist/page-edit/readers.js

@@ -1,6 +1,7 @@
-/** 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';
+/** The page edits' readers: the API, and the state declared once in `pageEditState`. The pages are the document's. */
+import { PageEditToken, pageEditState } from '@embedpdf/plugin-page-edit';
 import { useCapability } from '../runtime/readers.svelte.js';
+import { stateReader } from '../runtime/state.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
@@ -9,3 +10,9 @@ import { useCapability } from '../runtime/readers.svelte.js';
 export function usePageEdit() {
     return useCapability(PageEditToken);
 }
+/**
+ * The selected pages and whether you may edit and copy pages (the page's State table, declared
+ * once in `pageEditState`), as a reactive object: `state.selected`. With a selector, the value it
+ * picks as `{ current }`, which changes only when that value does.
+ */
+export const usePageEditState = stateReader(pageEditState);

package/dist/page-edit.d.ts

@@ -1,7 +1,7 @@
 /**
  * @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
+ * The plugin turns a page relative to its rotation and resolves positions, so this is binding
  * only. The pages themselves come from `usePageList()` (`@embedpdf/svelte/runtime`), which
  * follows every edit:
  *
@@ -9,4 +9,4 @@
  *   await pageEdit.rotateBy([page.ref], 90);
  */
 export * from '@embedpdf/plugin-page-edit';
-export { usePageEdit } from './page-edit/readers.js';
+export { usePageEdit, usePageEditState } from './page-edit/readers.js';

package/dist/page-edit.js

@@ -1,7 +1,7 @@
 /**
  * @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
+ * The plugin turns a page relative to its rotation and resolves positions, so this is binding
  * only. The pages themselves come from `usePageList()` (`@embedpdf/svelte/runtime`), which
  * follows every edit:
  *
@@ -10,4 +10,4 @@
  */
 // Registration travels with the UI.
 export * from '@embedpdf/plugin-page-edit';
-export { usePageEdit } from './page-edit/readers.js';
+export { usePageEdit, usePageEditState } from './page-edit/readers.js';

package/dist/runtime/Viewer.svelte

@@ -14,7 +14,7 @@
   import { untrack } from 'svelte';
   import { createKernel, isLocalEngine, viewerSettingsOf } from '@embedpdf/core';
   import type { Engine, EngineFactory, Kernel, ViewerSettings } from '@embedpdf/core';
-  import { browserClock } from '@embedpdf/web';
+  import { browserClock, browserPrinter } from '@embedpdf/web';
   import { KernelBinding, setKernelHolder } from './binding.svelte.js';
   import { isDev } from './dev.js';
   import type { ViewerProps } from './props.js';
@@ -57,7 +57,13 @@
       if (isLocalEngine(created)) created.warmup();
       let kernel: Kernel;
       try {
-        kernel = createKernel({ engine: created, plugins, settings, clock: browserClock() });
+        kernel = createKernel({
+          engine: created,
+          plugins,
+          settings,
+          clock: browserClock(),
+          printer: browserPrinter(),
+        });
       } catch (error) {
         // A plugin graph that can't be built shows `error`, not an exception mid-render.
         boot = { phase: 'error', error };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embedpdf/svelte",
-  "version": "3.0.0-next.15",
+  "version": "3.0.0-next.16",
   "private": false,
   "description": "Svelte 5 adapter for EmbedPDF v3: rune-based functions, components with bind: and snippets, headless layers. The whole framework surface, one entry point per feature.",
   "type": "module",
@@ -31,6 +31,11 @@
       "svelte": "./dist/metadata.js",
       "default": "./dist/metadata.js"
     },
+    "./outline": {
+      "types": "./dist/outline.d.ts",
+      "svelte": "./dist/outline.js",
+      "default": "./dist/outline.js"
+    },
     "./history": {
       "types": "./dist/history.d.ts",
       "svelte": "./dist/history.js",
@@ -116,6 +121,11 @@
       "svelte": "./dist/annotation.js",
       "default": "./dist/annotation.js"
     },
+    "./attachment": {
+      "types": "./dist/attachment.d.ts",
+      "svelte": "./dist/attachment.js",
+      "default": "./dist/attachment.js"
+    },
     "./stamp": {
       "types": "./dist/stamp.d.ts",
       "svelte": "./dist/stamp.js",
@@ -145,33 +155,35 @@
   },
   "dependencies": {
     "esm-env": "^1.2.2",
-    "@embedpdf/core": "3.0.0-next.15",
-    "@embedpdf/core-geometry": "3.0.0-next.15",
-    "@embedpdf/plugin-annotation": "3.0.0-next.15",
-    "@embedpdf/plugin-commands": "3.0.0-next.15",
-    "@embedpdf/plugin-form": "3.0.0-next.15",
-    "@embedpdf/plugin-i18n": "3.0.0-next.15",
-    "@embedpdf/core-annotation": "3.0.0-next.15",
-    "@embedpdf/plugin-interaction": "3.0.0-next.15",
-    "@embedpdf/plugin-metadata": "3.0.0-next.15",
-    "@embedpdf/plugin-link": "3.0.0-next.15",
-    "@embedpdf/plugin-history": "3.0.0-next.15",
-    "@embedpdf/plugin-page-edit": "3.0.0-next.15",
-    "@embedpdf/plugin-redaction": "3.0.0-next.15",
-    "@embedpdf/plugin-render": "3.0.0-next.15",
-    "@embedpdf/plugin-search": "3.0.0-next.15",
-    "@embedpdf/plugin-selection": "3.0.0-next.15",
-    "@embedpdf/plugin-shell": "3.0.0-next.15",
-    "@embedpdf/plugin-stage": "3.0.0-next.15",
-    "@embedpdf/plugin-stamp": "3.0.0-next.15",
-    "@embedpdf/plugin-signature": "3.0.0-next.15",
-    "@embedpdf/core-signature": "3.0.0-next.15",
-    "@embedpdf/plugin-view-manager": "3.0.0-next.15",
-    "@embedpdf/core-stage": "3.0.0-next.15",
-    "@embedpdf/core-ui": "3.0.0-next.15",
-    "@embedpdf/web": "3.0.0-next.15",
-    "@embedpdf/plugin-actions": "3.0.0-next.15",
-    "@embedpdf/plugin-measurement": "3.0.0-next.15"
+    "@embedpdf/core-annotation": "3.0.0-next.16",
+    "@embedpdf/core-geometry": "3.0.0-next.16",
+    "@embedpdf/plugin-commands": "3.0.0-next.16",
+    "@embedpdf/plugin-attachment": "3.0.0-next.16",
+    "@embedpdf/core": "3.0.0-next.16",
+    "@embedpdf/plugin-i18n": "3.0.0-next.16",
+    "@embedpdf/plugin-form": "3.0.0-next.16",
+    "@embedpdf/plugin-interaction": "3.0.0-next.16",
+    "@embedpdf/plugin-link": "3.0.0-next.16",
+    "@embedpdf/plugin-annotation": "3.0.0-next.16",
+    "@embedpdf/plugin-metadata": "3.0.0-next.16",
+    "@embedpdf/plugin-redaction": "3.0.0-next.16",
+    "@embedpdf/plugin-page-edit": "3.0.0-next.16",
+    "@embedpdf/plugin-history": "3.0.0-next.16",
+    "@embedpdf/plugin-render": "3.0.0-next.16",
+    "@embedpdf/plugin-search": "3.0.0-next.16",
+    "@embedpdf/plugin-outline": "3.0.0-next.16",
+    "@embedpdf/plugin-shell": "3.0.0-next.16",
+    "@embedpdf/plugin-selection": "3.0.0-next.16",
+    "@embedpdf/plugin-signature": "3.0.0-next.16",
+    "@embedpdf/plugin-stage": "3.0.0-next.16",
+    "@embedpdf/plugin-stamp": "3.0.0-next.16",
+    "@embedpdf/plugin-view-manager": "3.0.0-next.16",
+    "@embedpdf/core-stage": "3.0.0-next.16",
+    "@embedpdf/core-signature": "3.0.0-next.16",
+    "@embedpdf/web": "3.0.0-next.16",
+    "@embedpdf/core-ui": "3.0.0-next.16",
+    "@embedpdf/plugin-actions": "3.0.0-next.16",
+    "@embedpdf/plugin-measurement": "3.0.0-next.16"
   },
   "peerDependencies": {
     "svelte": "^5.29.0"
@@ -187,7 +199,7 @@
     "vite": "^6.3.5",
     "vitest": "^2.1.9",
     "@embedpdf/tooling-build": "0.0.0",
-    "@embedpdf/engine": "3.0.0-next.15"
+    "@embedpdf/engine": "3.0.0-next.16"
   },
   "scripts": {
     "build": "svelte-package --input src --output dist && node ../../../tooling/build/src/fully-specify-imports.mjs && node ../../../tooling/build/src/check-framework-package.mjs",