superdoc 2.2.0 → 2.3.0

package/dist/document-api/src/types/sd-props.d.ts

@@ -0,0 +1,240 @@
+/**
+ * SDM/1 property models: run, paragraph, table, list, image, drawing props.
+ *
+ * These define the direct formatting ("authored") property bags carried by
+ * style-bearing nodes. Resolved/provenance fields are separate concerns
+ * populated at read time by the style-engine.
+ */
+export type SDThemeFontRef = 'majorAscii' | 'majorHAnsi' | 'majorEastAsia' | 'majorBidi' | 'minorAscii' | 'minorHAnsi' | 'minorEastAsia' | 'minorBidi';
+export interface SDRunFonts {
+    ascii?: string;
+    hAnsi?: string;
+    eastAsia?: string;
+    cs?: string;
+    asciiTheme?: SDThemeFontRef;
+    hAnsiTheme?: SDThemeFontRef;
+    eastAsiaTheme?: SDThemeFontRef;
+    csTheme?: SDThemeFontRef;
+    hint?: 'default' | 'eastAsia' | 'cs';
+}
+export interface SDRunLanguages {
+    val?: string;
+    eastAsia?: string;
+    bidi?: string;
+}
+export type SDThemeColorName = 'dk1' | 'dk2' | 'lt1' | 'lt2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6' | 'hyperlink' | 'followedHyperlink';
+export type SDColorRef = {
+    model: 'rgb';
+    value: string;
+} | {
+    model: 'theme';
+    theme: SDThemeColorName;
+    tint?: number;
+    shade?: number;
+} | {
+    model: 'auto';
+};
+export type SDHighlightColor = 'black' | 'blue' | 'cyan' | 'green' | 'magenta' | 'red' | 'yellow' | 'white' | 'darkBlue' | 'darkCyan' | 'darkGreen' | 'darkMagenta' | 'darkRed' | 'darkYellow' | 'darkGray' | 'lightGray' | 'none';
+export type SDUnderlineStyle = 'none' | 'single' | 'words' | 'double' | 'thick' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashedHeavy' | 'dashLong' | 'dashLongHeavy' | 'dotDash' | 'dashDotHeavy' | 'dotDotDash' | 'dashDotDotHeavy' | 'wave' | 'wavyHeavy' | 'wavyDouble';
+export interface SDUnderline {
+    style?: SDUnderlineStyle;
+    color?: SDColorRef;
+}
+export interface SDShading {
+    pattern?: string;
+    fill?: SDColorRef;
+    color?: SDColorRef;
+}
+export interface SDRunBorder {
+    style?: string;
+    width?: number;
+    space?: number;
+    color?: SDColorRef;
+    frame?: boolean;
+    shadow?: boolean;
+}
+export type SDTabAlignment = 'left' | 'center' | 'right' | 'decimal' | 'bar' | 'clear' | 'num';
+export type SDTabLeader = 'none' | 'dot' | 'hyphen' | 'underscore' | 'middleDot' | 'heavy' | 'line';
+export interface SDTabStop {
+    kind: 'set' | 'clear';
+    /** Position in points. */
+    position: number;
+    alignment?: SDTabAlignment;
+    leader?: SDTabLeader;
+}
+export interface SDParagraphBorders {
+    top?: SDRunBorder;
+    left?: SDRunBorder;
+    bottom?: SDRunBorder;
+    right?: SDRunBorder;
+    between?: SDRunBorder;
+    bar?: SDRunBorder;
+}
+export interface SDRunProps {
+    fonts?: SDRunFonts;
+    /** Convenience alias when one family applies across scripts. */
+    fontFamily?: string;
+    lang?: SDRunLanguages;
+    /** Font size in points. */
+    fontSize?: number;
+    /** Complex-script font size in points. */
+    fontSizeCs?: number;
+    color?: SDColorRef;
+    highlight?: SDHighlightColor;
+    shading?: SDShading;
+    cs?: boolean;
+    rtl?: boolean;
+    bold?: boolean;
+    boldCs?: boolean;
+    italic?: boolean;
+    italicCs?: boolean;
+    underline?: SDUnderline;
+    strikethrough?: boolean;
+    doubleStrikethrough?: boolean;
+    caps?: boolean;
+    smallCaps?: boolean;
+    outline?: boolean;
+    shadow?: boolean;
+    emboss?: boolean;
+    imprint?: boolean;
+    verticalAlign?: 'baseline' | 'superscript' | 'subscript';
+    /** Character spacing in points. */
+    characterSpacing?: number;
+    /** Character scale as percentage. */
+    characterScale?: number;
+    /** Kerning threshold in points. */
+    kern?: number;
+    /** Baseline shift in points. */
+    baselineShift?: number;
+    /** Fit-text target width in points. */
+    fitTextWidth?: number;
+    vanish?: boolean;
+    webHidden?: boolean;
+    specVanish?: boolean;
+    border?: SDRunBorder;
+    textEffect?: string;
+}
+export interface SDParagraphProps {
+    alignment?: 'left' | 'center' | 'right' | 'justify' | 'start' | 'end' | 'distributed' | 'numTab' | 'lowKashida' | 'mediumKashida' | 'highKashida' | 'thaiDistribute';
+    indent?: {
+        /** Start indent in points. */
+        start?: number;
+        /** End indent in points. */
+        end?: number;
+        /** Left indent in points. */
+        left?: number;
+        /** Right indent in points. */
+        right?: number;
+        /** First line indent in points. */
+        firstLine?: number;
+        /** Hanging indent in points. */
+        hanging?: number;
+    };
+    spacing?: {
+        /** Space before in points. */
+        before?: number;
+        /** Space after in points. */
+        after?: number;
+        beforeLines?: number;
+        afterLines?: number;
+        beforeAutoSpacing?: boolean;
+        afterAutoSpacing?: boolean;
+        /** Line spacing: multiplier when lineRule=auto, otherwise points. */
+        line?: number;
+        lineRule?: 'auto' | 'multiple' | 'exact' | 'atLeast';
+    };
+    keepWithNext?: boolean;
+    keepLines?: boolean;
+    pageBreakBefore?: boolean;
+    widowControl?: boolean;
+    numbering?: {
+        numId?: string;
+        /** Numbering level 0..8. */
+        level?: number;
+    };
+    tabs?: SDTabStop[];
+    borders?: SDParagraphBorders;
+    shading?: SDShading;
+    bidi?: boolean;
+    textDirection?: 'lrTb' | 'tbRl' | 'btLr' | 'lrTbV' | 'tbLrV';
+    mirrorIndents?: boolean;
+    adjustRightIndent?: boolean;
+    textAlignment?: 'top' | 'center' | 'baseline' | 'bottom' | 'auto';
+    eastAsianLineBreak?: {
+        kinsoku?: boolean;
+        wordWrap?: boolean;
+        overflowPunctuation?: boolean;
+        topLinePunctuation?: boolean;
+        autoSpaceDE?: boolean;
+        autoSpaceDN?: boolean;
+        snapToGrid?: boolean;
+    };
+    markRunProps?: SDRunProps;
+    outlineLevel?: number;
+}
+export interface SDListProps {
+    tight?: boolean;
+}
+export type SDTableWidth = {
+    kind: 'auto';
+} | {
+    kind: 'points';
+    value: number;
+} | {
+    kind: 'percent';
+    value: number;
+} | {
+    kind: 'none';
+};
+export interface SDTableProps {
+    width?: SDTableWidth;
+    layout?: 'fixed' | 'autofit';
+    alignment?: 'left' | 'center' | 'right' | 'inside' | 'outside';
+    borders?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+        insideH?: string;
+        insideV?: string;
+    };
+}
+export interface SDRowProps {
+    /** Minimum row height in points. */
+    minHeight?: number;
+    cantSplit?: boolean;
+}
+export interface SDCellProps {
+    verticalAlign?: 'top' | 'center' | 'bottom';
+    shading?: SDColorRef;
+    /** Cell padding in points. */
+    padding?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    borders?: {
+        top?: string;
+        right?: string;
+        bottom?: string;
+        left?: string;
+    };
+}
+export interface SDImageProps {
+    alignment?: 'left' | 'center' | 'right';
+    /** Opacity 0..1. */
+    opacity?: number;
+}
+export interface SDDrawingProps {
+    alignment?: 'left' | 'center' | 'right';
+    /** Opacity 0..1. */
+    opacity?: number;
+}
+export interface SDDocumentMeta {
+    title?: string;
+    subject?: string;
+    author?: string;
+    description?: string;
+    keywords?: string[];
+}

