superdoc 2.2.0 → 2.3.0

package/dist/document-api/src/types/extract.types.d.ts

@@ -0,0 +1,163 @@
+import { CommentStatus, TrackChangeType, TrackChangeWordRevisionIds } from './index.js';
+/**
+ * Table coordinates for an {@link ExtractBlock} that lives inside a table cell.
+ *
+ * Blocks inside tables are extracted at paragraph granularity (one entry per
+ * paragraph/heading/listItem/image/sdt/tableOfContents in each cell). Group
+ * by these fields to reconstruct cells, rows, or whole tables:
+ *
+ * - cell:  group by `tableOrdinal + rowIndex + columnIndex`
+ * - row:   group by `tableOrdinal + rowIndex`
+ * - table: group by `tableOrdinal`
+ */
+export interface ExtractTableContext {
+    /** 0-based table ordinal, unique within one `extract()` result. */
+    tableOrdinal: number;
+    /** Ordinal of the parent table when this block is inside a nested table. */
+    parentTableOrdinal?: number;
+    /** Row index within the parent table. Only set with `parentTableOrdinal`. */
+    parentRowIndex?: number;
+    /** Column index within the parent table. Only set with `parentTableOrdinal`. */
+    parentColumnIndex?: number;
+    /** 0-based row index of the containing cell. */
+    rowIndex: number;
+    /** 0-based logical grid column of the containing cell, not the row's child order. */
+    columnIndex: number;
+    /** Number of rows the containing cell spans. 1 for unmerged cells. */
+    rowspan: number;
+    /** Number of columns the containing cell spans. 1 for unmerged cells. */
+    colspan: number;
+}
+/**
+ * Reference to a tracked change applied to one text span.
+ *
+ * The `entityId` matches an entry in `ExtractResult.trackedChanges`, so
+ * consumers can look up author/date or pass it to `scrollToElement()`.
+ */
+export interface ExtractTextSpanTrackedChange {
+    /** Tracked change entity ID. */
+    entityId: string;
+    /**
+     * The mark type carried on this run: insert, delete, or format.
+     * Entity-level paired replacements surface as `replacement` only on
+     * `ExtractResult.trackedChanges[]`, not on span marks.
+     */
+    type: TrackChangeType;
+}
+/**
+ * A contiguous run of text within a block, optionally tagged with the
+ * tracked-change marks that apply to it.
+ *
+ * Spans tile the block's text exactly:
+ * `block.textSpans.map(s => s.text).join('') === block.text`.
+ *
+ * Adjacent runs are coalesced when their `trackedChanges` sets are identical
+ * (same `(entityId, type)` pairs, ignoring order). Plain text with no tracked
+ * marks is one or more spans with `trackedChanges` omitted.
+ *
+ * A single span can carry multiple entries when overlapping marks apply, for
+ * example a run that is both inserted and bold-tracked.
+ */
+export interface ExtractTextSpan {
+    /** Raw text of the run. Tiles `block.text` when concatenated in order. */
+    text: string;
+    /** Tracked-change marks applied to this run. Omitted when none apply. */
+    trackedChanges?: ExtractTextSpanTrackedChange[];
+}
+/**
+ * One addressable unit of document content.
+ *
+ * Extraction is paragraph-granular: tables are NOT returned as a single block.
+ * Paragraph-like descendants of table cells are emitted individually with
+ * `tableContext` attached.
+ *
+ * Block SDTs (structured document tags / content controls) are transparent:
+ * their children emit individually as if they were direct children of the
+ * enclosing container. No wrapper `sdt` block is emitted. This prevents
+ * SDT-wrapped tables from re-flattening through the wrapper's textContent.
+ */
+export interface ExtractBlock {
+    /** Stable block ID. Pass to `scrollToElement()` for navigation. */
+    nodeId: string;
+    /** Block type: paragraph, heading, listItem, image, tableOfContents. */
+    type: string;
+    /** Full plain text content of the block. */
+    text: string;
+    /**
+     * Structured reconstruction of the block's text with tracked-change marks
+     * preserved per run. Present only when the block contains at least one
+     * tracked change. When concatenated, span text equals `text`.
+     */
+    textSpans?: ExtractTextSpan[];
+    /** Heading level (1-6). Only present for headings. */
+    headingLevel?: number;
+    /** Table coordinates. Only present for blocks inside a table cell. */
+    tableContext?: ExtractTableContext;
+}
+export interface ExtractComment {
+    /** Comment entity ID: pass to `scrollToElement()` for navigation. */
+    entityId: string;
+    /** Comment body text. */
+    text?: string;
+    /** The document text the comment is anchored to. */
+    anchoredText?: string;
+    /** Block ID the comment is anchored to (first segment). */
+    blockId?: string;
+    /** Comment status. */
+    status: CommentStatus;
+    /** Comment author name. */
+    author?: string;
+}
+export interface ExtractTrackedChange {
+    /** Tracked change entity ID. Pass to `scrollToElement()` for navigation. */
+    entityId: string;
+    /**
+     * Change type at the entity level.
+     *
+     * In paired replacement mode (the default: set
+     * `modules.trackChanges.replacements: 'independent'` for one entity per
+     * `<w:ins>` / `<w:del>` instead), a delete + insert pair shares one entity
+     * and `type` is `'replacement'`. Per-half information still lives on
+     * `block.textSpans[].trackedChanges[].type`, which is the source of truth
+     * for what each run actually represents.
+     *
+     * In independent mode every revision is its own entity and `type` is the
+     * entity's only type.
+     */
+    type: TrackChangeType;
+    /**
+     * Block IDs whose `textSpans` carry this change, in document order. Lets
+     * consumers iterate a single tracked change without scanning every block.
+     * Omitted when the resolver could not match the change to any block (e.g.
+     * orphan marks).
+     */
+    blockIds?: string[];
+    /**
+     * Original OOXML `w:id` values (per ECMA-376 §17.13.5) for the marks that
+     * make up this entity. In paired mode a replacement populates both
+     * `insert` and `delete`. In independent mode only one key is set. Useful
+     * for spec-aware consumers that need to map back to the source document.
+     */
+    wordRevisionIds?: TrackChangeWordRevisionIds;
+    /**
+     * Short text excerpt of the changed content. Omitted for paired
+     * replacements: the underlying text spans both halves and any single
+     * string would either concatenate them (misleading) or pick a side
+     * arbitrarily. Read `block.textSpans` for the per-half text instead.
+     */
+    excerpt?: string;
+    /** Change author name. */
+    author?: string;
+    /** Change date (ISO string). */
+    date?: string;
+}
+export interface ExtractResult {
+    /** All blocks in document order with stable IDs and full text. */
+    blocks: ExtractBlock[];
+    /** All comments with entity IDs and anchored block references. */
+    comments: ExtractComment[];
+    /** All tracked changes with entity IDs and excerpts. */
+    trackedChanges: ExtractTrackedChange[];
+    /** Document revision at the time of extraction. */
+    revision: string;
+}

