@embedpdf/plugin-form 3.0.0-next.10 → 3.0.0-next.11

package/dist/scripting.d.cts

@@ -0,0 +1,60 @@
+import { r as FormCommitResult, s as FormScriptingOptions } from "./types-Blr4QQM5.cjs";
+import { DocumentMeta } from "@embedpdf/core";
+import { DocumentHandle, FormFieldRef, FormFieldValue, PdfActionTree } from "@embedpdf/engine-core/runtime";
+import { ScriptBudget, ScriptTransaction } from "@embedpdf/core-acrojs";
+//#region src/scripting.d.ts
+type FormScriptingControllerOptions = {
+  doc: DocumentHandle;
+  document(): DocumentMeta | null;
+} & ({
+  /** The shared realm's transaction port ({@link ScriptTransaction}) —
+   *  the actions plugin's per-document host. The K/V/C/F pipeline runs
+   *  WHOLLY inside one transaction: snapshot fetch, every pass, and the
+   *  engine commit — the commit-inside-the-boundary law. */
+  transaction<T>(body: (txn: ScriptTransaction) => Promise<T>): Promise<T>;
+  budget?: ScriptBudget;
+} | {
+  /** Standalone convenience (stamp's detached documents, direct tests):
+   *  the controller builds and OWNS its own realm via
+   *  {@link createFormScriptingHost}; `dispose()` releases it. */
+  config: FormScriptingOptions;
+});
+/**
+ * A STANDALONE realm for one document, configured with the legacy
+ * `FormScriptingOptions` vocabulary — stamp's detached stamp-asset documents
+ * and direct controller tests construct their own host here; viewer
+ * documents get theirs from `actionsPlugin({ javascript })`.
+ */
+declare function createFormScriptingHost(options: {
+  doc: DocumentHandle;
+  document(): DocumentMeta | null;
+  config: FormScriptingOptions;
+}): {
+  transaction<T>(body: (txn: ScriptTransaction) => Promise<T>): Promise<T>;
+  dispose(): void;
+};
+declare class FormScriptingController {
+  private readonly options;
+  private disposed;
+  private readonly transaction;
+  private readonly transactionBudget;
+  private readonly ownedHost;
+  constructor(options: FormScriptingControllerOptions);
+  /** A shared realm belongs to its HOST (the actions plugin) — this only
+   *  fences further transactions; a standalone-owned realm is released. */
+  dispose(): void;
+  commit(ref: FormFieldRef, proposed: FormFieldValue): Promise<FormCommitResult>;
+  /** Execute one originating widget's activation action (`/A`, including `/Next`). */
+  activate(ref: FormFieldRef, action: PdfActionTree): Promise<FormCommitResult>;
+  /** Run lazy document boot plus the `/CO` chain without a user field change.
+   *  The anchor field resolves INSIDE the transaction (undefined ref). */
+  recalculate(): Promise<FormCommitResult>;
+  private transact;
+  private transactBody;
+  private failed;
+  private finishRejected;
+}
+declare function createFormScriptingController(options: FormScriptingControllerOptions): FormScriptingController;
+//#endregion
+export { FormScriptingController, FormScriptingControllerOptions, createFormScriptingController, createFormScriptingHost };
+//# sourceMappingURL=scripting.d.cts.map

package/dist/scripting.d.ts

@@ -0,0 +1,60 @@
+import { r as FormCommitResult, s as FormScriptingOptions } from "./types-BlXdnNRf.js";
+import { DocumentMeta } from "@embedpdf/core";
+import { DocumentHandle, FormFieldRef, FormFieldValue, PdfActionTree } from "@embedpdf/engine-core/runtime";
+import { ScriptBudget, ScriptTransaction } from "@embedpdf/core-acrojs";
+//#region src/scripting.d.ts
+type FormScriptingControllerOptions = {
+  doc: DocumentHandle;
+  document(): DocumentMeta | null;
+} & ({
+  /** The shared realm's transaction port ({@link ScriptTransaction}) —
+   *  the actions plugin's per-document host. The K/V/C/F pipeline runs
+   *  WHOLLY inside one transaction: snapshot fetch, every pass, and the
+   *  engine commit — the commit-inside-the-boundary law. */
+  transaction<T>(body: (txn: ScriptTransaction) => Promise<T>): Promise<T>;
+  budget?: ScriptBudget;
+} | {
+  /** Standalone convenience (stamp's detached documents, direct tests):
+   *  the controller builds and OWNS its own realm via
+   *  {@link createFormScriptingHost}; `dispose()` releases it. */
+  config: FormScriptingOptions;
+});
+/**
+ * A STANDALONE realm for one document, configured with the legacy
+ * `FormScriptingOptions` vocabulary — stamp's detached stamp-asset documents
+ * and direct controller tests construct their own host here; viewer
+ * documents get theirs from `actionsPlugin({ javascript })`.
+ */
+declare function createFormScriptingHost(options: {
+  doc: DocumentHandle;
+  document(): DocumentMeta | null;
+  config: FormScriptingOptions;
+}): {
+  transaction<T>(body: (txn: ScriptTransaction) => Promise<T>): Promise<T>;
+  dispose(): void;
+};
+declare class FormScriptingController {
+  private readonly options;
+  private disposed;
+  private readonly transaction;
+  private readonly transactionBudget;
+  private readonly ownedHost;
+  constructor(options: FormScriptingControllerOptions);
+  /** A shared realm belongs to its HOST (the actions plugin) — this only
+   *  fences further transactions; a standalone-owned realm is released. */
+  dispose(): void;
+  commit(ref: FormFieldRef, proposed: FormFieldValue): Promise<FormCommitResult>;
+  /** Execute one originating widget's activation action (`/A`, including `/Next`). */
+  activate(ref: FormFieldRef, action: PdfActionTree): Promise<FormCommitResult>;
+  /** Run lazy document boot plus the `/CO` chain without a user field change.
+   *  The anchor field resolves INSIDE the transaction (undefined ref). */
+  recalculate(): Promise<FormCommitResult>;
+  private transact;
+  private transactBody;
+  private failed;
+  private finishRejected;
+}
+declare function createFormScriptingController(options: FormScriptingControllerOptions): FormScriptingController;
+//#endregion
+export { FormScriptingController, FormScriptingControllerOptions, createFormScriptingController, createFormScriptingHost };
+//# sourceMappingURL=scripting.d.ts.map

