@embedpdf/plugin-redaction 3.0.0-next.13 → 3.0.0-next.15

package/dist/index.js

@@ -1,162 +1,391 @@
-import { t as RedactionToken } from "./contract-BZLrD3p2.js";
-import { definePlugin } from "@embedpdf/core";
+import { n as RedactionToken, t as REDACTION_DEFAULTS } from "./contract-eQ3P0UU-.js";
+import { PluginError, annotationKey, composeApi, definePlugin, defineState, memo, memoByKey, toPageRef, toPluginError, toPluginErrorInfo } from "@embedpdf/core";
 import { AnnotationToken } from "@embedpdf/plugin-annotation/contract/host";
-import { InteractionToken } from "@embedpdf/plugin-interaction/contract";
+import { SearchToken } from "@embedpdf/plugin-search/contract";
 import { SelectionToken } from "@embedpdf/plugin-selection/contract";
-//#region src/capability.ts
-/** Applying destroys content — its own granted power, narrower than annotate.
-*  The engine's apply asserts all three (LocalDocumentRedactionService; the
-*  cloud route guards match): the redact grant itself, the page-content
+import { rectsOverlap } from "@embedpdf/core-geometry";
+import { pageQuadBounds } from "@embedpdf/engine-core";
+//#region src/read/pending.ts
+/**
+* The pending view: `redact` annotations projected as marks, per page and
+* memoized on the annotation plane's own reference-stable lists, plus the
+* client-side collateral estimate.
+*/
+/** The regions a redact mark targets: its quads' boxes, else its `rect`. */
+const regionsOf = (dto) => dto.quadPoints.length === 0 ? [dto.rect] : dto.quadPoints.map(pageQuadBounds);
+const EMPTY = [];
+/** A `redact` annotation as a mark; `pageIndex` is its page's display index. */
+const markOf = (record, pageIndex) => ({
+	ref: record.ref,
+	page: record.ref.page,
+	pageIndex,
+	kind: record.quadPoints.length > 0 ? "text" : "area",
+	bounds: record.rect,
+	overlayText: record.overlayText ?? null,
+	repeat: record.repeat ?? false
+});
+function createPendingReads(ctx, { store, siblings }) {
+	const { pages, pageIndexOf } = store;
+	const { annotation } = siblings;
+	/** One page's marks, the same array while the plane's list and the page's position hold. */
+	const marksOn = memoByKey((pageObjectNumber) => {
+		const page = toPageRef(pageObjectNumber);
+		return [annotation.list({ pages: [page] }), pageIndexOf(page)];
+	}, (_pageObjectNumber, records, pageIndex) => {
+		const marks = records.flatMap((record) => record.subtype === "redact" ? [markOf(record, pageIndex)] : []);
+		return marks.length ? marks : EMPTY;
+	});
+	/** The whole document's marks, the same array while no page's marks changed. */
+	const allMarks = memo(() => pages().map((page) => marksOn(page.objectNumber)), (...perPage) => perPage.some((marks) => marks.length) ? perPage.flat() : EMPTY);
+	/** One page's marks (a ref or an index; none for a page that isn't there), or every mark. */
+	const listPending = (filter) => {
+		if (filter?.page === void 0) return allMarks();
+		const layout = ctx.getPage(filter.page);
+		return layout ? marksOn(layout.ref.objectNumber) : EMPTY;
+	};
+	/** A record the annotation plugin made or changed, as the mark it is. */
+	const markFor = (record) => record.subtype === "redact" ? markOf(record, pageIndexOf(record.ref.page)) : null;
+	const getPending = (ref) => {
+		const key = annotationKey(ref);
+		return listPending().find((mark) => annotationKey(mark.ref) === key) ?? null;
+	};
+	const estimateCollateral = (refs) => {
+		const wanted = refs ? new Set(refs.map(annotationKey)) : null;
+		const hits = [];
+		for (const page of pages()) {
+			const onPage = annotation.list({ pages: [page] });
+			const marks = onPage.filter((dto) => dto.subtype === "redact" && (!wanted || wanted.has(annotationKey(dto.ref))));
+			if (marks.length === 0) continue;
+			const regions = marks.flatMap(regionsOf);
+			for (const other of onPage) {
+				if (other.subtype === "redact") continue;
+				if (regions.some((region) => rectsOverlap(region, other.rect))) hits.push(other.ref);
+			}
+		}
+		return {
+			count: hits.length,
+			refs: hits
+		};
+	};
+	return {
+		listPending,
+		markFor,
+		api: {
+			listPending,
+			getPending,
+			getPendingCount: (page) => listPending(page === void 0 ? void 0 : { page }).length,
+			estimateCollateral
+		}
+	};
+}
+//#endregion
+//#region src/services/events.ts
+function createEvents(ctx) {
+	return {
+		applied: ctx.events.source(),
+		pendingChanged: ctx.events.source()
+	};
+}
+//#endregion
+//#region src/services/siblings.ts
+/** The sibling plugins: annotation (required, host lens), selection and search (optional). */
+function resolveSiblings(ctx) {
+	return {
+		annotation: ctx.get(AnnotationToken),
+		selection: () => ctx.tryGet(SelectionToken),
+		search: () => ctx.tryGet(SearchToken)
+	};
+}
+//#endregion
+//#region src/services/store.ts
+/** The page registry reads and the engine's redaction service. */
+/** Applying destroys content: its own granted power, narrower than annotate.
+*  The engine's apply asserts all three (the local redaction service and the
+*  cloud route guards alike): the redact grant itself, the page-content
 *  rewrite, and the annotation consumption. `canApply` mirrors the full set. */
 const APPLY_CAPABILITIES = [
 	"doc.redact",
 	"doc.pages.modify",
 	"doc.annotate.modify"
 ];
