@embedpdf/plugin-signature 2.15.1 → 3.0.0-next.13

package/dist/index.js

@@ -1,516 +1,455 @@
-import { BasePlugin, createEmitter, createScopedEmitter } from "@embedpdf/core";
-import { PdfAnnotationSubtype, uuidV4, PdfAnnotationName, expandRect } from "@embedpdf/models";
-import { applyInsertUpright, clampAnnotationToPage, defineAnnotationTool, patching } from "@embedpdf/plugin-annotation";
-var SignatureMode = /* @__PURE__ */ ((SignatureMode2) => {
-  SignatureMode2["SignatureOnly"] = "signature-only";
-  SignatureMode2["SignatureAndInitials"] = "signature-and-initials";
-  return SignatureMode2;
-})(SignatureMode || {});
-var SignatureCreationType = /* @__PURE__ */ ((SignatureCreationType2) => {
-  SignatureCreationType2["Draw"] = "draw";
-  SignatureCreationType2["Type"] = "type";
-  SignatureCreationType2["Upload"] = "upload";
-  return SignatureCreationType2;
-})(SignatureCreationType || {});
-var SignatureFieldKind = /* @__PURE__ */ ((SignatureFieldKind2) => {
-  SignatureFieldKind2["Signature"] = "signature";
-  SignatureFieldKind2["Initials"] = "initials";
-  return SignatureFieldKind2;
-})(SignatureFieldKind || {});
-const SIGNATURE_PLUGIN_ID = "signature";
-const manifest = {
-  id: SIGNATURE_PLUGIN_ID,
-  name: "Signature Plugin",
-  version: "1.0.0",
-  provides: ["signature"],
-  requires: ["annotation"],
-  optional: [],
-  defaultConfig: {
-    mode: SignatureMode.SignatureOnly
-  }
-};
-const ADD_SIGNATURE_ENTRY = "SIGNATURE/ADD_ENTRY";
-const REMOVE_SIGNATURE_ENTRY = "SIGNATURE/REMOVE_ENTRY";
-function addSignatureEntry(id) {
-  return { type: ADD_SIGNATURE_ENTRY, payload: id };
+import { a as markRoleOf, i as SignatureToken, n as SIGNATURES_LIBRARY_KIND, r as SIGNATURE_MARK_NAME, t as INITIALS_MARK_NAME } from "./contract-C3nQtwGf.js";
+import { createEventHook, definePlugin } from "@embedpdf/core";
+import { FormToken } from "@embedpdf/plugin-form/contract";
+import { InteractionToken } from "@embedpdf/plugin-interaction/contract";
+import { StampToken } from "@embedpdf/plugin-stamp/contract";
+import { ANNOTATION_EDIT_PRIORITY, ARMED_STAMP_TOOL_ID, AnnotationToken } from "@embedpdf/plugin-annotation/contract";
+import { certificateCommonName, createTestSigner, indexedDbKeyStore, memoryKeyStore, personalSigner, remoteSigner, sign, validateSignatures, webCryptoSigner } from "@embedpdf/core-signature";
+import { resolveBinarySource } from "@embedpdf/engine-core/runtime";
+//#region src/blank-page.ts
+const OBJECTS = [
+	"<< /Type /Catalog /Pages 2 0 R >>",
+	"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+	"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 200 60] /Contents 4 0 R /Resources << >> >>",
+	`<< /Length 3 >>\nstream\nq Q\nendstream`
+];
+let cached = null;
+function blankPagePdf() {
+	if (cached) return new Uint8Array(cached);
+	let body = "%PDF-1.7\n";
+	const offsets = [];
+	OBJECTS.forEach((object, index) => {
+		offsets.push(body.length);
+		body += `${index + 1} 0 obj\n${object}\nendobj\n`;
+	});
+	const xref = body.length;
+	body += `xref\n0 ${OBJECTS.length + 1}\n0000000000 65535 f \n`;
+	for (const offset of offsets) body += `${String(offset).padStart(10, "0")} 00000 n \n`;
+	body += `trailer\n<< /Size ${OBJECTS.length + 1} /Root 1 0 R >>\nstartxref\n${xref}\n%%EOF\n`;
+	cached = new TextEncoder().encode(body);
+	return new Uint8Array(cached);
 }
