@lofcz/embedpdf-plugin-actions 3.0.0-next.11

package/dist/index.js

@@ -0,0 +1,1380 @@
+import { n as eventOf, r as originOf, t as ActionsToken } from "./types-DgBMy5nE.js";
+import { n as createHoverPump, t as submitEntriesToUrlEncoded } from "./contract-DAem-EST.js";
+import { DocumentsToken, createEventHook, createSerialQueue, definePlugin } from "@embedpdf/core";
+import { createScriptHost, javaScriptProgramFromActionTree, resolveScriptIdentity, scriptFieldsFromSnapshot, seedFrom } from "@embedpdf/core-acrojs";
+//#region src/capability.ts
+const ALLOW_ALL = {
+	user: "allow",
+	hover: "allow",
+	lifecycle: "allow"
+};
+const DEFAULT_POLICY = {
+	goto: ALLOW_ALL,
+	named: ALLOW_ALL,
+	hide: ALLOW_ALL,
+	"reset-form": ALLOW_ALL,
+	javascript: ALLOW_ALL,
+	uri: {
+		user: "adapter",
+		hover: "report",
+		lifecycle: "report"
+	},
+	print: {
+		user: "adapter",
+		hover: "block",
+		lifecycle: "block"
+	},
+	"submit-form": {
+		user: "adapter",
+		hover: "block",
+		lifecycle: "block"
+	}
+};
+/** Never executable, not configurable — diagnostics only. */
+const NEVER_TYPES = /* @__PURE__ */ new Set([
+	"launch",
+	"goto-remote",
+	"goto-embedded",
+	"sound",
+	"movie",
+	"import-data"
+]);
+/** Recognized types with no Phase-1 interpreter. */
+const UNSUPPORTED_TYPES = /* @__PURE__ */ new Set([
+	"rendition",
+	"thread",
+	"set-ocg-state",
+	"transition",
+	"goto-3d-view",
+	"unknown"
+]);
+/** Document-lifetime node types: engine mutations, committed in walk order. */
+const DOCUMENT_TYPES = /* @__PURE__ */ new Set(["reset-form", "javascript"]);
+const sameRef = (left, right) => {
+	if (left.kind === "objectNumber" && right.kind === "objectNumber") return left.annotObjectNumber === right.annotObjectNumber;
+	if (left.kind === "nm" && right.kind === "nm") return left.pageObjectNumber === right.pageObjectNumber && left.nm === right.nm;
+	if (left.kind === "index" && right.kind === "index") return left.pageObjectNumber === right.pageObjectNumber && left.index === right.index;
+	return false;
+};
+const isPrintVerb = (node) => node.type === "named" && node.name === "Print";
+function createActionsCapability(ctx, config = {}) {
+	const policy = {
+		...DEFAULT_POLICY,
+		...config.policy
+	};
+	const enqueue = createSerialQueue();
+	const executors = /* @__PURE__ */ new Map();
+	let annotCommitSink = null;
+	let formCommitSink = null;
+	let uiAdapter = null;
+	/** Sink 1 of the submit chain (consent = installation). */
+	let submitHandler = null;
+	/** The form plugin's dataset resolver (D7's one door). */
+	let submitResolver = null;
+	/** D3's document-print latch: while a print event wrapper is active, a
+	*  nested print request is SUPPRESSED (`reentrant-print`) — the adapter
+	*  opens exactly one dialog per outer request. */
+	let docPrintEventActive = false;
+	/** D11's deterministic aggregate: JS nodes run in the CURRENT dispatch. */
+	let jsNodesThisDispatch = 0;
+	const actionHook = createEventHook((error) => globalThis.console?.error("[actions] onAction observer failed:", error));
+	const diagnosticHook = createEventHook((error) => globalThis.console?.error("[actions] onDiagnostic observer failed:", error));
+	const scriptDiagnosticHook = createEventHook((error) => globalThis.console?.error("[actions] onScriptDiagnostic observer failed:", error));
+	const scriptErrorHook = createEventHook((error) => globalThis.console?.error("[actions] onScriptError observer failed:", error));
+	ctx.cleanup(() => {
+		actionHook.dispose();
+		diagnosticHook.dispose();
+		scriptDiagnosticHook.dispose();
+		scriptErrorHook.dispose();
+	});
+	/** Policy lookup — `null` means "recognized, no interpreter" (inert). */
+	const decisionFor = (node, origin) => {
+		if (NEVER_TYPES.has(node.type)) return "never";
+		if (UNSUPPORTED_TYPES.has(node.type)) return "unsupported";
+		if (isPrintVerb(node)) return policy.print[origin];
+		const row = policy[node.type];
+		return row ? row[origin] : "unsupported";
+	};
+	const allowsPrint = () => ctx.tryGet(DocumentsToken)?.allows("doc.print", ctx.documentId ?? void 0) ?? true;
+	let actionsSnapshotPromise = null;
+	const readDocumentActions = () => {
+		if (!actionsSnapshotPromise) {
+			const doc = ctx.doc;
+			const memo = (doc?.actions ? Promise.resolve(doc.actions.read()) : Promise.resolve(null)).catch((error) => {
+				if (actionsSnapshotPromise === memo) actionsSnapshotPromise = null;
+				throw error;
+			});
+			actionsSnapshotPromise = memo;
+		}
+		return actionsSnapshotPromise;
+	};
+	/** The Table-200 key for each verb-shaped document trigger event. */
+	const DOC_EVENT_TREES = {
+		"will-save": "willSave",
+		"did-save": "didSave",
+		"will-print": "willPrint",
+		"did-print": "didPrint",
+		"will-close": "willClose"
+	};
+	const nowMs = () => js?.now?.() ?? Date.now();
+	const intentOfPayload = (payload) => ({
+		url: payload.url,
+		fields: payload.fields,
+		exclude: payload.flags.exclude,
+		includeNoValueFields: payload.flags.includeNoValueFields,
+		format: payload.flags.format,
+		method: payload.flags.method,
+		flagsRaw: payload.flags.raw,
+		...payload.charSet === void 0 ? {} : { charSet: payload.charSet }
+	});
+	const toFormSubmissionRequest = (request) => ({
+		entries: request.entries,
+		intent: {
+			url: request.url,
+			format: request.format,
+			method: request.method,
+			flagsRaw: request.flagsRaw,
+			...request.charSet === void 0 ? {} : { charSet: request.charSet }
+		},
+		origin: request.origin,
+		clientTimeMs: nowMs()
+	});
+	/**
+	* The ONE submit door — both sources land here after policy. Sink order:
+	* embedder handler (explicit beats ambient; detached-promise contract) →
+	* the document's home (`doc.forms.submit`, engine-asserted, AWAITED — a
+	* real op with a real receipt) → blocked with `no-submit-sink`. Never a
+	* network call from this plugin.
+	*/
+	const performSubmit = async (intent, actionCtx, diagnose) => {
+		const decision = policy["submit-form"][actionCtx.origin];
+		if (decision !== "adapter" && decision !== "allow") {
+			diagnose({
+				code: "blocked",
+				message: `submit-form: policy '${decision}' for origin '${actionCtx.origin}'`
+			});
+			return { status: "blocked" };
+		}
+		if (!submitResolver) {
+			diagnose({
+				code: "no-submit-resolver",
+				message: "submit-form: no dataset resolver registered (form plugin missing?)"
+			});
+			return {
+				status: "blocked",
+				detail: "no dataset resolver"
+			};
+		}
+		let request;
+		try {
+			request = await submitResolver(intent, actionCtx, diagnose);
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			diagnose({
+				code: "executor-failed",
+				message: `submit-form: dataset resolution: ${detail}`
+			});
+			return {
+				status: "failed",
+				detail
+			};
+		}
+		const doc = ctx.doc;
+		const homeSubmit = doc && typeof doc.forms.submit === "function" ? () => Promise.resolve(doc.forms.submit(toFormSubmissionRequest(request))) : null;
+		if (submitHandler) try {
+			const outcome = submitHandler(request, { submitToDocumentHome: homeSubmit });
+			if (outcome && typeof outcome.then === "function") outcome.catch((error) => {
+				diagnosticHook.emit({
+					code: "executor-failed",
+					message: `submit handler rejected (detached): ${error instanceof Error ? error.message : String(error)}`
+				});
+			});
+			return { status: "executed" };
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			diagnose({
+				code: "executor-failed",
+				message: `submit handler threw: ${detail}`
+			});
+			return {
+				status: "failed",
+				detail
+			};
+		}
+		if (homeSubmit) try {
+			await homeSubmit();
+			return { status: "executed" };
+		} catch (error) {
+			const detail = error instanceof Error ? error.message : String(error);
+			diagnose({
+				code: "executor-failed",
+				message: `document home refused submit: ${detail}`
+			});
+			return {
+				status: "failed",
+				detail
+			};
+		}
+		diagnose({
+			code: "no-submit-sink",
+			message: "submit-form: no handler installed and the document has no submit-capable home"
+		});
+		return {
+			status: "blocked",
+			detail: "no submit sink"
+		};
+	};
+	const js = config.javascript;
+	const scriptHost = js?.enabled && ctx.doc ? createScriptHost({
+		sandboxFactory: js.sandboxFactory ?? (() => import("@embedpdf/core-js-sandbox").then(({ createQuickJsSandbox }) => createQuickJsSandbox())),
+		document: () => {
+			const meta = ctx.document();
+			return {
+				id: ctx.documentId ?? "document",
+				fileName: js.fileName?.() ?? meta?.name ?? "document.pdf",
+				pageCount: meta?.pageCount ?? 0,
+				pageNumber: 0
+			};
+		},
+		identity: () => ctx.doc ? resolveScriptIdentity(ctx.doc, js.identity) : {
+			name: "",
+			loginName: "",
+			corporation: "",
+			email: ""
+		},
+		environment: (sequence) => {
+			const nowMs = js.now?.() ?? Date.now();
+			return {
+				nowMs,
+				utcOffsetMinutes: js.utcOffsetMinutes?.() ?? -new Date(nowMs).getTimezoneOffset(),
+				randomSeed: js.randomSeed?.() ?? seedFrom(ctx.documentId ?? "document", sequence)
+			};
+		},
+		bootSources: async () => {
+			return ((await readDocumentActions())?.nameTreeScripts ?? []).map(({ action }) => javaScriptProgramFromActionTree(action));
+		},
+		...js.budget ? { budget: js.budget } : {}
+	}) : null;
+	if (scriptHost) ctx.cleanup(() => scriptHost.dispose());
+	const surfaceScriptResult = (result) => {
+		const uiContext = {
+			origin: result.origin,
+			phase: result.phase
+		};
+		for (const effect of result.uiEffects) {
+			if (effect.kind === "submitForm") {
+				performSubmit(intentOfSubmitEffect(effect), {
+					origin: result.origin,
+					source: { kind: "api" },
+					event: { scope: "activate" }
+				}, (diagnostic) => diagnosticHook.emit(diagnostic));
+				continue;
+			}
+			if (effect.kind === "print" && !allowsPrint()) {
+				scriptDiagnosticHook.emit({
+					code: "ui-effect-suppressed",
+					message: "script print request withheld: doc.print is not allowed"
+				});
+				continue;
+			}
+			if (effect.kind === "print" && docPrintEventActive) {
+				scriptDiagnosticHook.emit({
+					code: "ui-effect-suppressed",
+					message: "script print request during a document print event — suppressed (reentrant)"
+				});
+				continue;
+			}
+			if (!uiAdapter) {
+				diagnosticHook.emit({
+					code: "no-adapter",
+					message: `script ${effect.kind}: no UI adapter installed`
+				});
+				continue;
+			}
+			if (effect.kind === "alert") uiAdapter.alert?.(effect.message, {
+				...uiContext,
+				icon: effect.icon,
+				...effect.title !== void 0 ? { title: effect.title } : {}
+			});
+			else if (effect.kind === "gotoPage") uiAdapter.gotoPage?.(effect.page, uiContext);
+			else uiAdapter.print(uiContext);
+		}
+		for (const diagnostic of result.diagnostics) scriptDiagnosticHook.emit(diagnostic);
+		if (result.error) scriptErrorHook.emit(result.error);
+	};
+	/** Script `doc.submitForm(...)` → the one normalized intent. Script field
+	*  names are include-mode by definition (Acrobat's aFields). */
+	const intentOfSubmitEffect = (effect) => {
+		const format = effect.format ?? "fdf";
+		return {
+			url: effect.url,
+			fields: effect.fieldNames?.map((name) => ({
+				kind: "name",
+				name
+			})) ?? null,
+			exclude: false,
+			includeNoValueFields: effect.includeEmpty,
+			format,
+			method: effect.method ?? "post",
+			flagsRaw: 0
+		};
+	};
+	const engineColorToArray = (color) => color ? [
+		"RGB",
+		color.r / 255,
+		color.g / 255,
+		color.b / 255
+	] : ["T"];
+	const pageIndexOf = (pon) => ctx.document()?.pages.findIndex((page) => page.pageObjectNumber === pon) ?? -1;
+	const scriptWorldFor = async (pon) => {
+		const doc = ctx.doc;
+		const snapshot = await doc.forms.list();
+		const pageIndex = Math.max(0, pageIndexOf(pon));
+		const { annotations } = await doc.page(pon).annotations.list();
+		const annots = annotations.filter((a) => a.subtype !== "link" && !a.subtype.startsWith("widget")).map((a) => {
+			const styled = a;
+			return {
+				ref: a.ref,
+				name: a.nm ?? "",
+				subtype: a.subtype,
+				page: pageIndex,
+				rect: [
+					a.rect.left,
+					a.rect.bottom,
+					a.rect.right,
+					a.rect.top
+				],
+				contents: a.contents ?? "",
+				author: a.author ?? "",
+				subject: a.subject ?? "",
+				strokeColor: engineColorToArray(styled.color),
+				fillColor: engineColorToArray(styled.interiorColor),
+				opacity: styled.opacity ?? 1,
+				width: styled.strokeWidth ?? 1,
+				borderStyle: styled.borderStyle === "dashed" ? "D" : "S",
+				dash: styled.dashArray ?? [],
+				hidden: a.flags.hidden,
+				print: a.flags.print,
+				readOnly: a.flags.readOnly,
+				locked: a.flags.locked,
+				noView: a.flags.noView,
+				toggleNoView: a.flags.toggleNoView,
+				opaqueBody: a.subtype === "stamp"
+			};
+		});
+		return {
+			snapshot,
+			world: {
+				fields: scriptFieldsFromSnapshot(snapshot),
+				annots,
+				annotPages: [pageIndex],
+				annotsCoverDocument: (ctx.document()?.pageCount ?? 0) <= 1
+			}
+		};
+	};
+	const ANNOTATION_EVENT_NAMES = {
+		cursorEnter: "Mouse Enter",
+		cursorExit: "Mouse Exit",
+		mouseDown: "Mouse Down",
+		mouseUp: "Mouse Up",
+		focus: "Focus",
+		blur: "Blur"
+	};
+	const PAGE_EVENT_NAMES = {
+		open: "Open",
+		close: "Close",
+		visible: "Visible",
+		invisible: "Invisible"
+	};
+	const DOC_EVENT_NAMES = {
+		open: "Open",
+		"will-save": "WillSave",
+		"did-save": "DidSave",
+		"will-print": "WillPrint",
+		"did-print": "DidPrint",
+		"will-close": "WillClose"
+	};
+	const scriptEventFor = (actionCtx, snapshot) => {
+		const provenance = actionCtx.event;
+		const type = provenance.scope === "page" ? "Page" : provenance.scope === "document" ? "Doc" : actionCtx.source.kind === "widget" ? "Field" : actionCtx.source.kind === "link" ? "Link" : "Annot";
+		const name = provenance.scope === "activate" ? "Mouse Up" : provenance.scope === "annotation" ? ANNOTATION_EVENT_NAMES[provenance.name] ?? "Mouse Up" : provenance.scope === "page" ? PAGE_EVENT_NAMES[provenance.name] ?? "Open" : DOC_EVENT_NAMES[provenance.name] ?? "Open";
+		const targetRef = actionCtx.source.kind === "widget" ? actionCtx.source.field : void 0;
+		const targetField = targetRef ? snapshot.fields.find((field) => targetRef.kind === "objectNumber" && field.ref.kind === "objectNumber" ? field.ref.fieldObjectNumber === targetRef.fieldObjectNumber : targetRef.kind === "fqn" && field.name === targetRef.name) : void 0;
+		return {
+			kind: "widget-activate",
+			type,
+			name,
+			...targetRef ? {
+				target: targetRef,
+				source: targetRef
+			} : {},
+			...targetField && targetField.valueEntry.kind === "scalar" ? { value: targetField.valueEntry.value } : {}
+		};
+	};
+	/** Commit one run's document effects through the owner sinks in the
+	*  DECLARED order (form first, then annot); the first failure skips the
+	*  rest across BOTH streams. Returns the failure summary, if any. */
+	const commitScriptOutput = async (output, diagnose) => {
+		let failure = null;
+		if (output.formEffects.length > 0) if (!formCommitSink) diagnose({
+			code: "no-commit-sink",
+			message: `script form effects dropped: no form commit sink registered (${output.formEffects.length})`
+		});
+		else {
+			const bad = (await formCommitSink(output.formEffects)).results.find((entry) => entry.status === "failed" || entry.status === "rejected");
+			if (bad) failure = `form effect ${bad.index}: ${bad.error?.message ?? bad.status}`;
+		}
+		if (output.annotEffects.length > 0) if (failure) diagnose({
+			code: "executor-failed",
+			message: `script annot effects skipped after form failure (${output.annotEffects.length})`
+		});
+		else if (!annotCommitSink) diagnose({
+			code: "no-commit-sink",
+			message: `script annot effects dropped: no annotation commit sink registered (${output.annotEffects.length})`
+		});
+		else {
+			const entries = output.annotEffects.map((effect) => ({
+				annotObjectNumber: effect.ref.kind === "objectNumber" ? effect.ref.annotObjectNumber : -1,
+				...effect.ref.kind === "objectNumber" ? { pageObjectNumber: effect.ref.pageObjectNumber } : {},
+				patch: effect.patch
+			}));
+			const bad = (await annotCommitSink(entries)).results.find((entry) => entry.status === "failed");
+			if (bad) failure = `annotation ${bad.annotObjectNumber}: ${bad.error ?? "failed"}`;
+		}
+		if (failure) diagnose({
+			code: "executor-failed",
+			message: `script commit: ${failure}`
+		});
+		return failure;
+	};
+	if (scriptHost) {
+		const nodeCap = js?.maxScriptNodesPerDispatch ?? 16;
+		executors.set("javascript", async (node, actionCtx) => {
+			if (node.type !== "javascript") return {
+				status: "inert",
+				reason: "not a JS node"
+			};
+			if (!ctx.doc) return {
+				status: "inert",
+				reason: "no document"
+			};
+			if (jsNodesThisDispatch >= nodeCap) return {
+				status: "inert",
+				reason: `dispatch script budget exhausted (${nodeCap} JS nodes)`
+			};
+			jsNodesThisDispatch += 1;
+			const source = actionCtx.source;
+			const pon = source.kind === "widget" ? source.pon : source.kind === "link" || source.kind === "annotation" ? source.pon ?? ctx.document()?.pages[0]?.pageObjectNumber : source.kind === "page" ? source.pon : ctx.document()?.pages[0]?.pageObjectNumber;
+			if (pon === void 0) return {
+				status: "inert",
+				reason: "no page to anchor the world on"
+			};
+			const diagnose = (diagnostic) => diagnosticHook.emit(diagnostic);
+			const pendingExternal = [];
+			const splitExternal = (output, phase) => output.uiEffects.filter((effect) => {
+				if (effect.kind === "print" || effect.kind === "submitForm") {
+					pendingExternal.push({
+						effect,
+						phase
+					});
+					return false;
+				}
+				return true;
+			});
+			const outcome = await scriptHost.transaction(async (txn) => {
+				let built = await scriptWorldFor(pon);
+				const boot = await txn.boot({
+					...built.world,
+					event: {
+						kind: "name-tree-boot",
+						type: "Doc",
+						name: "Open"
+					}
+				});
+				if (boot) {
+					await commitScriptOutput(boot, diagnose);
+					surfaceScriptResult({
+						uiEffects: splitExternal(boot, "boot"),
+						diagnostics: boot.diagnostics,
+						...boot.error ? { error: boot.error } : {},
+						origin: actionCtx.origin,
+						phase: "boot"
+					});
+					if (boot.formEffects.length || boot.annotEffects.length) built = await scriptWorldFor(pon);
+				}
+				const output = await txn.run(node.script, {
+					...built.world,
+					event: scriptEventFor(actionCtx, built.snapshot)
+				});
+				surfaceScriptResult({
+					uiEffects: splitExternal(output, "user"),
+					diagnostics: output.diagnostics,
+					...output.error ? { error: output.error } : {},
+					origin: actionCtx.origin,
+					phase: "user"
+				});
+				if (output.error) return {
+					status: "failed",
+					error: output.error.message
+				};
+				const failure = await commitScriptOutput(output, diagnose);
+				return failure ? {
+					status: "failed",
+					error: failure
+				} : { status: "executed" };
+			});
+			for (const entry of pendingExternal) if (entry.effect.kind === "print") await firePrintThroughAdapter({
+				origin: actionCtx.origin,
+				phase: entry.phase
+			}, diagnose);
+			else await performSubmit(intentOfSubmitEffect(entry.effect), actionCtx, diagnose);
+			return outcome;
+		});
+	}
+	async function run(tree, actionCtx) {
+		const diagnostics = [];
+		const diagnose = (diagnostic) => {
+			diagnostics.push(diagnostic);
+			diagnosticHook.emit(diagnostic);
+		};
+		if (tree.incomplete) {
+			diagnose({
+				code: "incomplete-tree",
+				message: "refused: the action tree is incomplete"
+			});
+			return {
+				status: "refused",
+				nodes: [],
+				diagnostics
+			};
+		}
+		if (!tree.root) return {
+			status: "inert",
+			nodes: [],
+			diagnostics
+		};
+		const nodes = [];
+		const deferred = [];
+		let documentFailed = false;
+		const settle = (result, outcome) => {
+			if (outcome.status === "executed") result.status = "executed";
+			else if (outcome.status === "inert") {
+				result.status = "inert";
+				result.detail = outcome.reason;
+				diagnose({
+					code: "executor-inert",
+					message: `${result.type}: ${outcome.reason}`
+				});
+			} else {
+				result.status = "failed";
+				result.detail = outcome.error;
+				diagnose({
+					code: "executor-failed",
+					message: `${result.type}: ${outcome.error}`
+				});
+			}
+		};
+		const interpretHide = async (node) => {
+			const doc = ctx.doc;
+			const display = node.hide ? "hidden" : "visible";
+			const fieldRefs = [];
+			const annotEntries = [];
+			const names = [];
+			const bareObjectNumbers = [];
+			for (const target of node.targets) if (target.kind === "objectNumber") bareObjectNumbers.push(target.objectNumber);
+			else names.push(target.name);
+			if ((names.length || bareObjectNumbers.length) && doc) {
+				const snapshot = names.length || bareObjectNumbers.length ? await doc.forms.list() : null;
+				for (const name of names) {
+					const field = snapshot?.fields.find((candidate) => candidate.name === name);
+					if (!field) {
+						diagnose({
+							code: "unresolved-target",
+							message: `hide: no field named '${name}'`
+						});
+						continue;
+					}
+					fieldRefs.push({
+						kind: "objectNumber",
+						fieldObjectNumber: field.fieldObjectNumber
+					});
+				}
+				for (const objectNumber of bareObjectNumbers) {
+					const owner = snapshot?.fields.find((field) => field.widgets.some((widget) => widget.annotObjectNumber === objectNumber));
+					if (owner) fieldRefs.push({
+						kind: "objectNumber",
+						fieldObjectNumber: owner.fieldObjectNumber
+					});
+					else annotEntries.push({
+						annotObjectNumber: objectNumber,
+						patch: { flags: { hidden: node.hide } }
+					});
+				}
+			}
+			let failedDetail;
+			if (fieldRefs.length) {
+				if (!formCommitSink) {
+					diagnose({
+						code: "no-commit-sink",
+						message: "hide: no form commit sink registered (form plugin absent)"
+					});
+					return { status: "no-executor" };
+				}
+				const bad = (await formCommitSink(fieldRefs.map((ref) => ({
+					kind: "setDisplay",
+					ref,
+					display
+				})))).results.find((entry) => entry.status === "failed" || entry.status === "rejected");
+				if (bad) {
+					failedDetail = bad.error?.message ?? bad.status;
+					diagnose({
+						code: "executor-failed",
+						message: `hide: ${failedDetail}`
+					});
+				}
+			}
+			if (annotEntries.length && !failedDetail) {
+				if (!annotCommitSink) {
+					diagnose({
+						code: "no-commit-sink",
+						message: "hide: no annotation commit sink registered (annotation plugin absent)"
+					});
+					return { status: "no-executor" };
+				}
+				const committed = await annotCommitSink(annotEntries);
+				const failed = committed.results.filter((entry) => entry.status === "failed");
+				for (const failure of failed) diagnose({
+					code: "executor-failed",
+					message: `hide: annotation ${failure.annotObjectNumber}: ${failure.error ?? "failed"}`
+				});
+				if (failed.length === committed.results.length && failed.length > 0) failedDetail = failed[0]?.error;
+			}
+			if (failedDetail) return {
+				status: "failed",
+				detail: failedDetail
+			};
+			return { status: "executed" };
+		};
+		const interpret = async (node, path) => {
+			const result = {
+				path,
+				type: node.type,
+				status: "blocked"
+			};
+			nodes.push(result);
+			const decision = decisionFor(node, actionCtx.origin);
+			if (decision === "never" || decision === "block" || decision === "report") {
+				result.status = "blocked";
+				diagnose({
+					code: "blocked",
+					message: `${node.type}: ${decision === "never" ? "never executable" : `policy '${decision}' for origin '${actionCtx.origin}'`}`
+				});
+				return;
+			}
+			if (decision === "unsupported") {
+				result.status = "no-executor";
+				return;
+			}
+			if (node.type === "hide") {
+				if (documentFailed) {
+					result.status = "skipped";
+					return;
+				}
+				const outcome = await interpretHide(node);
+				result.status = outcome.status;
+				if (outcome.detail) result.detail = outcome.detail;
+				if (outcome.status === "failed") documentFailed = true;
+				return;
+			}
+			if (DOCUMENT_TYPES.has(node.type)) {
+				if (documentFailed) {
+					result.status = "skipped";
+					return;
+				}
+				const executor = executors.get(node.type);
+				if (!executor) {
+					result.status = node.type === "javascript" ? "inert" : "no-executor";
+					diagnose({
+						code: "no-executor",
+						message: `${node.type}: no executor registered${node.type === "javascript" ? " (scripting unavailable)" : ""}`
+					});
+					return;
+				}
+				try {
+					settle(result, await executor(node, actionCtx));
+				} catch (error) {
+					settle(result, {
+						status: "failed",
+						error: error instanceof Error ? error.message : String(error)
+					});
+				}
+				if (result.status === "failed") documentFailed = true;
+				return;
+			}
+			if (node.type === "submit-form") {
+				if (!node.payload) {
+					result.status = "inert";
+					result.detail = "submit payload unavailable (older runtime extraction)";
+					diagnose({
+						code: "submit-payload-unavailable",
+						message: "submit-form: payload unavailable (older runtime extraction) — node inert"
+					});
+					return;
+				}
+				const payload = node.payload;
+				result.status = "skipped";
+				deferred.push({
+					result,
+					fire: async () => {
+						const outcome = await performSubmit(intentOfPayload(payload), actionCtx, diagnose);
+						result.status = outcome.status;
+						if (outcome.detail) result.detail = outcome.detail;
+					}
+				});
+				return;
+			}
+			if (isPrintVerb(node) || node.type === "uri") {
+				result.status = "skipped";
+				deferred.push({
+					result,
+					fire: async () => {
+						if (node.type === "uri") {
+							if (!uiAdapter) {
+								result.status = "no-executor";
+								diagnose({
+									code: "no-adapter",
+									message: `${node.type}: no UI adapter installed`
+								});
+								return;
+							}
+							uiAdapter.openUri(node.uri, {
+								isMap: node.isMap,
+								origin: actionCtx.origin
+							});
+							result.status = "executed";
+							return;
+						}
+						const outcome = await firePrintThroughAdapter(void 0, diagnose);
+						result.status = outcome.status;
+						if (outcome.detail) result.detail = outcome.detail;
+					}
+				});
+				return;
+			}
+			result.status = "skipped";
+			deferred.push({
+				result,
+				fire: async () => {
+					const executor = executors.get(node.type);
+					if (!executor) {
+						result.status = "no-executor";
+						diagnose({
+							code: "no-executor",
+							message: `${node.type}: no executor registered`
+						});
+						return;
+					}
+					try {
+						settle(result, await executor(node, actionCtx));
+					} catch (error) {
+						settle(result, {
+							status: "failed",
+							error: error instanceof Error ? error.message : String(error)
+						});
+					}
+				}
+			});
+		};
+		const walk = async (node, path) => {
+			await interpret(node, path);
+			for (let index = 0; index < node.next.length; index++) await walk(node.next[index], [...path, index]);
+		};
+		await walk(tree.root, []);
+		if (!documentFailed) for (const entry of deferred) await entry.fire();
+		const anyExecuted = nodes.some((node) => node.status === "executed");
+		const anyFailedOrSkipped = nodes.some((node) => node.status === "failed" || node.status === "skipped");
+		return {
+			status: anyExecuted ? anyFailedOrSkipped ? "partial" : "executed" : anyFailedOrSkipped ? "partial" : "inert",
+			nodes,
+			diagnostics
+		};
+	}
+	/** run + seq + event — the shared per-tree unit (queued by execute; called
+	*  inline per step by the queued trigger resolver). */
+	const runAndEmit = async (tree, actionCtx) => {
+		const result = await run(tree, actionCtx);
+		ctx.dispatch({ type: "ACTIONS_DISPATCHED" });
+		actionHook.emit({
+			ctx: actionCtx,
+			tree,
+			result
+		});
+		return result;
+	};
+	const execute = (tree, actionCtx) => {
+		if (actionCtx.origin === "user") noteUserActivity();
+		return enqueue(() => {
+			jsNodesThisDispatch = 0;
+			return runAndEmit(tree, actionCtx);
+		});
+	};
+	const canExecute = (tree, actionCtx) => {
+		if (tree.incomplete || !tree.root) return false;
+		const decision = decisionFor(tree.root, actionCtx.origin);
+		return decision === "allow" || decision === "adapter";
+	};
+	const triggerEnabled = (trigger) => {
+		switch (trigger.scope) {
+			case "activate": return true;
+			case "annotation": return config.triggers?.annotation !== false;
+			case "page": return config.triggers?.page !== false;
+			case "document": return config.triggers?.document !== false;
+		}
+	};
+	const lifecycleCache = /* @__PURE__ */ new Map();
+	const lifecycleTreesFor = async (pon) => {
+		const hit = lifecycleCache.get(pon);
+		if (hit) return hit;
+		const doc = ctx.doc;
+		if (!doc) return [];
+		const { annotations } = await doc.page(pon).annotations.list();
+		const bearing = annotations.filter((a) => a.actions && (a.actions.pageOpen?.root || a.actions.pageClose?.root || a.actions.pageVisible?.root || a.actions.pageInvisible?.root)).map((a) => ({
+			ref: a.ref,
+			actions: a.actions
+		}));
+		lifecycleCache.set(pon, bearing);
+		return bearing;
+	};
+	{
+		const unsubscribe = ctx.doc?.events?.subscribe((event) => {
+			if (event.type.startsWith("annotation.") || event.type === "stream.desynced") lifecycleCache.clear();
+		});
+		if (unsubscribe) ctx.cleanup(unsubscribe);
+	}
+	/**
+	* ISO order, verified against 32000-2 Table 197 (2026-09-02): PO "shall be
+	* executed after the O action … and the OpenAction entry"; PC "shall be
+	* executed before the C action". Rootless trees are skipped (a
+	* budget-degraded tree with no root has nothing to walk).
+	*/
+	const planPageSteps = (event, pon, pageActions, lifecycle) => {
+		const pageSource = {
+			kind: "page",
+			pon
+		};
+		const annotSteps = (key) => lifecycle.filter((a) => a.actions[key]?.root).map((a) => ({
+			source: {
+				kind: "annotation",
+				annotation: a.ref,
+				pon
+			},
+			tree: a.actions[key]
+		}));
+		switch (event) {
+			case "open": return [...pageActions?.open?.root ? [{
+				source: pageSource,
+				tree: pageActions.open
+			}] : [], ...annotSteps("pageOpen")];
+			case "close": return [...annotSteps("pageClose"), ...pageActions?.close?.root ? [{
+				source: pageSource,
+				tree: pageActions.close
+			}] : []];
+			case "visible": return annotSteps("pageVisible");
+			case "invisible": return annotSteps("pageInvisible");
+		}
+	};
+	/** Aggregate step statuses. A step failure never skips its siblings; this
+	*  only FOLDS what each step reported. */
+	const foldSteps = (steps, diagnostics) => {
+		const statuses = steps.map((s) => s.result.status);
+		return {
+			status: steps.length === 0 ? "inert" : statuses.every((s) => s === "refused") ? "refused" : statuses.every((s) => s === "inert") ? "inert" : statuses.every((s) => s === "executed") ? "executed" : "partial",
+			steps,
+			diagnostics
+		};
+	};
+	const runSteps = async (steps, origin, event, diagnostics) => {
+		const results = [];
+		for (const step of steps) {
+			const result = await runAndEmit(step.tree, {
+				origin,
+				source: step.source,
+				event
+			});
+			results.push({
+				source: step.source,
+				tree: step.tree,
+				result
+			});
+		}
+		return foldSteps(results, diagnostics);
+	};
+	/** Everything a trigger needs — reads included — INSIDE the queued op:
+	*  submission order is execution order. Never throws. */
+	const resolveAndRun = async (trigger) => {
+		const diagnostics = [];
+		const diagnose = (diagnostic) => {
+			diagnostics.push(diagnostic);
+			diagnosticHook.emit(diagnostic);
+		};
+		try {
+			const doc = ctx.doc;
+			if (!doc) return {
+				status: "inert",
+				steps: [],
+				diagnostics
+			};
+			if (!triggerEnabled(trigger)) {
+				diagnose({
+					code: "trigger-disabled",
+					message: `${trigger.scope}: trigger family disabled by config`
+				});
+				return {
+					status: "inert",
+					steps: [],
+					diagnostics
+				};
+			}
+			const origin = originOf(trigger);
+			switch (trigger.scope) {
+				case "activate":
+				case "annotation": {
+					const event = trigger.scope === "activate" ? "activate" : trigger.event;
+					const { annotations } = await doc.page(trigger.pon).annotations.list();
+					const annotation = annotations.find((candidate) => sameRef(candidate.ref, trigger.ref));
+					if (event === "mouseUp" && annotation?.actions?.activate) return {
+						status: "inert",
+						steps: [],
+						diagnostics
+					};
+					const tree = annotation?.actions?.[event];
+					if (!tree?.root && !tree?.incomplete) return {
+						status: "inert",
+						steps: [],
+						diagnostics
+					};
+					const source = trigger.source ?? {
+						kind: "annotation",
+						annotation: trigger.ref,
+						pon: trigger.pon
+					};
+					return await runSteps([{
+						source,
+						tree
+					}], origin, eventOf(trigger), diagnostics);
+				}
+				case "page": {
+					const layout = ctx.document()?.pages.find((page) => page.pageObjectNumber === trigger.pon);
+					const lifecycle = await lifecycleTreesFor(trigger.pon);
+					const steps = planPageSteps(trigger.event, trigger.pon, layout?.actions, lifecycle);
+					return await runSteps(steps, origin, eventOf(trigger), diagnostics);
+				}
+				case "document":
+					if (trigger.event !== "open") return await runDocumentEventOp(trigger.event, diagnostics, diagnose);
+					if (openFired) {
+						diagnose({
+							code: "open-sequence-replayed",
+							message: "document open sequence already fired for this document"
+						});
+						return {
+							status: "inert",
+							steps: [],
+							diagnostics
+						};
+					}
+					openFired = true;
+					return await runOpenSequenceOp();
+			}
+		} catch (error) {
+			diagnose({
+				code: "trigger-failed",
+				message: `trigger resolution failed: ${error instanceof Error ? error.message : String(error)}`
+			});
+			return {
+				status: "refused",
+				steps: [],
+				diagnostics
+			};
+		}
+	};
+	const dispatch = (trigger) => {
+		if (originOf(trigger) === "user") noteUserActivity();
+		return enqueue(() => {
+			jsNodesThisDispatch = 0;
+			return resolveAndRun(trigger);
+		});
+	};
+	const CASCADE_CAP = 8;
+	let barrierOpen = false;
+	let bufferedReport = null;
+	let lastEmitted = {
+		currentPon: null,
+		visible: /* @__PURE__ */ new Set()
+	};
+	let cascadeRounds = 0;
+	let openFired = false;
+	let sawUserActivity = false;
+	const emitForReport = (report) => {
+		if (report.cause === "user") cascadeRounds = 0;
+		const nextVisible = new Set(report.visiblePons);
+		const changedCurrent = report.currentPon !== lastEmitted.currentPon;
+		const leaving = [...lastEmitted.visible].filter((pon) => !nextVisible.has(pon));
+		const entering = [...nextVisible].filter((pon) => !lastEmitted.visible.has(pon));
+		if (!changedCurrent && leaving.length === 0 && entering.length === 0) return;
+		const previousCurrent = lastEmitted.currentPon;
+		lastEmitted = {
+			currentPon: report.currentPon,
+			visible: nextVisible
+		};
+		if (report.cause === "programmatic") {
+			cascadeRounds += 1;
+			if (cascadeRounds > CASCADE_CAP) {
+				diagnosticHook.emit({
+					code: "cascade-budget",
+					message: `page-lifecycle emission suppressed: ${cascadeRounds} consecutive programmatic rounds (cap ${CASCADE_CAP})`
+				});
+				return;
+			}
+		}
+		if (changedCurrent && previousCurrent !== null) dispatch({
+			scope: "page",
+			event: "close",
+			pon: previousCurrent
+		});
+		for (const pon of leaving) dispatch({
+			scope: "page",
+			event: "invisible",
+			pon
+		});
+		for (const pon of entering) dispatch({
+			scope: "page",
+			event: "visible",
+			pon
+		});
+		if (changedCurrent && report.currentPon !== null) dispatch({
+			scope: "page",
+			event: "open",
+			pon: report.currentPon
+		});
+	};
+	const reportPageState = (report) => {
+		if (!report.placed) return;
+		if (report.cause === "user") cascadeRounds = 0;
+		if (!barrierOpen) {
+			bufferedReport = report;
+			return;
+		}
+		emitForReport(report);
+	};
+	const releaseBarrier = (fireFallback) => {
+		barrierOpen = true;
+		const report = bufferedReport;
+		bufferedReport = null;
+		try {
+			if (report) emitForReport(report);
+			else if (fireFallback && config.openSequence === "headless") {
+				const first = ctx.document()?.pages[0]?.pageObjectNumber;
+				if (first !== void 0) {
+					lastEmitted = {
+						currentPon: first,
+						visible: lastEmitted.visible
+					};
+					dispatch({
+						scope: "page",
+						event: "open",
+						pon: first
+					});
+				}
+			}
+		} catch (error) {
+			diagnosticHook.emit({
+				code: "trigger-failed",
+				message: `barrier release failed: ${error instanceof Error ? error.message : String(error)}`
+			});
+		}
+	};
+	/** The §3.9 sequence body — runs INSIDE the queue (via dispatch or the
+	*  latch's own enqueue; callers guarantee openFired was set). */
+	const runOpenSequenceOp = async () => {
+		const diagnostics = [];
+		const steps = [];
+		const lifecycleCtx = {
+			origin: "lifecycle",
+			source: { kind: "document" },
+			event: {
+				scope: "document",
+				name: "open"
+			}
+		};
+		try {
+			const snapshot = await readDocumentActions();
+			if (snapshot?.openDestination) {
+				const tree = {
+					root: {
+						type: "goto",
+						subtype: "GoTo",
+						destination: snapshot.openDestination,
+						next: []
+					},
+					incomplete: false,
+					warningFlags: 0,
+					warnings: []
+				};
+				steps.push({
+					source: { kind: "document" },
+					tree,
+					result: await runAndEmit(tree, lifecycleCtx)
+				});
+			}
+			if (snapshot?.openAction?.root || snapshot?.openAction?.incomplete) steps.push({
+				source: { kind: "document" },
+				tree: snapshot.openAction,
+				result: await runAndEmit(snapshot.openAction, lifecycleCtx)
+			});
+		} catch (error) {
+			const diagnostic = {
+				code: "trigger-failed",
+				message: `open sequence failed: ${error instanceof Error ? error.message : String(error)}`
+			};
+			diagnostics.push(diagnostic);
+			diagnosticHook.emit(diagnostic);
+		} finally {
+			releaseBarrier(true);
+		}
+		return foldSteps(steps, diagnostics);
+	};
+	/**
+	* D1's open-ordering law: catalog `OpenAction` may never run AFTER a
+	* WillSave/WillPrint/WillClose script. Before the first verb-shaped
+	* document event, an armed-but-unfired open sequence runs inline (we are
+	* already inside the queue; `runOpenSequenceOp` never enqueues). It does
+	* NOT wait for the initial page `/O` — the guarantee is catalog-level.
+	*/
+	const ensureOpenSequenceBeforeDocEvent = async () => {
+		if (openFired || config.openSequence === "off") return;
+		openFired = true;
+		await runOpenSequenceOp();
+	};
+	/**
+	* Run ONE catalog lifecycle tree inside the current queue operation —
+	* shared by the dispatch path, `runDocumentVerb`, and the print wrapper.
+	* Never throws: a read/resolution failure degrades to a diagnostic (a
+	* broken script must not cancel the user's save/print — D2).
+	*/
+	const runDocEventTreeSafe = async (event, diagnose) => {
+		if (config.triggers?.document === false) return null;
+		try {
+			await ensureOpenSequenceBeforeDocEvent();
+			const tree = (await readDocumentActions())?.[DOC_EVENT_TREES[event]];
+			if (!tree?.root && !tree?.incomplete) return null;
+			return {
+				source: { kind: "document" },
+				tree,
+				result: await runAndEmit(tree, {
+					origin: "lifecycle",
+					source: { kind: "document" },
+					event: {
+						scope: "document",
+						name: event
+					}
+				})
+			};
+		} catch (error) {
+			diagnose({
+				code: "trigger-failed",
+				message: `${event}: ${error instanceof Error ? error.message : String(error)}`
+			});
+			return null;
+		}
+	};
+	/** The dispatch-path body for a verb-shaped document event. */
+	const runDocumentEventOp = async (event, diagnostics, diagnose) => {
+		const step = await runDocEventTreeSafe(event, diagnose);
+		return foldSteps(step ? [step] : [], diagnostics);
+	};
+	/**
+	* D3: BOTH adapter print invocations (the Named Print verb; script
+	* `doc.print()` effects from the actions plane) go through here — WP →
+	* `uiAdapter.print` exactly once → DP, latch reset in `finally`. While
+	* the latch is held (including `runDocumentVerb('print')`'s body) a
+	* nested request is suppressed with `reentrant-print`. An adapter throw
+	* skips DP (the latch still resets) — named deviation: DP otherwise
+	* fires when the adapter call RETURNS, since a browser cannot observe
+	* dialog completion.
+	*/
+	const firePrintThroughAdapter = async (uiContext, diagnose) => {
+		if (docPrintEventActive) {
+			diagnose({
+				code: "reentrant-print",
+				message: "print request during a document print event — suppressed (one dialog per request)"
+			});
+			return {
+				status: "blocked",
+				detail: "reentrant print suppressed"
+			};
+		}
+		if (!allowsPrint()) {
+			diagnose({
+				code: "blocked",
+				message: "print: doc.print is not allowed"
+			});
+			return {
+				status: "blocked",
+				detail: "doc.print is not allowed"
+			};
+		}
+		if (!uiAdapter) {
+			diagnose({
+				code: "no-adapter",
+				message: "print: no UI adapter installed"
+			});
+			return {
+				status: "no-executor",
+				detail: "no UI adapter installed"
+			};
+		}
+		docPrintEventActive = true;
+		try {
+			await runDocEventTreeSafe("will-print", diagnose);
+			const adapter = uiAdapter;
+			if (!adapter) return {
+				status: "no-executor",
+				detail: "UI adapter uninstalled mid-print"
+			};
+			if (uiContext) adapter.print(uiContext);
+			else adapter.print();
+			await runDocEventTreeSafe("did-print", diagnose);
+			return { status: "executed" };
+		} finally {
+			docPrintEventActive = false;
+		}
+	};
+	const maybeFireOpenSequence = () => {
+		if (openFired) return;
+		if (config.openSequence === "off") {
+			openFired = true;
+			releaseBarrier(false);
+			return;
+		}
+		if (!uiAdapter && config.openSequence !== "headless" && !sawUserActivity) return;
+		openFired = true;
+		enqueue(() => runOpenSequenceOp());
+	};
+	const noteUserActivity = () => {
+		cascadeRounds = 0;
+		if (!sawUserActivity) {
+			sawUserActivity = true;
+			maybeFireOpenSequence();
+		}
+	};
+	maybeFireOpenSequence();
+	return {
+		execute,
+		canExecute,
+		dispatch,
+		canDispatch: (trigger) => triggerEnabled(trigger) && ctx.doc !== null,
+		setUiAdapter: (adapter) => {
+			uiAdapter = adapter;
+			if (adapter) maybeFireOpenSequence();
+			return () => {
+				if (uiAdapter === adapter) uiAdapter = null;
+			};
+		},
+		runDocumentVerb: (verb, operation) => enqueue(async () => {
+			jsNodesThisDispatch = 0;
+			const diagnose = (diagnostic) => diagnosticHook.emit(diagnostic);
+			const before = verb === "save" ? "will-save" : "will-print";
+			const after = verb === "save" ? "did-save" : "did-print";
+			const body = async () => {
+				await runDocEventTreeSafe(before, diagnose);
+				const value = await operation();
+				await runDocEventTreeSafe(after, diagnose);
+				return value;
+			};
+			if (verb !== "print") return body();
+			docPrintEventActive = true;
+			try {
+				return await body();
+			} finally {
+				docPrintEventActive = false;
+			}
+		}),
+		prepareClose: () => dispatch({
+			scope: "document",
+			event: "will-close"
+		}),
+		setSubmitHandler: (handler) => {
+			submitHandler = handler;
+			return () => {
+				if (submitHandler === handler) submitHandler = null;
+			};
+		},
+		onAction: actionHook.on,
+		onDiagnostic: diagnosticHook.on,
+		onScriptDiagnostic: scriptDiagnosticHook.on,
+		onScriptError: scriptErrorHook.on,
+		registerExecutor: (type, executor) => {
+			if (executors.has(type)) diagnosticHook.emit({
+				code: "duplicate-executor",
+				message: `executor for '${type}' replaced (last-wins)`
+			});
+			executors.set(type, executor);
+			return () => {
+				if (executors.get(type) === executor) executors.delete(type);
+			};
+		},
+		registerAnnotCommitSink: (sink) => {
+			annotCommitSink = sink;
+			return () => {
+				if (annotCommitSink === sink) annotCommitSink = null;
+			};
+		},
+		registerFormCommitSink: (sink) => {
+			formCommitSink = sink;
+			return () => {
+				if (formCommitSink === sink) formCommitSink = null;
+			};
+		},
+		...scriptHost ? { scriptTransaction: (body) => scriptHost.transaction(body) } : {},
+		surfaceScriptResult,
+		reportPageState,
+		registerSubmitResolver: (resolver) => {
+			submitResolver = resolver;
+			return () => {
+				if (submitResolver === resolver) submitResolver = null;
+			};
+		}
+	};
+}
+//#endregion
+//#region src/reducer.ts
+const initialActionsState = () => ({ seq: 0 });
+function actionsReducer(state, action) {
+	switch (action.type) {
+		case "ACTIONS_DISPATCHED": return { seq: state.seq + 1 };
+		default: return state;
+	}
+}
+//#endregion
+//#region src/actions.plugin.ts
+/**
+* The action engine: the DEPENDENCY ROOT of the action architecture. It
+* interprets extracted /A and /AA trees; it never detects triggers and never
+* imports another plugin's token — stage, annotation, link, and form
+* optionally depend on ActionsToken and register their executors and sinks
+* at init (the kernel's topological order guarantees this plugin initializes
+* first). JavaScript is one registered interpreter among many: Hide,
+* ResetForm, GoTo, and Named work with scripting off.
+*/
+const actionsPlugin = (config) => definePlugin({
+	id: "actions",
+	token: ActionsToken,
+	scope: "document",
+	initialState: initialActionsState,
+	reduce: actionsReducer,
+	capability: (ctx) => createActionsCapability(ctx, config)
+});
+//#endregion
+export { ActionsToken, actionsPlugin, createHoverPump, originOf, submitEntriesToUrlEncoded };
+
+//# sourceMappingURL=index.js.map