package/dist/document-api/src/types/fragment.d.ts

@@ -0,0 +1,29 @@
+import { SDContentNode } from './sd-nodes.js';
+import { SDStyles, SDDocDefaults, SDTheme } from './sd-styles.js';
+import { SDNumberingCatalog, SDSection, SDReferenceCatalogs, SDAnnotations } from './sd-sections.js';
+import { SDDocumentMeta } from './sd-props.js';
+/** Structural content payload for insert and replace operations. */
+export type SDFragment = SDContentNode | SDContentNode[];
+export interface SDDocument {
+    modelVersion: 'sdm/1';
+    body: SDContentNode[];
+    styles?: SDStyles;
+    theme?: SDTheme;
+    docDefaults?: SDDocDefaults;
+    numbering?: SDNumberingCatalog;
+    sections?: SDSection[];
+    referenceCatalogs?: SDReferenceCatalogs;
+    annotations?: SDAnnotations;
+    metadata?: SDDocumentMeta;
+}
+export declare const SD_CONTENT_NODE_KINDS: readonly ["paragraph", "heading", "list", "table", "toc", "index", "bibliography", "tableOfAuthorities", "break", "sectionBreak", "sectPr", "image", "drawing", "sdt", "customXml", "altChunk", "math", "field"];
+export type SDContentNodeKind = (typeof SD_CONTENT_NODE_KINDS)[number];
+export declare const SD_INLINE_NODE_KINDS: readonly ["run", "hyperlink", "crossRef", "indexEntry", "sequenceField", "citation", "authorityEntry", "tocEntry", "image", "drawing", "sdt", "customXml", "math", "field", "tab", "lineBreak", "footnoteRef", "endnoteRef"];
+export type SDInlineNodeKind = (typeof SD_INLINE_NODE_KINDS)[number];
+export * from './sd-props.js';
+export * from './sd-objects.js';
+export * from './sd-nodes.js';
+export * from './sd-styles.js';
+export * from './sd-sections.js';
+export * from './sd-envelope.js';
+export * from './sd-contract.js';