package/dist/document-api/src/types/sd-sections.d.ts

@@ -0,0 +1,126 @@
+import { SDContentNode } from './sd-nodes.js';
+import { SDRunProps, SDParagraphProps } from './sd-props.js';
+export interface SDNumberingCatalog {
+    definitions?: Record<string, {
+        levels: Array<{
+            level: number;
+            kind: 'ordered' | 'bullet';
+            format?: string;
+            text?: string;
+            start?: number;
+            restartAfterLevel?: number | null;
+        }>;
+    }>;
+}
+export interface SDSection {
+    id: string;
+    breakType?: 'continuous' | 'nextPage' | 'evenPage' | 'oddPage';
+    pageSetup?: {
+        width?: number;
+        height?: number;
+        orientation?: 'portrait' | 'landscape';
+        paperSize?: string;
+    };
+    margins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+        gutter?: number;
+    };
+    headerFooterMargins?: {
+        header?: number;
+        footer?: number;
+    };
+    columns?: {
+        count?: number;
+        gap?: number;
+        equalWidth?: boolean;
+    };
+    lineNumbering?: {
+        enabled: boolean;
+        countBy?: number;
+        start?: number;
+        distance?: number;
+        restart?: 'continuous' | 'newPage' | 'newSection';
+    };
+    pageNumbering?: {
+        start?: number;
+        format?: 'decimal' | 'lowerLetter' | 'upperLetter' | 'lowerRoman' | 'upperRoman' | 'numberInDash';
+        chapterStyle?: number;
+        chapterSeparator?: 'hyphen' | 'period' | 'colon' | 'emDash' | 'enDash';
+    };
+    titlePage?: boolean;
+    oddEvenHeadersFooters?: boolean;
+    verticalAlign?: 'top' | 'center' | 'bottom' | 'both';
+    sectionDirection?: 'ltr' | 'rtl';
+    headerContent?: {
+        default?: SDContentNode[];
+        first?: SDContentNode[];
+        even?: SDContentNode[];
+    };
+    footerContent?: {
+        default?: SDContentNode[];
+        first?: SDContentNode[];
+        even?: SDContentNode[];
+    };
+}
+export interface SDCitationSource {
+    sourceId: string;
+    tag?: string;
+    type?: string;
+    fields?: Record<string, unknown>;
+}
+export interface SDReferenceCatalogs {
+    citationSources?: SDCitationSource[];
+}
+export interface SDAnchorRange {
+    kind: 'text';
+    segments: Array<{
+        blockId: string;
+        start: number;
+        end: number;
+    }>;
+}
+export interface SDBookmark {
+    id: string;
+    name: string;
+    target: SDAnchorRange;
+}
+export interface SDCommentThread {
+    id: string;
+    status: 'open' | 'resolved';
+    target: SDAnchorRange;
+    comments: Array<{
+        id: string;
+        author?: string;
+        createdAt?: string;
+        text: string;
+    }>;
+}
+export interface SDTrackedChange {
+    id: string;
+    /**
+     * Tracked-change broad type. Accepts the canonical v2 spec vocabulary
+     * (`insertion` / `deletion` / `replacement` / `formatting` / `move` /
+     * `structural`) and the legacy `insert` / `delete` / `format` aliases
+     * during the vocabulary migration.
+     */
+    type: 'insertion' | 'deletion' | 'replacement' | 'formatting' | 'move' | 'structural' | 'insert' | 'delete' | 'format';
+    author?: string;
+    date?: string;
+    target?: SDAnchorRange;
+    excerpt?: string;
+    formatChange?: {
+        scope?: 'run' | 'paragraph';
+        runPropsBefore?: Partial<SDRunProps>;
+        runPropsAfter?: Partial<SDRunProps>;
+        paragraphPropsBefore?: Partial<SDParagraphProps>;
+        paragraphPropsAfter?: Partial<SDParagraphProps>;
+    };
+}
+export interface SDAnnotations {
+    bookmarks?: SDBookmark[];
+    comments?: SDCommentThread[];
+    trackedChanges?: SDTrackedChange[];
+}

