@embedpdf/plugin-form 2.14.4 → 3.0.0-next.0

package/dist/index.js

@@ -1,1789 +1,1408 @@
-import { clamp, BasePlugin, createScopedEmitter } from "@embedpdf/core";
-import { PdfAnnotationSubtype, PdfStandardFont, uuidV4, PDF_FORM_FIELD_FLAG, PDF_FORM_FIELD_TYPE, PdfTaskHelper, PdfErrorCode, Task, isWidgetChecked, TaskSequence } from "@embedpdf/models";
-import { HistoryPlugin } from "@embedpdf/plugin-history";
-import { useState, useClickDetector, defineAnnotationTool } from "@embedpdf/plugin-annotation";
-const FORM_PLUGIN_ID = "form";
-const manifest = {
-  id: FORM_PLUGIN_ID,
-  name: "Form Plugin",
-  version: "1.0.0",
-  provides: ["form"],
-  requires: ["interaction-manager"],
-  optional: ["history", "annotation"],
-  defaultConfig: {
-    enabled: true
-  }
-};
-const INIT_FORM_STATE = "FORM/INIT_STATE";
-const CLEANUP_FORM_STATE = "FORM/CLEANUP_STATE";
-const SELECT_FIELD = "FORM/SELECT_FIELD";
-const DESELECT_FIELD = "FORM/DESELECT_FIELD";
-function initFormState(documentId, state) {
-  return { type: INIT_FORM_STATE, payload: { documentId, state } };
-}
-function cleanupFormState(documentId) {
-  return { type: CLEANUP_FORM_STATE, payload: documentId };
-}
-function selectField(documentId, annotationId) {
-  return { type: SELECT_FIELD, payload: { documentId, annotationId } };
+import { createCapabilityToken, definePlugin } from "@embedpdf/core";
+import { AnnotationToken, MIN_DRAG, resolveClickPlacement, widgetAppearanceFromProps } from "@embedpdf/plugin-annotation";
+import { AnnotationToken as AnnotationToken$1 } from "@embedpdf/plugin-annotation/internal";
+import { InteractionToken, samplePointOn } from "@embedpdf/plugin-interaction";
+import { DEFAULT_SCRIPT_BUDGET, javaScriptProgramFromActionTree, scriptFieldsFromSnapshot } from "@embedpdf/core-acrojs";
+//#region src/core/model.ts
+const fieldKeyOf = (field) => field.fieldObjectNumber > 0 ? `obj:${field.fieldObjectNumber}` : `fqn:${field.name}`;
+const initialModel = () => ({
+	snapshot: null,
+	byKey: {},
+	byWidget: {},
+	writing: {},
+	geom: {},
+	seq: 0
+});
+function index(snapshot) {
+	const byKey = {};
+	const byWidget = {};
+	snapshot.fields.forEach((field, i) => {
+		byKey[fieldKeyOf(field)] = i;
+		for (const w of field.widgets) if (w.annotObjectNumber > 0) byWidget[w.annotObjectNumber] = i;
+	});
+	return {
+		byKey,
+		byWidget
+	};
 }
-function deselectField(documentId) {
-  return { type: DESELECT_FIELD, payload: documentId };
+function update(model, msg) {
+	switch (msg.t) {
+		case "snapshot": return {
+			...model,
+			snapshot: msg.snapshot,
+			...index(msg.snapshot),
+			writing: {},
+			seq: model.seq + 1
+		};
+		case "writeStart": return {
+			...model,
+			writing: {
+				...model.writing,
+				[msg.key]: true
+			},
+			seq: model.seq + 1
+		};
+		case "writeDone": {
+			if (!model.snapshot) return model;
+			const i = model.byKey[msg.key];
+			if (i === void 0) return model;
+			const fields = model.snapshot.fields.slice();
+			fields[i] = msg.field;
+			const { [msg.key]: _done, ...writing } = model.writing;
+			const snapshot = {
+				...model.snapshot,
+				fields
+			};
+			return {
+				...model,
+				snapshot,
+				...index(snapshot),
+				writing,
+				seq: model.seq + 1
+			};
+		}
+		case "writeFailed": {
+			const { [msg.key]: _failed, ...writing } = model.writing;
+			return {
+				...model,
+				writing,
+				seq: model.seq + 1
+			};
+		}
+		case "pageGeom": return {
+			...model,
+			geom: {
+				...model.geom,
+				[msg.pageObjectNumber]: msg.boxes
+			},
+			seq: model.seq + 1
+		};
+		case "clearGeom": {
+			if (msg.pageObjectNumber === void 0) return {
+				...model,
+				geom: {},
+				seq: model.seq + 1
+			};
+			const geom = { ...model.geom };
+			delete geom[msg.pageObjectNumber];
+			return {
+				...model,
+				geom,
+				seq: model.seq + 1
+			};
+		}
+	}
 }
-const initialDocumentState = {
-  selectedFieldId: null
-};
-const initialState = {
-  documents: {}
+const fieldByKey = (model, key) => {
+	const i = model.byKey[key];
+	return i === void 0 ? null : model.snapshot?.fields[i] ?? null;
 };
-const reducer = (state = initialState, action) => {
-  switch (action.type) {
-    case INIT_FORM_STATE:
-      return {
-        ...state,
-        documents: {
-          ...state.documents,
-          [action.payload.documentId]: action.payload.state
-        }
-      };
-    case CLEANUP_FORM_STATE: {
-      const documentId = action.payload;
-      const { [documentId]: _, ...remaining } = state.documents;
-      return {
-        ...state,
-        documents: remaining
-      };
-    }
-    case SELECT_FIELD: {
-      const { documentId, annotationId } = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return {
-        ...state,
-        documents: {
-          ...state.documents,
-          [documentId]: {
-            ...docState,
-            selectedFieldId: annotationId
-          }
-        }
-      };
-    }
-    case DESELECT_FIELD: {
-      const documentId = action.payload;
-      const docState = state.documents[documentId];
-      if (!docState) return state;
-      return {
-        ...state,
-        documents: {
-          ...state.documents,
-          [documentId]: {
-            ...docState,
-            selectedFieldId: null
-          }
-        }
-      };
-    }
-    default:
-      return state;
-  }
+const fieldForWidget = (model, annotObjectNumber) => {
+	const i = model.byWidget[annotObjectNumber];
+	return i === void 0 ? null : model.snapshot?.fields[i] ?? null;
 };
-const textFieldHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.WIDGET,
-  create(context) {
-    const { pageIndex, onCommit, onPreview, getTool, pageSize } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
-        fontSize: tool.defaults.fontSize ?? 12,
-        fontColor: tool.defaults.fontColor ?? "#000000",
-        strokeColor: tool.defaults.strokeColor ?? "#000000",
-        color: tool.defaults.color ?? "#FFFFFF",
-        strokeWidth: tool.defaults.strokeWidth ?? 1,
-        field: tool.defaults.field
-      };
-    };
-    const buildRect = (start, end) => {
-      const minX = Math.min(start.x, end.x);
-      const minY = Math.min(start.y, end.y);
-      const width = Math.abs(start.x - end.x);
-      const height = Math.abs(start.y - end.y);
-      return {
-        origin: { x: minX, y: minY },
-        size: { width, height }
-      };
-    };
-    const buildAnnotation = (rect) => {
-      var _a;
-      const defaults = getDefaults();
-      const fieldName = `TextField_${uuidV4().slice(0, 8)}`;
-      return {
-        ...defaults,
-        type: PdfAnnotationSubtype.WIDGET,
-        id: uuidV4(),
-        pageIndex,
-        rect,
-        created: /* @__PURE__ */ new Date(),
-        fontFamily: defaults.fontFamily,
-        fontSize: defaults.fontSize,
-        fontColor: defaults.fontColor,
-        strokeColor: defaults.strokeColor,
-        color: defaults.color,
-        strokeWidth: defaults.strokeWidth,
-        field: {
-          type: PDF_FORM_FIELD_TYPE.TEXTFIELD,
-          flag: ((_a = defaults.field) == null ? void 0 : _a.flag) ?? PDF_FORM_FIELD_FLAG.NONE,
-          name: fieldName,
-          alternateName: fieldName,
-          value: ""
-        }
-      };
-    };
-    const clickDetector = useClickDetector({
-      getTool,
-      onClickDetected: (pos) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const tool = getTool();
-        const clickConfig = tool == null ? void 0 : tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const x = clamp(pos.x - width / 2, 0, pageSize.width - width);
-        const y = clamp(pos.y - height / 2, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        onCommit(buildAnnotation(rect));
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const rect = buildRect(start, current);
-      return {
-        type: PdfAnnotationSubtype.WIDGET,
-        bounds: rect,
-        data: { rect, ...defaults }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const rect = buildRect(start, clampedPos);
-          if (rect.size.width > 5 && rect.size.height > 5) {
-            onCommit(buildAnnotation(rect));
-          }
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
+//#endregion
+//#region src/core/fill-items.ts
+const ZERO_BOX = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0
 };
-const checkboxHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.WIDGET,
-  create(context) {
-    const { pageIndex, onCommit, onPreview, getTool, pageSize } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        strokeColor: tool.defaults.strokeColor ?? "#000000",
-        color: tool.defaults.color ?? "#FFFFFF",
-        strokeWidth: tool.defaults.strokeWidth ?? 1,
-        field: tool.defaults.field
-      };
-    };
-    const buildRect = (start, end) => {
-      const minX = Math.min(start.x, end.x);
-      const minY = Math.min(start.y, end.y);
-      const width = Math.abs(start.x - end.x);
-      const height = Math.abs(start.y - end.y);
-      return {
-        origin: { x: minX, y: minY },
-        size: { width, height }
-      };
-    };
-    const buildAnnotation = (rect) => {
-      var _a;
-      const defaults = getDefaults();
-      const fieldName = `Checkbox_${uuidV4().slice(0, 8)}`;
-      return {
-        ...defaults,
-        type: PdfAnnotationSubtype.WIDGET,
-        id: uuidV4(),
-        pageIndex,
-        rect,
-        created: /* @__PURE__ */ new Date(),
-        strokeColor: defaults.strokeColor,
-        color: defaults.color,
-        strokeWidth: defaults.strokeWidth,
-        exportValue: "Yes",
-        field: {
-          type: PDF_FORM_FIELD_TYPE.CHECKBOX,
-          flag: ((_a = defaults.field) == null ? void 0 : _a.flag) ?? PDF_FORM_FIELD_FLAG.NONE,
-          name: fieldName,
-          alternateName: fieldName,
-          value: "Off"
-        }
-      };
-    };
-    const clickDetector = useClickDetector({
-      getTool,
-      onClickDetected: (pos) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const tool = getTool();
-        const clickConfig = tool == null ? void 0 : tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const x = clamp(pos.x - width / 2, 0, pageSize.width - width);
-        const y = clamp(pos.y - height / 2, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        onCommit(buildAnnotation(rect));
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const rect = buildRect(start, current);
-      return {
-        type: PdfAnnotationSubtype.WIDGET,
-        bounds: rect,
-        data: { rect, ...defaults }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const rect = buildRect(start, clampedPos);
-          if (rect.size.width > 5 && rect.size.height > 5) {
-            onCommit(buildAnnotation(rect));
-          }
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
-};
-const radioButtonHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.WIDGET,
-  create(context) {
-    const { pageIndex, onCommit, onPreview, getTool, pageSize } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        strokeColor: tool.defaults.strokeColor ?? "#000000",
-        color: tool.defaults.color ?? "#FFFFFF",
-        strokeWidth: tool.defaults.strokeWidth ?? 1,
-        field: tool.defaults.field
-      };
-    };
-    const buildRect = (start, end) => {
-      const dx = end.x - start.x;
-      const dy = end.y - start.y;
-      const side = Math.max(Math.abs(dx), Math.abs(dy));
-      const sx = dx < 0 ? -side : side;
-      const sy = dy < 0 ? -side : side;
-      const minX = Math.min(start.x, start.x + sx);
-      const minY = Math.min(start.y, start.y + sy);
-      return {
-        origin: { x: minX, y: minY },
-        size: { width: side, height: side }
-      };
-    };
-    const buildAnnotation = (rect) => {
-      var _a;
-      const defaults = getDefaults();
-      const fieldName = `RadioButton_${uuidV4().slice(0, 8)}`;
-      const id = uuidV4();
-      return {
-        ...defaults,
-        type: PdfAnnotationSubtype.WIDGET,
-        id,
-        pageIndex,
-        rect,
-        created: /* @__PURE__ */ new Date(),
-        strokeColor: defaults.strokeColor,
-        color: defaults.color,
-        strokeWidth: defaults.strokeWidth,
-        exportValue: id,
-        field: {
-          type: PDF_FORM_FIELD_TYPE.RADIOBUTTON,
-          flag: ((_a = defaults.field) == null ? void 0 : _a.flag) ?? PDF_FORM_FIELD_FLAG.BUTTON_RADIO | PDF_FORM_FIELD_FLAG.BUTTON_NOTOGGLETOOFF,
-          name: fieldName,
-          alternateName: fieldName,
-          value: "Off",
-          options: []
-        }
-      };
-    };
-    const clickDetector = useClickDetector({
-      getTool,
-      onClickDetected: (pos) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const tool = getTool();
-        const clickConfig = tool == null ? void 0 : tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const x = clamp(pos.x - width / 2, 0, pageSize.width - width);
-        const y = clamp(pos.y - height / 2, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        onCommit(buildAnnotation(rect));
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const rect = buildRect(start, current);
-      return {
-        type: PdfAnnotationSubtype.WIDGET,
-        bounds: rect,
-        data: { rect, ...defaults }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const rect = buildRect(start, clampedPos);
-          if (rect.size.width > 5 && rect.size.height > 5) {
-            onCommit(buildAnnotation(rect));
-          }
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
+/**
+* Project ONE widget of a field into a fill control. `box` is supplied by the
+* caller: the page projection reads the model's widget geometry; a consumer
+* that already owns a live box (the annotation plane's RenderItem) passes it —
+* or nothing, when only the semantics matter. Null for families with no fill
+* control (signature/unknown: rendered by the annotation plane only).
+*/
+function projectWidget(model, field, annotObjectNumber, box = ZERO_BOX) {
+	const key = fieldKeyOf(field);
+	const base = {
+		key,
+		annotObjectNumber,
+		box,
+		disabled: field.flags.readOnly || model.writing[key] === true,
+		label: field.alternateName ?? field.name
+	};
+	switch (field.family) {
+		case "text": return {
+			...base,
+			control: "text",
+			value: field.value,
+			multiline: field.multiline,
+			password: field.password,
+			maxLength: field.maxLength,
+			comb: field.comb
+		};
+		case "checkbox": {
+			const toggle = field.widgets.find((w) => w.annotObjectNumber === annotObjectNumber);
+			return {
+				...base,
+				control: "toggle",
+				kind: "checkbox",
+				checked: field.checked,
+				onState: toggle && "onState" in toggle ? toggle.onState : "Yes"
+			};
+		}
+		case "radio": {
+			const toggle = field.widgets.find((w) => w.annotObjectNumber === annotObjectNumber);
+			return {
+				...base,
+				control: "toggle",
+				kind: "radio",
+				checked: toggle && "checked" in toggle ? toggle.checked : false,
+				onState: toggle && "onState" in toggle ? toggle.onState : ""
+			};
+		}
+		case "combobox": return {
+			...base,
+			control: "choice",
+			kind: "combo",
+			edit: field.edit,
+			multi: false,
+			options: field.options,
+			selected: field.value === "" ? [] : [field.value]
+		};
+		case "listbox": return {
+			...base,
+			control: "choice",
+			kind: "list",
+			edit: false,
+			multi: field.multiSelect,
+			options: field.options,
+			selected: field.selectedValues
+		};
+		case "pushbutton": return {
+			...base,
+			control: "button"
+		};
+		default: return null;
+	}
+}
+/**
+* Project one page's widgets into fill controls. Widgets whose geometry has
+* not arrived yet (or that are direct objects with no join key) are skipped —
+* the shell re-runs the projection when `pageGeom` lands.
+*/
+function fillItems(model, pageObjectNumber) {
+	const snapshot = model.snapshot;
+	const geom = model.geom[pageObjectNumber];
+	if (!snapshot || !geom) return [];
+	const items = [];
+	for (const field of snapshot.fields) for (const widget of field.widgets) {
+		if (widget.pageObjectNumber !== pageObjectNumber) continue;
+		const box = geom[widget.annotObjectNumber];
+		if (!box) continue;
+		const item = projectWidget(model, field, widget.annotObjectNumber, box);
+		if (item) items.push(item);
+	}
+	return items;
+}
+/**
+* Project a SINGLE widget by its annotation object number — the join the
+* annotation-plane render layer uses (it owns a live box already, so the
+* model's cached geometry is used only when it happens to be loaded; the
+* item's semantics never depend on it). Null while the snapshot hasn't
+* landed, or for families with no fill control.
+*/
+function fillItemForWidget(model, annotObjectNumber) {
+	const field = fieldForWidget(model, annotObjectNumber);
+	if (!field) return null;
+	const widget = field.widgets.find((w) => w.annotObjectNumber === annotObjectNumber);
+	if (!widget) return null;
+	const box = model.geom[widget.pageObjectNumber]?.[annotObjectNumber];
+	return projectWidget(model, field, annotObjectNumber, box);
+}
+//#endregion
+//#region src/mutationQueue.ts
+/** Small promise-tail queue: failures never poison later mutations. */
+function createSerialMutationQueue() {
+	let tail = Promise.resolve();
+	return (operation) => {
+		const result = tail.then(operation, operation);
+		tail = result.then(() => void 0, () => void 0);
+		return result;
+	};
+}
+//#endregion
+//#region src/scripting.ts
+const refKey = (ref) => ref.kind === "objectNumber" ? `obj:${ref.fieldObjectNumber}` : `fqn:${ref.name}`;
+const sameRef = (left, right) => refKey(left) === refKey(right);
+const cloneValue = (value) => Array.isArray(value) ? [...value] : value;
+const sameValue = (left, right) => Array.isArray(left) && Array.isArray(right) ? left.length === right.length && left.every((value, index) => value === right[index]) : left === right;
+function cloneFields(fields) {
+	return fields.map((field) => ({
+		...field,
+		ref: { ...field.ref },
+		value: cloneValue(field.value),
+		defaultValue: cloneValue(field.defaultValue),
+		...field.options ? { options: field.options.map((option) => ({ ...option })) } : {}
+	}));
+}
+function fieldByRef(fields, ref) {
+	return fields.find((field) => sameRef(field.ref, ref));
+}
+function snapshotField(snapshot, ref) {
+	return snapshot.fields.find((field) => sameRef(field.ref, ref));
+}
+function scriptValueFromFormValue(field, value) {
+	if (field.family === "text" && value.type === "text") return value.value;
+	if ((field.family === "checkbox" || field.family === "radio") && value.type === "toggle") return value.state ?? "Off";
+	if (field.family === "combobox" && value.type === "choice") return value.values[0] ?? "";
+	if (field.family === "listbox" && value.type === "choice") return [...value.values];
+	throw new Error(`Form value type '${value.type}' does not match field family '${field.family}'`);
+}
+function formValueFromScriptValue(field) {
+	switch (field.family) {
+		case "text": return {
+			type: "text",
+			value: String(field.value ?? "")
+		};
+		case "checkbox":
+		case "radio": return {
+			type: "toggle",
+			state: field.value === null || field.value === void 0 || String(field.value) === "Off" ? null : String(field.value)
+		};
+		case "combobox": return {
+			type: "choice",
+			values: Array.isArray(field.value) ? field.value.slice(0, 1) : [String(field.value ?? "")]
+		};
+		case "listbox": return {
+			type: "choice",
+			values: Array.isArray(field.value) ? [...field.value] : [String(field.value ?? "")]
+		};
+		default: return null;
+	}
+}
+function applyEffects(overlay, effects) {
+	for (const effect of effects) {
+		if (effect.kind === "reset") {
+			for (const ref of effect.refs) {
+				const field = fieldByRef(overlay.fields, ref);
+				if (!field) continue;
+				field.value = cloneValue(field.defaultValue);
+				overlay.resetKeys.add(refKey(ref));
+			}
+			continue;
+		}
+		const field = fieldByRef(overlay.fields, effect.ref);
+		if (!field) continue;
+		const key = refKey(effect.ref);
+		if (effect.kind === "setValue") {
+			field.value = scriptValueFromFormValue(field, effect.value);
+			overlay.resetKeys.delete(key);
+		} else if (effect.kind === "setDisplay") field.display = effect.display;
+		else overlay.appearances.set(key, {
+			ref: effect.ref,
+			text: effect.text
+		});
+	}
+}
+function canonicalEffects(overlay) {
+	const effects = [];
+	const resets = [];
+	for (const field of overlay.fields) {
+		const original = fieldByRef(overlay.original, field.ref);
+		if (!original) continue;
+		if (!sameValue(original.value, field.value)) {
+			const key = refKey(field.ref);
+			if (overlay.resetKeys.has(key) && sameValue(field.value, field.defaultValue)) resets.push(field.ref);
+			else {
+				const value = formValueFromScriptValue(field);
+				if (value) effects.push({
+					kind: "setValue",
+					ref: field.ref,
+					value
+				});
+			}
+		}
+		if (original.display !== field.display) effects.push({
+			kind: "setDisplay",
+			ref: field.ref,
+			display: field.display
+		});
+	}
+	if (resets.length > 0) effects.unshift({
+		kind: "reset",
+		refs: resets
+	});
+	effects.push(...Array.from(overlay.appearances.values(), ({ ref, text }) => ({
+		kind: "setAppearanceText",
+		ref,
+		text
+	})));
+	return effects;
+}
+function scriptError(message) {
+	return {
+		kind: "invalid-output",
+		message
+	};
+}
+function utf8Length(value) {
+	let length = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code < 128) length += 1;
+		else if (code < 2048) length += 2;
+		else if (code >= 55296 && code <= 56319 && index + 1 < value.length) {
+			length += 4;
+			index += 1;
+		} else length += 3;
+	}
+	return length;
+}
+function seedFrom(documentId, sequence) {
+	let hash = 2166136261;
+	for (const char of `${documentId}:${sequence}`) {
+		hash ^= char.charCodeAt(0);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
+}
+function resolvedIdentity(doc, config) {
+	const claims = doc.security.identity;
+	const supplied = typeof config.identity === "function" ? config.identity() : config.identity ?? {};
+	return {
+		name: supplied.name ?? claims?.display_name ?? claims?.user_id ?? "",
+		loginName: supplied.loginName ?? claims?.user_id ?? "",
+		corporation: supplied.corporation ?? claims?.group_id ?? "",
+		email: supplied.email ?? ""
+	};
+}
+function pageNumberFor(meta, field) {
+	const pon = field.widgets.find((widget) => widget.pageObjectNumber > 0)?.pageObjectNumber;
+	if (!meta || pon === void 0) return 0;
+	const index = meta.pages.findIndex((page) => page.pageObjectNumber === pon);
+	return Math.max(0, index);
+}
+function statusFromEffects(result) {
+	if (result.results.some(({ status }) => status === "failed" || status === "skipped")) return "failed";
+	if (result.results.some(({ status }) => status === "rejected")) return "failed";
+	return result.results.some(({ status }) => status === "applied") ? "applied" : "unchanged";
+}
+var FormScriptingController = class {
+	constructor(options) {
+		this.options = options;
+		this.sandboxPromise = null;
+		this.booted = false;
+		this.disposed = false;
+		this.sequence = 0;
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.sandboxPromise?.then((sandbox) => sandbox.dispose()).catch(() => void 0);
+	}
+	async commit(snapshot, ref, proposed) {
+		return this.transact(snapshot, ref, proposed);
+	}
+	/** Execute one originating widget's activation action (`/A`, including `/Next`). */
+	async activate(snapshot, ref, action) {
+		return this.transact(snapshot, ref, void 0, action);
+	}
+	/** Run lazy document boot plus the `/CO` chain without a user field change. */
+	async recalculate(snapshot) {
+		const target = snapshot.calculationOrder.find((ref) => ref !== null && snapshotField(snapshot, ref) !== void 0) ?? snapshot.fields[0]?.ref;
+		if (!target) return {
+			status: "unchanged",
+			scripted: true,
+			effectsResult: null,
+			uiEffects: [],
+			diagnostics: []
+		};
+		return this.transact(snapshot, target);
+	}
+	async transact(snapshot, ref, proposed, activation) {
+		if (this.disposed) throw new Error("Form scripting controller is disposed");
+		const target = snapshotField(snapshot, ref);
+		if (!target) return this.failed([], [], scriptError(`Form field '${refKey(ref)}' no longer exists`));
+		const original = scriptFieldsFromSnapshot(snapshot);
+		const overlay = {
+			original,
+			fields: cloneFields(original),
+			resetKeys: /* @__PURE__ */ new Set(),
+			appearances: /* @__PURE__ */ new Map()
+		};
+		const targetInput = fieldByRef(overlay.fields, ref);
+		if (!targetInput) return this.failed([], [], scriptError(`Form field '${refKey(ref)}' has no script view`));
+		const hasProposedValue = proposed !== void 0;
+		let proposedValue = cloneValue(targetInput.value);
+		if (proposed) try {
+			proposedValue = scriptValueFromFormValue(targetInput, proposed);
+		} catch (error) {
+			return this.failed([], [], scriptError(error instanceof Error ? error.message : String(error)));
+		}
+		const uiEffects = [];
+		const diagnostics = [];
+		const meta = this.options.document();
+		const nowMs = this.options.config.now?.() ?? Date.now();
+		const inputBase = {
+			document: {
+				id: this.options.doc.id,
+				fileName: this.options.config.fileName?.() ?? meta?.name ?? this.options.doc.id,
+				pageCount: meta?.pageCount ?? 0,
+				pageNumber: pageNumberFor(meta, target)
+			},
+			identity: resolvedIdentity(this.options.doc, this.options.config),
+			environment: {
+				nowMs,
+				utcOffsetMinutes: this.options.config.utcOffsetMinutes?.() ?? -new Date(nowMs).getTimezoneOffset(),
+				randomSeed: this.options.config.randomSeed?.() ?? seedFrom(this.options.doc.id, this.sequence++)
+			}
+		};
+		const budget = this.options.config.budget ?? DEFAULT_SCRIPT_BUDGET;
+		let executionMs = 0;
+		let aggregateOutputSize = 0;
+		const consume = (output, phase) => {
+			aggregateOutputSize += utf8Length(JSON.stringify(output));
+			uiEffects.push(...output.uiEffects.map((effect) => ({
+				...effect,
+				phase
+			})));
+			diagnostics.push(...output.diagnostics);
+			if (aggregateOutputSize > budget.maxOutputBytes) return {
+				kind: "budget",
+				message: `Form script transaction output exceeded ${budget.maxOutputBytes} bytes`
+			};
+			return output.error ?? null;
+		};
+		const remainingBudget = () => {
+			const remaining = budget.maxExecutionMs - executionMs;
+			return remaining <= 0 ? null : {
+				...budget,
+				maxExecutionMs: remaining
+			};
+		};
+		const run = async (kind, source, input) => {
+			const remaining = remainingBudget();
+			if (!remaining) return { error: {
+				kind: "budget",
+				message: "Form script transaction timed out"
+			} };
+			let output;
+			try {
+				const sandbox = await this.sandbox();
+				const startedAt = Date.now();
+				output = kind === "boot" ? sandbox.boot(source, input, remaining) : sandbox.run(source, input, remaining);
+				executionMs += Date.now() - startedAt;
+			} catch (error) {
+				return { error: scriptError(error instanceof Error ? error.message : String(error)) };
+			}
+			const error = consume(output, kind === "boot" ? "boot" : "user");
+			return error ? { error } : { output };
+		};
+		if (!this.booted) {
+			this.booted = true;
+			let sources = [];
+			let bootError = null;
+			try {
+				sources = (this.options.doc.actions ? await this.options.doc.actions.read() : null)?.nameTreeScripts.map(({ action }) => javaScriptProgramFromActionTree(action)) ?? [];
+			} catch (error) {
+				bootError = scriptError(error instanceof Error ? error.message : String(error));
+			}
+			if (!bootError && sources.length > 0) {
+				const boot = await run("boot", sources, {
+					...inputBase,
+					fields: overlay.fields,
+					event: { kind: "name-tree-boot" }
+				});
+				if (boot.error) bootError = boot.error;
+				else applyEffects(overlay, boot.output.formEffects);
+			}
+			if (bootError) diagnostics.push({
+				code: "script-error",
+				message: `Document boot script failed (continuing without it): ${bootError.message}`
+			});
+		}
+		const bootEffects = canonicalEffects(overlay);
+		if (activation) {
+			let program;
+			try {
+				program = javaScriptProgramFromActionTree(activation);
+			} catch (error) {
+				return this.failed(uiEffects, diagnostics, scriptError(error instanceof Error ? error.message : String(error)));
+			}
+			if (program) {
+				const activated = await run("run", program, {
+					...inputBase,
+					fields: overlay.fields,
+					event: {
+						kind: "widget-activate",
+						target: ref,
+						source: ref,
+						value: targetInput.value
+					}
+				});
+				if (activated.error) return this.failed(uiEffects, diagnostics, activated.error);
+				applyEffects(overlay, activated.output.formEffects);
+			}
+		}
+		if (!activation && hasProposedValue && target.actions?.keystroke && target.family === "text") {
+			let program;
+			try {
+				program = javaScriptProgramFromActionTree(target.actions.keystroke);
+			} catch (error) {
+				return this.failed(uiEffects, diagnostics, scriptError(error instanceof Error ? error.message : String(error)));
+			}
+			if (program) {
+				const oldValue = String(targetInput.value ?? "");
+				const key = await run("run", program, {
+					...inputBase,
+					fields: overlay.fields,
+					event: {
+						kind: "field-keystroke",
+						target: ref,
+						source: ref,
+						value: oldValue,
+						change: String(proposedValue ?? ""),
+						selStart: 0,
+						selEnd: oldValue.length,
+						willCommit: true
+					}
+				});
+				if (key.error) return this.failed(uiEffects, diagnostics, key.error);
+				if (!key.output.event.rc) return this.finishRejected(bootEffects, uiEffects, diagnostics);
+				applyEffects(overlay, key.output.formEffects);
+				const event = key.output.event;
+				const base = String(event.value ?? "");
+				proposedValue = base.slice(0, event.selStart) + event.change + base.slice(Math.max(event.selStart, event.selEnd));
+			}
+		}
+		if (!activation && hasProposedValue) {
+			targetInput.value = cloneValue(proposedValue);
+			overlay.resetKeys.delete(refKey(ref));
+		}
+		if (!activation && hasProposedValue && target.actions?.validate) {
+			let program;
+			try {
+				program = javaScriptProgramFromActionTree(target.actions.validate);
+			} catch (error) {
+				return this.failed(uiEffects, diagnostics, scriptError(error instanceof Error ? error.message : String(error)));
+			}
+			if (program) {
+				const validation = await run("run", program, {
+					...inputBase,
+					fields: overlay.fields,
+					event: {
+						kind: "field-validate",
+						target: ref,
+						source: ref,
+						value: proposedValue,
+						willCommit: true
+					}
+				});
+				if (validation.error) return this.failed(uiEffects, diagnostics, validation.error);
+				if (!validation.output.event.rc) return this.finishRejected(bootEffects, uiEffects, diagnostics);
+				targetInput.value = cloneValue(validation.output.event.value);
+				applyEffects(overlay, validation.output.formEffects);
+			}
+		}
+		const formatRefs = !activation && hasProposedValue ? [ref] : [];
+		for (const calculationRef of activation ? [] : snapshot.calculationOrder) {
+			if (!calculationRef) continue;
+			const calculated = snapshotField(snapshot, calculationRef);
+			const tree = calculated?.actions?.calculate;
+			if (!calculated || !tree) continue;
+			let program;
+			try {
+				program = javaScriptProgramFromActionTree(tree);
+			} catch (error) {
+				return this.failed(uiEffects, diagnostics, scriptError(error instanceof Error ? error.message : String(error)));
+			}
+			const calculatedInput = fieldByRef(overlay.fields, calculationRef);
+			if (program && calculatedInput) {
+				const calculation = await run("run", program, {
+					...inputBase,
+					fields: overlay.fields,
+					event: {
+						kind: "field-calculate",
+						target: calculationRef,
+						...hasProposedValue ? { source: ref } : {},
+						value: calculatedInput.value
+					}
+				});
+				if (calculation.error) return this.failed(uiEffects, diagnostics, calculation.error);
+				applyEffects(overlay, calculation.output.formEffects);
+			}
+			if (!formatRefs.some((candidate) => sameRef(candidate, calculationRef))) formatRefs.push(calculationRef);
+		}
+		for (const formatRef of formatRefs) {
+			const field = snapshotField(snapshot, formatRef);
+			const tree = field?.actions?.format;
+			const overlayField = fieldByRef(overlay.fields, formatRef);
+			if (!field || !tree || !overlayField) continue;
+			let program;
+			try {
+				program = javaScriptProgramFromActionTree(tree);
+			} catch (error) {
+				return this.failed(uiEffects, diagnostics, scriptError(error instanceof Error ? error.message : String(error)));
+			}
+			if (!program) continue;
+			const format = await run("run", program, {
+				...inputBase,
+				fields: overlay.fields,
+				event: {
+					kind: "field-format",
+					target: formatRef,
+					...hasProposedValue ? { source: ref } : {},
+					value: overlayField.value
+				}
+			});
+			if (format.error) return this.failed(uiEffects, diagnostics, format.error);
+			applyEffects(overlay, format.output.formEffects);
+		}
+		const effects = canonicalEffects(overlay);
+		if (effects.length + uiEffects.length > budget.maxEffects) return this.failed(uiEffects, diagnostics, {
+			kind: "budget",
+			message: `Form script transaction exceeded ${budget.maxEffects} effects`
+		});
+		if (effects.length === 0) return {
+			status: "unchanged",
+			scripted: true,
+			effectsResult: null,
+			uiEffects,
+			diagnostics
+		};
+		if (!this.options.doc.forms.applyEffects) return this.failed(uiEffects, diagnostics, scriptError("This engine does not support batched form effects"));
+		const effectsResult = await this.options.doc.forms.applyEffects(effects);
+		const status = statusFromEffects(effectsResult);
+		return {
+			status,
+			scripted: true,
+			effectsResult,
+			uiEffects,
+			diagnostics,
+			...status === "failed" ? { error: scriptError("One or more native form effects failed") } : {}
+		};
+	}
+	async sandbox() {
+		this.sandboxPromise ?? (this.sandboxPromise = this.options.sandboxFactory().then((sandbox) => {
+			if (this.disposed) sandbox.dispose();
+			return sandbox;
+		}));
+		return this.sandboxPromise;
+	}
+	failed(uiEffects, diagnostics, error) {
+		return {
+			status: "failed",
+			scripted: true,
+			effectsResult: null,
+			uiEffects,
+			diagnostics,
+			error
+		};
+	}
+	async finishRejected(bootEffects, uiEffects, diagnostics) {
+		if (bootEffects.length === 0) return {
+			status: "rejected",
+			scripted: true,
+			effectsResult: null,
+			uiEffects,
+			diagnostics
+		};
+		if (!this.options.doc.forms.applyEffects) return this.failed(uiEffects, diagnostics, scriptError("Batched form effects are unavailable"));
+		const effectsResult = await this.options.doc.forms.applyEffects(bootEffects);
+		if (statusFromEffects(effectsResult) === "failed") return this.failed(uiEffects, diagnostics, scriptError("A name-tree boot effect failed"));
+		return {
+			status: "rejected",
+			scripted: true,
+			effectsResult,
+			uiEffects,
+			diagnostics
+		};
+	}
 };
-const comboboxHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.WIDGET,
-  create(context) {
-    const { pageIndex, onCommit, onPreview, getTool, pageSize } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
-        fontSize: tool.defaults.fontSize ?? 12,
-        fontColor: tool.defaults.fontColor ?? "#000000",
-        strokeColor: tool.defaults.strokeColor ?? "#000000",
-        color: tool.defaults.color ?? "#FFFFFF",
-        strokeWidth: tool.defaults.strokeWidth ?? 1,
-        field: tool.defaults.field
-      };
-    };
-    const buildRect = (start, end) => {
-      const minX = Math.min(start.x, end.x);
-      const minY = Math.min(start.y, end.y);
-      const width = Math.abs(start.x - end.x);
-      const height = Math.abs(start.y - end.y);
-      return {
-        origin: { x: minX, y: minY },
-        size: { width, height }
-      };
-    };
-    const buildAnnotation = (rect) => {
-      var _a;
-      const defaults = getDefaults();
-      const fieldName = `Combobox_${uuidV4().slice(0, 8)}`;
-      return {
-        ...defaults,
-        type: PdfAnnotationSubtype.WIDGET,
-        id: uuidV4(),
-        pageIndex,
-        rect,
-        created: /* @__PURE__ */ new Date(),
-        fontFamily: defaults.fontFamily,
-        fontSize: defaults.fontSize,
-        fontColor: defaults.fontColor,
-        strokeColor: defaults.strokeColor,
-        color: defaults.color,
-        strokeWidth: defaults.strokeWidth,
-        field: {
-          type: PDF_FORM_FIELD_TYPE.COMBOBOX,
-          flag: ((_a = defaults.field) == null ? void 0 : _a.flag) ?? PDF_FORM_FIELD_FLAG.NONE,
-          name: fieldName,
-          alternateName: fieldName,
-          value: "",
-          options: [
-            { label: "Option 1", isSelected: true },
-            { label: "Option 2", isSelected: false },
-            { label: "Option 3", isSelected: false }
-          ]
-        }
-      };
-    };
-    const clickDetector = useClickDetector({
-      getTool,
-      onClickDetected: (pos) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const tool = getTool();
-        const clickConfig = tool == null ? void 0 : tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const x = clamp(pos.x - width / 2, 0, pageSize.width - width);
-        const y = clamp(pos.y - height / 2, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        onCommit(buildAnnotation(rect));
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const rect = buildRect(start, current);
-      return {
-        type: PdfAnnotationSubtype.WIDGET,
-        bounds: rect,
-        data: { rect, ...defaults }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const rect = buildRect(start, clampedPos);
-          if (rect.size.width > 5 && rect.size.height > 5) {
-            onCommit(buildAnnotation(rect));
-          }
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
+function createFormScriptingController(options) {
+	return new FormScriptingController(options);
+}
+//#endregion
+//#region src/capability.ts
+/** PDF user-space rect (y-up) → content-space box (y-down, crop-relative). */
+const toBox = (rect, crop) => ({
+	x: rect.left - crop.left,
+	y: crop.top - rect.top,
+	width: rect.right - rect.left,
+	height: rect.top - rect.bottom
+});
+const sameAnnotationRef = (left, right) => {
+	if (left.kind !== right.kind || left.pageObjectNumber !== right.pageObjectNumber) return false;
+	if (left.kind === "objectNumber" && right.kind === "objectNumber") return left.annotObjectNumber === right.annotObjectNumber;
+	if (left.kind === "nm" && right.kind === "nm") return left.nm === right.nm;
+	return left.kind === "index" && right.kind === "index" && left.index === right.index && left.revision === right.revision;
 };
-const listboxHandlerFactory = {
-  annotationType: PdfAnnotationSubtype.WIDGET,
-  create(context) {
-    const { pageIndex, onCommit, onPreview, getTool, pageSize } = context;
-    const [getStart, setStart] = useState(null);
-    const clampToPage = (pos) => ({
-      x: clamp(pos.x, 0, pageSize.width),
-      y: clamp(pos.y, 0, pageSize.height)
-    });
-    const getDefaults = () => {
-      const tool = getTool();
-      if (!tool) return null;
-      return {
-        ...tool.defaults,
-        fontFamily: tool.defaults.fontFamily ?? PdfStandardFont.Helvetica,
-        fontSize: tool.defaults.fontSize ?? 12,
-        fontColor: tool.defaults.fontColor ?? "#000000",
-        strokeColor: tool.defaults.strokeColor ?? "#000000",
-        color: tool.defaults.color ?? "#FFFFFF",
-        strokeWidth: tool.defaults.strokeWidth ?? 1,
-        field: tool.defaults.field
-      };
-    };
-    const buildRect = (start, end) => {
-      const minX = Math.min(start.x, end.x);
-      const minY = Math.min(start.y, end.y);
-      const width = Math.abs(start.x - end.x);
-      const height = Math.abs(start.y - end.y);
-      return {
-        origin: { x: minX, y: minY },
-        size: { width, height }
-      };
-    };
-    const buildAnnotation = (rect) => {
-      var _a;
-      const defaults = getDefaults();
-      const fieldName = `Listbox_${uuidV4().slice(0, 8)}`;
-      return {
-        ...defaults,
-        type: PdfAnnotationSubtype.WIDGET,
-        id: uuidV4(),
-        pageIndex,
-        rect,
-        created: /* @__PURE__ */ new Date(),
-        fontFamily: defaults.fontFamily,
-        fontSize: defaults.fontSize,
-        fontColor: defaults.fontColor,
-        strokeColor: defaults.strokeColor,
-        color: defaults.color,
-        strokeWidth: defaults.strokeWidth,
-        field: {
-          type: PDF_FORM_FIELD_TYPE.LISTBOX,
-          flag: ((_a = defaults.field) == null ? void 0 : _a.flag) ?? PDF_FORM_FIELD_FLAG.NONE,
-          name: fieldName,
-          alternateName: fieldName,
-          value: "",
-          options: [
-            { label: "Option 1", isSelected: true },
-            { label: "Option 2", isSelected: false },
-            { label: "Option 3", isSelected: false }
-          ]
-        }
-      };
-    };
-    const clickDetector = useClickDetector({
-      getTool,
-      onClickDetected: (pos) => {
-        const defaults = getDefaults();
-        if (!defaults) return;
-        const tool = getTool();
-        const clickConfig = tool == null ? void 0 : tool.clickBehavior;
-        if (!(clickConfig == null ? void 0 : clickConfig.enabled)) return;
-        const { width, height } = clickConfig.defaultSize;
-        const x = clamp(pos.x - width / 2, 0, pageSize.width - width);
-        const y = clamp(pos.y - height / 2, 0, pageSize.height - height);
-        const rect = {
-          origin: { x, y },
-          size: { width, height }
-        };
-        onCommit(buildAnnotation(rect));
-      }
-    });
-    const getPreview = (current) => {
-      const start = getStart();
-      if (!start) return null;
-      const defaults = getDefaults();
-      if (!defaults) return null;
-      const rect = buildRect(start, current);
-      return {
-        type: PdfAnnotationSubtype.WIDGET,
-        bounds: rect,
-        data: { rect, ...defaults }
-      };
-    };
-    return {
-      onPointerDown: (pos, evt) => {
-        var _a;
-        const clampedPos = clampToPage(pos);
-        setStart(clampedPos);
-        clickDetector.onStart(clampedPos);
-        onPreview(getPreview(clampedPos));
-        (_a = evt.setPointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerMove: (pos) => {
-        const clampedPos = clampToPage(pos);
-        clickDetector.onMove(clampedPos);
-        if (getStart() && clickDetector.hasMoved()) {
-          onPreview(getPreview(clampedPos));
-        }
-      },
-      onPointerUp: (pos, evt) => {
-        var _a;
-        const start = getStart();
-        if (!start) return;
-        const clampedPos = clampToPage(pos);
-        if (!clickDetector.hasMoved()) {
-          clickDetector.onEnd(clampedPos);
-        } else {
-          const rect = buildRect(start, clampedPos);
-          if (rect.size.width > 5 && rect.size.height > 5) {
-            onCommit(buildAnnotation(rect));
-          }
-        }
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerLeave: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      },
-      onPointerCancel: (_, evt) => {
-        var _a;
-        setStart(null);
-        onPreview(null);
-        clickDetector.reset();
-        (_a = evt.releasePointerCapture) == null ? void 0 : _a.call(evt);
-      }
-    };
-  }
+/**
+* The form shell. Pure `update` runs here; the resulting model is dispatched
+* to the store; engine calls happen around it. Every read the frameworks do
+* goes through memoized projections keyed on `model.seq`.
+*/
+function createFormCapability(ctx, options = {}) {
+	const model = () => ctx.getState().model;
+	const apply = (msg) => {
+		ctx.dispatch({
+			type: "SET_MODEL",
+			model: update(model(), msg)
+		});
+	};
+	const refKeyOf = (key) => {
+		if (key.startsWith("obj:")) return {
+			kind: "objectNumber",
+			fieldObjectNumber: Number(key.slice(4))
+		};
+		return {
+			kind: "fqn",
+			name: key.slice(4)
+		};
+	};
+	const enqueueMutation = createSerialMutationQueue();
+	const scripting = options.scripting?.enabled && ctx.doc ? createFormScriptingController({
+		doc: ctx.doc,
+		document: () => ctx.document(),
+		config: options.scripting,
+		sandboxFactory: options.scripting.sandboxFactory ?? (() => import("@embedpdf/core-js-sandbox").then(({ createQuickJsSandbox }) => createQuickJsSandbox()))
+	}) : null;
+	if (scripting) ctx.cleanup(() => scripting.dispose());
+	let uiEffectProvider = null;
+	const surfaceScriptingResult = (result) => {
+		const observe = (callback) => {
+			if (!callback) return;
+			try {
+				callback();
+			} catch (error) {
+				globalThis.console?.error("[form] scripting observer failed:", error);
+			}
+		};
+		for (const effect of result.uiEffects) {
+			observe(options.scripting?.onUiEffect ? () => options.scripting.onUiEffect(effect) : void 0);
+			observe(uiEffectProvider ? () => uiEffectProvider(effect) : void 0);
+		}
+		for (const diagnostic of result.diagnostics) observe(options.scripting?.onDiagnostic ? () => options.scripting.onDiagnostic(diagnostic) : void 0);
+		if (result.error) observe(options.scripting?.onError ? () => options.scripting.onError(result.error) : void 0);
+	};
+	let refreshPromise = null;
+	const refresh = async (force = false) => {
+		const doc = ctx.doc;
+		if (!doc) return;
+		if (refreshPromise) {
+			await refreshPromise;
+			if (!force) return;
+		}
+		refreshPromise = doc.forms.list().then((snapshot) => apply({
+			t: "snapshot",
+			snapshot
+		})).finally(() => {
+			refreshPromise = null;
+		});
+		return refreshPromise;
+	};
+	const geomLoading = /* @__PURE__ */ new Set();
+	const ensureGeom = (pon) => {
+		const doc = ctx.doc;
+		if (!doc || geomLoading.has(pon) || model().geom[pon]) return;
+		const crop = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon)?.boxes.crop;
+		if (!crop) return;
+		geomLoading.add(pon);
+		doc.page(pon).annotations.list().then(({ annotations }) => {
+			const boxes = {};
+			for (const dto of annotations) {
+				if (dto.subtype !== "widget") continue;
+				const objectNumber = dto.ref.kind === "objectNumber" ? dto.ref.annotObjectNumber : 0;
+				if (objectNumber > 0) boxes[objectNumber] = toBox(dto.rect, crop);
+			}
+			apply({
+				t: "pageGeom",
+				pageObjectNumber: pon,
+				boxes
+			});
+		}).finally(() => {
+			geomLoading.delete(pon);
+		});
+	};
+	const fillCache = /* @__PURE__ */ new Map();
+	const fillItems$1 = (pon) => {
+		const m = model();
+		const hit = fillCache.get(pon);
+		if (hit && hit.seq === m.seq) return hit.items;
+		const items = fillItems(m, pon);
+		fillCache.set(pon, {
+			seq: m.seq,
+			items
+		});
+		return items;
+	};
+	const fillItemCache = /* @__PURE__ */ new Map();
+	const fillItem = (annotObjectNumber) => {
+		const m = model();
+		const hit = fillItemCache.get(annotObjectNumber);
+		if (hit && hit.seq === m.seq) return hit.item;
+		const item = fillItemForWidget(m, annotObjectNumber);
+		fillItemCache.set(annotObjectNumber, {
+			seq: m.seq,
+			item
+		});
+		return item;
+	};
+	const commitValueNow = async (ref, value) => {
+		const doc = ctx.doc;
+		if (!doc) throw new Error("no document");
+		if (scripting) {
+			const result = await scripting.commit(await doc.forms.list(), ref, value);
+			surfaceScriptingResult(result);
+			if (result.effectsResult !== null) await refresh(true);
+			return result;
+		}
+		const result = await doc.forms.setValue(ref, value);
+		await refresh(true);
+		return {
+			status: result.changedWidgets.length > 0 ? "applied" : "unchanged",
+			scripted: false,
+			effectsResult: null,
+			uiEffects: [],
+			diagnostics: []
+		};
+	};
+	const write = (key, value) => enqueueMutation(async () => {
+		if (!ctx.doc) return;
+		apply({
+			t: "writeStart",
+			key
+		});
+		try {
+			const result = await commitValueNow(refKeyOf(key), value);
+			if (result.status === "rejected" || result.status === "failed") apply({
+				t: "writeFailed",
+				key
+			});
+			else if (result.effectsResult === null && result.scripted) apply({
+				t: "writeFailed",
+				key
+			});
+		} catch (err) {
+			apply({
+				t: "writeFailed",
+				key
+			});
+			throw err;
+		}
+	});
+	const can = (cap) => ctx.doc?.security.allows(cap) ?? false;
+	const annotationHost = ctx.tryGet(AnnotationToken$1);
+	const annotationActivation = async (ref) => {
+		const doc = ctx.doc;
+		if (!doc) return null;
+		const loaded = annotationHost?.get(ref);
+		if (loaded?.subtype === "widget") return loaded.actions?.activate ?? null;
+		const { annotations } = await doc.page(ref.pageObjectNumber).annotations.list();
+		const annotation = annotations.find((candidate) => sameAnnotationRef(candidate.ref, ref));
+		return annotation?.subtype === "widget" ? annotation.actions?.activate ?? null : null;
+	};
+	const activateWidgetNow = async (key, annotationRef) => {
+		const doc = ctx.doc;
+		if (!doc) throw new Error("no document");
+		if (!scripting) return {
+			status: "unchanged",
+			scripted: false,
+			effectsResult: null,
+			uiEffects: [],
+			diagnostics: []
+		};
+		const action = await annotationActivation(annotationRef);
+		if (!action) return {
+			status: "unchanged",
+			scripted: true,
+			effectsResult: null,
+			uiEffects: [],
+			diagnostics: []
+		};
+		const result = await scripting.activate(await doc.forms.list(), refKeyOf(key), action);
+		surfaceScriptingResult(result);
+		if (result.effectsResult !== null) await refresh(true);
+		return result;
+	};
+	const nudgeAnnotations = (pons) => {
+		if (!annotationHost) return;
+		for (const pon of new Set(pons)) annotationHost.reloadPage(pon);
+	};
+	/** Content-space box → PDF rect (inverse of `toBox`). */
+	const toPdfRect = (box, crop) => ({
+		left: box.x + crop.left,
+		top: crop.top - box.y,
+		right: box.x + crop.left + box.width,
+		bottom: crop.top - box.y - box.height
+	});
+	/** The page's content box (`{0,0,w,h}`), for page-bound placement math. */
+	const pageBox = (pon) => {
+		const crop = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon)?.boxes.crop;
+		return crop ? {
+			x: 0,
+			y: 0,
+			width: crop.right - crop.left,
+			height: crop.top - crop.bottom
+		} : null;
+	};
+	/** Deterministic, collision-free auto-name: `text_1`, `text_2`, … counted
+	*  against the CURRENT snapshot (rename in the field panel). */
+	const autoName = (family) => {
+		const names = new Set((model().snapshot?.fields ?? []).map((f) => f.name));
+		let n = 1;
+		while (names.has(`${family}_${n}`)) n++;
+		return `${family}_${n}`;
+	};
+	const placeFieldNow = async (input) => {
+		const doc = ctx.doc;
+		const pon = input.pageObjectNumber;
+		const crop = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon)?.boxes.crop;
+		if (!doc || !crop) throw new Error("[form] placeField: document/page not ready");
+		const page = pageBox(pon);
+		const x = Math.max(page.x, Math.min(input.box.x, page.width));
+		const y = Math.max(page.y, Math.min(input.box.y, page.height));
+		const box = {
+			x,
+			y,
+			width: Math.max(0, Math.min(input.box.x + input.box.width, page.width) - x),
+			height: Math.max(0, Math.min(input.box.y + input.box.height, page.height) - y)
+		};
+		if (box.width < 1 || box.height < 1) throw new Error("[form] placeField: degenerate box (size the box before placing)");
+		const { family, appearance } = input;
+		const name = autoName(family);
+		const placement = {
+			pageObjectNumber: pon,
+			rect: toPdfRect(box, crop),
+			...appearance ? { appearance } : {}
+		};
+		const draft = family === "radio" ? {
+			family,
+			name,
+			widgets: [{
+				...placement,
+				onState: "option1"
+			}]
+		} : family === "combobox" || family === "listbox" ? {
+			family,
+			name,
+			widget: placement,
+			options: [{
+				label: "Option 1",
+				value: "Option 1"
+			}, {
+				label: "Option 2",
+				value: "Option 2"
+			}]
+		} : {
+			family,
+			name,
+			widget: placement
+		};
+		const result = await doc.forms.createField(draft);
+		await refresh(true);
+		apply({
+			t: "clearGeom",
+			pageObjectNumber: pon
+		});
+		if (annotationHost) await annotationHost.reloadPage(pon);
+		const widget = result.field.widgets.find((w) => w.pageObjectNumber === pon) ?? null;
+		return {
+			field: result.field,
+			widget
+		};
+	};
+	const updateFieldNow = async (key, patch) => {
+		const doc = ctx.doc;
+		if (!doc) return;
+		await doc.forms.updateField(refKeyOf(key), patch);
+		await refresh(true);
+	};
+	const deleteFieldNow = async (key) => {
+		const doc = ctx.doc;
+		if (!doc) return;
+		const pons = fieldByKey(model(), key)?.widgets.map((w) => w.pageObjectNumber).filter((p) => p > 0) ?? [];
+		await doc.forms.deleteField(refKeyOf(key));
+		await refresh(true);
+		for (const pon of new Set(pons)) apply({
+			t: "clearGeom",
+			pageObjectNumber: pon
+		});
+		nudgeAnnotations(pons);
+	};
+	const detachWidgetNow = async (key, annotObjectNumber) => {
+		const doc = ctx.doc;
+		if (!doc) return;
+		const widget = fieldByKey(model(), key)?.widgets.find((w) => w.annotObjectNumber === annotObjectNumber);
+		await doc.forms.detachWidget(refKeyOf(key), {
+			annotObjectNumber,
+			pageObjectNumber: widget?.pageObjectNumber ?? 0
+		});
+		await refresh(true);
+		if (widget && widget.pageObjectNumber > 0) {
+			apply({
+				t: "clearGeom",
+				pageObjectNumber: widget.pageObjectNumber
+			});
+			nudgeAnnotations([widget.pageObjectNumber]);
+		}
+	};
+	refresh();
+	return {
+		snapshot: () => model().snapshot,
+		refresh,
+		fillItems: fillItems$1,
+		fillItem,
+		ensureGeom,
+		field: (key) => fieldByKey(model(), key),
+		fieldForWidget: (annotObjectNumber) => fieldForWidget(model(), annotObjectNumber),
+		setText: (key, value) => write(key, {
+			type: "text",
+			value
+		}),
+		toggle: (key, onState) => write(key, {
+			type: "toggle",
+			state: onState
+		}),
+		choose: (key, values) => write(key, {
+			type: "choice",
+			values
+		}),
+		reset: (key) => enqueueMutation(async () => {
+			const doc = ctx.doc;
+			if (!doc) return;
+			apply({
+				t: "writeStart",
+				key
+			});
+			try {
+				const result = await doc.forms.reset(refKeyOf(key));
+				apply({
+					t: "writeDone",
+					key,
+					field: result.field
+				});
+			} catch (err) {
+				apply({
+					t: "writeFailed",
+					key
+				});
+				throw err;
+			}
+		}),
+		commitValue: (ref, value) => enqueueMutation(() => commitValueNow(ref, value)),
+		activateWidget: (key, annotationRef) => enqueueMutation(() => activateWidgetNow(key, annotationRef)),
+		setUiEffectProvider: (provider) => {
+			uiEffectProvider = provider;
+		},
+		setValue: (ref, value) => enqueueMutation(async () => {
+			const doc = ctx.doc;
+			if (!doc) throw new Error("no document");
+			const result = await doc.forms.setValue(ref, value);
+			await refresh(true);
+			return result;
+		}),
+		exportData: async (format = "xfdf") => {
+			const doc = ctx.doc;
+			if (!doc) throw new Error("no document");
+			return doc.forms.exportData(format);
+		},
+		importData: (data, format) => enqueueMutation(async () => {
+			const doc = ctx.doc;
+			if (!doc) throw new Error("no document");
+			const result = await doc.forms.importData(data, format);
+			apply({
+				t: "snapshot",
+				snapshot: result.snapshot
+			});
+			return result;
+		}),
+		repair: (repairOptions) => enqueueMutation(async () => {
+			const doc = ctx.doc;
+			if (!doc) throw new Error("no document");
+			const result = await doc.forms.repair(repairOptions);
+			await refresh(true);
+			return result;
+		}),
+		placeField: (input) => enqueueMutation(() => placeFieldNow(input)),
+		pageBox,
+		updateField: (key, patch) => enqueueMutation(() => updateFieldNow(key, patch)),
+		deleteField: (key) => enqueueMutation(() => deleteFieldNow(key)),
+		detachWidget: (key, annotObjectNumber) => enqueueMutation(() => detachWidgetNow(key, annotObjectNumber)),
+		canFill: () => can("doc.forms.fill"),
+		canModify: () => can("doc.forms.modify")
+	};
+}
+//#endregion
+//#region src/effects.ts
+const STRUCTURAL = /* @__PURE__ */ new Set([
+	"form.fieldCreated",
+	"form.fieldUpdated",
+	"form.fieldDeleted",
+	"form.widgetAttached",
+	"form.widgetDetached",
+	"form.repaired"
+]);
+function registerFormEffects(ctx) {
+	const doc = ctx.doc;
+	if (!doc) return;
+	let refreshing = false;
+	const refresh = async () => {
+		if (refreshing) return;
+		refreshing = true;
+		try {
+			const snapshot = await doc.forms.list();
+			ctx.dispatch({
+				type: "SET_MODEL",
+				model: update(ctx.getState().model, {
+					t: "snapshot",
+					snapshot
+				})
+			});
+		} finally {
+			refreshing = false;
+		}
+	};
+	const unsubscribe = doc.events.subscribe((event) => {
+		if (!event.type.startsWith("form.")) return;
+		const structural = STRUCTURAL.has(event.type);
+		if (event.origin.kind !== "remote" && !structural) return;
+		if (structural) ctx.dispatch({
+			type: "SET_MODEL",
+			model: update(ctx.getState().model, { t: "clearGeom" })
+		});
+		refresh();
+	});
+	ctx.cleanup(unsubscribe);
+}
+//#endregion
+//#region src/tools.ts
+/** Palette tools keep widgets editable right after placement. */
+const PLACE_TAGS = ["form-place", "annotation-edit"];
+const FIELD_CHROME = {
+	interiorColor: "#ffffff",
+	color: "#6b7280",
+	strokeWidth: 1
 };
-const formTextFieldTool = defineAnnotationTool({
-  id: "formTextField",
-  name: "Text Field",
-  labelKey: "form.textfield",
-  categories: ["annotation", "form"],
-  matchScore: (a) => {
-    var _a;
-    if (a.type !== PdfAnnotationSubtype.WIDGET) return 0;
-    const widget = a;
-    return ((_a = widget.field) == null ? void 0 : _a.type) === PDF_FORM_FIELD_TYPE.TEXTFIELD ? 10 : 0;
-  },
-  interaction: {
-    exclusive: false,
-    cursor: "crosshair",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.WIDGET,
-    fontFamily: PdfStandardFont.Helvetica,
-    fontSize: 12,
-    fontColor: "#000000",
-    strokeColor: "#000000",
-    color: "#FFFFFF",
-    strokeWidth: 1,
-    field: {
-      flag: PDF_FORM_FIELD_FLAG.NONE,
-      name: "TextField",
-      alternateName: "TextField",
-      value: "",
-      type: PDF_FORM_FIELD_TYPE.TEXTFIELD
-    }
-  },
-  behavior: {
-    useAppearanceStream: false
-  },
-  clickBehavior: {
-    enabled: true,
-    defaultSize: { width: 150, height: 24 }
-  },
-  pointerHandler: textFieldHandlerFactory
-});
-const formCheckboxTool = defineAnnotationTool({
-  id: "formCheckbox",
-  name: "Checkbox",
-  labelKey: "form.checkbox",
-  categories: ["annotation", "form"],
-  matchScore: (a) => {
-    var _a;
-    if (a.type !== PdfAnnotationSubtype.WIDGET) return 0;
-    const widget = a;
-    return ((_a = widget.field) == null ? void 0 : _a.type) === PDF_FORM_FIELD_TYPE.CHECKBOX ? 10 : 0;
-  },
-  interaction: {
-    exclusive: false,
-    cursor: "crosshair",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.WIDGET,
-    strokeColor: "#000000",
-    color: "#FFFFFF",
-    strokeWidth: 1,
-    field: {
-      flag: PDF_FORM_FIELD_FLAG.NONE,
-      name: "Checkbox",
-      alternateName: "Checkbox",
-      value: "Off",
-      type: PDF_FORM_FIELD_TYPE.CHECKBOX
-    }
-  },
-  behavior: {
-    useAppearanceStream: false
-  },
-  clickBehavior: {
-    enabled: true,
-    defaultSize: { width: 20, height: 20 }
-  },
-  pointerHandler: checkboxHandlerFactory
-});
-const formRadioButtonTool = defineAnnotationTool({
-  id: "formRadioButton",
-  name: "Radio Button",
-  labelKey: "form.radiobutton",
-  categories: ["annotation", "form"],
-  matchScore: (a) => {
-    var _a;
-    if (a.type !== PdfAnnotationSubtype.WIDGET) return 0;
-    const widget = a;
-    return ((_a = widget.field) == null ? void 0 : _a.type) === PDF_FORM_FIELD_TYPE.RADIOBUTTON ? 10 : 0;
-  },
-  interaction: {
-    exclusive: false,
-    cursor: "crosshair",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    lockAspectRatio: true,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.WIDGET,
-    strokeColor: "#000000",
-    color: "#FFFFFF",
-    strokeWidth: 1,
-    field: {
-      flag: PDF_FORM_FIELD_FLAG.BUTTON_RADIO | PDF_FORM_FIELD_FLAG.BUTTON_NOTOGGLETOOFF,
-      name: "RadioButton",
-      alternateName: "RadioButton",
-      value: "Off",
-      type: PDF_FORM_FIELD_TYPE.RADIOBUTTON,
-      options: []
-    }
-  },
-  behavior: {
-    useAppearanceStream: false
-  },
-  clickBehavior: {
-    enabled: true,
-    defaultSize: { width: 20, height: 20 }
-  },
-  pointerHandler: radioButtonHandlerFactory
-});
-const formComboboxTool = defineAnnotationTool({
-  id: "formCombobox",
-  name: "Combo Box",
-  labelKey: "form.combobox",
-  categories: ["annotation", "form"],
-  matchScore: (a) => {
-    var _a;
-    if (a.type !== PdfAnnotationSubtype.WIDGET) return 0;
-    const widget = a;
-    return ((_a = widget.field) == null ? void 0 : _a.type) === PDF_FORM_FIELD_TYPE.COMBOBOX ? 10 : 0;
-  },
-  interaction: {
-    exclusive: false,
-    cursor: "crosshair",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.WIDGET,
-    fontFamily: PdfStandardFont.Helvetica,
-    fontSize: 12,
-    fontColor: "#000000",
-    strokeColor: "#000000",
-    color: "#FFFFFF",
-    strokeWidth: 1,
-    field: {
-      flag: PDF_FORM_FIELD_FLAG.NONE,
-      name: "ComboBox",
-      alternateName: "ComboBox",
-      value: "",
-      type: PDF_FORM_FIELD_TYPE.COMBOBOX,
-      options: [
-        { label: "Option 1", isSelected: true },
-        { label: "Option 2", isSelected: false },
-        { label: "Option 3", isSelected: false }
-      ]
-    }
-  },
-  behavior: {
-    useAppearanceStream: false
-  },
-  clickBehavior: {
-    enabled: true,
-    defaultSize: { width: 200, height: 40 }
-  },
-  pointerHandler: comboboxHandlerFactory
+const FORM_TOOLS = [
+	{
+		id: "form-text",
+		family: "text",
+		visualKind: "widget-text",
+		clickCreate: {
+			width: 160,
+			height: 24
+		},
+		defaults: {
+			...FIELD_CHROME,
+			fontSize: 12
+		},
+		cursor: "crosshair"
+	},
+	{
+		id: "form-checkbox",
+		family: "checkbox",
+		visualKind: "widget-toggle",
+		clickCreate: {
+			width: 18,
+			height: 18
+		},
+		defaults: FIELD_CHROME,
+		cursor: "crosshair"
+	},
+	{
+		id: "form-radio",
+		family: "radio",
+		visualKind: "widget-toggle",
+		clickCreate: {
+			width: 18,
+			height: 18
+		},
+		defaults: FIELD_CHROME,
+		cursor: "crosshair"
+	},
+	{
+		id: "form-combobox",
+		family: "combobox",
+		visualKind: "widget-choice",
+		clickCreate: {
+			width: 140,
+			height: 24
+		},
+		defaults: {
+			...FIELD_CHROME,
+			fontSize: 12
+		},
+		cursor: "crosshair"
+	},
+	{
+		id: "form-listbox",
+		family: "listbox",
+		visualKind: "widget-choice",
+		clickCreate: {
+			width: 140,
+			height: 72
+		},
+		defaults: {
+			...FIELD_CHROME,
+			fontSize: 12
+		},
+		cursor: "crosshair"
+	}
+];
+const FORM_TOOL_BY_ID = new Map(FORM_TOOLS.map((t) => [t.id, t]));
+//#endregion
+//#region src/handler.ts
+const rectFrom = (a, b) => ({
+	x: Math.min(a.x, b.x),
+	y: Math.min(a.y, b.y),
+	width: Math.abs(b.x - a.x),
+	height: Math.abs(b.y - a.y)
 });
-const formListboxTool = defineAnnotationTool({
-  id: "formListbox",
-  name: "List Box",
-  labelKey: "form.listbox",
-  categories: ["annotation", "form"],
-  matchScore: (a) => {
-    var _a;
-    if (a.type !== PdfAnnotationSubtype.WIDGET) return 0;
-    const widget = a;
-    return ((_a = widget.field) == null ? void 0 : _a.type) === PDF_FORM_FIELD_TYPE.LISTBOX ? 10 : 0;
-  },
-  interaction: {
-    exclusive: false,
-    cursor: "crosshair",
-    isDraggable: true,
-    isResizable: true,
-    isRotatable: false,
-    isGroupDraggable: true,
-    isGroupResizable: false,
-    isGroupRotatable: false
-  },
-  defaults: {
-    type: PdfAnnotationSubtype.WIDGET,
-    fontFamily: PdfStandardFont.Helvetica,
-    fontSize: 12,
-    fontColor: "#000000",
-    strokeColor: "#000000",
-    color: "#FFFFFF",
-    strokeWidth: 1,
-    field: {
-      flag: PDF_FORM_FIELD_FLAG.NONE,
-      name: "ListBox",
-      alternateName: "ListBox",
-      value: "",
-      type: PDF_FORM_FIELD_TYPE.LISTBOX,
-      options: [
-        { label: "Option 1", isSelected: true },
-        { label: "Option 2", isSelected: false },
-        { label: "Option 3", isSelected: false }
-      ]
-    }
-  },
-  behavior: {
-    useAppearanceStream: false
-  },
-  clickBehavior: {
-    enabled: true,
-    defaultSize: { width: 150, height: 150 }
-  },
-  pointerHandler: listboxHandlerFactory
+/**
+* Draw-to-place: drag a box (live placement preview through the annotation
+* plane's ghost pipeline) or just click (the tool's `clickCreate` policy,
+* resolved by the SAME `resolveClickPlacement` the annotation core uses) —
+* the commit creates field + widget through `doc.forms.placeField`, styled
+* from the tool's live defaults. The tool stays active for repeat placement
+* (v2 rubber-stamp feel) and the fresh widget is auto-selected.
+*
+* Gesture rules match the annotation handlers: page-anchored via the sample
+* projection (the box keeps sizing along the edge when the cursor overshoots
+* or crosses a gap), the UP sample is the final point, and a CLICK means
+* width AND height under the shared threshold — a thin 100×2 drag is a drag.
+*/
+function createPlaceHandler(form, interaction, annotation) {
+	let origin = null;
+	return {
+		id: "form-place",
+		priority: 95,
+		enabledFor: (t) => t.enables.has("form-place"),
+		onDown: (s) => {
+			if (!s.page || !FORM_TOOL_BY_ID.has(interaction.activeToolId())) return false;
+			if (!form.canModify()) return false;
+			origin = {
+				pon: s.page.pon,
+				start: s.page.point,
+				last: s.page.point
+			};
+			return true;
+		},
+		onMove: (s) => {
+			if (!origin) return;
+			const point = samplePointOn(s, origin.pon);
+			if (!point) return;
+			origin.last = point;
+			const box = rectFrom(origin.start, point);
+			if (annotation) if (Math.max(box.width, box.height) >= MIN_DRAG) annotation.setPlacementPreview(interaction.activeToolId(), origin.pon, box);
+			else annotation.clearPlacementPreview();
+		},
+		onUp: (s) => {
+			if (!origin) return;
+			const o = origin;
+			origin = null;
+			annotation?.clearPlacementPreview();
+			const toolId = interaction.activeToolId();
+			const tool = FORM_TOOL_BY_ID.get(toolId);
+			if (!tool) return;
+			const end = samplePointOn(s, o.pon) ?? o.last;
+			const dragged = rectFrom(o.start, end);
+			const isClick = dragged.width < MIN_DRAG && dragged.height < MIN_DRAG;
+			const pageBox = form.pageBox(o.pon);
+			const box = isClick ? boxOfClick(o.start, tool.clickCreate, pageBox) : dragged;
+			form.placeField({
+				family: tool.family,
+				pageObjectNumber: o.pon,
+				box,
+				appearance: widgetAppearanceFromProps(annotation ? annotation.currentDefaults(toolId) : tool.defaults)
+			}).then((placed) => {
+				if (!annotation || interaction.activeToolId() !== toolId) return;
+				const widget = placed.widget;
+				if (!widget || widget.annotObjectNumber <= 0) return;
+				annotation.select({
+					kind: "objectNumber",
+					annotObjectNumber: widget.annotObjectNumber,
+					pageObjectNumber: o.pon
+				});
+			}).catch((err) => {
+				globalThis.console?.error("[form] placeField failed:", err);
+			});
+		}
+	};
+}
+/** The click-create box through the SHARED placement layer (fields are boxes;
+*  the policy anchor + page clamp are exactly the annotation click's). */
+function boxOfClick(point, policy, pageBox) {
+	const placement = resolveClickPlacement(point, policy, { pageBox: pageBox ?? void 0 });
+	return placement.kind === "box" ? placement.rect : {
+		x: point.x,
+		y: point.y,
+		width: policy.width,
+		height: policy.height
+	};
+}
+//#endregion
+//#region src/reducer.ts
+const initialFormState = () => ({ model: initialModel() });
+/** Dumb store: the pure core computes the next model; the shell dispatches it. */
+const formReducer = (state, action) => action.type === "SET_MODEL" ? { model: action.model } : state;
+//#endregion
+//#region src/types.ts
+const FormToken = createCapabilityToken("form");
+//#endregion
+//#region src/form.plugin.ts
+/**
+* The form plugin: the FIELD plane. Document-scoped; requires the
+* interaction hub. Fill mode works with no annotation plugin at all —
+* geometry is read from the engine's widget DTOs. When the annotation
+* plugin IS present, a Behavior keeps widgets geometry-inert while the
+* active tool carries 'form-fill' (the built-in pointer/pan tools do, so
+* filling is the resting state) and stands the fill controls down under
+* every other tool — the single-active-tool hub IS the mode switch.
+* Design mode = the 'form-edit' / palette tools: no 'form-fill' tag, so
+* widgets become ordinary editable annotations.
+*/
+const formPlugin = (options = {}) => definePlugin({
+	id: "form",
+	token: FormToken,
+	scope: "document",
+	requires: [InteractionToken],
+	optional: [AnnotationToken],
+	initialState: initialFormState,
+	reduce: formReducer,
+	capability: (ctx) => createFormCapability(ctx, options),
+	effects: registerFormEffects,
+	init: (ctx) => {
+		const interaction = ctx.get(InteractionToken);
+		const form = ctx.get(FormToken);
+		interaction.registerTool({
+			id: "form-fill",
+			cursor: "default",
+			enables: /* @__PURE__ */ new Set(["form-fill", "link-nav"])
+		});
+		interaction.registerTool({
+			id: "form-edit",
+			cursor: "default",
+			enables: /* @__PURE__ */ new Set(["annotation-edit", "annotation-marquee"])
+		});
+		const annotation = ctx.tryGet(AnnotationToken$1);
+		for (const t of FORM_TOOLS) if (annotation) annotation.registerTool({
+			id: t.id,
+			subtype: t.visualKind,
+			cursor: t.cursor,
+			enables: [...PLACE_TAGS],
+			clickCreate: t.clickCreate,
+			defaults: t.defaults
+		});
+		else interaction.registerTool({
+			id: t.id,
+			cursor: t.cursor,
+			enables: new Set(PLACE_TAGS)
+		});
+		interaction.registerHandler(createPlaceHandler(form, interaction, annotation));
+		if (annotation) annotation.registerBehavior({
+			id: "form-widgets",
+			matches: (a) => a.subtype.startsWith("widget"),
+			engaged: () => interaction.activeTool()?.enables.has("form-fill") ?? false
+		});
+	}
 });
-const formTools = [
-  formTextFieldTool,
-  formCheckboxTool,
-  formRadioButtonTool,
-  formComboboxTool,
-  formListboxTool
-];
-const _FormPlugin = class _FormPlugin extends BasePlugin {
-  constructor(id, registry, _config) {
-    var _a, _b;
-    super(id, registry);
-    this.FORM_HISTORY_TOPIC = "form-fields";
-    this.annotation = null;
-    this.history = null;
-    this.state$ = createScopedEmitter(
-      (documentId, state) => ({ documentId, state })
-    );
-    this.fieldValueChange$ = createScopedEmitter((_, event) => event, { cache: false });
-    this.formReady$ = createScopedEmitter(
-      (documentId, fields) => ({ documentId, fields }),
-      { cache: false }
-    );
-    this.fieldGroupIndex = /* @__PURE__ */ new Map();
-    this.fieldNameIndex = /* @__PURE__ */ new Map();
-    this.orderedFieldIndex = /* @__PURE__ */ new Map();
-    this.propagationInProgress = /* @__PURE__ */ new Set();
-    this.annotation = ((_a = registry.getPlugin("annotation")) == null ? void 0 : _a.provides()) ?? null;
-    this.history = ((_b = registry.getPlugin(HistoryPlugin.id)) == null ? void 0 : _b.provides()) ?? null;
-    if (this.annotation) {
-      for (const tool of formTools) {
-        this.annotation.addTool(tool);
-      }
-      this.annotation.onAnnotationEvent((event) => this.handleAnnotationEvent(event));
-    }
-  }
-  async initialize() {
-  }
-  onDocumentLoadingStarted(documentId) {
-    this.dispatch(initFormState(documentId, { ...initialDocumentState }));
-  }
-  onDocumentClosed(documentId) {
-    this.dispatch(cleanupFormState(documentId));
-    this.fieldGroupIndex.delete(documentId);
-    this.fieldNameIndex.delete(documentId);
-    this.orderedFieldIndex.delete(documentId);
-    this.state$.clearScope(documentId);
-    this.fieldValueChange$.clearScope(documentId);
-    this.formReady$.clearScope(documentId);
-  }
-  onStoreUpdated(prev, next) {
-    for (const documentId in next.documents) {
-      const prevDoc = prev.documents[documentId];
-      const nextDoc = next.documents[documentId];
-      if (prevDoc !== nextDoc) {
-        this.state$.emit(documentId, nextDoc);
-      }
-    }
-  }
-  buildCapability() {
-    return {
-      getPageFormAnnoWidgets: (pageIndex, documentId) => this.getPageFormAnnoWidgets(pageIndex, documentId),
-      setFormFieldValues: (pageIndex, annotation, newField, documentId) => this.setFormFieldValues(pageIndex, annotation, newField, documentId),
-      renameField: (annotationId, name, documentId) => this.renameFieldMethod(annotationId, name, documentId),
-      shareField: (annotationId, targetAnnotationId, documentId) => this.shareFieldMethod(annotationId, targetAnnotationId, documentId),
-      renderWidget: (options, documentId) => this.renderWidget(options, documentId),
-      selectField: (annotationId, documentId) => this.selectFieldMethod(annotationId, documentId),
-      deselectField: (documentId) => this.deselectFieldMethod(documentId),
-      getSelectedFieldId: (documentId) => this.getSelectedFieldId(documentId),
-      selectNextField: (documentId) => this.selectNextFieldMethod(documentId),
-      selectPreviousField: (documentId) => this.selectPreviousFieldMethod(documentId),
-      activateField: (documentId) => this.activateFieldMethod(documentId),
-      getState: (documentId) => this.getDocumentState(documentId),
-      getFieldGroup: (annotationId, documentId) => this.getFieldGroup(annotationId, documentId),
-      getFieldSiblings: (annotationId, documentId) => this.getFieldSiblings(annotationId, documentId),
-      getFormValues: (documentId) => this.getFormValuesMethod(documentId),
-      getFormFields: (documentId) => this.getFormFieldsMethod(documentId),
-      setFormValues: (values, documentId) => this.setFormValuesMethod(values, documentId),
-      forDocument: (documentId) => this.createFormScope(documentId),
-      onStateChange: this.state$.onGlobal,
-      onFieldValueChange: this.fieldValueChange$.onGlobal,
-      onFormReady: this.formReady$.onGlobal
-    };
-  }
-  createFormScope(documentId) {
-    return {
-      getPageFormAnnoWidgets: (pageIndex) => this.getPageFormAnnoWidgets(pageIndex, documentId),
-      setFormFieldValues: (pageIndex, annotation, newField) => this.setFormFieldValues(pageIndex, annotation, newField, documentId),
-      renameField: (annotationId, name) => this.renameFieldMethod(annotationId, name, documentId),
-      shareField: (annotationId, targetAnnotationId) => this.shareFieldMethod(annotationId, targetAnnotationId, documentId),
-      renderWidget: (options) => this.renderWidget(options, documentId),
-      selectField: (annotationId) => this.selectFieldMethod(annotationId, documentId),
-      deselectField: () => this.deselectFieldMethod(documentId),
-      getSelectedFieldId: () => this.getSelectedFieldId(documentId),
-      selectNextField: () => this.selectNextFieldMethod(documentId),
-      selectPreviousField: () => this.selectPreviousFieldMethod(documentId),
-      activateField: () => this.activateFieldMethod(documentId),
-      getState: () => this.getDocumentState(documentId),
-      getFieldGroup: (annotationId) => this.getFieldGroup(annotationId, documentId),
-      getFieldSiblings: (annotationId) => this.getFieldSiblings(annotationId, documentId),
-      getFormValues: () => this.getFormValuesMethod(documentId),
-      getFormFields: () => this.getFormFieldsMethod(documentId),
-      setFormValues: (values) => this.setFormValuesMethod(values, documentId),
-      onStateChange: this.state$.forScope(documentId),
-      onFieldValueChange: this.fieldValueChange$.forScope(documentId),
-      onFormReady: this.formReady$.forScope(documentId)
-    };
-  }
-  handleAnnotationEvent(event) {
-    switch (event.type) {
-      case "loaded":
-        this.buildFieldGroupIndex(event.documentId);
-        this.formReady$.emit(event.documentId, this.getFormFieldsMethod(event.documentId));
-        break;
-      case "create":
-      case "delete": {
-        if (event.annotation.type !== PdfAnnotationSubtype.WIDGET) break;
-        this.buildFieldGroupIndex(event.documentId);
-        break;
-      }
-      case "update": {
-        if (!event.committed) break;
-        const anno = event.annotation;
-        if (anno.type !== PdfAnnotationSubtype.WIDGET) break;
-        if (this.propagationInProgress.has(anno.id)) {
-          this.propagationInProgress.delete(anno.id);
-          break;
-        }
-        const patch = event.patch;
-        this.buildFieldGroupIndex(event.documentId);
-        this.propagateFieldLevelChanges(event.documentId, anno, patch);
-        break;
-      }
-    }
-  }
-  propagateFieldLevelChanges(documentId, annotation, patch) {
-    if (!this.annotation || !patch.field) return;
-    const fieldPatch = patch.field;
-    const siblings = this.getFieldSiblings(annotation.id, documentId);
-    if (siblings.length === 0) return;
-    const siblingPatches = [];
-    for (const sibling of siblings) {
-      this.propagationInProgress.add(sibling.annotationId);
-      siblingPatches.push({
-        pageIndex: sibling.pageIndex,
-        id: sibling.annotationId,
-        patch: { field: { ...fieldPatch } }
-      });
-    }
-    this.annotation.forDocument(documentId).updateAnnotations(siblingPatches);
-  }
-  buildFieldGroupIndex(documentId) {
-    if (!this.annotation) return;
-    const annoState = this.annotation.forDocument(documentId).getState();
-    if (!annoState) return;
-    const idx = /* @__PURE__ */ new Map();
-    const allWidgets = [];
-    for (const [pageStr, uids] of Object.entries(annoState.pages)) {
-      const pageIndex = Number(pageStr);
-      for (const uid of uids) {
-        const tracked = annoState.byUid[uid];
-        if (!tracked || tracked.object.type !== PdfAnnotationSubtype.WIDGET) continue;
-        const widget = tracked.object;
-        const entry = { annotationId: uid, pageIndex };
-        allWidgets.push({ entry, widget });
-        const fieldKey = this.getFieldKey(widget.field);
-        if (!fieldKey) continue;
-        const group = idx.get(fieldKey) ?? [];
-        group.push(entry);
-        idx.set(fieldKey, group);
-      }
-    }
-    this.fieldGroupIndex.set(documentId, idx);
-    const nameIdx = /* @__PURE__ */ new Map();
-    for (const { entry, widget } of allWidgets) {
-      const name = widget.field.name.trim();
-      if (!name) continue;
-      const group = nameIdx.get(name) ?? [];
-      group.push(entry);
-      nameIdx.set(name, group);
-    }
-    this.fieldNameIndex.set(documentId, nameIdx);
-    const navigable = allWidgets.filter(
-      ({ widget }) => !(widget.field.flag & PDF_FORM_FIELD_FLAG.READONLY)
-    );
-    this.orderedFieldIndex.set(
-      documentId,
-      navigable.map(({ entry }) => entry)
-    );
-  }
-  getDocumentState(documentId) {
-    const id = documentId ?? this.getActiveDocumentId();
-    return this.state.documents[id] ?? { ...initialDocumentState };
-  }
-  // ─────────────────────────────────────────────────────────
-  // Field Group Index
-  // ─────────────────────────────────────────────────────────
-  getDocIndex(documentId) {
-    let idx = this.fieldGroupIndex.get(documentId);
-    if (!idx) {
-      idx = /* @__PURE__ */ new Map();
-      this.fieldGroupIndex.set(documentId, idx);
-    }
-    return idx;
-  }
-  getFieldKey(field) {
-    if (typeof field.fieldObjectId === "number" && field.fieldObjectId > 0) {
-      return `field:${field.fieldObjectId}`;
-    }
-    const normalizedName = field.name.trim();
-    if (!normalizedName) return null;
-    return `legacy:${field.type}:${normalizedName}`;
-  }
-  resolveWidgetAnnotation(annotationId, documentId) {
-    if (!this.annotation) return null;
-    const annoState = this.annotation.forDocument(documentId).getState();
-    const tracked = annoState == null ? void 0 : annoState.byUid[annotationId];
-    if (!tracked || tracked.object.type !== PdfAnnotationSubtype.WIDGET) {
-      return null;
-    }
-    return tracked.object;
-  }
-  getFieldGroup(annotationId, documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const widget = this.resolveWidgetAnnotation(annotationId, docId);
-    if (!widget) return [];
-    const fieldKey = this.getFieldKey(widget.field);
-    if (!fieldKey) {
-      return [{ annotationId: widget.id, pageIndex: widget.pageIndex }];
-    }
-    return this.getDocIndex(docId).get(fieldKey) ?? [
-      { annotationId: widget.id, pageIndex: widget.pageIndex }
-    ];
-  }
-  getFieldSiblings(annotationId, documentId) {
-    return this.getFieldGroup(annotationId, documentId).filter(
-      (e) => e.annotationId !== annotationId
-    );
-  }
-  // ─────────────────────────────────────────────────────────
-  // Form Values API
-  // ─────────────────────────────────────────────────────────
-  getFormValuesMethod(documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const nameIdx = this.fieldNameIndex.get(docId);
-    if (!nameIdx) return {};
-    const values = {};
-    for (const [name, entries] of nameIdx) {
-      const widget = this.resolveWidgetAnnotation(entries[0].annotationId, docId);
-      if (widget) {
-        values[name] = widget.field.value;
-      }
-    }
-    return values;
-  }
-  getFormFieldsMethod(documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const nameIdx = this.fieldNameIndex.get(docId);
-    if (!nameIdx) return [];
-    const fields = [];
-    for (const [name, entries] of nameIdx) {
-      const widget = this.resolveWidgetAnnotation(entries[0].annotationId, docId);
-      if (!widget) continue;
-      fields.push({
-        name,
-        type: widget.field.type,
-        value: widget.field.value,
-        readOnly: !!(widget.field.flag & PDF_FORM_FIELD_FLAG.READONLY),
-        ..."options" in widget.field && widget.field.options ? { options: widget.field.options } : {}
-      });
-    }
-    return fields;
-  }
-  setFormValuesMethod(values, documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const nameIdx = this.fieldNameIndex.get(docId);
-    if (!nameIdx) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "no form fields indexed for this document"
-      });
-    }
-    const entries = Object.entries(values);
-    if (entries.length === 0) {
-      return PdfTaskHelper.resolve(true);
-    }
-    const resultTask = new Task();
-    let pending = entries.length;
-    let failed = false;
-    const onComplete = () => {
-      pending--;
-      if (pending === 0 && !failed) {
-        resultTask.resolve(true);
-      }
-    };
-    const onError = (err) => {
-      if (!failed) {
-        failed = true;
-        resultTask.reject(err);
-      }
-    };
-    for (const [name, value] of entries) {
-      const fieldEntries = nameIdx.get(name);
-      if (!fieldEntries || fieldEntries.length === 0) {
-        onComplete();
-        continue;
-      }
-      let targetEntry = fieldEntries[0];
-      let widget = this.resolveWidgetAnnotation(targetEntry.annotationId, docId);
-      if (!widget) {
-        onComplete();
-        continue;
-      }
-      if (widget.field.type === PDF_FORM_FIELD_TYPE.RADIOBUTTON || widget.field.type === PDF_FORM_FIELD_TYPE.CHECKBOX) {
-        for (const entry of fieldEntries) {
-          const w = this.resolveWidgetAnnotation(entry.annotationId, docId);
-          if (w && w.exportValue === value) {
-            widget = w;
-            targetEntry = entry;
-            break;
-          }
-        }
-      }
-      this.setFormFieldValues(
-        targetEntry.pageIndex,
-        widget,
-        this.buildImportField(widget, value),
-        docId
-      ).wait(
-        () => onComplete(),
-        (error) => onError(error.reason)
-      );
-    }
-    return resultTask;
-  }
-  buildImportField(widget, value) {
-    const field = widget.field;
-    if ((field.type === PDF_FORM_FIELD_TYPE.COMBOBOX || field.type === PDF_FORM_FIELD_TYPE.LISTBOX) && "options" in field) {
-      return {
-        ...field,
-        value,
-        options: field.options.map((opt) => ({
-          ...opt,
-          isSelected: opt.label === value
-        }))
-      };
-    }
-    if (field.type === PDF_FORM_FIELD_TYPE.CHECKBOX) {
-      const normalizedValue = value === "Off" ? "Off" : widget.exportValue ?? "Yes";
-      return { ...field, value: normalizedValue };
-    }
-    return { ...field, value };
-  }
-  isToggleField(field) {
-    return field.type === PDF_FORM_FIELD_TYPE.CHECKBOX || field.type === PDF_FORM_FIELD_TYPE.RADIOBUTTON;
-  }
-  shouldRegenerateWidgetAppearances(field) {
-    return !this.isToggleField(field);
-  }
-  getFieldBatchTarget(batch) {
-    const entries = [...batch.values()];
-    const checkedToggleEntry = entries.find(
-      (entry) => this.isToggleField(entry.widget.field) && isWidgetChecked(entry.widget)
-    );
-    return checkedToggleEntry ?? entries[0];
-  }
-  async readFieldWidgets(doc, groupEntries, seq, regenerateAppearances) {
-    const pageSet = new Set(groupEntries.map((entry) => entry.pageIndex));
-    const memberIds = new Set(groupEntries.map((entry) => entry.annotationId));
-    const batch = /* @__PURE__ */ new Map();
-    for (const pageIndex of pageSet) {
-      const page = doc.pages.find((entry) => entry.index === pageIndex);
-      if (!page) continue;
-      const pageMemberIds = groupEntries.filter((entry) => entry.pageIndex === pageIndex).map((entry) => entry.annotationId);
-      if (regenerateAppearances) {
-        await seq.run(() => this.engine.regenerateWidgetAppearances(doc, page, pageMemberIds));
-      }
-      const widgets = await seq.run(() => this.engine.getPageAnnoWidgets(doc, page));
-      for (const widget of widgets) {
-        if (memberIds.has(widget.id)) {
-          batch.set(widget.id, { widget, pageIndex });
-        }
-      }
-    }
-    return batch;
-  }
-  syncFieldBatch(documentId, batch, options = {}) {
-    if (!this.annotation) return;
-    for (const [id, { widget, pageIndex }] of batch) {
-      this.annotation.syncAnnotationObject(id, widget, documentId);
-      this.annotation.invalidatePageAppearances(pageIndex, documentId);
-      if (options.emitFieldValueChanges) {
-        this.fieldValueChange$.emit(documentId, {
-          documentId,
-          pageIndex,
-          annotationId: id,
-          widget
-        });
-      }
-    }
-    this.buildFieldGroupIndex(documentId);
-  }
-  resolveWidgetPage(annotationId, documentId, doc) {
-    const widget = this.resolveWidgetAnnotation(annotationId, documentId);
-    if (!widget) return null;
-    const page = doc.pages.find((entry) => entry.index === widget.pageIndex);
-    if (!page) return null;
-    return { widget, page };
-  }
-  getPageFormAnnoWidgets(pageIndex, documentId) {
-    const docState = this.getCoreDocumentOrThrow(documentId);
-    const doc = docState.document;
-    if (!doc) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.DocNotOpen,
-        message: "document is not open"
-      });
-    }
-    const page = doc.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "page does not exist"
-      });
-    }
-    return this.engine.getPageAnnoWidgets(doc, page);
-  }
-  setFormFieldValues(pageIndex, annotation, newField, documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const coreDoc = this.getCoreDocumentOrThrow(docId);
-    const doc = coreDoc.document;
-    if (!doc) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.DocNotOpen,
-        message: "document is not open"
-      });
-    }
-    const page = doc.pages.find((p) => p.index === pageIndex);
-    if (!page) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "page does not exist"
-      });
-    }
-    const resultTask = new Task();
-    const seq = new TaskSequence(resultTask);
-    seq.execute(
-      async () => {
-        const groupEntries = this.getFieldGroup(annotation.id, docId);
-        const beforeEntries = await this.readFieldWidgets(doc, groupEntries, seq, false);
-        await seq.run(() => this.engine.setFormFieldState(doc, page, annotation, newField));
-        const afterEntries = await this.readFieldWidgets(
-          doc,
-          groupEntries,
-          seq,
-          this.shouldRegenerateWidgetAppearances(newField)
-        );
-        let isFirstExecution = true;
-        const applyToEngine = async (batch) => {
-          const target = this.getFieldBatchTarget(batch);
-          if (!target) return;
-          const pg = doc.pages.find((p) => p.index === target.pageIndex);
-          if (!pg) return;
-          await new Promise((resolve) => {
-            this.engine.setFormFieldState(doc, pg, target.widget, target.widget.field).wait(
-              () => resolve(),
-              () => resolve()
-            );
-          });
-          if (this.shouldRegenerateWidgetAppearances(target.widget.field)) {
-            for (const pi of new Set([...batch.values()].map((entry) => entry.pageIndex))) {
-              const p = doc.pages.find((pp) => pp.index === pi);
-              if (!p) continue;
-              const ids = [...batch.entries()].filter(([, entry]) => entry.pageIndex === pi).map(([id]) => id);
-              await new Promise((resolve) => {
-                this.engine.regenerateWidgetAppearances(doc, p, ids).wait(
-                  () => resolve(),
-                  () => resolve()
-                );
-              });
-            }
-          }
-        };
-        const command = {
-          execute: () => {
-            const skipEngine = isFirstExecution;
-            isFirstExecution = false;
-            if (skipEngine) {
-              this.syncFieldBatch(docId, afterEntries, { emitFieldValueChanges: true });
-            } else {
-              applyToEngine(afterEntries).then(
-                () => this.syncFieldBatch(docId, afterEntries, { emitFieldValueChanges: true })
-              );
-            }
-          },
-          undo: () => {
-            applyToEngine(beforeEntries).then(
-              () => this.syncFieldBatch(docId, beforeEntries, { emitFieldValueChanges: true })
-            );
-          }
-        };
-        if (this.history) {
-          this.history.forDocument(docId).register(command, this.FORM_HISTORY_TOPIC);
-        } else {
-          command.execute();
-        }
-        resultTask.resolve(true);
-      },
-      (err) => ({ code: PdfErrorCode.Unknown, message: String(err) })
-    );
-    return resultTask;
-  }
-  findConflictingFieldGroups(normalizedName, sourceAnnotationId, documentId) {
-    const result = /* @__PURE__ */ new Map();
-    if (!this.annotation) return result;
-    const annoState = this.annotation.forDocument(documentId).getState();
-    if (!annoState) return result;
-    const sourceFieldKey = (() => {
-      const w = this.resolveWidgetAnnotation(sourceAnnotationId, documentId);
-      return w ? this.getFieldKey(w.field) : null;
-    })();
-    for (const [pageStr, uids] of Object.entries(annoState.pages)) {
-      const pageIndex = Number(pageStr);
-      for (const uid of uids) {
-        const tracked = annoState.byUid[uid];
-        if (!tracked || tracked.object.type !== PdfAnnotationSubtype.WIDGET) continue;
-        const widget = tracked.object;
-        if (widget.field.name.trim() !== normalizedName) continue;
-        const fieldKey = this.getFieldKey(widget.field);
-        if (!fieldKey || fieldKey === sourceFieldKey) continue;
-        if (!result.has(fieldKey)) {
-          result.set(fieldKey, { entries: [], widget });
-        }
-        result.get(fieldKey).entries.push({ annotationId: uid, pageIndex });
-      }
-    }
-    return result;
-  }
-  renameFieldMethod(annotationId, name, documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const normalizedName = name.trim();
-    if (!normalizedName) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.Unknown,
-        message: "Field name must not be empty."
-      });
-    }
-    const coreDoc = this.getCoreDocumentOrThrow(docId);
-    const doc = coreDoc.document;
-    if (!doc) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.DocNotOpen,
-        message: "document is not open"
-      });
-    }
-    const source = this.resolveWidgetPage(annotationId, docId, doc);
-    if (!source) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "widget annotation not found"
-      });
-    }
-    if (source.widget.field.name.trim() === normalizedName) {
-      return PdfTaskHelper.resolve({ outcome: "no-op" });
-    }
-    const conflicts = this.findConflictingFieldGroups(normalizedName, annotationId, docId);
-    if (conflicts.size > 0) {
-      if (conflicts.size > 1) {
-        return PdfTaskHelper.reject({
-          code: PdfErrorCode.Unknown,
-          message: "That field name is used by multiple fields. Choose a unique name."
-        });
-      }
-      const [, match] = [...conflicts.entries()][0];
-      if (match.widget.field.type !== source.widget.field.type) {
-        return PdfTaskHelper.reject({
-          code: PdfErrorCode.Unknown,
-          message: "That field name is already used by a different widget type."
-        });
-      }
-      return PdfTaskHelper.resolve({
-        outcome: "conflict",
-        targetAnnotationId: match.entries[0].annotationId,
-        fieldName: normalizedName
-      });
-    }
-    const resultTask = new Task();
-    const seq = new TaskSequence(resultTask);
-    seq.execute(
-      async () => {
-        const groupEntries = this.getFieldGroup(annotationId, docId);
-        await seq.run(
-          () => this.engine.renameWidgetField(doc, source.page, source.widget, normalizedName)
-        );
-        const syncedEntries = await this.readFieldWidgets(doc, groupEntries, seq, false);
-        this.syncFieldBatch(docId, syncedEntries);
-        resultTask.resolve({ outcome: "renamed" });
-      },
-      (err) => ({ code: PdfErrorCode.Unknown, message: String(err) })
-    );
-    return resultTask;
-  }
-  shareFieldMethod(annotationId, targetAnnotationId, documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    if (annotationId === targetAnnotationId) {
-      return PdfTaskHelper.resolve(true);
-    }
-    const coreDoc = this.getCoreDocumentOrThrow(docId);
-    const doc = coreDoc.document;
-    if (!doc) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.DocNotOpen,
-        message: "document is not open"
-      });
-    }
-    const source = this.resolveWidgetPage(annotationId, docId, doc);
-    const target = this.resolveWidgetPage(targetAnnotationId, docId, doc);
-    if (!source || !target) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "widget annotation not found"
-      });
-    }
-    if (source.widget.field.type !== target.widget.field.type) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.Unknown,
-        message: "cannot share fields with different widget types"
-      });
-    }
-    if (source.widget.field.fieldObjectId && target.widget.field.fieldObjectId && source.widget.field.fieldObjectId === target.widget.field.fieldObjectId) {
-      return PdfTaskHelper.resolve(true);
-    }
-    const affectedEntryMap = /* @__PURE__ */ new Map();
-    for (const entry of this.getFieldGroup(annotationId, docId)) {
-      affectedEntryMap.set(entry.annotationId, entry);
-    }
-    for (const entry of this.getFieldGroup(targetAnnotationId, docId)) {
-      affectedEntryMap.set(entry.annotationId, entry);
-    }
-    const affectedEntries = [...affectedEntryMap.values()];
-    const resultTask = new Task();
-    const seq = new TaskSequence(resultTask);
-    seq.execute(
-      async () => {
-        await seq.run(
-          () => this.engine.shareWidgetField(doc, source.page, source.widget, target.page, target.widget)
-        );
-        const syncedEntries = await this.readFieldWidgets(
-          doc,
-          affectedEntries,
-          seq,
-          this.shouldRegenerateWidgetAppearances(target.widget.field)
-        );
-        this.syncFieldBatch(docId, syncedEntries);
-        resultTask.resolve(true);
-      },
-      (err) => ({ code: PdfErrorCode.Unknown, message: String(err) })
-    );
-    return resultTask;
-  }
-  selectFieldMethod(annotationId, documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    this.dispatch(selectField(docId, annotationId));
-  }
-  deselectFieldMethod(documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    this.dispatch(deselectField(docId));
-  }
-  getSelectedFieldId(documentId) {
-    return this.getDocumentState(documentId).selectedFieldId;
-  }
-  selectNextFieldMethod(documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const ordered = this.orderedFieldIndex.get(docId);
-    if (!ordered || ordered.length === 0) return;
-    const currentId = this.getSelectedFieldId(docId);
-    let nextIndex = 0;
-    if (currentId) {
-      const currentIndex = ordered.findIndex((e) => e.annotationId === currentId);
-      nextIndex = currentIndex >= 0 ? (currentIndex + 1) % ordered.length : 0;
-    }
-    const next = ordered[nextIndex];
-    this.dispatch(selectField(docId, next.annotationId));
-  }
-  selectPreviousFieldMethod(documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const ordered = this.orderedFieldIndex.get(docId);
-    if (!ordered || ordered.length === 0) return;
-    const currentId = this.getSelectedFieldId(docId);
-    let prevIndex = ordered.length - 1;
-    if (currentId) {
-      const currentIndex = ordered.findIndex((e) => e.annotationId === currentId);
-      prevIndex = currentIndex >= 0 ? (currentIndex - 1 + ordered.length) % ordered.length : ordered.length - 1;
-    }
-    const prev = ordered[prevIndex];
-    this.dispatch(selectField(docId, prev.annotationId));
-  }
-  activateFieldMethod(documentId) {
-    const docId = documentId ?? this.getActiveDocumentId();
-    const selectedId = this.getSelectedFieldId(docId);
-    if (!selectedId) return;
-    const widget = this.resolveWidgetAnnotation(selectedId, docId);
-    if (!widget) return;
-    const field = widget.field;
-    if (field.type === PDF_FORM_FIELD_TYPE.CHECKBOX) {
-      const checked = isWidgetChecked(widget);
-      const newValue = checked ? "Off" : widget.exportValue ?? "Yes";
-      this.setFormFieldValues(widget.pageIndex, widget, { ...field, value: newValue }, docId);
-    } else if (field.type === PDF_FORM_FIELD_TYPE.RADIOBUTTON) {
-      if (!isWidgetChecked(widget) && widget.exportValue) {
-        this.setFormFieldValues(
-          widget.pageIndex,
-          widget,
-          { ...field, value: widget.exportValue },
-          docId
-        );
-      }
-    }
-  }
-  renderWidget(options, documentId) {
-    if (!this.annotation) {
-      return PdfTaskHelper.reject({
-        code: PdfErrorCode.NotFound,
-        message: "annotation plugin not found"
-      });
-    }
-    const id = documentId ?? this.getActiveDocumentId();
-    return this.annotation.forDocument(id).renderAnnotation(options);
-  }
-  async destroy() {
-    this.state$.clear();
-    this.fieldValueChange$.clear();
-    this.formReady$.clear();
-    super.destroy();
-  }
-};
-_FormPlugin.id = "form";
-let FormPlugin = _FormPlugin;
-const FormPluginPackage = {
-  manifest,
-  create: (registry, config) => new FormPlugin(FORM_PLUGIN_ID, registry, config),
-  reducer,
-  initialState
-};
-export {
-  FORM_PLUGIN_ID,
-  FormPlugin,
-  FormPluginPackage,
-  formCheckboxTool,
-  formComboboxTool,
-  formListboxTool,
-  formRadioButtonTool,
-  formTextFieldTool,
-  formTools,
-  initialDocumentState,
-  initialState,
-  manifest
-};
-//# sourceMappingURL=index.js.map
+//#endregion
+export { FORM_TOOLS, FORM_TOOL_BY_ID, FormScriptingController, FormToken, createFormScriptingController, createSerialMutationQueue, fieldKeyOf, formPlugin };
+
+//# sourceMappingURL=index.js.map