-function removeSignatureEntry(id) {
-  return { type: REMOVE_SIGNATURE_ENTRY, payload: id };
+//#endregion
+//#region src/capability.ts
+const sameRef = (a, b) => a.kind === "objectNumber" && b.kind === "objectNumber" ? a.fieldObjectNumber === b.fieldObjectNumber : a.kind === "fqn" && b.kind === "fqn" ? a.name === b.name : false;
+const sameProtection = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function createSignatureCapability(ctx, config = {}) {
+	const form = ctx.get(FormToken);
+	const changed = createEventHook((error) => globalThis.console?.error("[signature] listener failed:", error));
+	ctx.cleanup(() => changed.dispose());
+	const state = () => ctx.getState();
+	const requireDoc = () => {
+		const doc = ctx.doc;
+		if (!doc) throw new Error("[signature] no document bound");
+		return doc;
+	};
+	const requireSignatures = () => {
+		const doc = requireDoc();
+		if (!doc.signatures) throw new Error("[signature] this engine does not implement signatures");
+		return {
+			doc,
+			signatures: doc.signatures
+		};
+	};
+	const stamp = () => ctx.tryGet(StampToken);
+	const documentId = () => {
+		const id = ctx.documentId;
+		if (!id) throw new Error("[signature] no document id");
+		return id;
+	};
+	const mode = () => config.mode ?? (config.signer ? "sign" : "visual");
+	const resolveSigner = async () => {
+		const signer = config.signer;
+		if (!signer) throw new Error("[signature] no signer configured (mode \"sign\" needs one)");
+		return typeof signer === "function" ? signer() : signer;
+	};
+	const allows = (cap) => ctx.doc?.security.allows(cap) ?? false;
+	const refresh = async () => {
+		const doc = ctx.doc;
+		if (!doc?.signatures) {
+			ctx.dispatch({
+				type: "SNAPSHOT",
+				snapshot: null
+			});
+			return null;
+		}
+		const before = state().snapshot?.protection ?? null;
+		const snapshot = await doc.signatures.list();
+		ctx.dispatch({
+			type: "SNAPSHOT",
+			snapshot
+		});
+		if (!sameProtection(before, snapshot.protection)) changed.emit({
+			type: "protectionChanged",
+			protection: snapshot.protection
+		});
+		return snapshot;
+	};
+	const validate = async (opts) => {
+		const doc = ctx.doc;
+		if (!doc?.signatures) return [];
+		const verdicts = await validateSignatures(doc, {
+			trust: config.trust ?? null,
+			at: opts?.at,
+			until: opts?.until ?? "working-copy"
+		});
+		const before = state().verdicts;
+		ctx.dispatch({
+			type: "VERDICTS",
+			verdicts
+		});
+		changed.emit({
+			type: "validated",
+			verdicts
+		});
+		for (const v of verdicts) {
+			if (v.modifications.basis !== "working-copy" || v.summary !== "invalid") continue;
+			const was = before?.find((b) => b.signature.index === v.signature.index);
+			if (was && was.summary === "invalid") continue;
+			changed.emit({
+				type: "invalidating",
+				field: v.signature.field,
+				detail: v.modifications.detail ?? ""
+			});
+		}
+		return verdicts;
+	};
+	let revalidateTimer = null;
+	const revalidateSoon = () => {
+		if (!state().snapshot?.signatures.some((s) => s.signed)) return;
+		if (revalidateTimer) clearTimeout(revalidateTimer);
+		revalidateTimer = setTimeout(() => {
+			revalidateTimer = null;
+			validate().catch((error) => globalThis.console?.error("[signature] re-validation failed:", error));
+		}, 300);
+	};
+	ctx.cleanup(() => {
+		if (revalidateTimer) clearTimeout(revalidateTimer);
+	});
+	const analyze = (input) => requireSignatures().signatures.analyze(input);
+	const signatureOf = (field) => {
+		const snapshot = state().snapshot;
+		if (!snapshot) return null;
+		if ("annotObjectNumber" in field) {
+			const byWidget = snapshot.signatures.find((s) => s.widget?.annotObjectNumber === field.annotObjectNumber);
+			if (byWidget) return byWidget;
+			const owner = form.fieldForWidget(field.annotObjectNumber);
+			return owner ? signatureOf(owner.ref) : null;
+		}
+		return snapshot.signatures.find((s) => field.kind === "fqn" ? s.fieldName === field.name : sameRef(s.field, field)) ?? null;
+	};
+	const verdictOf = (field) => {
+		const signature = signatureOf(field);
+		if (!signature) return null;
+		return state().verdicts?.find((v) => v.signature.index === signature.index) ?? null;
+	};
+	const bytesOf = async (source) => new Uint8Array((await resolveBinarySource(source)).bytes);
+	const markBytes = async (mark) => {
+		if ("assetId" in mark) {
+			const bytes = stamp()?.assetBytes(mark.assetId);
+			if (!bytes) throw new Error(`[signature] unknown mark '${mark.assetId}'`);
+			return bytes;
+		}
+		return bytesOf(mark.source);
+	};
+	const withBusy = async (work) => {
+		ctx.dispatch({
+			type: "BUSY",
+			busy: true
+		});
+		try {
+			return await work();
+		} finally {
+			ctx.dispatch({
+				type: "BUSY",
+				busy: false
+			});
+		}
+	};
+	const signField = (input) => withBusy(async () => {
+		const { doc } = requireSignatures();
+		const signer = await resolveSigner();
+		const subject = signer.kind === "raw" && signer.certificateChain[0] ? certificateCommonName(signer.certificateChain[0]) : null;
+		const attribution = {
+			...subject ? { name: subject } : {},
+			...input.attribution
+		};
+		const appearance = input.appearance ? await bytesOf(input.appearance) : await markBytes(input.mark);
+		const result = await sign(doc, {
+			field: input.field,
+			signer,
+			attribution,
+			certify: input.certify,
+			lock: input.lock,
+			appearance: {
+				pdf: appearance,
+				pageIndex: 0
+			}
+		});
+		if (state().target && sameRef(state().target, input.field)) setTarget(null);
+		await refresh();
+		validate().catch((error) => globalThis.console?.error("[signature] validation after signing failed:", error));
+		changed.emit({
+			type: "signed",
+			field: input.field,
+			result
+		});
+		return result;
+	});
+	const setAppearance = async (field, pdf) => {
+		const doc = requireDoc();
+		if (!doc.forms.setSignatureAppearance) throw new Error("[signature] this engine cannot draw into a signature field");
+		const signature = signatureOf(field);
+		if (signature?.signed) throw new Error(`[signature] '${signature.fieldName}' is signed`);
+		await doc.forms.setSignatureAppearance(field, {
+			pdf,
+			pageIndex: 0
+		});
+		await form.refresh();
+	};
+	const fillField = (field, mark) => withBusy(async () => {
+		await setAppearance(field, await markBytes(mark));
+		if (state().target && sameRef(state().target, field)) setTarget(null);
+		changed.emit({
+			type: "filled",
+			field
+		});
+	});
+	const clearField = (field) => withBusy(async () => {
+		await setAppearance(field, blankPagePdf());
+		changed.emit({
+			type: "cleared",
+			field
+		});
+	});
+	const placeMark = async (mark, target) => {
+		if (!("field" in target)) {
+			if ("assetId" in mark) {
+				const library = stamp();
+				if (!library) throw new Error("[signature] no stamp plugin to place an asset");
+				await library.placeAsset(documentId(), mark.assetId, target);
+			} else await ctx.get(AnnotationToken).placeStamp({ source: mark.source }, target);
+			return;
+		}
+		switch (mode()) {
+			case "sign":
+				if (config.allowCertify && !state().snapshot?.signatures.some((s) => s.signed)) {
+					changed.emit({
+						type: "ask",
+						field: target.field,
+						mark
+					});
+					return;
+				}
+				await signField({
+					field: target.field,
+					mark
+				});
+				return;
+			case "visual":
+				await fillField(target.field, mark);
+				return;
+			case "ask":
+				changed.emit({
+					type: "ask",
+					field: target.field,
+					mark
+				});
+				return;
+		}
+	};
+	const setTarget = (field) => {
+		const current = state().target;
+		if (current === field || current && field && sameRef(current, field)) return;
+		ctx.dispatch({
+			type: "TARGET",
+			field
+		});
+		changed.emit({
+			type: "target",
+			field
+		});
+	};
+	const doc = ctx.doc;
+	if (doc) {
+		const unsubscribe = doc.events.subscribe((event) => {
+			switch (event.type) {
+				case "signature.prepared":
+					ctx.dispatch({
+						type: "PENDING",
+						pending: {
+							signingId: event.signingId,
+							field: event.field
+						}
+					});
+					return;
+				case "signature.aborted":
+					ctx.dispatch({
+						type: "PENDING",
+						pending: null
+					});
+					return;
+				case "signature.completed":
+					ctx.dispatch({
+						type: "PENDING",
+						pending: null
+					});
+					return;
+				case "document.versioned":
+				case "stream.desynced":
+					refresh().then(() => validate()).catch((error) => globalThis.console?.error("[signature] refresh failed:", error));
+					return;
+				case "form.fieldCreated":
+				case "form.fieldDeleted":
+				case "form.widgetAttached":
+				case "form.widgetDetached":
+				case "form.imported":
+				case "form.repaired":
+					refresh().then(() => revalidateSoon()).catch((error) => globalThis.console?.error("[signature] refresh failed:", error));
+					return;
+				case "annotation.created":
+				case "annotation.updated":
+				case "annotation.deleted":
+				case "annotation.moved":
+				case "form.valueChanged":
+				case "form.fieldUpdated":
+				case "form.effectsApplied":
+					revalidateSoon();
+					return;
+				default: return;
+			}
+		});
+		ctx.cleanup(unsubscribe);
+	}
+	return {
+		snapshot: () => state().snapshot,
+		verdicts: () => state().verdicts,
+		protection: () => state().snapshot?.protection ?? null,
+		pending: () => state().pending,
+		target: () => state().target,
+		busy: () => state().busy,
+		mode,
+		signatureOf,
+		verdictOf,
+		canSign: () => allows("doc.sign") && config.signer != null,
+		canFill: () => allows("doc.forms.fill") && ctx.doc?.forms.setSignatureAppearance != null,
+		canCertify: () => config.allowCertify === true && allows("doc.sign.certify"),
+		signField,
+		fillField,
+		clearField,
+		placeMark,
+		setTarget,
+		inspect: (field) => changed.emit({
+			type: "inspect",
+			field
+		}),
+		refresh,
+		validate,
+		analyze,
+		revisionBytes: (revisionIndex) => requireSignatures().signatures.revisionBytes(revisionIndex),
+		onChanged: changed.on
+	};
 }
-const signatureStampHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.STAMP,
-  create(context) {
-    const { onPreview, onCommit, getTool, pageSize, pageRotation, getToolContext } = context;
-    return {
-      onPointerMove: (pos) => {
-        const ctx = getToolContext();
-        if (!(ctx == null ? void 0 : ctx.targetSize)) return;
-        const { width, height } = ctx.targetSize;
-        onPreview({
-          type: PdfAnnotationSubtype.STAMP,
-          bounds: {
-            origin: { x: pos.x - width / 2, y: pos.y - height / 2 },
-            size: { width, height }
-          },
-          data: {
-            rect: {
-              origin: { x: pos.x - width / 2, y: pos.y - height / 2 },
-              size: { width, height }
-            },
-            ghostUrl: ctx.ghostUrl,
-            pageRotation
-          }
-        });
-      },
-      onPointerDown: (pos) => {
-        var _a;
-        const tool = getTool();
-        const ctx = getToolContext();
-        if (!tool || !(ctx == null ? void 0 : ctx.targetSize)) return;
-        const { width, height } = ctx.targetSize;
-        const rect = {
-          origin: { x: pos.x - width / 2, y: pos.y - height / 2 },
-          size: { width, height }
-        };
-        let anno = {
-          ...tool.defaults,
-          rect,
-          type: PdfAnnotationSubtype.STAMP,
-          name: PdfAnnotationName.Custom,
-          subject: "Signature",
-          flags: tool.defaults.flags ?? ["print"],
-          pageIndex: context.pageIndex,
-          id: uuidV4(),
-          created: /* @__PURE__ */ new Date()
-        };
-        if ((_a = tool.behavior) == null ? void 0 : _a.insertUpright) {
-          anno = applyInsertUpright(anno, pageRotation, false);
-        }
-        anno = clampAnnotationToPage(anno, pageSize);
-        onCommit(anno, { data: ctx.imageData });
-        onPreview(null);
-      },
-      onPointerLeave: () => {
-        onPreview(null);
-      }
-    };
-  }
-};
-function translateAndScaleInk(inkData, targetSize, centerPos) {
-  const scaleX = targetSize.width / inkData.size.width;
-  const scaleY = targetSize.height / inkData.size.height;
-  const scale = Math.min(scaleX, scaleY);
-  const scaledW = inkData.size.width * scale;
-  const scaledH = inkData.size.height * scale;
-  const offsetX = centerPos.x - scaledW / 2;
-  const offsetY = centerPos.y - scaledH / 2;
-  const inkList = inkData.inkList.map((stroke) => ({
-    points: stroke.points.map((p) => ({
-      x: p.x * scale + offsetX,
-      y: p.y * scale + offsetY
-    }))
-  }));
-  return { inkList, strokeWidth: Math.round(inkData.strokeWidth * scale * 10) / 10 };
+//#endregion
+//#region src/handler.ts
+/**
+* The armed mark over a field. The annotation plugin places an armed stamp
+* on click (`annotation-place`, priority 95) and selects an existing
+* annotation under the pointer before that (`annotation-edit`, 100 — a
+* widget is an annotation). This handler sits above BOTH, enabled for the
+* armed stamp's tool only, and captures exactly when the armed asset is a
+* person's mark (a library of kind `signatures`) and the pointer is over a
+* signature field: then the destination decides — the mark goes INTO the
+* field (`placeMark` by mode) instead of onto the page. Everywhere else it
+* declines and the click stays a stamp placement, as in Preview.
+*/
+function createArmedMarkHandler(documentId, signature, form, stamp) {
+	return {
+		id: "signature:armed-mark-on-field",
+		priority: ANNOTATION_EDIT_PRIORITY + 1,
+		enabledFor: (tool) => tool.id === ARMED_STAMP_TOOL_ID,
+		onDown: (sample) => {
+			if (!sample.page) return false;
+			const armed = stamp.armedAsset(documentId);
+			if (!armed || stamp.library(armed.libraryId)?.kind !== "signatures") return false;
+			const hit = form.widgetAt(sample.page.pon, sample.page.point);
+			if (!hit || hit.field.family !== "signature") return false;
+			if (signature.signatureOf(hit.field.ref)?.signed || hit.field.valueEntry.kind !== "none") return true;
+			stamp.disarm(documentId);
+			signature.placeMark({ assetId: armed.id }, { field: hit.field.ref }).catch((error) => globalThis.console?.error("[signature] placing the mark failed:", error));
+			return true;
+		}
+	};
 }
-const signatureInkHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.INK,
-  create(context) {
-    const { onPreview, onCommit, getTool, pageSize, getToolContext } = context;
-    return {
-      onPointerMove: (pos) => {
-        const ctx = getToolContext();
-        if (!(ctx == null ? void 0 : ctx.inkData) || !(ctx == null ? void 0 : ctx.targetSize)) return;
-        const { inkList, strokeWidth } = translateAndScaleInk(ctx.inkData, ctx.targetSize, pos);
-        const allPoints = inkList.flatMap((s) => s.points);
-        if (allPoints.length === 0) return;
-        const rect = expandRect(
-          {
-            origin: {
-              x: Math.min(...allPoints.map((p) => p.x)),
-              y: Math.min(...allPoints.map((p) => p.y))
-            },
-            size: {
-              width: Math.max(...allPoints.map((p) => p.x)) - Math.min(...allPoints.map((p) => p.x)),
-              height: Math.max(...allPoints.map((p) => p.y)) - Math.min(...allPoints.map((p) => p.y))
-            }
-          },
-          strokeWidth / 2
-        );
-        onPreview({
-          type: PdfAnnotationSubtype.INK,
-          bounds: rect,
-          data: {
-            rect,
-            inkList,
-            strokeWidth,
-            strokeColor: ctx.inkData.strokeColor,
-            opacity: 0.5
-          }
-        });
-      },
-      onPointerDown: (pos) => {
-        const tool = getTool();
-        const ctx = getToolContext();
-        if (!tool || !(ctx == null ? void 0 : ctx.inkData) || !(ctx == null ? void 0 : ctx.targetSize)) return;
-        const { inkList, strokeWidth } = translateAndScaleInk(ctx.inkData, ctx.targetSize, pos);
-        const allPoints = inkList.flatMap((s) => s.points);
-        if (allPoints.length === 0) return;
-        const rect = expandRect(
-          {
-            origin: {
-              x: Math.min(...allPoints.map((p) => p.x)),
-              y: Math.min(...allPoints.map((p) => p.y))
-            },
-            size: {
-              width: Math.max(...allPoints.map((p) => p.x)) - Math.min(...allPoints.map((p) => p.x)),
-              height: Math.max(...allPoints.map((p) => p.y)) - Math.min(...allPoints.map((p) => p.y))
-            }
-          },
-          strokeWidth / 2
-        );
-        let anno = {
-          ...tool.defaults,
-          inkList,
-          rect,
-          strokeWidth,
-          strokeColor: ctx.inkData.strokeColor,
-          opacity: 1,
-          type: PdfAnnotationSubtype.INK,
-          subject: "Signature",
-          flags: tool.defaults.flags ?? ["print"],
-          pageIndex: context.pageIndex,
-          id: uuidV4(),
-          created: /* @__PURE__ */ new Date()
-        };
-        const unclamped = anno.rect;
-        anno = clampAnnotationToPage(anno, pageSize);
-        const dx = anno.rect.origin.x - unclamped.origin.x;
-        const dy = anno.rect.origin.y - unclamped.origin.y;
-        if (dx !== 0 || dy !== 0) {
-          anno = {
-            ...anno,
-            inkList: anno.inkList.map((s) => ({
-              points: s.points.map((p) => ({ x: p.x + dx, y: p.y + dy }))
-            }))
-          };
-        }
-        onCommit(anno);
-        onPreview(null);
-      },
-      onPointerLeave: () => {
-        onPreview(null);
-      }
-    };
-  }
-};
-const SIGNATURE_STAMP_TOOL_ID = "signatureStamp";
-const SIGNATURE_INK_TOOL_ID = "signatureInk";
-const signatureStampTool = defineAnnotationTool({
-  id: SIGNATURE_STAMP_TOOL_ID,
-  name: "Signature Stamp",
-  labelKey: "signature.stamp",
-  categories: ["annotation", "signature", "insert"],
-  matchScore: () => 0,
-  interaction: {
-    exclusive: true,
-    cursor: "copy",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    lockAspectRatio: true,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.STAMP
-  },
-  behavior: {
-    deactivateToolAfterCreate: true,
-    selectAfterCreate: true,
-    insertUpright: true,
-    useAppearanceStream: true
-  },
-  pointerHandler: signatureStampHandlerFactory
+//#endregion
+//#region src/reducer.ts
+const initialSignatureState = () => ({
+	snapshot: null,
+	verdicts: null,
+	target: null,
+	pending: null,
+	busy: false
 });
-const signatureInkTool = defineAnnotationTool({
-  id: SIGNATURE_INK_TOOL_ID,
-  name: "Signature Ink",
-  labelKey: "signature.ink",
-  categories: ["annotation", "signature", "insert"],
-  matchScore: (a) => a.type === PdfAnnotationSubtype.INK && a.subject === "Signature" ? 20 : 0,
-  interaction: {
-    exclusive: true,
-    cursor: "copy",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    lockAspectRatio: true,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.INK
-  },
-  behavior: {
-    deactivateToolAfterCreate: true,
-    selectAfterCreate: true
-  },
-  transform: patching.patchInk,
-  pointerHandler: signatureInkHandlerFactory
-});
-const signatureTools = [signatureStampTool, signatureInkTool];
-const _SignaturePlugin = class _SignaturePlugin extends BasePlugin {
-  constructor(id, registry, config) {
-    var _a;
-    super(id, registry);
-    this.config = config;
-    this.entries = /* @__PURE__ */ new Map();
-    this.entriesChange$ = createEmitter();
-    this.activePlacement$ = createScopedEmitter((documentId, activePlacement) => ({ documentId, activePlacement }));
-    this.annotation = null;
-    this.toolChangeUnsubscribe = null;
-    this.currentGhostUrl = null;
-    this.annotation = ((_a = registry.getPlugin("annotation")) == null ? void 0 : _a.provides()) ?? null;
-    if (this.annotation) {
-      for (const tool of signatureTools) {
-        this.annotation.addTool(tool);
-      }
-      this.toolChangeUnsubscribe = this.annotation.onActiveToolChange(({ documentId, tool }) => {
-        if ((tool == null ? void 0 : tool.id) !== SIGNATURE_STAMP_TOOL_ID && (tool == null ? void 0 : tool.id) !== SIGNATURE_INK_TOOL_ID) {
-          this.revokeGhostUrl();
-          this.activePlacement$.emit(documentId, null);
-        }
-      });
-    }
-  }
-  async initialize() {
-  }
-  buildCapability() {
-    return {
-      mode: this.config.mode,
-      getEntries: () => this.getEntries(),
-      addEntry: (entry) => this.addEntry(entry),
-      removeEntry: (id) => this.removeEntry(id),
-      loadEntries: (entries) => this.loadEntries(entries),
-      exportEntries: () => this.exportEntries(),
-      onEntriesChange: this.entriesChange$.on,
-      forDocument: (documentId) => this.createSignatureScope(documentId),
-      onActivePlacementChange: this.activePlacement$.onGlobal
-    };
-  }
-  getEntries() {
-    return Array.from(this.entries.values());
-  }
-  addEntry(entry) {
-    const id = uuidV4();
-    const fullEntry = {
-      ...entry,
-      id,
-      createdAt: Date.now()
-    };
-    this.entries.set(id, fullEntry);
-    this.dispatch(addSignatureEntry(id));
-    this.emitEntriesChange();
-    return id;
-  }
-  removeEntry(id) {
-    if (!this.entries.has(id)) return;
-    this.entries.delete(id);
-    this.dispatch(removeSignatureEntry(id));
-    this.emitEntriesChange();
-  }
-  loadEntries(entries) {
-    for (const entry of entries) {
-      this.entries.set(entry.id, entry);
-      this.dispatch(addSignatureEntry(entry.id));
-    }
-    this.emitEntriesChange();
-  }
-  exportEntries() {
-    return this.getEntries();
-  }
-  createSignatureScope(documentId) {
-    return {
-      activateSignaturePlacement: (entryId) => this.activatePlacement(documentId, entryId, SignatureFieldKind.Signature),
-      activateInitialsPlacement: (entryId) => this.activatePlacement(documentId, entryId, SignatureFieldKind.Initials),
-      deactivatePlacement: () => this.deactivatePlacement(documentId),
-      getActivePlacement: () => this.activePlacement$.getValue(documentId) ?? null,
-      onActivePlacementChange: this.activePlacement$.forScope(documentId)
-    };
-  }
-  activatePlacement(documentId, entryId, kind) {
-    const entry = this.entries.get(entryId);
-    if (!entry || !this.annotation) return;
-    const field = kind === SignatureFieldKind.Initials ? entry.initials : entry.signature;
-    if (!field) return;
-    this.revokeGhostUrl();
-    if (field.creationType === SignatureCreationType.Draw) {
-      if (entry.signature.creationType !== SignatureCreationType.Draw) return;
-      const defaultSize = this.config.defaultSize ?? { width: 150, height: 50 };
-      const referenceSize = entry.signature.inkData.size;
-      const scale = Math.min(
-        defaultSize.width / referenceSize.width,
-        defaultSize.height / referenceSize.height
-      );
-      const targetSize = {
-        width: field.inkData.size.width * scale,
-        height: field.inkData.size.height * scale
-      };
-      this.annotation.setActiveTool(SIGNATURE_INK_TOOL_ID, {
-        inkData: field.inkData,
-        targetSize,
-        entryId,
-        kind
-      });
-    } else {
-      if (!field.imageData) return;
-      const ghostUrl = URL.createObjectURL(
-        new Blob([field.imageData], { type: field.imageMimeType ?? "image/png" })
-      );
-      this.currentGhostUrl = ghostUrl;
-      const defaultSize = this.config.defaultSize ?? { width: 150, height: 50 };
-      let targetSize = defaultSize;
-      if (field.imageSize) {
-        const referenceSize = entry.signature.creationType !== SignatureCreationType.Draw ? entry.signature.imageSize ?? field.imageSize : field.imageSize;
-        const scale = Math.min(
-          defaultSize.width / referenceSize.width,
-          defaultSize.height / referenceSize.height
-        );
-        targetSize = {
-          width: field.imageSize.width * scale,
-          height: field.imageSize.height * scale
-        };
-      }
-      this.annotation.setActiveTool(SIGNATURE_STAMP_TOOL_ID, {
-        imageData: field.imageData,
-        ghostUrl,
-        targetSize,
-        entryId,
-        kind
-      });
-    }
-    this.activePlacement$.emit(documentId, { entryId, kind });
-  }
-  deactivatePlacement(documentId) {
-    if (!this.annotation) return;
-    this.annotation.setActiveTool(null);
-    this.revokeGhostUrl();
-    this.activePlacement$.emit(documentId, null);
-  }
-  revokeGhostUrl() {
-    if (this.currentGhostUrl) {
-      URL.revokeObjectURL(this.currentGhostUrl);
-      this.currentGhostUrl = null;
-    }
-  }
-  emitEntriesChange() {
-    this.entriesChange$.emit(this.getEntries());
-  }
-  async destroy() {
-    var _a;
-    this.revokeGhostUrl();
-    (_a = this.toolChangeUnsubscribe) == null ? void 0 : _a.call(this);
-    this.entries.clear();
-  }
-};
-_SignaturePlugin.id = SIGNATURE_PLUGIN_ID;
-let SignaturePlugin = _SignaturePlugin;
-const initialState = {
-  entryIds: []
-};
-const signatureReducer = (state = initialState, action) => {
-  switch (action.type) {
-    case ADD_SIGNATURE_ENTRY:
-      return {
-        ...state,
-        entryIds: [...state.entryIds, action.payload]
-      };
-    case REMOVE_SIGNATURE_ENTRY:
-      return {
-        ...state,
-        entryIds: state.entryIds.filter((id) => id !== action.payload)
-      };
-    default:
-      return state;
-  }
-};
-function arrayBufferToBase64(buffer) {
-  const bytes = new Uint8Array(buffer);
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
-function base64ToArrayBuffer(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
-function serializeField(field) {
-  if (field.creationType === SignatureCreationType.Draw) {
-    return field;
-  }
-  const { imageData, ...rest } = field;
-  return {
-    ...rest,
-    imageData: imageData ? arrayBufferToBase64(imageData) : void 0
-  };
-}
-function deserializeField(field) {
-  if (field.creationType === SignatureCreationType.Draw) {
-    return field;
-  }
-  const { imageData, ...rest } = field;
-  return {
-    ...rest,
-    imageData: imageData ? base64ToArrayBuffer(imageData) : void 0
-  };
+function signatureReducer(state, action) {
+	switch (action.type) {
+		case "SNAPSHOT": return {
+			...state,
+			snapshot: action.snapshot
+		};
+		case "VERDICTS": return {
+			...state,
+			verdicts: action.verdicts
+		};
+		case "TARGET": return {
+			...state,
+			target: action.field
+		};
+		case "PENDING": return {
+			...state,
+			pending: action.pending
+		};
+		case "BUSY": return {
+			...state,
+			busy: action.busy
+		};
+		default: return state;
+	}
 }
-function serializeEntries(entries) {
-  return entries.map((entry) => ({
-    id: entry.id,
-    createdAt: entry.createdAt,
-    signature: serializeField(entry.signature),
-    ...entry.initials && { initials: serializeField(entry.initials) }
-  }));
-}
-function deserializeEntries(data) {
-  return data.map((entry) => ({
-    id: entry.id,
-    createdAt: entry.createdAt,
-    signature: deserializeField(entry.signature),
-    ...entry.initials && { initials: deserializeField(entry.initials) }
-  }));
-}
-const SignaturePluginPackage = {
-  manifest,
-  create: (registry, config) => new SignaturePlugin(SIGNATURE_PLUGIN_ID, registry, config),
-  reducer: signatureReducer,
-  initialState
-};
-export {
-  ADD_SIGNATURE_ENTRY,
-  REMOVE_SIGNATURE_ENTRY,
-  SIGNATURE_INK_TOOL_ID,
-  SIGNATURE_PLUGIN_ID,
-  SIGNATURE_STAMP_TOOL_ID,
-  SignatureCreationType,
-  SignatureFieldKind,
-  SignatureMode,
-  SignaturePlugin,
-  SignaturePluginPackage,
-  addSignatureEntry,
-  deserializeEntries,
-  initialState,
-  manifest,
-  removeSignatureEntry,
-  serializeEntries,
-  signatureReducer
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+//#region src/signature.plugin.ts
+/**
+* The signature plugin — the ACT of signing, document-scoped. It owns no
+* mark: marks are stamp-library assets (or bytes the embedder brings), and
+* the mark IS the appearance the engine draws into the field. Signing goes
+* through `@embedpdf/core-signature` with the configured signer port; the
+* engine seals; on the cloud the server publishes the new version.
+*
+* With the interaction hub and the stamp plugin present, an armed mark from
+* a `signatures` library dropped over an unsigned signature field goes into
+* the field (sign / visual fill / ask, by mode) instead of onto the page.
+*/
+const signaturePlugin = (config = {}) => definePlugin({
+	id: "signature",
+	token: SignatureToken,
+	scope: "document",
+	requires: [FormToken],
+	optional: [
+		InteractionToken,
+		StampToken,
+		AnnotationToken
+	],
+	initialState: initialSignatureState,
+	reduce: signatureReducer,
+	capability: (ctx) => createSignatureCapability(ctx, config),
+	init: (ctx) => {
+		const signature = ctx.get(SignatureToken);
+		signature.refresh().then((snapshot) => snapshot?.signatures.some((s) => s.signed) ? signature.validate() : null).catch((error) => globalThis.console?.error("[signature] initial read failed:", error));
+		const interaction = ctx.tryGet(InteractionToken);
+		const stamp = ctx.tryGet(StampToken);
+		if (interaction && stamp && ctx.documentId) ctx.cleanup(interaction.registerHandler(createArmedMarkHandler(ctx.documentId, signature, ctx.get(FormToken), stamp)));
+	}
+});
+//#endregion
+export { INITIALS_MARK_NAME, SIGNATURES_LIBRARY_KIND, SIGNATURE_MARK_NAME, SignatureToken, createArmedMarkHandler, createTestSigner, indexedDbKeyStore, markRoleOf, memoryKeyStore, personalSigner, remoteSigner, signaturePlugin, webCryptoSigner };
+
+//# sourceMappingURL=index.js.map