package/dist/document-api/src/types/sd-styles.d.ts

@@ -0,0 +1,36 @@
+import { SDRunProps, SDParagraphProps, SDTableProps, SDThemeColorName } from './sd-props.js';
+export interface SDStyleBase<TProps> {
+    name?: string;
+    basedOn?: string;
+    next?: string;
+    linked?: string;
+    props?: TProps;
+}
+export type SDParagraphStyleDef = SDStyleBase<SDParagraphProps>;
+export type SDCharacterStyleDef = SDStyleBase<SDRunProps>;
+export type SDTableStyleDef = SDStyleBase<SDTableProps>;
+export interface SDStyles {
+    paragraph?: Record<string, SDParagraphStyleDef>;
+    character?: Record<string, SDCharacterStyleDef>;
+    table?: Record<string, SDTableStyleDef>;
+}
+export interface SDTheme {
+    colorScheme: Record<SDThemeColorName, string>;
+    fontScheme?: {
+        major?: {
+            latin?: string;
+            eastAsia?: string;
+            complexScript?: string;
+        };
+        minor?: {
+            latin?: string;
+            eastAsia?: string;
+            complexScript?: string;
+        };
+    };
+}
+export interface SDDocDefaults {
+    run?: SDRunProps;
+    paragraph?: SDParagraphProps;
+    table?: SDTableProps;
+}