package/dist/document-api/src/types/index.d.ts

@@ -0,0 +1,30 @@
+export * from './base.js';
+export * from './node.js';
+export * from './query.js';
+export * from './address.js';
+export * from './receipt.js';
+export * from './paragraph.types.js';
+export * from './inline.types.js';
+export * from './tables.types.js';
+export * from './media.types.js';
+export * from './structured.types.js';
+export * from './comments.types.js';
+export * from './references.types.js';
+export * from './track-changes.types.js';
+export * from './create.types.js';
+export * from './table-operations.types.js';
+export * from './info.types.js';
+export * from './extract.types.js';
+export * from './style-policy.types.js';
+export * from './mutation-plan.types.js';
+export * from './query-match.types.js';
+export * from './step-manifest.types.js';
+export * from './discovery.js';
+export * from './blocks.types.js';
+export * from './toc.types.js';
+export * from './fragment.js';
+export * from './placement.js';
+export * from './adapter-result.js';
+export * from './structural-input.js';
+export * from './story.types.js';
+export * from './clipboard.js';

package/dist/document-api/src/types/info.types.d.ts

@@ -0,0 +1,109 @@
+export interface DocumentInfoCounts {
+    words: number;
+    /**
+     * Length of the Document API plain-text projection.
+     *
+     * This is a "characters with spaces" metric derived from
+     * `doc.textBetween(0, size, '\n', '\n')`. It includes whitespace,
+     * inter-block newline separators, and one `'\n'` per non-text leaf node
+     * (images, tabs, breaks). It is neither Word's `ap:Characters` nor
+     * `ap:CharactersWithSpaces`.
+     */
+    characters: number;
+    paragraphs: number;
+    headings: number;
+    tables: number;
+    images: number;
+    comments: number;
+    /** Count of grouped tracked-change entities (insertions, deletions, format changes). */
+    trackedChanges: number;
+    /** Count of field-like SDT/content-control nodes (text/date/checkbox/choice controls). */
+    sdtFields: number;
+    /** Count of unique list sequences, not individual list items. */
+    lists: number;
+    /** Number of layout pages. Absent when pagination is inactive or layout hasn't completed. */
+    pages?: number;
+}
+export interface DocumentInfoOutlineItem {
+    level: number;
+    text: string;
+    nodeId: string;
+}
+export interface DocumentInfoCapabilities {
+    canFind: boolean;
+    canGetNode: boolean;
+    canComment: boolean;
+    canReplace: boolean;
+}
+/** A paragraph style discovered in the document. */
+export interface DocumentStyleInfo {
+    /** Style identifier (e.g. 'Normal', 'Heading1', 'BodyText'). */
+    styleId: string;
+    /** Number of paragraphs using this style. */
+    count: number;
+    /** Font family used by text in this style (from actual text marks). */
+    fontFamily?: string;
+    /** Font size in half-points used by text in this style. */
+    fontSize?: number;
+}
+/** Style information collected from the document. */
+export interface DocumentStyles {
+    /** Paragraph styles currently in use, sorted by frequency (most common first). */
+    paragraphStyles: DocumentStyleInfo[];
+}
+/** Default formatting detected from the document's body text. */
+export interface DocumentDefaults {
+    /** Most common body text font family. */
+    fontFamily?: string;
+    /** Most common body text font size in half-points. */
+    fontSize?: number;
+    /** Most common body paragraph styleId. */
+    styleId?: string;
+}
+/** A block in the document snapshot with its formatting. */
+export interface DocumentSnapshotBlock {
+    /** Block index in document order. */
+    ordinal: number;
+    /** Block ID for targeting (pass to superdoc_create, superdoc_format, etc.). */
+    nodeId: string;
+    /** Block type: paragraph, heading, table, listItem, image, etc. */
+    nodeType: string;
+    /** First 80 chars of text content. */
+    textPreview: string | null;
+    /** True if the block has no text content. */
+    isEmpty: boolean;
+    /** Named paragraph style ID (e.g. 'Normal', 'Heading1'). Null if implicit. */
+    styleId?: string | null;
+    /** Font family from the block's first text run. */
+    fontFamily?: string;
+    /** Font size from the block's first text run. */
+    fontSize?: number;
+    /** True if the block's text is bold. */
+    bold?: boolean;
+    /** Paragraph alignment: left, center, right, justify. */
+    alignment?: string;
+    /** Heading level (1-6). Only present for headings. */
+    headingLevel?: number;
+}
+/** Full document snapshot: structure, blocks with formatting, and defaults. */
+export interface DocumentSnapshot {
+    /** Total block count. */
+    total: number;
+    /** All blocks in document order with IDs, types, text, and formatting. */
+    blocks: DocumentSnapshotBlock[];
+    /** Default formatting detected from body text. */
+    defaults: DocumentDefaults;
+    /** Document revision. */
+    revision: string;
+}
+export interface DocumentInfo {
+    counts: DocumentInfoCounts;
+    outline: DocumentInfoOutlineItem[];
+    capabilities: DocumentInfoCapabilities;
+    /** Monotonic decimal-string revision counter. Increments on every document change. */
+    revision: string;
+    /** Styles currently in use in the document. */
+    styles?: DocumentStyles;
+    /** Default formatting detected from the document's most common body text. */
+    defaults?: DocumentDefaults;
+}