-/** The annotation plugin's model-id convention for a durable ref. */
-const idOf = (ref) => ref.kind === "objectNumber" ? `obj:${ref.annotObjectNumber}` : ref.kind === "nm" ? `nm:${ref.nm}` : `idx:${ref.pageObjectNumber}:${ref.index}`;
-/** The PDF-space regions a redact mark targets: its quads' boxes, else `/Rect`. */
-function regionsOf(dto) {
-	if (dto.quadPoints.length === 0) return [dto.rect];
-	return dto.quadPoints.map((q) => {
-		const xs = [
-			q.p1.x,
-			q.p2.x,
-			q.p3.x,
-			q.p4.x
-		];
-		const ys = [
-			q.p1.y,
-			q.p2.y,
-			q.p3.y,
-			q.p4.y
-		];
-		return {
-			left: Math.min(...xs),
-			right: Math.max(...xs),
-			bottom: Math.min(...ys),
-			top: Math.max(...ys)
-		};
-	});
+function createStore(ctx) {
+	const requireService = () => {
+		const service = ctx.doc.redaction;
+		if (!service) throw new PluginError("unsupported", "redaction", "this engine has no redaction service");
+		return service;
+	};
+	/** Every page's ref, in display order. */
+	const pages = () => (ctx.document()?.pages ?? []).map((page) => page.ref);
+	/** Page object number → display index, rebuilt only when the page registry changes. */
+	const indexByPage = memo(() => [ctx.document()?.pages], (layouts) => new Map((layouts ?? []).map((page) => [page.ref.objectNumber, page.index])));
+	const pageIndexOf = (page) => indexByPage().get(page.objectNumber) ?? -1;
+	const canApply = () => ctx.doc.redaction !== void 0 && APPLY_CAPABILITIES.every((capability) => ctx.doc.security.allows(capability));
+	return {
+		requireService,
+		pages,
+		pageIndexOf,
+		canApply
+	};
 }
-/** Positive-area intersection — the engine's collateral rule. */
-const intersects = (a, b) => Math.min(a.right, b.right) > Math.max(a.left, b.left) && Math.min(a.top, b.top) > Math.max(a.bottom, b.bottom);
-function createRedactionCapability(ctx) {
-	const anno = ctx.get(AnnotationToken);
-	const appliedCallbacks = /* @__PURE__ */ new Set();
-	const requireDoc = () => {
-		const doc = ctx.doc;
-		if (!doc) throw new Error("[redaction] no document bound");
-		return doc;
+//#endregion
+//#region src/services/index.ts
+function createServices(ctx) {
+	return {
+		events: createEvents(ctx),
+		store: createStore(ctx),
+		siblings: resolveSiblings(ctx)
 	};
-	const requireService = () => {
-		const doc = requireDoc();
-		if (!doc.redaction) throw new Error("[redaction] engine has no redaction service");
-		return doc.redaction;
-	};
-	const pons = () => (ctx.document()?.pages ?? []).map((p) => p.pageObjectNumber);
-	const pageIndexOf = (pon) => ctx.document()?.pages.find((p) => p.pageObjectNumber === pon)?.index ?? -1;
-	const pendingOn = (pon) => anno.list(pon).filter((a) => a.subtype === "redact");
-	const collectPending = () => {
-		const items = [];
-		for (const pon of pons()) for (const dto of pendingOn(pon)) items.push({
-			id: idOf(dto.ref),
-			ref: dto.ref,
-			pageObjectNumber: pon,
-			pageIndex: pageIndexOf(pon),
-			kind: dto.quadPoints.length > 0 ? "text" : "area",
-			overlayText: dto.overlayText
+}
+//#endregion
+//#region src/model.ts
+const initialRedactionState = () => ({
+	applying: false,
+	lastResult: null
+});
+const startApply = (state) => state.applying ? state : {
+	...state,
+	applying: true
+};
+const finishApply = (state) => state.applying ? {
+	...state,
+	applying: false
+} : state;
+const setLastResult = (state, result) => state.lastResult === result ? state : {
+	...state,
+	lastResult: result
+};
+//#endregion
+//#region src/sync/document-events.ts
+function subscribeChanges(ctx, { events, siblings }) {
+	const { applied, pendingChanged } = events;
+	const { annotation } = siblings;
+	ctx.listen(ctx.doc.events, (event) => {
+		if (event.type !== "redaction.applied") return;
+		const { type: _type, origin, ...result } = event;
+		ctx.state.update(setLastResult, result);
+		applied.emit({
+			result,
+			origin
 		});
-		return items;
-	};
-	const fireApplied = (result) => {
-		for (const cb of appliedCallbacks) try {
-			cb(result);
-		} catch (err) {
-			console.error("[redaction] onApplied callback failed", err);
-		}
+	});
+	const markChanged = ({ annotation: changed }) => {
+		if (changed.subtype === "redact") pendingChanged.emit({ pages: [changed.page] });
 	};
-	const runApply = async (scope) => {
+	ctx.listen(annotation.onCreated, markChanged);
+	ctx.listen(annotation.onUpdated, markChanged);
+	ctx.listen(annotation.onDeleted, (event) => pendingChanged.emit({ pages: [event.page] }));
+}
+//#endregion
+//#region src/sync/overlay.ts
+/** The redact tool's fields the overlay settings stand for. */
+const toolDefaultsOf = ({ overlay }) => ({
+	interiorColor: overlay.fill,
+	fontColor: overlay.text.color,
+	fontFamily: overlay.text.fontFamily,
+	fontSize: overlay.text.fontSize
+});
+function syncOverlay(ctx, { siblings }) {
+	const { annotation } = siblings;
+	const settings = ctx.settings();
+	const write = () => annotation.tools.updateDefaults("redact", toolDefaultsOf(settings.get()));
+	write();
+	ctx.listen(settings.api.onSettingsChanged, ({ changed }) => {
+		if (changed.includes("overlay")) write();
+	});
+}
+//#endregion
+//#region src/write/apply.ts
+/**
+* The destructive half: `doc.redaction.apply` in refs or pages scope. Applies
+* run one at a time, in call order, so each one sees the marks the previous
+* one left. The result reaches `lastResult` and `onApplied` through the
+* confirmed `redaction.applied` event, which the engine publishes before the
+* apply resolves; this area only brackets the call with the `applying` flag.
+*/
+function createApplying(ctx, { store }, { listPending }) {
+	const { requireService, pages } = store;
+	const queue = ctx.serialQueue("apply");
+	ctx.onSettle(() => queue.idle());
+	/**
+	* Queue an apply whose scope is computed when its turn comes. One whose
+	* signal fired while it waited never starts; one cancelled while the
+	* engine applies rejects `operation-cancelled` at once, and the engine's
+	* `redaction.applied` says what it removed.
+	*/
+	const runApply = (scopeOf, options) => queue(async () => {
 		const service = requireService();
-		ctx.dispatch({ type: "APPLY_STARTED" });
+		const scope = scopeOf();
+		ctx.state.update(startApply);
 		try {
-			const result = await service.apply(scope);
-			ctx.dispatch({
-				type: "APPLY_FINISHED",
-				result
-			});
-			fireApplied(result);
-			return result;
-		} catch (err) {
-			ctx.dispatch({
-				type: "APPLY_FINISHED",
-				result: null
-			});
-			throw err;
+			return await ctx.cancellable(options?.signal, service.apply(scope));
+		} finally {
+			ctx.state.update(finishApply);
 		}
+	}, { signal: options?.signal });
+	const apply = (refs, options) => runApply(() => {
+		const wanted = new Set(refs.map(annotationKey));
+		const marks = listPending().filter((mark) => wanted.has(annotationKey(mark.ref))).map((mark) => mark.ref);
+		if (marks.length === 0) throw new PluginError("not-found", "redaction", "no matching pending marks");
+		return { annotations: marks };
+	}, options);
+	const applyPages = async (targets, options) => {
+		if (targets.length === 0) throw new PluginError("invalid-input", "redaction", "no pages given");
+		const pages = targets.map((page) => ctx.pageOf(page).ref);
+		return runApply(() => ({ pages }), options);
 	};
-	const doc = ctx.doc;
-	if (doc) ctx.cleanup(doc.events.subscribe((event) => {
-		if (event.type !== "redaction.applied") return;
-		if (event.origin.kind !== "remote") return;
-		ctx.dispatch({
-			type: "APPLY_FINISHED",
-			result: event
+	const applyAll = (options) => runApply(() => {
+		const all = pages();
+		if (all.length === 0) throw new PluginError("not-ready", "redaction", "the document has no pages");
+		return { pages: all };
+	}, options);
+	return { api: {
+		apply,
+		applyPages,
+		applyAll
+	} };
+}
+//#endregion
+//#region src/write/marks.ts
+/**
+* Marking: every mark is a `redact` annotation created through the annotation
+* plugin, in the style of the redact tool's defaults, which follow the
+* `overlay` settings (`sync/overlay.ts`). Removing a mark and changing its
+* label are annotation deletes and updates, checked per mark.
+*/
+/** Stop before the next step once the caller cancelled. */
+const throwIfCancelled = (signal) => {
+	if (signal?.aborted) throw new PluginError("operation-cancelled", "redaction", "operation cancelled", { cause: signal.reason });
+};
+function createMarking(ctx, { siblings }, { listPending, markFor }) {
+	const { annotation, selection, search } = siblings;
+	/**
+	* A new mark's style, as the engine takes it: the redact tool's current
+	* defaults, which carry the `overlay` settings, so a mark from code looks
+	* like one drawn with the tool.
+	*/
+	const markStyle = () => {
+		const tool = annotation.tools.getDefaults("redact");
+		return {
+			color: tool.color,
+			interiorColor: tool.interiorColor,
+			opacity: tool.opacity,
+			fontFamily: tool.fontFamily,
+			fontSize: tool.fontSize,
+			fontColor: tool.fontColor,
+			textAlign: tool.textAlign
+		};
+	};
+	/** The mark a created or changed record is. */
+	const markOfRecord = (record) => {
+		const mark = markFor(record);
+		if (!mark) throw new PluginError("operation-failed", "redaction", "the record is not a mark");
+		return mark;
+	};
+	/** Whether a ref is a mark waiting to be applied. */
+	const isPending = (ref) => {
+		const key = annotationKey(ref);
+		return listPending().some((mark) => annotationKey(mark.ref) === key);
+	};
+	const canUnmark = (ref) => isPending(ref) && annotation.canDelete(ref);
+	const canUpdateLabel = (ref) => isPending(ref) && annotation.canUpdate(ref);
+	const markSelection = async (options) => {
+		ctx.assertAllowed("annotations:create", "redaction.markSelection");
+		const plane = selection();
+		if (!plane) throw new PluginError("unsupported", "redaction", "no selection plugin");
+		if (!plane.hasSelection()) return { marks: [] };
+		const { annotations } = await annotation.createFromSelection("redact", {
+			clear: true,
+			signal: options?.signal
 		});
-		fireApplied(event);
-	}));
-	return {
-		canMark: () => anno.canCreate(),
-		canApply: () => {
-			const doc = ctx.doc;
-			if (!doc || doc.redaction === void 0) return false;
-			return APPLY_CAPABILITIES.every((cap) => doc.security.allows(cap));
-		},
-		isApplying: () => ctx.getState().applying,
-		lastResult: () => ctx.getState().lastResult,
-		enableRedact: () => ctx.tryGet(InteractionToken)?.activateTool("redact"),
-		toggleRedact: () => {
-			const interaction = ctx.tryGet(InteractionToken);
-			if (!interaction) return;
-			interaction.activateTool(interaction.activeToolId() === "redact" ? "pointer" : "redact");
-		},
-		isRedactActive: () => ctx.tryGet(InteractionToken)?.activeToolId() === "redact",
-		queueCurrentSelection: async () => {
-			if (!anno.canCreate()) return false;
-			const selection = ctx.tryGet(SelectionToken);
-			if (!selection || !selection.hasSelection()) return false;
-			const snapshot = selection.snapshot();
-			for (const page of snapshot.pages) {
-				if (page.segments.length === 0) continue;
-				anno.createMarkup("redact", page.pon, page.segments.map((segment) => segment.quad), "redact");
+		return { marks: annotations.map(markOfRecord) };
+	};
+	const createMark = async (page, region, signal) => {
+		const created = await annotation.create(page, {
+			subtype: "redact",
+			...region,
+			...markStyle()
+		}, void 0, { signal });
+		return markOfRecord(created.annotation);
+	};
+	const markArea = async (page, bounds, options) => {
+		ctx.assertAllowed("annotations:create", "redaction.markArea");
+		const target = ctx.pageOf(page).ref;
+		return { mark: await createMark(target, { rect: bounds }, options?.signal) };
+	};
+	const markPage = async (page, options) => {
+		ctx.assertAllowed("annotations:create", "redaction.markPage");
+		const layout = ctx.pageOf(page);
+		const whole = {
+			x: 0,
+			y: 0,
+			width: layout.size.width,
+			height: layout.size.height
+		};
+		return { mark: await createMark(layout.ref, { rect: whole }, options?.signal) };
+	};
+	const markMatches = async (query, options) => {
+		ctx.assertAllowed("annotations:create", "redaction.markMatches");
+		const signal = options?.signal;
+		const finder = search();
+		if (!finder) throw new PluginError("unsupported", "redaction", "no search plugin");
+		const wanted = options?.pages ? new Set(options.pages.map((page) => ctx.pageOf(page).ref.objectNumber)) : null;
+		await finder.search(query, { signal });
+		const marks = [];
+		for (const hit of finder.listHits()) {
+			if (wanted && !wanted.has(hit.page.objectNumber)) continue;
+			if (hit.segments.length === 0) continue;
+			throwIfCancelled(signal);
+			marks.push(await createMark(hit.page, { quadPoints: hit.segments.map((segment) => segment.quad) }, signal));
+		}
+		return { marks };
+	};
+	const unmark = async (refs, options) => {
+		const signal = options?.signal;
+		throwIfCancelled(signal);
+		const applied = [];
+		const skipped = [];
+		const failed = [];
+		for (const ref of refs) {
+			if (!isPending(ref)) {
+				skipped.push({
+					ref,
+					reason: "not a pending redaction mark"
+				});
+				continue;
+			}
+			if (!annotation.canDelete(ref)) {
+				const refused = new PluginError("permission-denied", "redaction", "redaction.unmark requires annotations:delete", { permission: "annotations:delete" });
+				failed.push({
+					ref,
+					error: toPluginErrorInfo(refused)
+				});
+				continue;
 			}
-			selection.clear();
-			return true;
-		},
-		preparePending: async () => {
-			await Promise.all(pons().map((pon) => anno.ensurePage(pon)));
-		},
-		getPending: collectPending,
-		pendingCount: () => collectPending().length,
-		estimateCollateral: (ids) => {
-			const wanted = ids ? new Set(ids) : null;
-			let count = 0;
-			for (const pon of pons()) {
-				const all = anno.list(pon);
-				const marks = all.filter((a) => a.subtype === "redact" && (!wanted || wanted.has(idOf(a.ref))));
-				if (marks.length === 0) continue;
-				const regions = marks.flatMap(regionsOf);
-				for (const other of all) {
-					if (other.subtype === "redact") continue;
-					if (regions.some((r) => intersects(r, other.rect))) count++;
-				}
+			try {
+				await annotation.delete(ref, { signal });
+				applied.push(ref);
+			} catch (error) {
+				const refused = toPluginError("redaction", error);
+				if (refused.code === "operation-cancelled") throw refused;
+				failed.push({
+					ref,
+					error: toPluginErrorInfo(refused)
+				});
 			}
-			return count;
-		},
-		setLabel: async (ref, patch) => {
-			const current = anno.get(ref);
-			if (!current || current.subtype !== "redact") throw new Error("[redaction] setLabel target is not a redact annotation");
-			await anno.update(ref, {
+		}
+		return {
+			applied,
+			skipped,
+			failed
+		};
+	};
+	const clearPending = (options) => unmark(listPending().map((mark) => mark.ref), options);
+	const updateLabel = async (ref, patch, options) => {
+		const current = annotation.get(ref);
+		if (!current || current.subtype !== "redact") throw new PluginError("not-found", "redaction", "the target is not a redaction mark");
+		if (!annotation.canUpdate(ref)) throw new PluginError("permission-denied", "redaction", "redaction.updateLabel requires annotations:update", { permission: "annotations:update" });
+		try {
+			const updated = await annotation.update(ref, {
 				subtype: "redact",
 				...patch.overlayText !== void 0 ? { overlayText: patch.overlayText } : {},
 				...patch.repeat !== void 0 ? { repeat: patch.repeat } : {},
@@ -164,73 +393,107 @@ function createRedactionCapability(ctx) {
 				fontSize: current.fontSize,
 				fontColor: current.fontColor,
 				textAlign: current.textAlign
-			});
-		},
-		apply: async (ids) => {
-			const wanted = new Set(ids);
-			const refs = collectPending().filter((p) => wanted.has(p.id)).map((p) => p.ref);
-			if (refs.length === 0) throw new Error("[redaction] no matching pending redactions");
-			return runApply({
-				kind: "annotations",
-				refs
-			});
-		},
-		applyAll: async () => {
-			const pageObjectNumbers = pons();
-			if (pageObjectNumbers.length === 0) throw new Error("[redaction] document has no pages");
-			return runApply({
-				kind: "pages",
-				pageObjectNumbers
-			});
-		},
-		onApplied: (cb) => {
-			appliedCallbacks.add(cb);
-			return () => appliedCallbacks.delete(cb);
+			}, void 0, { signal: options?.signal });
+			return { mark: markOfRecord(updated.annotation) };
+		} catch (error) {
+			throw toPluginError("redaction", error);
 		}
 	};
+	return { api: {
+		canUnmark,
+		canUpdateLabel,
+		markSelection,
+		markArea,
+		markPage,
+		markMatches,
+		unmark,
+		clearPending,
+		updateLabel
+	} };
 }
 //#endregion
-//#region src/reducer.ts
-const initialRedactionState = () => ({
-	applying: false,
-	lastResult: null
-});
-const redactionReducer = (state, action) => {
-	switch (action.type) {
-		case "APPLY_STARTED": return {
-			...state,
-			applying: true
-		};
-		case "APPLY_FINISHED": return {
-			applying: false,
-			lastResult: action.result ?? state.lastResult
-		};
-		default: return state;
-	}
-};
+//#region src/controller.ts
+/**
+* The redaction controller: the composition root. It builds the plugin's
+* services once, wires each area with the services it declares, and
+* assembles the capability from the areas' API slices. No behavior lives
+* here: every verb and read has a home in `read/`, `write/` or `sync/`.
+*/
+function createRedactionController(ctx) {
+	const services = createServices(ctx);
+	const { events, store } = services;
+	const settings = ctx.settings();
+	const pending = createPendingReads(ctx, services);
+	const marking = createMarking(ctx, services, pending);
+	const applying = createApplying(ctx, services, pending);
+	return {
+		api: composeApi("redaction", [
+			settings.api,
+			pending.api,
+			marking.api,
+			applying.api,
+			{
+				canMark: () => ctx.allows("annotations:create"),
+				canApply: store.canApply,
+				isApplying: () => ctx.state.get().applying,
+				getLastResult: () => ctx.state.get().lastResult,
+				onApplied: events.applied.on,
+				onPendingChanged: events.pendingChanged.on
+			}
+		]),
+		connect() {
+			subscribeChanges(ctx, services);
+			syncOverlay(ctx, services);
+		}
+	};
+}
 //#endregion
 //#region src/redaction.plugin.ts
 /**
-* Document-scoped redaction plugin — the DESTRUCTIVE half of the two-stage
-* model. Marking is annotation-plane work (the composed `redact` tool ships
-* with plugin-annotation); this plugin wraps `doc.redaction.apply`, projects
-* the pending queue out of annotation state, and estimates collateral for
+* Document-scoped redaction plugin: the destructive half of the two-stage
+* model. Marking is annotation work (the composed `redact` tool ships with
+* plugin-annotation); this plugin wraps `doc.redaction.apply`, projects the
+* pending queue out of annotation state, and estimates collateral for
 * confirm dialogs. It owns no mark state of its own.
 *
-* Trust boundary: on a layered document, applying rewrites the LAYER's bytes;
-* the immutable base keeps the original. See the package README.
+* Trust boundary: on a layered document, applying rewrites the layer's bytes;
+* the immutable base keeps the original. The package README explains the consequences.
+* `config` is the settings the app registers, over {@link REDACTION_DEFAULTS}.
 */
-const redactionPlugin = () => definePlugin({
+const redactionPlugin = (config) => definePlugin({
 	id: "redaction",
 	token: RedactionToken,
 	scope: "document",
 	requires: [AnnotationToken],
-	optional: [InteractionToken, SelectionToken],
-	initialState: initialRedactionState,
-	reduce: redactionReducer,
-	capability: createRedactionCapability
+	optional: [SelectionToken, SearchToken],
+	state: initialRedactionState,
+	settings: {
+		defaults: REDACTION_DEFAULTS,
+		registered: config
+	},
+	create: createRedactionController
+});
+//#endregion
+//#region src/state.ts
+/**
+* The redaction page's State table as code: what `useRedactionState()`
+* returns, and the same fields in every other framework. The marks
+* themselves are not here: `usePendingRedactions()` reads them, so a
+* component that only shows the count doesn't re-render for every mark.
+*/
+const redactionState = defineState(RedactionToken, {
+	read: (redaction) => ({
+		pendingCount: redaction.getPendingCount(),
+		applying: redaction.isApplying(),
+		lastResult: redaction.getLastResult()
+	}),
+	empty: {
+		pendingCount: 0,
+		applying: false,
+		lastResult: null
+	}
 });
 //#endregion
-export { RedactionToken, redactionPlugin };
+export { REDACTION_DEFAULTS, RedactionToken, redactionPlugin, redactionState };
 
 //# sourceMappingURL=index.js.map