package/dist/document-api/src/types/step-manifest.types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Step manifest types: public, engine-agnostic metadata for step ops.
+ *
+ * These types describe a rich manifest model for mutation step operations.
+ * The current catalog used by docs and capabilities lives in
+ * `contract/step-op-catalog.ts`; this type remains available for future
+ * expansion to schema-level per-step metadata.
+ */
+export interface IdentityStrategy {
+    refType: string;
+    stableAcrossUndoRedo: boolean;
+    stableAcrossConcurrentEdits: boolean;
+    usableInWhere: boolean;
+}
+export interface StepCapabilities {
+    idempotency: 'idempotent' | 'non-idempotent';
+    supportsDryRun: boolean;
+    supportsTrackedMode: boolean;
+    possibleFailureCodes: string[];
+    deterministicTargetResolution: boolean;
+    identityStrategy: IdentityStrategy;
+}
+export interface StepManifest {
+    opId: string;
+    domain: string;
+    argsSchema: Record<string, unknown>;
+    outcomeSchema: Record<string, unknown>;
+    capabilities: StepCapabilities;
+    compatibleDomains?: string[];
+}

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

@@ -0,0 +1,123 @@
+import { SectionAddress } from '../sections/sections.types.js';
+/** All recognized story types. */
+export declare const STORY_TYPES: readonly ["body", "headerFooterSlot", "headerFooterPart", "footnote", "endnote", "textbox"];
+/** Valid header/footer story kinds. */
+export declare const STORY_HEADER_FOOTER_KINDS: readonly ["header", "footer"];
+/** Valid header/footer slot variants. */
+export declare const STORY_HEADER_FOOTER_VARIANTS: readonly ["default", "first", "even"];
+/** Valid header/footer slot resolution modes. */
+export declare const STORY_HEADER_FOOTER_RESOLUTIONS: readonly ["effective", "explicit"];
+/** Valid header/footer slot write modes. */
+export declare const STORY_HEADER_FOOTER_ON_WRITE_VALUES: readonly ["materializeIfInherited", "editResolvedPart", "error"];
+export type StoryType = (typeof STORY_TYPES)[number];
+export type StoryHeaderFooterKind = (typeof STORY_HEADER_FOOTER_KINDS)[number];
+export type StoryHeaderFooterVariant = (typeof STORY_HEADER_FOOTER_VARIANTS)[number];
+export type StoryHeaderFooterResolution = (typeof STORY_HEADER_FOOTER_RESOLUTIONS)[number];
+export type StoryHeaderFooterOnWrite = (typeof STORY_HEADER_FOOTER_ON_WRITE_VALUES)[number];
+/** The main document body. */
+export interface BodyStoryLocator {
+    kind: 'story';
+    storyType: 'body';
+}
+/**
+ * A header/footer slot identified by section, kind, and variant.
+ *
+ * This is the high-level "logical" locator: it represents a slot that may
+ * resolve to an explicit part in the targeted section or inherit from an
+ * earlier section.
+ *
+ * - `resolution` controls whether the locator resolves to the effective part
+ *   (following inheritance) or only matches an explicit local reference.
+ *   Defaults to `'effective'` when omitted.
+ * - `onWrite` controls mutation behavior when the slot is inherited:
+ *   - `'materializeIfInherited'`: creates a local copy before editing (default).
+ *   - `'editResolvedPart'`: edits the inherited part in place.
+ *   - `'error'`: fails if the slot is not explicitly defined in this section.
+ */
+export interface HeaderFooterSlotStoryLocator {
+    kind: 'story';
+    storyType: 'headerFooterSlot';
+    section: SectionAddress;
+    headerFooterKind: StoryHeaderFooterKind;
+    variant: StoryHeaderFooterVariant;
+    /** Resolution strategy. Defaults to `'effective'` when omitted. */
+    resolution?: StoryHeaderFooterResolution;
+    /** Write behavior when the slot is inherited. Defaults to `'materializeIfInherited'`. */
+    onWrite?: StoryHeaderFooterOnWrite;
+}
+/**
+ * A header/footer part identified by its relationship ID.
+ *
+ * This is the low-level "physical" locator: it points directly at a specific
+ * header or footer XML part, bypassing section-level resolution.
+ */
+export interface HeaderFooterPartStoryLocator {
+    kind: 'story';
+    storyType: 'headerFooterPart';
+    refId: string;
+}
+/** A footnote story identified by its note ID. */
+export interface FootnoteStoryLocator {
+    kind: 'story';
+    storyType: 'footnote';
+    noteId: string;
+}
+/** An endnote story identified by its note ID. */
+export interface EndnoteStoryLocator {
+    kind: 'story';
+    storyType: 'endnote';
+    noteId: string;
+}
+/**
+ * A textbox story identified by a stable textbox id.
+ *
+ * The supported subset is DrawingML textbox content (`w:txbxContent` inside
+ * `w:drawing`) hosted in the main body story. VML textbox content
+ * (`v:textbox` / `w:pict`), linked textbox chains (`w:linkedTxbxContent`),
+ * nested textbox stories, and textbox stories inside headers/footers are
+ * rejected at admission time with named diagnostics rather than silently
+ * widened.
+ */
+export interface TextboxStoryLocator {
+    kind: 'story';
+    storyType: 'textbox';
+    textboxId: string;
+}
+/**
+ * Identifies a content story within a document.
+ *
+ * Discriminate on `storyType` to narrow to a specific variant.
+ */
+export type StoryLocator = BodyStoryLocator | HeaderFooterSlotStoryLocator | HeaderFooterPartStoryLocator | FootnoteStoryLocator | EndnoteStoryLocator | TextboxStoryLocator;
+/**
+ * Type guard: returns `true` if `value` is a valid {@link StoryLocator}.
+ *
+ * Checks the full discriminated-union shape so malformed partial locators do
+ * not leak through validation and fail later with raw property-access errors.
+ */
+export declare function isStoryLocator(value: unknown): value is StoryLocator;
+/**
+ * Type guard: returns `true` if `locator` targets the document body.
+ */
+export declare function isBodyStory(locator: StoryLocator): locator is BodyStoryLocator;
+/**
+ * Returns the effective resolution mode for a header/footer slot locator.
+ */
+export declare function getStoryHeaderFooterResolution(locator: Pick<HeaderFooterSlotStoryLocator, 'resolution'>): StoryHeaderFooterResolution;
+/**
+ * Returns the effective write mode for a header/footer slot locator.
+ */
+export declare function getStoryHeaderFooterOnWrite(locator: Pick<HeaderFooterSlotStoryLocator, 'onWrite'>): StoryHeaderFooterOnWrite;
+/**
+ * Converts a {@link StoryLocator} to a canonical string key.
+ *
+ * The key is deterministic and suitable for use as a map key or cache key.
+ * Round-tripping is NOT guaranteed: this is a one-way serialization.
+ *
+ * Examples:
+ * - `{ kind: 'story', storyType: 'body' }` → `'story:body'`
+ * - `{ kind: 'story', storyType: 'footnote', noteId: 'fn1' }` → `'story:footnote:fn1'`
+ * - `{ kind: 'story', storyType: 'headerFooterSlot', section: { kind: 'section', sectionId: 's1' }, headerFooterKind: 'header', variant: 'default' }` → `'story:headerFooterSlot:s1:header:default:effective:materializeIfInherited'`
+ * - `{ kind: 'story', storyType: 'headerFooterPart', refId: 'rId7' }` → `'story:headerFooterPart:rId7'`
+ */
+export declare function storyLocatorToKey(locator: StoryLocator): string;