package/dist/document-api/src/types/inline.types.d.ts

@@ -0,0 +1,28 @@
+import { BaseNodeInfo } from './base.js';
+export interface RunNodeInfo extends BaseNodeInfo {
+    nodeType: 'run';
+    kind: 'inline';
+    properties: RunProperties;
+}
+export interface TabNodeInfo extends BaseNodeInfo {
+    nodeType: 'tab';
+    kind: 'inline';
+    properties: Record<string, never>;
+}
+export interface LineBreakNodeInfo extends BaseNodeInfo {
+    nodeType: 'lineBreak';
+    kind: 'inline';
+    properties: Record<string, never>;
+}
+export interface RunProperties {
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    font?: string;
+    size?: number;
+    color?: string;
+    highlight?: string;
+    styleId?: string;
+    language?: string;
+}

package/dist/document-api/src/types/media.types.d.ts

@@ -0,0 +1,72 @@
+import { BaseNodeInfo, NodeKind } from './base.js';
+export interface ImageNodeInfo extends BaseNodeInfo {
+    nodeType: 'image';
+    kind: NodeKind;
+    properties: ImageProperties;
+}
+export interface ImageSize {
+    width?: number;
+    height?: number;
+    unit?: 'px' | 'pt' | 'twip';
+}
+/** Wrap type for OOXML image placement. */
+export type ImageWrapType = 'Inline' | 'None' | 'Square' | 'Tight' | 'Through' | 'TopAndBottom';
+/** Wrap side: controls which side(s) text flows around the image. */
+export type ImageWrapSide = 'bothSides' | 'left' | 'right' | 'largest';
+export interface ImageWrapAttrs {
+    wrapText?: string;
+    distTop?: number;
+    distBottom?: number;
+    distLeft?: number;
+    distRight?: number;
+}
+export interface ImageWrapInfo {
+    type: ImageWrapType;
+    attrs?: ImageWrapAttrs;
+}
+export interface ImageAnchorData {
+    hRelativeFrom?: string;
+    vRelativeFrom?: string;
+    alignH?: string;
+    alignV?: string;
+}
+export interface ImageMarginOffset {
+    horizontal?: number;
+    top?: number;
+}
+export interface ImageTransformInfo {
+    rotation?: number;
+    verticalFlip?: boolean;
+    horizontalFlip?: boolean;
+}
+export interface ImageCropInfo {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+}
+export interface ImageHyperlinkInfo {
+    url: string;
+    tooltip?: string;
+}
+export interface ImageProperties {
+    src?: string;
+    alt?: string;
+    size?: ImageSize;
+    placement: 'inline' | 'floating';
+    wrap: ImageWrapInfo;
+    anchorData?: ImageAnchorData | null;
+    marginOffset?: ImageMarginOffset | null;
+    relativeHeight?: number | null;
+    /** Object name (maps to wp:docPr/@name). */
+    name?: string;
+    /** Accessibility description (maps to wp:docPr/@descr). */
+    description?: string;
+    transform?: ImageTransformInfo | null;
+    crop?: ImageCropInfo | null;
+    lockAspectRatio?: boolean;
+    decorative?: boolean;
+    hyperlink?: ImageHyperlinkInfo | null;
+    /** True if an adjacent Caption paragraph exists. */
+    hasCaption?: boolean;
+}

