@embedpdf/plugin-redaction 3.0.0-next.14 → 3.0.0-next.16

package/README.md

@@ -1,6 +1,6 @@
 # @embedpdf/plugin-redaction
 
-Redaction for EmbedPDF v3 — mark content for removal, review the pending
+Redaction for EmbedPDF — mark content for removal, review the pending
 marks, then destroy the content permanently.
 
 Redaction is a **two-stage** workflow (ISO 32000-2):
@@ -9,7 +9,7 @@ Redaction is a **two-stage** workflow (ISO 32000-2):
    redaction mark is a real `redact` annotation: it renders, selects,
    syncs, and deletes like any other annotation, and nothing is removed
    yet. You don't need this plugin to mark — the `redact` tool ships with
-   `@embedpdf/plugin-annotation`.
+   `@embedpdf/plugin-annotation` — but it adds marking verbs for code.
 2. **Applying** is destructive and is what this plugin wraps: the content
    under every marked region is permanently removed, the configured
    overlay (fill + label) is painted in its place, and the consumed marks
@@ -37,7 +37,15 @@ const plugins = [
 
 Requires `plugin-annotation`. With `plugin-selection` and
 `plugin-interaction` present (the usual viewer setup), the marking tool
-and `queueCurrentSelection()` light up too.
+and `markSelection()` light up too; `markMatches()` needs `plugin-search`.
+
+`redactionPlugin({ overlay })` sets what applying paints over every mark,
+whichever way it was made (the `redact` tool, the selected text, or code):
+`overlay.fill` is the colour painted on apply (default black) and
+`overlay.text` styles the label (`color`, default white; `fontFamily`,
+default Helvetica; `fontSize`, where the default 0 fits the area). The
+settings become the redact tool's defaults, and `redaction.updateSettings()`
+changes them for the marks made from then on.
 
 ## Marking
 
@@ -46,16 +54,29 @@ text marks the selected text (per-line quads, like a highlight), and
 dragging anywhere else marks a rectangular area. One tool, both modes.
 
 ```ts
-const redaction = useCapability(RedactionToken);
+import { useInteraction, useInteractionState } from '@embedpdf/react/interaction';
+import { useRedaction } from '@embedpdf/react/redaction';
+
+const redaction = useRedaction();
+const interaction = useInteraction();
+const { activeToolId } = useInteractionState();
 
-redaction.toggleRedact(); // toggle the redact tool
-redaction.isRedactActive();
+interaction.activateTool('redact'); // arm the redact tool
+activeToolId === 'redact';
 
 // Mark the current text selection without switching tools
 // (context-menu "Mark for Redaction"):
-await redaction.queueCurrentSelection();
+const { marks } = await redaction.markSelection();
+
+// Or mark from code (page space; a page is a ref or an index):
+const { mark } = await redaction.markArea(page, { x: 72, y: 72, width: 200, height: 40 });
+await redaction.markPage(0);
+await redaction.markMatches({ text: 'Confidential' }); // every search hit: { marks }
 ```
 
+`canMark()` is annotation create authority: a mark is an ordinary
+annotation, so anyone who can annotate can propose redactions.
+
 Marks carry their appearance: `color` (marking outline), `interiorColor`
 (the fill painted on apply), and an optional label (`/OverlayText`)
 styled by `fontFamily`/`fontSize`/`fontColor`/`textAlign` with
@@ -63,9 +84,12 @@ styled by `fontFamily`/`fontSize`/`fontColor`/`textAlign` with
 normal annotation style panel; the label text itself:
 
 ```ts
-redaction.setLabel(id, { overlayText: 'REDACTED', repeat: true });
+const { mark } = await redaction.updateLabel(ref, { overlayText: 'REDACTED', repeat: true });
 ```
 
+`canUnmark(ref)` and `canUpdateLabel(ref)` answer per mark, as the
+annotation's own delete and update checks do.
+
 ## The pending queue
 
 Pending marks are **not plugin state** — they are a live view over the
@@ -73,37 +97,55 @@ annotation plane (`subtype === 'redact'`). Deleting a mark is just
 deleting an annotation.
 
 ```ts
-redaction.getPending(); // RedactionPendingItem[] — id, ref, page, kind: 'area' | 'text', label
-redaction.pendingCount();
-redaction.estimateCollateral(); // client-side count of OTHER annotations
-// the pending marks would destroy — show
-// this in your confirm dialog BEFORE applying
+redaction.listPending(); // RedactionMark[] — ref, page, pageIndex, kind: 'area' | 'text', bounds, overlayText, repeat
+redaction.listPending({ page }); // one page's marks
+redaction.getPending(ref); // one mark, or null
+redaction.getPendingCount();
+redaction.estimateCollateral(); // { count, refs }: a client-side estimate of the
+// other annotations the pending marks would destroy — show
+// this in your confirm dialog before applying
+
+await redaction.unmark([ref]); // remove marks; refs that are not marks are skipped, refused ones fail
+await redaction.clearPending(); // remove every mark
+
+redaction.onPendingChanged(({ pages }) => {
+  /* marks were created, changed or removed on these pages */
+});
 ```
 
 ## Applying
 
 ```ts
-// Everything pending:
+// Everything in the document, including marks on pages this client never loaded:
 const result = await redaction.applyAll();
-
-// Or specific marks:
-const result = await redaction.apply([id1, id2]);
+// Or specific marks:        await redaction.apply([ref1, ref2]);
+// Or the marks on pages:    await redaction.applyPages([page]);
 
 result.removedAnnotationCount; // authoritative collateral count
 result.results; // per-page applied/unchanged/failed/skipped
 
-redaction.onApplied((result) => {
+redaction.onApplied(({ result, origin }) => {
   /* toast, audit, ... */
 });
 ```
 
-`apply` resolves after the engine confirms. Affected pages re-rasterize
-(content-scope invalidation) and their annotation lists reload
-automatically — including when a **collaborator** applies on a shared
-document. On a document whose token lacks the `doc.redact` capability,
-`canApply()` is false and `apply` rejects.
+`apply` resolves after the engine confirms. Applies run one at a time,
+in call order. Affected pages re-rasterize (content-scope invalidation)
+and their annotation lists reload automatically — including when a
+**collaborator** applies on a shared document. On a document whose token
+lacks `doc.redact` (or `doc.pages.modify` and `doc.annotate.modify`, which
+apply also asserts), `canApply()` is false and `apply` rejects with
+`permission-denied`; without an engine redaction service it rejects with
+`unsupported`.
 
 ```ts
-redaction.canApply(); // engine service present AND doc.redact granted
+redaction.canApply(); // engine service present and every apply capability granted
 redaction.isApplying(); // in-flight state for spinners
+redaction.getLastResult(); // the last confirmed apply, from this session or another
 ```
+
+In React, `useRedaction()` is the capability, `useRedactionState()` reads
+`{ pendingCount, applying, lastResult }`, `usePendingRedactions(filter?)` is
+the reactive pending list, `useRedactionSettings()` the settings, and
+`useRedactionEvent((redaction) => redaction.onApplied, handler)` subscribes
+for the mounted lifetime — all from `@embedpdf/react/redaction`.

package/dist/contract-Ib0iOWF3.cjs

@@ -0,0 +1,43 @@
+//#region src/token.ts
+/** The package token, created once here and re-exported by `contract.ts`. */
+const RedactionToken = (0, require("@embedpdf/core").createCapabilityToken)("redaction", {
+	hint: `add redactionPlugin() from '@embedpdf/plugin-redaction' to your plugins list`,
+	promises: {
+		markSelection: true,
+		markArea: true,
+		markPage: true,
+		markMatches: true,
+		unmark: true,
+		clearPending: true,
+		updateLabel: true,
+		apply: true,
+		applyAll: true,
+		applyPages: true
+	}
+});
+//#endregion
+//#region src/contract.ts
+/** What the redaction settings are when the app registers none. */
+const REDACTION_DEFAULTS = { overlay: {
+	fill: "#000000",
+	text: {
+		color: "#ffffff",
+		fontFamily: "helvetica",
+		fontSize: 0
+	}
+} };
+//#endregion
+Object.defineProperty(exports, "REDACTION_DEFAULTS", {
+	enumerable: true,
+	get: function() {
+		return REDACTION_DEFAULTS;
+	}
+});
+Object.defineProperty(exports, "RedactionToken", {
+	enumerable: true,
+	get: function() {
+		return RedactionToken;
+	}
+});
+
+//# sourceMappingURL=contract-Ib0iOWF3.cjs.map

package/dist/contract-Ib0iOWF3.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-Ib0iOWF3.cjs","names":[],"sources":["../src/token.ts","../src/contract.ts"],"sourcesContent":["/** The package token, created once here and re-exported by `contract.ts`. */\nimport { createCapabilityToken } from '@embedpdf/core';\n\nimport type { RedactionCapability } from './contract';\n\nexport const RedactionToken = createCapabilityToken<RedactionCapability>('redaction', {\n  hint: `add redactionPlugin() from '@embedpdf/plugin-redaction' to your plugins list`,\n  // Without a document, an adapter's stand-in rejects these with `not-ready`, as the\n  // capability would; the type asks for every member that returns a promise.\n  promises: {\n    markSelection: true,\n    markArea: true,\n    markPage: true,\n    markMatches: true,\n    unmark: true,\n    clearPending: true,\n    updateLabel: true,\n    apply: true,\n    applyAll: true,\n    applyPages: true,\n  },\n});\n","/**\n * @embedpdf/plugin-redaction/contract: the public redaction vocabulary.\n * Marking is annotation authoring (a mark is a `redact` annotation); applying\n * is the destructive document mutation. The plugin owns no mark state: the\n * pending view is a live projection of the annotation plane.\n */\nimport type {\n  BatchResult,\n  DeepPartial,\n  EventHook,\n  EventOrigin,\n  OperationOptions,\n  SettingsApi,\n} from '@embedpdf/core';\nimport type { Rect } from '@embedpdf/core-geometry';\nimport type {\n  AnnotationRef,\n  FreeTextFont,\n  PageRef,\n  RedactionApplyResult,\n  SearchQuery,\n} from '@embedpdf/engine-core';\n\nexport { RedactionToken } from './token';\nexport type { RedactionApplyResult } from '@embedpdf/engine-core';\n\n/**\n * The redaction plugin's settings. `redactionPlugin(config)` registers them\n * over {@link REDACTION_DEFAULTS}, and `updateSettings()` changes them for\n * every document while the app runs. They are PDF colors and fonts, written\n * into each mark, so CSS doesn't reach them.\n */\nexport interface RedactionSettings {\n  /**\n   * What applying paints over every mark, whichever way it was made: the\n   * `redact` tool, the selected text, or code. They are the redact tool's\n   * defaults from then on; a style panel can still change one mark.\n   */\n  readonly overlay: {\n    /** The color of a redacted area. */\n    readonly fill: string;\n    readonly text: {\n      /** The color of a label. */\n      readonly color: string;\n      /** The label's font: a standard font or a registered one. */\n      readonly fontFamily: FreeTextFont;\n      /** The label's size in points; `0` fits it to the area. */\n      readonly fontSize: number;\n    };\n  };\n}\n\n/** What the redaction settings are when the app registers none. */\nexport const REDACTION_DEFAULTS: RedactionSettings = {\n  overlay: {\n    fill: '#000000',\n    text: { color: '#ffffff', fontFamily: 'helvetica', fontSize: 0 },\n  },\n};\n\n/** What `redactionPlugin(config)` takes: any of the settings, merged over the defaults. */\nexport type RedactionConfig = DeepPartial<RedactionSettings>;\n\n/**\n * One pending redaction mark — a live projection of a `redact` annotation on\n * the annotation plane (delete the annotation and the mark is gone).\n */\nexport interface RedactionMark {\n  readonly ref: AnnotationRef;\n  readonly page: PageRef;\n  /** Display index (0-based) from the page registry — for \"page N\" labels. */\n  readonly pageIndex: number;\n  /** `area` = rect-only mark (marquee); `text` = per-line quads (selection). */\n  readonly kind: 'area' | 'text';\n  /** Page-space bounds of the region. */\n  readonly bounds: Rect;\n  /** `/OverlayText` label, when set. */\n  readonly overlayText: string | null;\n  /** Whether the label fills the area over and over, or shows once. */\n  readonly repeat: boolean;\n}\n\nexport interface RedactionMarkFilter {\n  /** One page's marks: its ref or its index. */\n  readonly page?: PageRef | number;\n}\n\n/** A label edit: `overlayText: null` clears it; `repeat` tiles it. */\nexport interface RedactionLabelPatch {\n  overlayText?: string | null;\n  repeat?: boolean;\n}\n\n/** Which other annotations an apply would destroy (a client-side estimate; the result is authoritative). */\nexport interface RedactionCollateral {\n  readonly count: number;\n  readonly refs: readonly AnnotationRef[];\n}\n\n// ── events ──\n/** A confirmed apply, from this session or another. */\nexport interface RedactionAppliedEvent {\n  readonly result: RedactionApplyResult;\n  readonly origin: EventOrigin;\n}\n/** Marks were created, changed or removed on these pages. */\nexport interface RedactionPendingChangedEvent {\n  readonly pages: readonly PageRef[];\n}\n\n/**\n * Redaction for one document: marking (a mark is a `redact` annotation), the\n * pending marks, and applying them, which can't be undone. A page argument\n * is a ref or an index: a read given a page that isn't there answers empty,\n * a verb refuses it with `not-found`. Every async verb takes a `signal`. The\n * settings belong to the plugin, not to a document.\n */\nexport interface RedactionCapability extends SettingsApi<RedactionSettings> {\n  /**\n   * Whether marking is allowed. Marking and applying are different powers: a\n   * mark is an ordinary `redact` annotation, so this is annotation create\n   * authority (matches Acrobat: any reviewer who can annotate can propose\n   * redactions).\n   */\n  canMark(): boolean;\n  /** Whether this mark may be removed before it's applied: it is a mark, and may be deleted (`annotations:delete`). */\n  canUnmark(ref: AnnotationRef): boolean;\n  /** Whether this mark's label may change: it is a mark, and may be changed (`annotations:update`). */\n  canUpdateLabel(ref: AnnotationRef): boolean;\n  /**\n   * Whether applying is allowed: the engine has a redaction service and every\n   * capability its apply asserts is granted (`doc.redact`, `doc.pages.modify`,\n   * `doc.annotate.modify`).\n   */\n  canApply(): boolean;\n  /** An apply of this session is running at the engine. */\n  isApplying(): boolean;\n  /** The last confirmed apply result, from this session or another. */\n  getLastResult(): RedactionApplyResult | null;\n\n  // ── the pending view ──\n  /** Pending marks in page order, or one page's. Reference-stable while unchanged. */\n  listPending(filter?: RedactionMarkFilter): readonly RedactionMark[];\n  getPending(ref: AnnotationRef): RedactionMark | null;\n  /** How many marks wait to be applied, in the document or on one page. */\n  getPendingCount(page?: PageRef | number): number;\n  /** Which other annotations applying these marks (default: all) would destroy. */\n  estimateCollateral(refs?: readonly AnnotationRef[]): RedactionCollateral;\n\n  // ── marking ──\n  // Every marking verb rejects `permission-denied` without annotation create\n  // authority (see `canMark`). Marks take the `overlay` settings.\n  /**\n   * Mark the current text selection (one mark per page) and clear it.\n   * Resolves `{ marks }`, empty without a selection; rejects `unsupported`\n   * without the selection plugin.\n   */\n  markSelection(options?: OperationOptions): Promise<{ marks: readonly RedactionMark[] }>;\n  /** Mark a page-space rectangle. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */\n  markArea(\n    page: PageRef | number,\n    bounds: Rect,\n    options?: OperationOptions,\n  ): Promise<{ mark: RedactionMark }>;\n  /** Mark a whole page. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */\n  markPage(page: PageRef | number, options?: OperationOptions): Promise<{ mark: RedactionMark }>;\n  /**\n   * Mark every match of a search, or the ones on some pages. Runs the query\n   * through the search plugin, so it replaces the user's current search.\n   * Resolves `{ marks }`, one per match; rejects `unsupported` without the\n   * search plugin.\n   */\n  markMatches(\n    query: SearchQuery,\n    options?: { pages?: readonly (PageRef | number)[] } & OperationOptions,\n  ): Promise<{ marks: readonly RedactionMark[] }>;\n  /**\n   * Remove marks without applying them. Refs that are not pending marks are\n   * skipped; a mark this session may not delete fails with\n   * `permission-denied` (see `canUnmark`).\n   */\n  unmark(\n    refs: readonly AnnotationRef[],\n    options?: OperationOptions,\n  ): Promise<BatchResult<AnnotationRef, AnnotationRef>>;\n  /** Remove every mark, as `unmark` does. */\n  clearPending(options?: OperationOptions): Promise<BatchResult<AnnotationRef, AnnotationRef>>;\n  /**\n   * Set the label a mark shows once it's applied; `overlayText: null` clears\n   * it. Keeps the mark's font and colors. Resolves `{ mark }`. Rejects\n   * `not-found` for a ref that isn't a mark, `permission-denied` when\n   * `canUpdateLabel(ref)` is false.\n   */\n  updateLabel(\n    ref: AnnotationRef,\n    patch: RedactionLabelPatch,\n    options?: OperationOptions,\n  ): Promise<{ mark: RedactionMark }>;\n\n  // ── applying (irreversible) ──\n  /**\n   * Apply specific pending marks. Per-page outcomes ride the result. Applies\n   * run one at a time in call order; when one resolves, `getLastResult()`\n   * holds its result and `onApplied` has fired. Rejects with `not-found` when\n   * none of the refs is a pending mark, `unsupported` without an engine\n   * redaction service, or the engine's `permission-denied`.\n   */\n  apply(refs: readonly AnnotationRef[], options?: OperationOptions): Promise<RedactionApplyResult>;\n  /**\n   * Apply every redaction in the document, in pages scope, including marks\n   * on pages this client never loaded. Rejects like `apply`, and with\n   * `not-ready` when the document has no pages.\n   */\n  applyAll(options?: OperationOptions): Promise<RedactionApplyResult>;\n  /**\n   * Apply the marks on some pages. Rejects like `apply`, with\n   * `invalid-input` for no pages, and `not-found` for a page that isn't there.\n   */\n  applyPages(\n    pages: readonly (PageRef | number)[],\n    options?: OperationOptions,\n  ): Promise<RedactionApplyResult>;\n\n  // ── events ──\n  /** A confirmed apply, from this session or another; fires after `getLastResult()` changed. */\n  readonly onApplied: EventHook<RedactionAppliedEvent>;\n  /** Marks were created, changed or removed on some pages. */\n  readonly onPendingChanged: EventHook<RedactionPendingChangedEvent>;\n}\n"],"mappings":";;AAKA,MAAa,kBAAA,2BAAA,CAAA,CAAA,sBAAA,CAA4D,aAAa;CACpF,MAAM;CAGN,UAAU;EACR,eAAe;EACf,UAAU;EACV,UAAU;EACV,aAAa;EACb,QAAQ;EACR,cAAc;EACd,aAAa;EACb,OAAO;EACP,UAAU;EACV,YAAY;CACd;AACF,CAAC;;;;ACgCD,MAAa,qBAAwC,EACnD,SAAS;CACP,MAAM;CACN,MAAM;EAAE,OAAO;EAAW,YAAY;EAAa,UAAU;CAAE;AACjE,EACF"}

package/dist/contract-TU9orxrO.d.cts

@@ -0,0 +1,184 @@
+import { BatchResult, DeepPartial, EventHook, EventOrigin, OperationOptions, SettingsApi } from "@embedpdf/core";
+import { Rect } from "@embedpdf/core-geometry";
+import { AnnotationRef, FreeTextFont, PageRef, RedactionApplyResult, RedactionApplyResult as RedactionApplyResult$1, SearchQuery } from "@embedpdf/engine-core";
+//#region src/token.d.ts
+declare const RedactionToken: import("@embedpdf/core").CapabilityToken<RedactionCapability>;
+//#endregion
+//#region src/contract.d.ts
+/**
+ * The redaction plugin's settings. `redactionPlugin(config)` registers them
+ * over {@link REDACTION_DEFAULTS}, and `updateSettings()` changes them for
+ * every document while the app runs. They are PDF colors and fonts, written
+ * into each mark, so CSS doesn't reach them.
+ */
+interface RedactionSettings {
+  /**
+   * What applying paints over every mark, whichever way it was made: the
+   * `redact` tool, the selected text, or code. They are the redact tool's
+   * defaults from then on; a style panel can still change one mark.
+   */
+  readonly overlay: {
+    /** The color of a redacted area. */
+    readonly fill: string;
+    readonly text: {
+      /** The color of a label. */
+      readonly color: string;
+      /** The label's font: a standard font or a registered one. */
+      readonly fontFamily: FreeTextFont;
+      /** The label's size in points; `0` fits it to the area. */
+      readonly fontSize: number;
+    };
+  };
+}
+/** What the redaction settings are when the app registers none. */
+declare const REDACTION_DEFAULTS: RedactionSettings;
+/** What `redactionPlugin(config)` takes: any of the settings, merged over the defaults. */
+type RedactionConfig = DeepPartial<RedactionSettings>;
+/**
+ * One pending redaction mark — a live projection of a `redact` annotation on
+ * the annotation plane (delete the annotation and the mark is gone).
+ */
+interface RedactionMark {
+  readonly ref: AnnotationRef;
+  readonly page: PageRef;
+  /** Display index (0-based) from the page registry — for "page N" labels. */
+  readonly pageIndex: number;
+  /** `area` = rect-only mark (marquee); `text` = per-line quads (selection). */
+  readonly kind: 'area' | 'text';
+  /** Page-space bounds of the region. */
+  readonly bounds: Rect;
+  /** `/OverlayText` label, when set. */
+  readonly overlayText: string | null;
+  /** Whether the label fills the area over and over, or shows once. */
+  readonly repeat: boolean;
+}
+interface RedactionMarkFilter {
+  /** One page's marks: its ref or its index. */
+  readonly page?: PageRef | number;
+}
+/** A label edit: `overlayText: null` clears it; `repeat` tiles it. */
+interface RedactionLabelPatch {
+  overlayText?: string | null;
+  repeat?: boolean;
+}
+/** Which other annotations an apply would destroy (a client-side estimate; the result is authoritative). */
+interface RedactionCollateral {
+  readonly count: number;
+  readonly refs: readonly AnnotationRef[];
+}
+/** A confirmed apply, from this session or another. */
+interface RedactionAppliedEvent {
+  readonly result: RedactionApplyResult;
+  readonly origin: EventOrigin;
+}
+/** Marks were created, changed or removed on these pages. */
+interface RedactionPendingChangedEvent {
+  readonly pages: readonly PageRef[];
+}
+/**
+ * Redaction for one document: marking (a mark is a `redact` annotation), the
+ * pending marks, and applying them, which can't be undone. A page argument
+ * is a ref or an index: a read given a page that isn't there answers empty,
+ * a verb refuses it with `not-found`. Every async verb takes a `signal`. The
+ * settings belong to the plugin, not to a document.
+ */
+interface RedactionCapability extends SettingsApi<RedactionSettings> {
+  /**
+   * Whether marking is allowed. Marking and applying are different powers: a
+   * mark is an ordinary `redact` annotation, so this is annotation create
+   * authority (matches Acrobat: any reviewer who can annotate can propose
+   * redactions).
+   */
+  canMark(): boolean;
+  /** Whether this mark may be removed before it's applied: it is a mark, and may be deleted (`annotations:delete`). */
+  canUnmark(ref: AnnotationRef): boolean;
+  /** Whether this mark's label may change: it is a mark, and may be changed (`annotations:update`). */
+  canUpdateLabel(ref: AnnotationRef): boolean;
+  /**
+   * Whether applying is allowed: the engine has a redaction service and every
+   * capability its apply asserts is granted (`doc.redact`, `doc.pages.modify`,
+   * `doc.annotate.modify`).
+   */
+  canApply(): boolean;
+  /** An apply of this session is running at the engine. */
+  isApplying(): boolean;
+  /** The last confirmed apply result, from this session or another. */
+  getLastResult(): RedactionApplyResult | null;
+  /** Pending marks in page order, or one page's. Reference-stable while unchanged. */
+  listPending(filter?: RedactionMarkFilter): readonly RedactionMark[];
+  getPending(ref: AnnotationRef): RedactionMark | null;
+  /** How many marks wait to be applied, in the document or on one page. */
+  getPendingCount(page?: PageRef | number): number;
+  /** Which other annotations applying these marks (default: all) would destroy. */
+  estimateCollateral(refs?: readonly AnnotationRef[]): RedactionCollateral;
+  /**
+   * Mark the current text selection (one mark per page) and clear it.
+   * Resolves `{ marks }`, empty without a selection; rejects `unsupported`
+   * without the selection plugin.
+   */
+  markSelection(options?: OperationOptions): Promise<{
+    marks: readonly RedactionMark[];
+  }>;
+  /** Mark a page-space rectangle. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */
+  markArea(page: PageRef | number, bounds: Rect, options?: OperationOptions): Promise<{
+    mark: RedactionMark;
+  }>;
+  /** Mark a whole page. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */
+  markPage(page: PageRef | number, options?: OperationOptions): Promise<{
+    mark: RedactionMark;
+  }>;
+  /**
+   * Mark every match of a search, or the ones on some pages. Runs the query
+   * through the search plugin, so it replaces the user's current search.
+   * Resolves `{ marks }`, one per match; rejects `unsupported` without the
+   * search plugin.
+   */
+  markMatches(query: SearchQuery, options?: {
+    pages?: readonly (PageRef | number)[];
+  } & OperationOptions): Promise<{
+    marks: readonly RedactionMark[];
+  }>;
+  /**
+   * Remove marks without applying them. Refs that are not pending marks are
+   * skipped; a mark this session may not delete fails with
+   * `permission-denied` (see `canUnmark`).
+   */
+  unmark(refs: readonly AnnotationRef[], options?: OperationOptions): Promise<BatchResult<AnnotationRef, AnnotationRef>>;
+  /** Remove every mark, as `unmark` does. */
+  clearPending(options?: OperationOptions): Promise<BatchResult<AnnotationRef, AnnotationRef>>;
+  /**
+   * Set the label a mark shows once it's applied; `overlayText: null` clears
+   * it. Keeps the mark's font and colors. Resolves `{ mark }`. Rejects
+   * `not-found` for a ref that isn't a mark, `permission-denied` when
+   * `canUpdateLabel(ref)` is false.
+   */
+  updateLabel(ref: AnnotationRef, patch: RedactionLabelPatch, options?: OperationOptions): Promise<{
+    mark: RedactionMark;
+  }>;
+  /**
+   * Apply specific pending marks. Per-page outcomes ride the result. Applies
+   * run one at a time in call order; when one resolves, `getLastResult()`
+   * holds its result and `onApplied` has fired. Rejects with `not-found` when
+   * none of the refs is a pending mark, `unsupported` without an engine
+   * redaction service, or the engine's `permission-denied`.
+   */
+  apply(refs: readonly AnnotationRef[], options?: OperationOptions): Promise<RedactionApplyResult>;
+  /**
+   * Apply every redaction in the document, in pages scope, including marks
+   * on pages this client never loaded. Rejects like `apply`, and with
+   * `not-ready` when the document has no pages.
+   */
+  applyAll(options?: OperationOptions): Promise<RedactionApplyResult>;
+  /**
+   * Apply the marks on some pages. Rejects like `apply`, with
+   * `invalid-input` for no pages, and `not-found` for a page that isn't there.
+   */
+  applyPages(pages: readonly (PageRef | number)[], options?: OperationOptions): Promise<RedactionApplyResult>;
+  /** A confirmed apply, from this session or another; fires after `getLastResult()` changed. */
+  readonly onApplied: EventHook<RedactionAppliedEvent>;
+  /** Marks were created, changed or removed on some pages. */
+  readonly onPendingChanged: EventHook<RedactionPendingChangedEvent>;
+}
+//#endregion
+export { RedactionCollateral as a, RedactionMark as c, RedactionSettings as d, RedactionToken as f, RedactionCapability as i, RedactionMarkFilter as l, RedactionAppliedEvent as n, RedactionConfig as o, RedactionApplyResult$1 as r, RedactionLabelPatch as s, REDACTION_DEFAULTS as t, RedactionPendingChangedEvent as u };
+//# sourceMappingURL=contract-TU9orxrO.d.cts.map

package/dist/contract-TU9orxrO.d.ts

@@ -0,0 +1,184 @@
+import { BatchResult, DeepPartial, EventHook, EventOrigin, OperationOptions, SettingsApi } from "@embedpdf/core";
+import { Rect } from "@embedpdf/core-geometry";
+import { AnnotationRef, FreeTextFont, PageRef, RedactionApplyResult, RedactionApplyResult as RedactionApplyResult$1, SearchQuery } from "@embedpdf/engine-core";
+//#region src/token.d.ts
+declare const RedactionToken: import("@embedpdf/core").CapabilityToken<RedactionCapability>;
+//#endregion
+//#region src/contract.d.ts
+/**
+ * The redaction plugin's settings. `redactionPlugin(config)` registers them
+ * over {@link REDACTION_DEFAULTS}, and `updateSettings()` changes them for
+ * every document while the app runs. They are PDF colors and fonts, written
+ * into each mark, so CSS doesn't reach them.
+ */
+interface RedactionSettings {
+  /**
+   * What applying paints over every mark, whichever way it was made: the
+   * `redact` tool, the selected text, or code. They are the redact tool's
+   * defaults from then on; a style panel can still change one mark.
+   */
+  readonly overlay: {
+    /** The color of a redacted area. */
+    readonly fill: string;
+    readonly text: {
+      /** The color of a label. */
+      readonly color: string;
+      /** The label's font: a standard font or a registered one. */
+      readonly fontFamily: FreeTextFont;
+      /** The label's size in points; `0` fits it to the area. */
+      readonly fontSize: number;
+    };
+  };
+}
+/** What the redaction settings are when the app registers none. */
+declare const REDACTION_DEFAULTS: RedactionSettings;
+/** What `redactionPlugin(config)` takes: any of the settings, merged over the defaults. */
+type RedactionConfig = DeepPartial<RedactionSettings>;
+/**
+ * One pending redaction mark — a live projection of a `redact` annotation on
+ * the annotation plane (delete the annotation and the mark is gone).
+ */
+interface RedactionMark {
+  readonly ref: AnnotationRef;
+  readonly page: PageRef;
+  /** Display index (0-based) from the page registry — for "page N" labels. */
+  readonly pageIndex: number;
+  /** `area` = rect-only mark (marquee); `text` = per-line quads (selection). */
+  readonly kind: 'area' | 'text';
+  /** Page-space bounds of the region. */
+  readonly bounds: Rect;
+  /** `/OverlayText` label, when set. */
+  readonly overlayText: string | null;
+  /** Whether the label fills the area over and over, or shows once. */
+  readonly repeat: boolean;
+}
+interface RedactionMarkFilter {
+  /** One page's marks: its ref or its index. */
+  readonly page?: PageRef | number;
+}
+/** A label edit: `overlayText: null` clears it; `repeat` tiles it. */
+interface RedactionLabelPatch {
+  overlayText?: string | null;
+  repeat?: boolean;
+}
+/** Which other annotations an apply would destroy (a client-side estimate; the result is authoritative). */
+interface RedactionCollateral {
+  readonly count: number;
+  readonly refs: readonly AnnotationRef[];
+}
+/** A confirmed apply, from this session or another. */
+interface RedactionAppliedEvent {
+  readonly result: RedactionApplyResult;
+  readonly origin: EventOrigin;
+}
+/** Marks were created, changed or removed on these pages. */
+interface RedactionPendingChangedEvent {
+  readonly pages: readonly PageRef[];
+}
+/**
+ * Redaction for one document: marking (a mark is a `redact` annotation), the
+ * pending marks, and applying them, which can't be undone. A page argument
+ * is a ref or an index: a read given a page that isn't there answers empty,
+ * a verb refuses it with `not-found`. Every async verb takes a `signal`. The
+ * settings belong to the plugin, not to a document.
+ */
+interface RedactionCapability extends SettingsApi<RedactionSettings> {
+  /**
+   * Whether marking is allowed. Marking and applying are different powers: a
+   * mark is an ordinary `redact` annotation, so this is annotation create
+   * authority (matches Acrobat: any reviewer who can annotate can propose
+   * redactions).
+   */
+  canMark(): boolean;
+  /** Whether this mark may be removed before it's applied: it is a mark, and may be deleted (`annotations:delete`). */
+  canUnmark(ref: AnnotationRef): boolean;
+  /** Whether this mark's label may change: it is a mark, and may be changed (`annotations:update`). */
+  canUpdateLabel(ref: AnnotationRef): boolean;
+  /**
+   * Whether applying is allowed: the engine has a redaction service and every
+   * capability its apply asserts is granted (`doc.redact`, `doc.pages.modify`,
+   * `doc.annotate.modify`).
+   */
+  canApply(): boolean;
+  /** An apply of this session is running at the engine. */
+  isApplying(): boolean;
+  /** The last confirmed apply result, from this session or another. */
+  getLastResult(): RedactionApplyResult | null;
+  /** Pending marks in page order, or one page's. Reference-stable while unchanged. */
+  listPending(filter?: RedactionMarkFilter): readonly RedactionMark[];
+  getPending(ref: AnnotationRef): RedactionMark | null;
+  /** How many marks wait to be applied, in the document or on one page. */
+  getPendingCount(page?: PageRef | number): number;
+  /** Which other annotations applying these marks (default: all) would destroy. */
+  estimateCollateral(refs?: readonly AnnotationRef[]): RedactionCollateral;
+  /**
+   * Mark the current text selection (one mark per page) and clear it.
+   * Resolves `{ marks }`, empty without a selection; rejects `unsupported`
+   * without the selection plugin.
+   */
+  markSelection(options?: OperationOptions): Promise<{
+    marks: readonly RedactionMark[];
+  }>;
+  /** Mark a page-space rectangle. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */
+  markArea(page: PageRef | number, bounds: Rect, options?: OperationOptions): Promise<{
+    mark: RedactionMark;
+  }>;
+  /** Mark a whole page. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */
+  markPage(page: PageRef | number, options?: OperationOptions): Promise<{
+    mark: RedactionMark;
+  }>;
+  /**
+   * Mark every match of a search, or the ones on some pages. Runs the query
+   * through the search plugin, so it replaces the user's current search.
+   * Resolves `{ marks }`, one per match; rejects `unsupported` without the
+   * search plugin.
+   */
+  markMatches(query: SearchQuery, options?: {
+    pages?: readonly (PageRef | number)[];
+  } & OperationOptions): Promise<{
+    marks: readonly RedactionMark[];
+  }>;
+  /**
+   * Remove marks without applying them. Refs that are not pending marks are
+   * skipped; a mark this session may not delete fails with
+   * `permission-denied` (see `canUnmark`).
+   */
+  unmark(refs: readonly AnnotationRef[], options?: OperationOptions): Promise<BatchResult<AnnotationRef, AnnotationRef>>;
+  /** Remove every mark, as `unmark` does. */
+  clearPending(options?: OperationOptions): Promise<BatchResult<AnnotationRef, AnnotationRef>>;
+  /**
+   * Set the label a mark shows once it's applied; `overlayText: null` clears
+   * it. Keeps the mark's font and colors. Resolves `{ mark }`. Rejects
+   * `not-found` for a ref that isn't a mark, `permission-denied` when
+   * `canUpdateLabel(ref)` is false.
+   */
+  updateLabel(ref: AnnotationRef, patch: RedactionLabelPatch, options?: OperationOptions): Promise<{
+    mark: RedactionMark;
+  }>;
+  /**
+   * Apply specific pending marks. Per-page outcomes ride the result. Applies
+   * run one at a time in call order; when one resolves, `getLastResult()`
+   * holds its result and `onApplied` has fired. Rejects with `not-found` when
+   * none of the refs is a pending mark, `unsupported` without an engine
+   * redaction service, or the engine's `permission-denied`.
+   */
+  apply(refs: readonly AnnotationRef[], options?: OperationOptions): Promise<RedactionApplyResult>;
+  /**
+   * Apply every redaction in the document, in pages scope, including marks
+   * on pages this client never loaded. Rejects like `apply`, and with
+   * `not-ready` when the document has no pages.
+   */
+  applyAll(options?: OperationOptions): Promise<RedactionApplyResult>;
+  /**
+   * Apply the marks on some pages. Rejects like `apply`, with
+   * `invalid-input` for no pages, and `not-found` for a page that isn't there.
+   */
+  applyPages(pages: readonly (PageRef | number)[], options?: OperationOptions): Promise<RedactionApplyResult>;
+  /** A confirmed apply, from this session or another; fires after `getLastResult()` changed. */
+  readonly onApplied: EventHook<RedactionAppliedEvent>;
+  /** Marks were created, changed or removed on some pages. */
+  readonly onPendingChanged: EventHook<RedactionPendingChangedEvent>;
+}
+//#endregion
+export { RedactionCollateral as a, RedactionMark as c, RedactionSettings as d, RedactionToken as f, RedactionCapability as i, RedactionMarkFilter as l, RedactionAppliedEvent as n, RedactionConfig as o, RedactionApplyResult$1 as r, RedactionLabelPatch as s, REDACTION_DEFAULTS as t, RedactionPendingChangedEvent as u };
+//# sourceMappingURL=contract-TU9orxrO.d.ts.map

package/dist/contract-eQ3P0UU-.js

@@ -0,0 +1,33 @@
+import { createCapabilityToken } from "@embedpdf/core";
+//#region src/token.ts
+/** The package token, created once here and re-exported by `contract.ts`. */
+const RedactionToken = createCapabilityToken("redaction", {
+	hint: `add redactionPlugin() from '@embedpdf/plugin-redaction' to your plugins list`,
+	promises: {
+		markSelection: true,
+		markArea: true,
+		markPage: true,
+		markMatches: true,
+		unmark: true,
+		clearPending: true,
+		updateLabel: true,
+		apply: true,
+		applyAll: true,
+		applyPages: true
+	}
+});
+//#endregion
+//#region src/contract.ts
+/** What the redaction settings are when the app registers none. */
+const REDACTION_DEFAULTS = { overlay: {
+	fill: "#000000",
+	text: {
+		color: "#ffffff",
+		fontFamily: "helvetica",
+		fontSize: 0
+	}
+} };
+//#endregion
+export { RedactionToken as n, REDACTION_DEFAULTS as t };
+
+//# sourceMappingURL=contract-eQ3P0UU-.js.map

package/dist/contract-eQ3P0UU-.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-eQ3P0UU-.js","names":[],"sources":["../src/token.ts","../src/contract.ts"],"sourcesContent":["/** The package token, created once here and re-exported by `contract.ts`. */\nimport { createCapabilityToken } from '@embedpdf/core';\n\nimport type { RedactionCapability } from './contract';\n\nexport const RedactionToken = createCapabilityToken<RedactionCapability>('redaction', {\n  hint: `add redactionPlugin() from '@embedpdf/plugin-redaction' to your plugins list`,\n  // Without a document, an adapter's stand-in rejects these with `not-ready`, as the\n  // capability would; the type asks for every member that returns a promise.\n  promises: {\n    markSelection: true,\n    markArea: true,\n    markPage: true,\n    markMatches: true,\n    unmark: true,\n    clearPending: true,\n    updateLabel: true,\n    apply: true,\n    applyAll: true,\n    applyPages: true,\n  },\n});\n","/**\n * @embedpdf/plugin-redaction/contract: the public redaction vocabulary.\n * Marking is annotation authoring (a mark is a `redact` annotation); applying\n * is the destructive document mutation. The plugin owns no mark state: the\n * pending view is a live projection of the annotation plane.\n */\nimport type {\n  BatchResult,\n  DeepPartial,\n  EventHook,\n  EventOrigin,\n  OperationOptions,\n  SettingsApi,\n} from '@embedpdf/core';\nimport type { Rect } from '@embedpdf/core-geometry';\nimport type {\n  AnnotationRef,\n  FreeTextFont,\n  PageRef,\n  RedactionApplyResult,\n  SearchQuery,\n} from '@embedpdf/engine-core';\n\nexport { RedactionToken } from './token';\nexport type { RedactionApplyResult } from '@embedpdf/engine-core';\n\n/**\n * The redaction plugin's settings. `redactionPlugin(config)` registers them\n * over {@link REDACTION_DEFAULTS}, and `updateSettings()` changes them for\n * every document while the app runs. They are PDF colors and fonts, written\n * into each mark, so CSS doesn't reach them.\n */\nexport interface RedactionSettings {\n  /**\n   * What applying paints over every mark, whichever way it was made: the\n   * `redact` tool, the selected text, or code. They are the redact tool's\n   * defaults from then on; a style panel can still change one mark.\n   */\n  readonly overlay: {\n    /** The color of a redacted area. */\n    readonly fill: string;\n    readonly text: {\n      /** The color of a label. */\n      readonly color: string;\n      /** The label's font: a standard font or a registered one. */\n      readonly fontFamily: FreeTextFont;\n      /** The label's size in points; `0` fits it to the area. */\n      readonly fontSize: number;\n    };\n  };\n}\n\n/** What the redaction settings are when the app registers none. */\nexport const REDACTION_DEFAULTS: RedactionSettings = {\n  overlay: {\n    fill: '#000000',\n    text: { color: '#ffffff', fontFamily: 'helvetica', fontSize: 0 },\n  },\n};\n\n/** What `redactionPlugin(config)` takes: any of the settings, merged over the defaults. */\nexport type RedactionConfig = DeepPartial<RedactionSettings>;\n\n/**\n * One pending redaction mark — a live projection of a `redact` annotation on\n * the annotation plane (delete the annotation and the mark is gone).\n */\nexport interface RedactionMark {\n  readonly ref: AnnotationRef;\n  readonly page: PageRef;\n  /** Display index (0-based) from the page registry — for \"page N\" labels. */\n  readonly pageIndex: number;\n  /** `area` = rect-only mark (marquee); `text` = per-line quads (selection). */\n  readonly kind: 'area' | 'text';\n  /** Page-space bounds of the region. */\n  readonly bounds: Rect;\n  /** `/OverlayText` label, when set. */\n  readonly overlayText: string | null;\n  /** Whether the label fills the area over and over, or shows once. */\n  readonly repeat: boolean;\n}\n\nexport interface RedactionMarkFilter {\n  /** One page's marks: its ref or its index. */\n  readonly page?: PageRef | number;\n}\n\n/** A label edit: `overlayText: null` clears it; `repeat` tiles it. */\nexport interface RedactionLabelPatch {\n  overlayText?: string | null;\n  repeat?: boolean;\n}\n\n/** Which other annotations an apply would destroy (a client-side estimate; the result is authoritative). */\nexport interface RedactionCollateral {\n  readonly count: number;\n  readonly refs: readonly AnnotationRef[];\n}\n\n// ── events ──\n/** A confirmed apply, from this session or another. */\nexport interface RedactionAppliedEvent {\n  readonly result: RedactionApplyResult;\n  readonly origin: EventOrigin;\n}\n/** Marks were created, changed or removed on these pages. */\nexport interface RedactionPendingChangedEvent {\n  readonly pages: readonly PageRef[];\n}\n\n/**\n * Redaction for one document: marking (a mark is a `redact` annotation), the\n * pending marks, and applying them, which can't be undone. A page argument\n * is a ref or an index: a read given a page that isn't there answers empty,\n * a verb refuses it with `not-found`. Every async verb takes a `signal`. The\n * settings belong to the plugin, not to a document.\n */\nexport interface RedactionCapability extends SettingsApi<RedactionSettings> {\n  /**\n   * Whether marking is allowed. Marking and applying are different powers: a\n   * mark is an ordinary `redact` annotation, so this is annotation create\n   * authority (matches Acrobat: any reviewer who can annotate can propose\n   * redactions).\n   */\n  canMark(): boolean;\n  /** Whether this mark may be removed before it's applied: it is a mark, and may be deleted (`annotations:delete`). */\n  canUnmark(ref: AnnotationRef): boolean;\n  /** Whether this mark's label may change: it is a mark, and may be changed (`annotations:update`). */\n  canUpdateLabel(ref: AnnotationRef): boolean;\n  /**\n   * Whether applying is allowed: the engine has a redaction service and every\n   * capability its apply asserts is granted (`doc.redact`, `doc.pages.modify`,\n   * `doc.annotate.modify`).\n   */\n  canApply(): boolean;\n  /** An apply of this session is running at the engine. */\n  isApplying(): boolean;\n  /** The last confirmed apply result, from this session or another. */\n  getLastResult(): RedactionApplyResult | null;\n\n  // ── the pending view ──\n  /** Pending marks in page order, or one page's. Reference-stable while unchanged. */\n  listPending(filter?: RedactionMarkFilter): readonly RedactionMark[];\n  getPending(ref: AnnotationRef): RedactionMark | null;\n  /** How many marks wait to be applied, in the document or on one page. */\n  getPendingCount(page?: PageRef | number): number;\n  /** Which other annotations applying these marks (default: all) would destroy. */\n  estimateCollateral(refs?: readonly AnnotationRef[]): RedactionCollateral;\n\n  // ── marking ──\n  // Every marking verb rejects `permission-denied` without annotation create\n  // authority (see `canMark`). Marks take the `overlay` settings.\n  /**\n   * Mark the current text selection (one mark per page) and clear it.\n   * Resolves `{ marks }`, empty without a selection; rejects `unsupported`\n   * without the selection plugin.\n   */\n  markSelection(options?: OperationOptions): Promise<{ marks: readonly RedactionMark[] }>;\n  /** Mark a page-space rectangle. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */\n  markArea(\n    page: PageRef | number,\n    bounds: Rect,\n    options?: OperationOptions,\n  ): Promise<{ mark: RedactionMark }>;\n  /** Mark a whole page. Resolves `{ mark }`; rejects `not-found` for a page that isn't there. */\n  markPage(page: PageRef | number, options?: OperationOptions): Promise<{ mark: RedactionMark }>;\n  /**\n   * Mark every match of a search, or the ones on some pages. Runs the query\n   * through the search plugin, so it replaces the user's current search.\n   * Resolves `{ marks }`, one per match; rejects `unsupported` without the\n   * search plugin.\n   */\n  markMatches(\n    query: SearchQuery,\n    options?: { pages?: readonly (PageRef | number)[] } & OperationOptions,\n  ): Promise<{ marks: readonly RedactionMark[] }>;\n  /**\n   * Remove marks without applying them. Refs that are not pending marks are\n   * skipped; a mark this session may not delete fails with\n   * `permission-denied` (see `canUnmark`).\n   */\n  unmark(\n    refs: readonly AnnotationRef[],\n    options?: OperationOptions,\n  ): Promise<BatchResult<AnnotationRef, AnnotationRef>>;\n  /** Remove every mark, as `unmark` does. */\n  clearPending(options?: OperationOptions): Promise<BatchResult<AnnotationRef, AnnotationRef>>;\n  /**\n   * Set the label a mark shows once it's applied; `overlayText: null` clears\n   * it. Keeps the mark's font and colors. Resolves `{ mark }`. Rejects\n   * `not-found` for a ref that isn't a mark, `permission-denied` when\n   * `canUpdateLabel(ref)` is false.\n   */\n  updateLabel(\n    ref: AnnotationRef,\n    patch: RedactionLabelPatch,\n    options?: OperationOptions,\n  ): Promise<{ mark: RedactionMark }>;\n\n  // ── applying (irreversible) ──\n  /**\n   * Apply specific pending marks. Per-page outcomes ride the result. Applies\n   * run one at a time in call order; when one resolves, `getLastResult()`\n   * holds its result and `onApplied` has fired. Rejects with `not-found` when\n   * none of the refs is a pending mark, `unsupported` without an engine\n   * redaction service, or the engine's `permission-denied`.\n   */\n  apply(refs: readonly AnnotationRef[], options?: OperationOptions): Promise<RedactionApplyResult>;\n  /**\n   * Apply every redaction in the document, in pages scope, including marks\n   * on pages this client never loaded. Rejects like `apply`, and with\n   * `not-ready` when the document has no pages.\n   */\n  applyAll(options?: OperationOptions): Promise<RedactionApplyResult>;\n  /**\n   * Apply the marks on some pages. Rejects like `apply`, with\n   * `invalid-input` for no pages, and `not-found` for a page that isn't there.\n   */\n  applyPages(\n    pages: readonly (PageRef | number)[],\n    options?: OperationOptions,\n  ): Promise<RedactionApplyResult>;\n\n  // ── events ──\n  /** A confirmed apply, from this session or another; fires after `getLastResult()` changed. */\n  readonly onApplied: EventHook<RedactionAppliedEvent>;\n  /** Marks were created, changed or removed on some pages. */\n  readonly onPendingChanged: EventHook<RedactionPendingChangedEvent>;\n}\n"],"mappings":";;;AAKA,MAAa,iBAAiB,sBAA2C,aAAa;CACpF,MAAM;CAGN,UAAU;EACR,eAAe;EACf,UAAU;EACV,UAAU;EACV,aAAa;EACb,QAAQ;EACR,cAAc;EACd,aAAa;EACb,OAAO;EACP,UAAU;EACV,YAAY;CACd;AACF,CAAC;;;;ACgCD,MAAa,qBAAwC,EACnD,SAAS;CACP,MAAM;CACN,MAAM;EAAE,OAAO;EAAW,YAAY;EAAa,UAAU;CAAE;AACjE,EACF"}

package/dist/contract.cjs

@@ -1,3 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_contract = require("./contract-CyLm5eeQ.cjs");
+const require_contract = require("./contract-Ib0iOWF3.cjs");
+exports.REDACTION_DEFAULTS = require_contract.REDACTION_DEFAULTS;
 exports.RedactionToken = require_contract.RedactionToken;