package/dist/scripting.js

@@ -0,0 +1,534 @@
+import { DEFAULT_SCRIPT_BUDGET, createScriptHost, javaScriptProgramFromActionTree, resolveScriptIdentity, scriptFieldsFromSnapshot, seedFrom } from "@embedpdf/core-acrojs";
+//#region src/scripting.ts
+/**
+* A STANDALONE realm for one document, configured with the legacy
+* `FormScriptingOptions` vocabulary — stamp's detached stamp-asset documents
+* and direct controller tests construct their own host here; viewer
+* documents get theirs from `actionsPlugin({ javascript })`.
+*/
+function createFormScriptingHost(options) {
+	const { doc, config } = options;
+	const host = createScriptHost({
+		sandboxFactory: config.sandboxFactory ?? (() => import("@embedpdf/core-js-sandbox").then(({ createQuickJsSandbox }) => createQuickJsSandbox())),
+		document: () => {
+			const meta = options.document();
+			return {
+				id: doc.id,
+				fileName: config.fileName?.() ?? meta?.name ?? doc.id,
+				pageCount: meta?.pageCount ?? 0,
+				pageNumber: 0
+			};
+		},
+		identity: () => resolveScriptIdentity(doc, config.identity),
+		environment: (sequence) => {
+			const nowMs = config.now?.() ?? Date.now();
+			return {
+				nowMs,
+				utcOffsetMinutes: config.utcOffsetMinutes?.() ?? -new Date(nowMs).getTimezoneOffset(),
+				randomSeed: config.randomSeed?.() ?? seedFrom(doc.id, sequence)
+			};
+		},
+		bootSources: async () => {
+			return (doc.actions ? await doc.actions.read() : null)?.nameTreeScripts.map(({ action }) => javaScriptProgramFromActionTree(action)) ?? [];
+		},
+		...config.budget ? { budget: config.budget } : {}
+	});
+	return {
+		transaction: host.transaction.bind(host),
+		dispose: () => host.dispose()
+	};
+}
+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 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.disposed = false;
+		if ("transaction" in options) {
+			this.transaction = options.transaction.bind(options);
+			this.transactionBudget = options.budget;
+			this.ownedHost = null;
+		} else {
+			const host = createFormScriptingHost({
+				doc: options.doc,
+				document: () => options.document(),
+				config: options.config
+			});
+			this.transaction = host.transaction;
+			this.transactionBudget = options.config.budget;
+			this.ownedHost = host;
+		}
+	}
+	/** A shared realm belongs to its HOST (the actions plugin) — this only
+	*  fences further transactions; a standalone-owned realm is released. */
+	dispose() {
+		this.disposed = true;
+		this.ownedHost?.dispose();
+	}
+	async commit(ref, proposed) {
+		return this.transact(ref, proposed);
+	}
+	/** Execute one originating widget's activation action (`/A`, including `/Next`). */
+	async activate(ref, action) {
+		return this.transact(ref, void 0, action);
+	}
+	/** Run lazy document boot plus the `/CO` chain without a user field change.
+	*  The anchor field resolves INSIDE the transaction (undefined ref). */
+	async recalculate() {
+		return this.transact(void 0);
+	}
+	async transact(refInput, proposed, activation) {
+		if (this.disposed) throw new Error("Form scripting controller is disposed");
+		return this.transaction((txn) => this.transactBody(txn, refInput, proposed, activation));
+	}
+	async transactBody(txn, refInput, proposed, activation) {
+		const snapshot = await this.options.doc.forms.list();
+		const ref = refInput ?? snapshot.calculationOrder.find((candidate) => candidate !== null && snapshotField(snapshot, candidate) !== void 0) ?? snapshot.fields[0]?.ref;
+		if (!ref) return {
+			status: "unchanged",
+			scripted: true,
+			effectsResult: null,
+			uiEffects: [],
+			diagnostics: []
+		};
+		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 pageNumber = pageNumberFor(this.options.document(), target);
+		const budget = this.transactionBudget ?? 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 world = (fields, event) => ({
+			fields,
+			pageNumber,
+			event
+		});
+		const run = async (source, input) => {
+			const remaining = remainingBudget();
+			if (!remaining) return { error: {
+				kind: "budget",
+				message: "Form script transaction timed out"
+			} };
+			let output;
+			try {
+				const startedAt = Date.now();
+				output = await txn.run(source, input, remaining);
+				executionMs += Date.now() - startedAt;
+			} catch (error) {
+				return { error: scriptError(error instanceof Error ? error.message : String(error)) };
+			}
+			const error = consume(output, "user");
+			return error ? { error } : { output };
+		};
+		{
+			let boot = null;
+			try {
+				boot = await txn.boot(world(overlay.fields, { kind: "name-tree-boot" }), budget);
+			} catch (error) {
+				diagnostics.push({
+					code: "script-error",
+					message: `Document boot script failed (continuing without it): ${error instanceof Error ? error.message : String(error)}`
+				});
+			}
+			if (boot) {
+				const bootError = consume(boot, "boot");
+				if (!bootError) applyEffects(overlay, boot.formEffects);
+				else 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(program, world(overlay.fields, {
+					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 typing = await run(program, world(overlay.fields, {
+					kind: "field-keystroke",
+					target: ref,
+					source: ref,
+					value: oldValue,
+					change: String(proposedValue ?? ""),
+					selStart: 0,
+					selEnd: oldValue.length,
+					willCommit: false
+				}));
+				if (typing.error && typing.error.kind !== "exception") return this.failed(uiEffects, diagnostics, typing.error);
+				if (typing.error) diagnostics.push({
+					code: "script-error",
+					message: `Keystroke script failed (kept the typed value): ${typing.error.message}`
+				});
+				else {
+					if (!typing.output.event.rc) return this.finishRejected(bootEffects, uiEffects, diagnostics);
+					applyEffects(overlay, typing.output.formEffects);
+					const event = typing.output.event;
+					const base = String(event.value ?? "");
+					proposedValue = base.slice(0, event.selStart) + event.change + base.slice(Math.max(event.selStart, event.selEnd));
+				}
+				const commit = await run(program, world(overlay.fields, {
+					kind: "field-keystroke",
+					target: ref,
+					source: ref,
+					value: proposedValue,
+					change: "",
+					selStart: 0,
+					selEnd: 0,
+					willCommit: true
+				}));
+				if (commit.error && commit.error.kind !== "exception") return this.failed(uiEffects, diagnostics, commit.error);
+				if (commit.error) diagnostics.push({
+					code: "script-error",
+					message: `Keystroke commit script failed (kept the typed value): ${commit.error.message}`
+				});
+				else {
+					if (!commit.output.event.rc) return this.finishRejected(bootEffects, uiEffects, diagnostics);
+					applyEffects(overlay, commit.output.formEffects);
+					proposedValue = cloneValue(commit.output.event.value);
+				}
+			}
+		}
+		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(program, world(overlay.fields, {
+					kind: "field-validate",
+					target: ref,
+					source: ref,
+					value: proposedValue,
+					willCommit: true
+				}));
+				if (validation.error && validation.error.kind !== "exception") return this.failed(uiEffects, diagnostics, validation.error);
+				if (validation.error) diagnostics.push({
+					code: "script-error",
+					message: `Validate script failed (accepted the value): ${validation.error.message}`
+				});
+				else {
+					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(program, world(overlay.fields, {
+					kind: "field-calculate",
+					target: calculationRef,
+					...hasProposedValue ? { source: ref } : {},
+					value: calculatedInput.value
+				}));
+				if (calculation.error && calculation.error.kind !== "exception") return this.failed(uiEffects, diagnostics, calculation.error);
+				if (calculation.error) diagnostics.push({
+					code: "script-error",
+					message: `Calculate script failed (field left unchanged): ${calculation.error.message}`
+				});
+				else 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(program, world(overlay.fields, {
+				kind: "field-format",
+				target: formatRef,
+				...hasProposedValue ? { source: ref } : {},
+				value: overlayField.value
+			}));
+			if (format.error && format.error.kind !== "exception") return this.failed(uiEffects, diagnostics, format.error);
+			if (format.error) {
+				diagnostics.push({
+					code: "script-error",
+					message: `Format script failed (kept the raw value): ${format.error.message}`
+				});
+				continue;
+			}
+			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") } : {}
+		};
+	}
+	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
+		};
+	}
+};
+function createFormScriptingController(options) {
+	return new FormScriptingController(options);
+}
+//#endregion
+export { FormScriptingController, createFormScriptingController, createFormScriptingHost };
+
+//# sourceMappingURL=scripting.js.map