package/dist/document-api/src/types/mutation-plan.types.d.ts

@@ -0,0 +1,264 @@
+import { BlockNodeAddress, BlockNodeType } from './base.js';
+import { TextAddress, TrackedChangeAddress, SelectionTarget, DeleteBehavior } from './address.js';
+import { TextSelector, NodeSelector } from './query.js';
+import { InsertStylePolicy, StylePolicy } from './style-policy.types.js';
+import { InlineRunPatch } from '../format/inline-run-patch.js';
+import { SDFragment } from './fragment.js';
+import { Placement, NestingPolicy } from './placement.js';
+import { ChangeMode } from '../write/write.js';
+import { StoryLocator } from './story.types.js';
+export type SelectWhere = {
+    by: 'select';
+    select: TextSelector | NodeSelector;
+    within?: BlockNodeAddress;
+    require: 'first' | 'exactlyOne' | 'all';
+};
+export type RefWhere = {
+    by: 'ref';
+    ref: string;
+    within?: BlockNodeAddress;
+};
+export type TargetWhere = {
+    by: 'target';
+    target: SelectionTarget;
+};
+export type BlockWhere = {
+    by: 'block';
+    nodeType: BlockNodeType;
+    nodeId: string;
+};
+export type StepWhere = SelectWhere | RefWhere | TargetWhere | BlockWhere;
+export type AssertWhere = {
+    by: 'select';
+    select: TextSelector | NodeSelector;
+    within?: BlockNodeAddress;
+};
+/**
+ * A single replacement block for structured multi-paragraph replacements.
+ * In this workstream, per-block inline style overrides are not supported;
+ * step-level `style` policy applies uniformly to all replacement blocks.
+ */
+export type ReplacementBlock = {
+    text: string;
+};
+/**
+ * Replacement payload for text.rewrite steps.
+ *
+ * - `{ text }`: flat string. For single-block (range) targets, used as-is.
+ *   For cross-block (span) targets, normalized via deterministic paragraph
+ *   boundary detection (\n\n+).
+ * - `{ blocks }`: structured multi-paragraph payload, authoritative when provided.
+ *   Use this for explicit control over paragraph structure.
+ *
+ * Exactly one of `text` or `blocks` must be provided.
+ */
+export type ReplacementPayload = {
+    text: string;
+    blocks?: undefined;
+} | {
+    text?: undefined;
+    blocks: ReplacementBlock[];
+};
+export type TextRewriteStep = {
+    id: string;
+    op: 'text.rewrite';
+    where: StepWhere;
+    args: {
+        replacement: ReplacementPayload;
+        /**
+         * Style policy for the replacement text.
+         * When omitted, defaults to preserve mode:
+         *   inline: { mode: 'preserve', onNonUniform: 'majority' }
+         *   paragraph: { mode: 'preserve' }
+         */
+        style?: StylePolicy;
+    };
+};
+export type TextInsertStep = {
+    id: string;
+    op: 'text.insert';
+    where: StepWhere;
+    args: {
+        position: 'before' | 'after';
+        content: {
+            text: string;
+        };
+        style?: InsertStylePolicy;
+    };
+};
+export type TextDeleteStep = {
+    id: string;
+    op: 'text.delete';
+    where: StepWhere;
+    args: {
+        /** Controls block-edge expansion. Defaults to `'selection'`. */
+        behavior?: DeleteBehavior;
+    };
+};
+export type StyleApplyStep = {
+    id: string;
+    op: 'format.apply';
+    where: StepWhere;
+    args: {
+        inline?: InlineRunPatch;
+        alignment?: 'left' | 'center' | 'right' | 'justify';
+        /** When "block", inline formatting expands to cover the entire parent textblock(s), not just the matched range. Default: "match". */
+        scope?: 'match' | 'block';
+    };
+};
+export type AssertStep = {
+    id: string;
+    op: 'assert';
+    where: AssertWhere;
+    args: {
+        expectCount: number;
+    };
+};
+export type StructuralInsertStep = {
+    id: string;
+    op: 'structural.insert';
+    where: StepWhere;
+    args: {
+        content: SDFragment;
+        placement?: Placement;
+        nestingPolicy?: NestingPolicy;
+    };
+};
+export type StructuralReplaceStep = {
+    id: string;
+    op: 'structural.replace';
+    where: StepWhere;
+    args: {
+        content: SDFragment;
+        nestingPolicy?: NestingPolicy;
+    };
+};
+export type DomainStep = {
+    id: string;
+    op: string;
+    where: StepWhere;
+    args: Record<string, unknown>;
+};
+export type MutationStep = TextRewriteStep | TextInsertStep | TextDeleteStep | StyleApplyStep | StructuralInsertStep | StructuralReplaceStep | AssertStep | DomainStep;
+export type { ChangeMode } from '../write/write.js';
+export type MutationsApplyInput = {
+    /** Target story for the mutation plan. Omit for body (backward compatible). */
+    in?: StoryLocator;
+    expectedRevision?: string;
+    atomic: true;
+    changeMode: ChangeMode;
+    steps: MutationStep[];
+};
+export type MutationsPreviewInput = {
+    /** Target story for the mutation preview. Omit for body (backward compatible). */
+    in?: StoryLocator;
+    expectedRevision?: string;
+    atomic: true;
+    changeMode: ChangeMode;
+    steps: MutationStep[];
+};
+/** Maximum number of steps per mutation plan. */
+export declare const MAX_PLAN_STEPS = 200;
+/** Maximum total resolved targets across all steps in a plan. */
+export declare const MAX_PLAN_RESOLVED_TARGETS = 500;
+export type StepEffect = 'changed' | 'noop' | 'error' | 'assert_passed' | 'assert_failed';
+/** Resolution for a single-block (range) target. */
+export type TextStepResolution = {
+    target: TextAddress;
+    range: {
+        from: number;
+        to: number;
+    };
+    text: string;
+};
+/** Resolution for a cross-block (span) target. */
+export type SpanStepResolution = {
+    targets: TextAddress[];
+    matchId: string;
+    text: string;
+};
+/** Resolution for a selection-based target (may span multiple blocks). */
+export type SelectionStepResolution = {
+    selectionTarget: SelectionTarget;
+    range: {
+        from: number;
+        to: number;
+    };
+    text: string;
+};
+export type TextStepData = {
+    domain: 'text';
+    resolutions: TextStepResolution[];
+    spanResolutions?: SpanStepResolution[];
+    selectionResolutions?: SelectionStepResolution[];
+};
+export type AssertStepData = {
+    domain: 'assert';
+    expectedCount: number;
+    actualCount: number;
+};
+export type DomainStepData = {
+    domain: 'command';
+    commandDispatched: boolean;
+};
+export type TableStepData = {
+    domain: 'table';
+    tableId: string;
+    affectedRows?: string[];
+    affectedCells?: string[];
+    affectedColumns?: number[];
+};
+export type StructuralStepData = {
+    domain: 'structural';
+    insertedBlockIds?: string[];
+};
+export type StepOutcomeData = TextStepData | AssertStepData | DomainStepData | TableStepData | StructuralStepData;
+export type StepOutcome = {
+    stepId: string;
+    op: string;
+    effect: StepEffect;
+    matchCount: number;
+    trackedChangeIds?: string[];
+    data: StepOutcomeData;
+};
+export type PlanReceipt = {
+    success: true;
+    revision: {
+        before: string;
+        after: string;
+    };
+    steps: StepOutcome[];
+    trackedChanges?: TrackedChangeAddress[];
+    timing: {
+        totalMs: number;
+    };
+};
+export type PreviewFailurePhase = 'compile' | 'execute' | 'assert';
+export type PreviewFailure = {
+    code: string;
+    stepId: string;
+    phase: PreviewFailurePhase;
+    message: string;
+    details?: unknown;
+};
+export type StepPreview = {
+    stepId: string;
+    op: string;
+    resolutions?: TextStepResolution[];
+    spanResolutions?: SpanStepResolution[];
+    selectionResolutions?: SelectionStepResolution[];
+    style?: unknown;
+};
+export type MutationsPreviewOutput = {
+    evaluatedRevision: string;
+    steps: StepPreview[];
+    valid: boolean;
+    failures?: PreviewFailure[];
+};
+export type PlanExecutionError = {
+    code: string;
+    message: string;
+    stepId?: string;
+    details?: unknown;
+};
+export type { RevisionGuardOptions, MutationOptions } from '../write/write.js';