package/dist/document-api/src/types/structural-input.d.ts

@@ -0,0 +1,40 @@
+import { BlockNodeAddress } from './base.js';
+import { SelectionTarget } from './address.js';
+import { SDFragment } from './fragment.js';
+import { Placement, NestingPolicy } from './placement.js';
+import { StoryLocator } from './story.types.js';
+/** Structural shape for the insert operation. */
+export interface SDInsertInput {
+    /** Optional insertion target. When omitted, inserts at the end of the document. */
+    target?: BlockNodeAddress;
+    /** Structural content to insert. */
+    content: SDFragment;
+    /** Target a specific document story (body, header, footer, footnote, endnote). */
+    in?: StoryLocator;
+    /** Where to place content relative to the target. Defaults to 'after'. */
+    placement?: Placement;
+    /** Nesting policy. Defaults to { tables: 'forbid' }. */
+    nestingPolicy?: NestingPolicy;
+}
+/** Structural shape for the replace operation. */
+type StructuralReplaceLocator = {
+    /** Target to replace. BlockNodeAddress replaces the entire block; SelectionTarget replaces a contiguous selection. */
+    target: BlockNodeAddress | SelectionTarget;
+    /** Opaque ref string (alternative to `target`). */
+    ref?: undefined;
+} | {
+    /** Opaque ref string (alternative to `target`). */
+    ref: string;
+    /** Target to replace. BlockNodeAddress replaces the entire block; SelectionTarget replaces a contiguous selection. */
+    target?: undefined;
+};
+/** Structural shape for the replace operation. */
+export type SDReplaceInput = StructuralReplaceLocator & {
+    /** Structural content to replace with. */
+    content: SDFragment;
+    /** Target a specific document story (body, header, footer, footnote, endnote). */
+    in?: StoryLocator;
+    /** Nesting policy. Defaults to { tables: 'forbid' }. */
+    nestingPolicy?: NestingPolicy;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import { BaseNodeInfo } from './base.js';
+export type { ContentControlInfo } from '../content-controls/content-controls.types.js';
+export interface BookmarkNodeInfo extends BaseNodeInfo {
+    nodeType: 'bookmark';
+    kind: 'inline';
+    properties: BookmarkProperties;
+}
+export interface HyperlinkNodeInfo extends BaseNodeInfo {
+    nodeType: 'hyperlink';
+    kind: 'inline';
+    properties: HyperlinkProperties;
+}
+export interface BookmarkProperties {
+    name?: string;
+    bookmarkId?: string;
+}
+export interface HyperlinkProperties {
+    href?: string;
+    anchor?: string;
+    tooltip?: string;
+}

package/dist/document-api/src/types/style-policy.types.d.ts

@@ -0,0 +1,49 @@
+import { CorePropertyId } from '../inline-semantics/property-ids.js';
+export type NonUniformStrategy = 'error' | 'useLeadingRun' | 'majority' | 'union';
+/**
+ * Canonical mark key set: derived from inline-semantics property IDs.
+ * Retained for backward compatibility; prefer {@link CORE_PROPERTY_IDS} in new code.
+ */
+export declare const MARK_KEYS: readonly ["bold", "italic", "underline", "strike"];
+/** A single canonical mark key. Equivalent to {@link CorePropertyId}. */
+export type MarkKey = CorePropertyId;
+/** Runtime set for O(1) mark key validation. Equivalent to {@link CORE_PROPERTY_ID_SET}. */
+export declare const MARK_KEY_SET: ReadonlySet<string>;
+/** Canonical directive vocabulary for inline toggle properties. */
+export declare const INLINE_DIRECTIVES: readonly ["on", "off", "clear"];
+/** A single inline toggle directive. */
+export type InlineToggleDirective = (typeof INLINE_DIRECTIVES)[number];
+/** Runtime set for O(1) directive validation. */
+export declare const INLINE_DIRECTIVE_SET: ReadonlySet<string>;
+/**
+ * Inline toggle directives for core-4 marks.
+ *
+ * - `'on'`   : write direct ON formatting.
+ * - `'off'`  : write explicit run-level OFF/negation override.
+ * - `'clear'`: remove direct run-level property (inherit from style cascade).
+ */
+export interface SetMarks {
+    bold?: InlineToggleDirective;
+    italic?: InlineToggleDirective;
+    underline?: InlineToggleDirective;
+    strike?: InlineToggleDirective;
+}
+export interface InlineStylePolicy {
+    mode: 'preserve' | 'set' | 'clear' | 'merge';
+    requireUniform?: boolean;
+    onNonUniform?: NonUniformStrategy;
+    setMarks?: SetMarks;
+}
+export interface ParagraphStylePolicy {
+    mode: 'preserve' | 'set' | 'clear';
+}
+export interface StylePolicy {
+    inline: InlineStylePolicy;
+    paragraph?: ParagraphStylePolicy;
+}
+export interface InsertStylePolicy {
+    inline: {
+        mode: 'inherit' | 'set' | 'clear';
+        setMarks?: SetMarks;
+    };
+}