@betteroffice/docx 0.0.1

package/dist/layout/render/index.d.mts

@@ -0,0 +1,733 @@
+import { b as DisplayPage, c as DisplayPrimitive, D as DisplayList, G as GlyphRunPrimitive, L as LinePrimitive, T as TextRunPrimitive } from '../../rustDisplayList-dqunvwxH.mjs';
+export { d as DecodedFrameDelta, e as DecorationPrimitive, f as DisplayBounds, g as DisplayListBuildInputs, a as DisplayListHeadersFooters, h as DisplayListHfVariant, i as DisplayListPictureWatermark, j as DisplayListTextWatermark, k as DisplayListWatermark, l as DocAttrs, F as FRAME_DELTA_HEADER_BYTES, m as FRAME_DELTA_PAGE_OP_BYTES, n as FRAME_DELTA_VERSION, o as FrameDeltaError, p as FrameDeltaErrorCode, q as FramePageOperation, H as HfRegion, I as ImagePrimitive, P as PositionedGlyph, r as RectPrimitive, s as RetainedFrame, t as RetainedFramePage, u as RustDisplayFrameResult, v as RustDisplayListEngine, R as RustDisplayListQueryEngine, w as RustDisplayListSourceError, x as RustDisplayListSourceErrorStage, y as TableCellRef, z as applyFrameDelta, A as applyFrameDeltaOwned, B as buildRustDisplayFrame, C as buildRustDisplayList, E as decodeFrameDelta, J as encodeDisplayListFrameExtras, K as loadRustDisplayListQueryEngine } from '../../rustDisplayList-dqunvwxH.mjs';
+import { a as DisplayListQueries, b as DisplayListRegionHit, D as DisplayListRect } from '../../displayListQueries-p-ijSzdh.mjs';
+export { c as DisplayListHitRegion, d as DisplayListImageGeometry, e as DisplayListImageRegion, f as DisplayListParagraphGeometry, g as DisplayListQuerySourceState, h as DisplayListVisualLine, L as LocatedImagePrimitive, R as ResidentDisplayListQueryEngine, i as captureInlinePositionEmuFromDisplayList, j as createDisplayListQueries, k as findImagePrimitiveAtPoint, l as findImagePrimitiveByDocPos } from '../../displayListQueries-p-ijSzdh.mjs';
+import { YrsLoc, YrsSession, YrsRevisionInfo } from '../../yrs/index.mjs';
+import { TrackedChangeEntry } from '../../utils/comments.mjs';
+import '../../types-DNrYr6yQ.mjs';
+import '../../content-sSHuWw49.mjs';
+import '../../formatting-DoL7KBSL.mjs';
+import '../../docx/wrapTypes.mjs';
+import '../../measuredBlock-DZwz8zhD.mjs';
+import '../../types/document.mjs';
+import '../../styles-VxNcXLdi.mjs';
+import '../../settingsParser-CcGvtmCK.mjs';
+
+/** a cached glyph: its outline path (font units) plus the font's units-per-em. */
+interface GlyphOutline {
+    /**
+     * the glyph contours as a Path2D in font units, or `null` when the glyph has
+     * no visible contours (space/whitespace) — the backend skips null paths.
+     */
+    path: Path2D | null;
+    /** the font's units-per-em; the backend scales the path by `size`/upem. */
+    upem: number;
+}
+/** fetch a glyph's outline as JSON — `outlineGlyphJson` in production, a fake in tests. */
+type GlyphOutlineProvider = (fontId: number, glyphId: number) => string;
+interface GlyphCacheOptions {
+    /** outline source; throws/invalid JSON propagate to the caller (fallback). */
+    provider: GlyphOutlineProvider;
+    /** max cached glyphs before LRU eviction (default 4096). */
+    maxEntries?: number;
+    /**
+     * Path2D factory — injectable so tests (and non-DOM environments) can supply
+     * a recording double. Defaults to the browser `Path2D` constructor.
+     */
+    createPath?: () => Path2D;
+}
+/**
+ * LRU cache keyed `(fontId, glyphId)` → `GlyphOutline`. `Map` preserves
+ * insertion order, so the oldest key is `keys().next()` and touching an entry
+ * is delete-then-set (reinsert at the tail).
+ */
+declare class GlyphCache {
+    private readonly provider;
+    private readonly maxEntries;
+    private readonly createPath;
+    private readonly entries;
+    constructor(options: GlyphCacheOptions);
+    /** number of cached glyphs (for tests / eviction assertions). */
+    get size(): number;
+    /**
+     * Outline for one glyph, building and caching it on first request. Throws if
+     * the provider throws or returns unparseable JSON — the caller falls back.
+     */
+    get(fontId: number, glyphId: number): GlyphOutline;
+    private build;
+}
+
+/**
+ * Lazy accessor for the embedded wasm glyph-outline provider — the production
+ * source a canvas host feeds to {@link GlyphCache}.
+ *
+ * Reached through the SAME dynamic `import('../wasm/index')` specifier the
+ * display-list builder (`buildRustDisplayList`) and the measure engine
+ * (`getRustTextEngine`) use, so all three resolve to ONE wasm module instance —
+ * i.e. one measurement `FontStore`. That shared identity is load-bearing:
+ * `outlineGlyphJson(fontId, glyphId)` must read glyph outlines from the very
+ * store `registerMeasureFont` populated during measurement, otherwise the ids
+ * in a GlyphRun would resolve against an empty store and every glyph would
+ * rasterize as `.notdef`. Keeping the import dynamic also keeps the ~800KB
+ * inlined wasm out of the default bundle (see `layout/wasm/index.ts`).
+ *
+ * @experimental part of the rust-canvas-engine glyph pipeline; shape may evolve.
+ */
+
+/**
+ * Resolve the wasm-backed {@link GlyphOutlineProvider} (`outlineGlyphJson`).
+ * The returned function is synchronous and initializes the wasm instance on
+ * first call; it throws when the embedded module lacks the `outline_glyph_json`
+ * export, which the canvas backend catches and repaints the run via `fillText`
+ * so text is never invisible. Shares the module promise with the display-list
+ * builder, so on the canvas path the wasm is already resolved by the time the
+ * first display list lands.
+ */
+declare function loadGlyphOutlineProvider(): Promise<GlyphOutlineProvider>;
+
+declare const MIRROR_CLASS_NAMES: {
+    page: string;
+    content: string;
+    header: string;
+    footer: string;
+    block: string;
+    table: string;
+    tableRow: string;
+    tableCell: string;
+    text: string;
+    rect: string;
+    image: string;
+    shape: string;
+    chart: string;
+    decoration: string;
+    line: string;
+    pageBorder: string;
+    tableCut: string;
+    blockSdt: string;
+    inlineSdtWidget: string;
+    revisionPmark: string;
+    revisionPmarkGlyph: string;
+    revisionPmarkIns: string;
+    revisionPmarkDel: string;
+    listMarker: string;
+    revisionTable: string;
+    revisionRow: string;
+    revisionCell: string;
+    revisionIns: string;
+    revisionDel: string;
+    revisionMerge: string;
+    notes: string;
+    note: string;
+    noteBacklink: string;
+};
+/**
+ * screen-reader labels for the mirror's structural wrappers. all strings are
+ * user-facing — hosts pass localized values (React adapter: `t('a11y.*')`);
+ * core deliberately ships no English defaults so no locale bypasses i18n.
+ */
+interface MirrorLabels {
+    /** page container label, e.g. "Page 3" */
+    page?: string;
+    /** header band label, e.g. "Page header" */
+    header?: string;
+    /** footer band label, e.g. "Page footer" */
+    footer?: string;
+    /**
+     * note→reference backlink label, e.g. "Back to reference". Optional: without
+     * it the backlink anchor falls back to the note's own label (a number, not
+     * hardcoded English), so no locale bypasses i18n.
+     */
+    noteBacklink?: string;
+}
+interface BuildMirrorPageOptions {
+    /** document to create elements in (default: global document) */
+    document?: Document;
+    /** localized aria-labels for page/header/footer wrappers */
+    labels?: MirrorLabels;
+}
+/**
+ * build the mirror DOM for one display page: an invisible (opacity 0,
+ * pointer-events none) absolutely-positioned tree whose elements sit at the
+ * exact page-local coordinates of their display primitives, carry the painter
+ * dataset contract, and expose real text nodes in reading order for
+ * accessibility. primitives sharing a blockId group under one block wrapper
+ * (role=paragraph, or role=table with row/cell structure when primitives
+ * carry `cell` grid coordinates) stamped with the union of the children's doc
+ * range; blockless primitives (table borders, separators) attach directly to
+ * `.layout-page-content`.
+ *
+ * header/footer regions mirror the painter's structural classes: each HfRegion
+ * becomes a `.layout-page-header` / `.layout-page-footer` wrapper at the band's
+ * page-local y, and all of the region's primitives (including their block
+ * wrappers and doc-range attrs, which refer to the HF PM doc identified by
+ * `data-hf-rid`) stay scoped inside it — never under `.layout-page-content`.
+ *
+ * data-from-line/to-line ride on paragraph fragment primitives (body, HF, text
+ * box) and land on the paragraph wrapper; data-vmerge-continuation comes from
+ * the cell's `continuation` flag and lands on the ARIA cell. still not derivable
+ * from the v0 display list and therefore not emitted: data-carried-from-prev/
+ * to-next (display-list contract gap — see openspec/changes/rust-canvas-engine).
+ */
+declare function buildMirrorPage(page: DisplayPage, options?: BuildMirrorPageOptions): HTMLElement;
+
+/**
+ * Framework-neutral interactive overlay for canvas-rendered content controls.
+ *
+ * The accessibility mirror must remain invisible and pointer-inert. This module
+ * therefore derives a separate, visible DOM layer from the same display-list
+ * metadata. React and Vue mount the returned element above a canvas page and
+ * keep their existing delegated `.layout-sdt-widget` / repeat handlers.
+ *
+ * Security: every DOCX-derived string is assigned through `textContent`,
+ * `dataset`, or `setAttribute`; no HTML strings are parsed.
+ */
+
+interface InteractiveOverlayLabels {
+    /** Accessible name for a repeating-section add button. */
+    addRepeatingItem?: string;
+    /** Accessible name for a repeating-section remove button. */
+    removeRepeatingItem?: string;
+    /** Accessible name used when a control has no authored alias or tag. */
+    control?: string;
+}
+interface BuildInteractiveOverlayOptions {
+    /** Document used to create elements (default: global `document`). */
+    document?: Document;
+    /** Host-localized button names. */
+    labels?: InteractiveOverlayLabels;
+}
+/** Apply PM-derived content-control focus to the interactive overlay boxes. */
+declare function applyInteractiveSdtFocus(root: ParentNode, focusedGroupIds: ReadonlySet<string>): void;
+/**
+ * Build the visible/pointer-active overlay for one page.
+ *
+ * Coordinates remain page-local CSS pixels. The caller applies the same zoom
+ * transform as the canvas and mirror. Boundary boxes themselves never receive
+ * pointer events; only real buttons are interactive/focusable.
+ */
+declare function buildInteractiveOverlayPage(page: DisplayPage, options?: BuildInteractiveOverlayOptions): HTMLElement;
+
+/**
+ * Resolves an image relationship id to a drawable source. Media decode stays
+ * in the host (browser decoders, object URLs, ImageBitmap caches) — the
+ * backend only replays the resolved source at the primitive's rect. Return
+ * null (or resolve to null) to skip the image.
+ */
+type ImageResolver = (relId: string) => CanvasImageSource | Promise<CanvasImageSource | null> | null;
+interface DrawPageOptions {
+    resolveImage?: ImageResolver;
+    /**
+     * Glyph-outline cache for `glyphRun` primitives (phase-2 shaped text). When
+     * absent, or when an outline cannot be resolved, the run is painted with
+     * `fillText` so text is never invisible. Owned by the host and reused across
+     * pages/renders.
+     */
+    glyphCache?: GlyphCache;
+}
+/**
+ * Minimal structural view of a canvas element for DPR sizing. Matches
+ * HTMLCanvasElement without requiring one, so hosts and tests can pass
+ * lookalikes.
+ */
+interface PageCanvasLike {
+    width: number;
+    height: number;
+    style: {
+        width: string;
+        height: string;
+    };
+}
+type PageCanvasBuffer = HTMLCanvasElement | OffscreenCanvas;
+/**
+ * Raster a complete page into a detached backing surface. Callers can prepare
+ * every damaged page concurrently, then present the finished buffers in one
+ * synchronous pass without ever exposing the renderer's initial clear.
+ */
+declare function rasterizeDisplayPageToBackBuffer(canvas: PageCanvasBuffer, page: DisplayPage, options?: DrawPageOptions, devicePixelRatio?: number, zoom?: number): Promise<PageCanvasBuffer>;
+/** Atomically replace one visible canvas with a fully rastered page buffer. */
+declare function presentDisplayPageBackBuffer(canvas: PageCanvasBuffer, buffer: PageCanvasBuffer, page: DisplayPage, zoom?: number): void;
+/** Zero-copy atomic presentation for a worker-owned transferred canvas. */
+declare function presentOffscreenPageBackBuffer(canvas: OffscreenCanvas, buffer: OffscreenCanvas): void;
+/**
+ * DPR- and zoom-aware canvas sizing: the bitmap is the page's logical px size
+ * times `devicePixelRatio * zoom`, the CSS box is the page size times `zoom`
+ * (so the page physically grows with the zoom control, mirroring the DOM
+ * painter's `transform: scale`), and the context is scaled by the same factor
+ * so all drawing keeps using page-local px coordinates. Rastering at
+ * `zoom * DPR` — rather than CSS-scaling a `zoom=1` bitmap — is what keeps text
+ * and vector outlines crisp when zoomed: glyph `Path2D` fills re-rasterize at
+ * the higher backing resolution instead of being upsampled. `zoom` defaults to
+ * 1, so the un-zoomed path is byte-identical to before.
+ *
+ * Setting canvas.width resets the context state, so call this before drawing
+ * (and re-call after any resize/zoom change) — the scale applies to the fresh
+ * transform.
+ */
+declare function sizeCanvasForPage(canvas: PageCanvasLike, ctx: CanvasRenderingContext2D, page: Pick<DisplayPage, 'width' | 'height'>, devicePixelRatio: number, zoom?: number): void;
+/** Raster every display page without requiring a mounted renderer surface. */
+declare function rasterizeDisplayListPages(list: DisplayList, options?: DrawPageOptions, devicePixelRatio?: number): Promise<HTMLCanvasElement[]>;
+/**
+ * Replays one DisplayPage onto a 2D context, honoring primitive paint order.
+ * Header/footer bands replay after the body, mirroring the DOM painter's
+ * append order in renderPage (content, then header, then footer); their
+ * primitives are already in page coordinates so they go through the same
+ * replay path. Async only because image sources may resolve lazily; each
+ * image is awaited in sequence so later primitives still paint above it.
+ * Every primitive sets the full context state it depends on, so no
+ * save/restore per primitive is needed (images use save/restore for their
+ * rotation transform only).
+ */
+declare function drawDisplayPage(ctx: CanvasRenderingContext2D, page: DisplayPage, options?: DrawPageOptions): Promise<void>;
+/** Replays a single primitive; exported for hosts that paint incrementally. */
+declare function drawPrimitive(ctx: CanvasRenderingContext2D, primitive: DisplayPrimitive, options?: DrawPageOptions): Promise<void>;
+
+/**
+ * Renderer-neutral geometry helpers for display-list primitives.
+ *
+ * These helpers are shared by canvas replay, interaction queries, the a11y
+ * mirror, and the temporary painter/display-list differential harness. They
+ * must not depend on DOM layout: every returned rectangle is page-local px.
+ */
+
+interface GeoRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Parse the px size from a CSS font shorthand, with Word's 11pt default. */
+declare function fontSizePxFromShorthand(font: string): number;
+/** Canonical page-local box for a text-run primitive. */
+declare function textRunRect(p: Pick<TextRunPrimitive, 'x' | 'baselineY' | 'width' | 'font'>): GeoRect;
+/** Canonical page-local box for a shaped glyph-run primitive. */
+declare function glyphRunRect(p: Pick<GlyphRunPrimitive, 'glyphs' | 'size'>): GeoRect;
+/** Canonical stroke-expanded page-local box for a line primitive. */
+declare function lineRect(p: Pick<LinePrimitive, 'x1' | 'y1' | 'x2' | 'y2' | 'strokeWidth'>): GeoRect;
+
+/**
+ * Layout constants + vertical page math for the experimental canvas pages
+ * hosts (React `CanvasPagesView` / Vue `CanvasPagesView.vue`): a flex column
+ * of one <canvas> per page. Shared by the views themselves and by the
+ * display-list consumers that need scroll-container Y coordinates (sidebar
+ * anchor positions) so the two can never drift.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+
+/** vertical gap between canvas pages (flex `gap`) */
+declare const CANVAS_PAGE_GAP_PX = 16;
+/** padding around the canvas pages column */
+declare const CANVAS_PAGES_PADDING_PX = 24;
+/**
+ * Top Y of each canvas page inside the `.canvas-pages` host, derived from the
+ * display list's own page heights. `tops[i] + pageLocalY` converts a
+ * display-list rect into host coordinates.
+ */
+declare function canvasPageTops(queries: DisplayListQueries): number[];
+
+/**
+ * Client-coordinate → display-list resolution for the canvas renderer's
+ * pointer path. Framework-free: both the React and the Vue adapter route
+ * their pointer events through this resolver.
+ *
+ * The pointer hooks map the client point onto one of the
+ * `<canvas data-page-index>` pages, convert it to page-local px (the
+ * display list's unit space), and ask the Rust `hit_test_regions` query for
+ * the region + doc position.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+
+interface CanvasPointHit {
+    pageIndex: number;
+    /** page-local px, the display list's unit space */
+    x: number;
+    y: number;
+    /** region-aware hit from the Rust query (null when the engine isn't ready) */
+    hit: DisplayListRegionHit | null;
+}
+interface DisplayPageHostOptions {
+    /** Vertical space between page shells when the host has no live canvases. */
+    pageGap?: number;
+    /** Space before the first page when the host has no live canvases. */
+    paddingTop?: number;
+}
+interface DisplayPageClientRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+    width: number;
+    height: number;
+}
+/**
+ * Resolve the client-space shell for one display-list page. A mounted canvas
+ * is the preferred projection host. During the Phase-2 transition the DOM
+ * painter may still be the visible renderer, so its *container* is used as a
+ * page-stack projection host without inspecting any painted page/text/table
+ * node. Page sizes remain display-list-owned.
+ */
+declare function resolveDisplayPageClientRect(host: HTMLElement, queries: DisplayListQueries, pageIndex: number, options?: DisplayPageHostOptions): DisplayPageClientRect | null;
+/**
+ * Resolve a client point against the canvas pages.
+ *
+ * Containment picks the page; with `clampToNearestPage` (drag-selection) a
+ * point outside every page snaps to the vertically nearest one and clamps
+ * into its bounds, so drags keep extending past page edges — the analogue of
+ * the DOM path's nearest-span snapping. Coordinates convert through the
+ * page's CSS rect vs its display-list size, so any ancestor scale transform
+ * is factored out.
+ */
+declare function resolveCanvasPoint(host: HTMLElement, queries: DisplayListQueries, clientX: number, clientY: number, options?: {
+    clampToNearestPage?: boolean;
+    pageGap?: number;
+    paddingTop?: number;
+}): CanvasPointHit | null;
+
+/**
+ * Image resolver for the canvas replay backend, shared by both adapters.
+ *
+ * v0 display lists carry the flow-block image `src` as the primitive's
+ * relId — for embedded media that is a blob:/data: URL minted by the parser.
+ * Shape picture fills resolve through the same gate via
+ * `fillPaint.pictureSrc`. Only those schemes are decoded; anything else
+ * (notably remote http urls from external-mode relationships, or a raw
+ * unresolved `rId`) resolves to null so opening a document never triggers a
+ * network fetch (the no-zero-click-external-fetch security contract). Decode
+ * results are cached per source so repaints reuse the same HTMLImageElement.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+
+declare function createCanvasImageResolver(): ImageResolver;
+
+/**
+ * Selection → live-region announcement derivation for the canvas renderer's
+ * accessibility layer. Framework-free: the React `CanvasA11yLiveRegion` and
+ * the Vue `CanvasA11yLiveRegion.vue` both derive their announcements here so
+ * assistive-tech behavior cannot drift between adapters.
+ *
+ * The hidden textarea stays the focused editing surface in canvas mode, so
+ * character/word echo while the caret moves comes from native input. The live
+ * region only announces state *transitions* the visual layer would otherwise
+ * communicate silently: a selection appearing or collapsing, the caret
+ * entering commented / tracked-change / list content. Edge-triggered on the
+ * selection context, so plain typing and uniform caret movement stay silent.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+interface A11ySelectionContext {
+    hasSelection: boolean;
+    inInsertion: boolean;
+    inDeletion: boolean;
+    inList: boolean;
+    listLevel?: number;
+    activeCommentIds: number[];
+}
+/** The slice of selection context the announcer reacts to. */
+interface A11ySelectionSnapshot {
+    hasSelection: boolean;
+    inInsertion: boolean;
+    inDeletion: boolean;
+    hasComment: boolean;
+    inList: boolean;
+    listLevel: number;
+    /** display name of the active comment thread's author, when the host knows it */
+    commentAuthor?: string;
+    /** reply count of the active comment thread, when the host knows it */
+    commentReplyCount?: number;
+}
+/**
+ * host-supplied details of the comment thread(s) under the caret, resolved
+ * from the same parsed comment model the sidebar uses. All strings are
+ * file-derived — the live region renders them as text, never markup.
+ */
+interface A11yCommentThreadDetails {
+    authorName?: string;
+    replyCount?: number;
+}
+declare function snapshotFromSelectionContext(ctx: A11ySelectionContext, 
+/** optional lookup so the `commentedText` announcement can carry author/reply vars */
+lookupCommentThread?: (commentIds: number[]) => A11yCommentThreadDetails | undefined): A11ySelectionSnapshot;
+/** i18n key under `a11y.*` plus interpolation vars */
+interface A11yAnnouncement {
+    key: 'selected' | 'selectionCleared' | 'commentedText' | 'trackedInsertion' | 'trackedDeletion' | 'listItem';
+    vars?: Record<string, string | number>;
+}
+/**
+ * announcements for one selection-state transition, in speaking order.
+ * `prev === null` (first observation) announces nothing — there is no
+ * transition to describe.
+ */
+declare function computeA11yAnnouncements(prev: A11ySelectionSnapshot | null, next: A11ySelectionSnapshot): A11yAnnouncement[];
+
+/** A yrs location projected into the PM-shaped position space used by the display list. */
+interface YrsSidebarDisplayPoint {
+    story: string;
+    position: number;
+    /** Header/footer relationship id; absent for body and nested body stories. */
+    hfRid?: string;
+}
+/** Read-only converter used by the yrs-backed sidebar data sources. */
+interface YrsSidebarProjection {
+    locToDisplayPoint(loc: YrsLoc): YrsSidebarDisplayPoint | null;
+    storyOffsetToDisplayPoint(story: string, offset: number): YrsSidebarDisplayPoint | null;
+}
+/**
+ * Convert a string yrs identity into the numeric id used by the existing
+ * layout/sidebar contract. This is the same UTF-8 FNV-1a projection used by
+ * the yrs render and Document bridges; numeric OOXML ids pass through.
+ */
+declare function yrsIdToNumericId(value: string): number;
+/**
+ * Build a lazy PM-free projection from live yrs stories to display positions.
+ * The canonical yrs segment stream supplies paragraph/atom units; table-cell
+ * and block-SDT stories are recursively sized so container tokens are included.
+ */
+declare function createYrsSidebarProjection(session: YrsSession): YrsSidebarProjection;
+
+/**
+ * Comment / tracked-change anchor derivation over the display list, shared
+ * by both adapters' sidebar plumbing on the canvas-renderer path.
+ *
+ * `visitAnchorKeys` walks the PM doc and reports every comment /
+ * tracked-change anchor as `(key, pos)` — shared between each adapter's
+ * layout-math derivation (DOM painter path) and the display-list derivation
+ * here, so both register identical keys in identical order.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+
+/** Structural view shape used only by the legacy display-list anchor walker. */
+interface AnchorEditorView {
+    readonly state: {
+        readonly doc: {
+            descendants(callback: (node: any, pos: number) => boolean | void): void;
+        };
+        readonly schema: {
+            readonly marks: Record<string, any>;
+        };
+    };
+}
+/**
+ * Walk the PM doc and report every comment / tracked-change anchor as
+ * `(key, pos)`. `register` is called once per occurrence; callers dedupe.
+ */
+declare function visitAnchorKeys(pmView: AnchorEditorView, register: (key: string, pos: number) => void): void;
+/**
+ * Display-list variant of the adapters' layout-based anchor derivation for
+ * the experimental canvas renderer: anchor Ys come from Rust `range_rects`
+ * queries over the display list (page-local px) plus the canvas page stack
+ * math, instead of layout-fragment scans in the DOM viewport's coordinate
+ * space. Returns `.canvas-pages`-host Y offsets keyed by
+ * `comment-{id}` / `revision-{revisionId}`.
+ */
+declare function computeAnchorPositionsFromDisplayList(pmView: AnchorEditorView | null, queries: DisplayListQueries, projectY?: (rect: DisplayListRect) => number | null): Map<string, number>;
+interface YrsHeaderFooterRegions {
+    get(rId: string): 'header' | 'footer' | undefined;
+}
+/**
+ * yrs-authoritative sidebar anchors. Comment coverage comes from sticky yrs
+ * side-map positions and tracked-change anchors come from `listRevisions()`;
+ * neither path reads an EditorView or ProseMirror document.
+ */
+declare function computeAnchorPositionsFromYrs(session: YrsSession, commentIds: Iterable<string | number>, revisions: readonly YrsRevisionInfo[], projection: YrsSidebarProjection, queries: DisplayListQueries, hfRegions?: YrsHeaderFooterRegions, projectY?: (rect: DisplayListRect) => number | null): Map<string, number>;
+interface DisplayListHfAnchorSource {
+    region: 'header' | 'footer';
+    rId: string;
+    view: AnchorEditorView;
+}
+/** Merge header/footer comment and revision anchors into an existing map. */
+declare function mergeHfAnchorPositionsFromDisplayList(sources: Iterable<DisplayListHfAnchorSource>, queries: DisplayListQueries, positions: Map<string, number>, projectY?: (rect: DisplayListRect) => number | null): Map<string, number>;
+
+/** Tracked-change sidebar data derived from the authoritative Yrs session. */
+interface TrackedChangesResult {
+    entries: TrackedChangeEntry[];
+    commentToRevision: Map<number, number>;
+}
+/** Project Yrs revisions onto the display-position sidebar contract. */
+declare function extractTrackedChangesFromYrs(revisions: readonly YrsRevisionInfo[], projection: YrsSidebarProjection): TrackedChangesResult;
+
+/**
+ * Derive table-resize handle geometry from a built DisplayList.
+ *
+ * On the canvas path the DOM painter's `.layout-table-*-handle` elements are
+ * parked/hidden, so the canvas table-resize overlay must place its column / row
+ * / edge handles from the display list instead. This module walks the list and
+ * returns, per painted table fragment, the geometry an adapter needs to mount
+ * handles over the visible canvas:
+ *
+ *  - `originX` / `originY` — the fragment's page-local top-left. `originX` is
+ *    taken from an EXACT edge source (an outer vertical table-border line)
+ *    whenever one exists, so column handles land on the true column boundary
+ *    rather than inset by cell padding. Only a fully borderless table falls back
+ *    to the content bbox minus an estimated inset (documented, approximate).
+ *  - `bottomY` — the fragment's bottom edge (exact when a bottom border exists,
+ *    else content bbox bottom).
+ *  - `rowBands` — per anchor-row content band `{ rowIndex, top, bottom }`,
+ *    grouped by the `cell.row` carried on every in-cell primitive. Row-boundary
+ *    handles sit in the gap between consecutive bands, and the `rowIndex` maps
+ *    straight to `commitRowResize` (robust to vmerge, which suppresses interior
+ *    border lines but keeps the anchor row on every primitive).
+ *  - `tableKey` — the caller-supplied identity of the enclosing table; also the
+ *    handle key the adapter resolves back to the table node.
+ *
+ * Grouping key: cell content primitives carry each cell-paragraph's block id,
+ * NOT the table's, so grouping by block id would split a table into one fragment
+ * per cell. The adapter therefore supplies `tableKeyOf`, mapping an in-cell doc
+ * position to a stable per-table key (in the React adapter: the enclosing table
+ * node's PM `before` position, resolved against the live doc). Primitives whose
+ * position doesn't resolve to a table are skipped.
+ *
+ * Column-boundary x's and the right edge are intentionally NOT computed here:
+ * they come from the PM doc's `columnWidths` (twips) anchored at `originX`,
+ * which is exact and robust to horizontally-merged cells (colspan suppresses
+ * the interior border line the display list would otherwise expose).
+ *
+ * Body region only. The HF caret + selection on canvas are now sourced from the
+ * region-aware `hfRangeRects` / `hfCaretRects` queries (see
+ * `CanvasHfSelectionOverlay`), but HF *table* resize handles remain a documented
+ * gap: this walker takes `page.primitives` (body), and the overlay's
+ * `tableKeyOf` / commit path resolves against the body PM doc. Closing it needs
+ * (1) an optional region parameter here to walk `page.header|footer.primitives`,
+ * (2) a `tableKeyOf` bound to the active HF EditorView, and (3) the same
+ * nearest-viewport page pick the HF caret uses (the part paints on every page).
+ * HF tables are rare, so this is deferred.
+ *
+ * @experimental part of the rust-canvas-engine change; shape may evolve.
+ */
+
+interface TableRowBand {
+    /** 0-based anchor-row index (from `cell.row`) */
+    rowIndex: number;
+    top: number;
+    bottom: number;
+}
+interface DisplayListTableFragment {
+    pageIndex: number;
+    /** caller-supplied identity of the enclosing table (also the handle key) */
+    tableKey: string;
+    /** smallest in-cell `docStart` seen for this table on this page */
+    docStartSample: number;
+    /** page-local left edge (exact when a border exposes it, else approximate) */
+    originX: number;
+    /** page-local top edge of the fragment's content */
+    originY: number;
+    /** page-local bottom edge of the fragment's content */
+    bottomY: number;
+    /** true when `originX` came from an exact edge source (border line) */
+    originExact: boolean;
+    /** per anchor-row content bands, ascending by `rowIndex` */
+    rowBands: TableRowBand[];
+}
+/** Resolve an in-cell doc position to its enclosing table's stable key, or null. */
+type TableKeyResolver = (docStart: number | undefined) => string | null;
+type DisplayListTableRegion = {
+    kind?: 'body';
+    rId?: undefined;
+} | {
+    kind: 'header' | 'footer';
+    rId?: string | null;
+};
+interface DisplayListSelectedCellSpec {
+    /** caller-supplied identity of the enclosing table */
+    tableKey: string;
+    row: number;
+    col: number;
+    rowSpan: number;
+    colSpan: number;
+}
+interface DisplayListSelectedCellRect {
+    pageIndex: number;
+    tableKey: string;
+    row: number;
+    col: number;
+    rowSpan: number;
+    colSpan: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    exact: boolean;
+    region: 'body' | 'header' | 'footer';
+    rId?: string;
+}
+interface DisplayListTableInsertHoverInput {
+    list: DisplayList;
+    pageIndex: number;
+    /** Page-local pointer x/y in display-list px. */
+    x: number;
+    y: number;
+    /** Client-space canvas rect for `pageIndex`, used to return DOM-path anchors. */
+    canvasRect: Pick<DOMRect, 'left' | 'top' | 'width' | 'height'>;
+    /** Display-list page size for `pageIndex`. */
+    pageSize: {
+        width: number;
+        height: number;
+    };
+    tableKeyOf: TableKeyResolver;
+    /** Resolve a table grid cell to its PM cell-start position. */
+    cellPmPosOf: (tableKey: string, row: number, col: number) => number | null;
+    region?: DisplayListTableRegion;
+    edgeProximity?: number;
+}
+interface DisplayListTableInsertHoverHit {
+    type: 'row' | 'column';
+    clientX: number;
+    clientY: number;
+    cellPmPos: number;
+}
+declare const DISPLAY_LIST_TABLE_INSERT_HIDE_DELAY_MS = 200;
+/**
+ * All body table fragments across every page of the display list, each with the
+ * geometry an adapter needs to mount canvas resize handles. `tableKeyOf` maps an
+ * in-cell doc position to its enclosing table's stable key (see module docs).
+ */
+declare function deriveDisplayListTableFragments(list: DisplayList, tableKeyOf: TableKeyResolver): DisplayListTableFragment[];
+/**
+ * Full selected-cell boxes for canvas overlays.
+ *
+ * The DOM painter highlights `.layout-table-cell` elements directly; in canvas
+ * mode those cells are parked, so adapters pass the live PM CellSelection as
+ * grid coordinates and this helper resolves visible page-local boxes from the
+ * display-list table geometry. Border lines provide exact grid edges when
+ * present; borderless fragments fall back to the selected cell's content bbox
+ * padded by the same conservative inset used by table-resize geometry.
+ */
+declare function deriveDisplayListSelectedCellRects(list: DisplayList, selectedCells: DisplayListSelectedCellSpec[], tableKeyOf: TableKeyResolver, region?: DisplayListTableRegion): DisplayListSelectedCellRect[];
+/**
+ * Canvas/display-list version of the table insert "+" hover detector.
+ *
+ * Mirrors `detectTableInsertHover`'s edge threshold and button offsets, but
+ * reads table/cell boxes from display-list geometry because the painter DOM is
+ * parked while canvas is active.
+ */
+declare function detectDisplayListTableInsertHover(input: DisplayListTableInsertHoverInput): DisplayListTableInsertHoverHit | null;
+
+interface DisplayListHyperlinkHit {
+    pageIndex: number;
+    region: 'body' | 'header' | 'footer';
+    rId?: string;
+    href: string;
+    tooltip?: string;
+    displayText: string;
+    rect: GeoRect;
+}
+declare function findDisplayListHyperlinkAtPoint(list: DisplayList, pageIndex: number, x: number, y: number, region?: DisplayListTableRegion): DisplayListHyperlinkHit | null;
+
+/**
+ * Display-list rendering surface: the renderer-agnostic contract between
+ * layout output and every backend, plus the web canvas replay backend.
+ *
+ * @experimental The display-list pipeline is under active development
+ * (rust-canvas-engine change); shape may evolve while the Rust builder lands.
+ */
+
+/**
+ * Demo display list used as the default provider value until the Rust
+ * display-list builder plugs in. One page, one paragraph of two runs with a
+ * highlight and underline, a table border line, and an image reference.
+ */
+declare const demoDisplayList: DisplayList;
+
+export { type A11yAnnouncement, type A11yCommentThreadDetails, type A11ySelectionSnapshot, type AnchorEditorView, type BuildInteractiveOverlayOptions, type BuildMirrorPageOptions, CANVAS_PAGES_PADDING_PX, CANVAS_PAGE_GAP_PX, type CanvasPointHit, DISPLAY_LIST_TABLE_INSERT_HIDE_DELAY_MS, DisplayList, type DisplayListHfAnchorSource, type DisplayListHyperlinkHit, DisplayListQueries, DisplayListRect, DisplayListRegionHit, type DisplayListSelectedCellRect, type DisplayListSelectedCellSpec, type DisplayListTableFragment, type DisplayListTableInsertHoverHit, type DisplayListTableInsertHoverInput, type DisplayListTableRegion, DisplayPage, type DisplayPageClientRect, type DisplayPageHostOptions, DisplayPrimitive, type DrawPageOptions, type GeoRect, GlyphCache, type GlyphCacheOptions, type GlyphOutline, type GlyphOutlineProvider, GlyphRunPrimitive, type ImageResolver, type InteractiveOverlayLabels, LinePrimitive, MIRROR_CLASS_NAMES, type MirrorLabels, type PageCanvasBuffer, type PageCanvasLike, type TableKeyResolver, type TableRowBand, TextRunPrimitive, type TrackedChangesResult, type YrsHeaderFooterRegions, type YrsSidebarDisplayPoint, type YrsSidebarProjection, applyInteractiveSdtFocus, buildInteractiveOverlayPage, buildMirrorPage, canvasPageTops, computeA11yAnnouncements, computeAnchorPositionsFromDisplayList, computeAnchorPositionsFromYrs, createCanvasImageResolver, createYrsSidebarProjection, demoDisplayList, deriveDisplayListSelectedCellRects, deriveDisplayListTableFragments, detectDisplayListTableInsertHover, drawDisplayPage, drawPrimitive, extractTrackedChangesFromYrs, findDisplayListHyperlinkAtPoint, fontSizePxFromShorthand, glyphRunRect, lineRect, loadGlyphOutlineProvider, mergeHfAnchorPositionsFromDisplayList, presentDisplayPageBackBuffer, presentOffscreenPageBackBuffer, rasterizeDisplayListPages, rasterizeDisplayPageToBackBuffer, resolveCanvasPoint, resolveDisplayPageClientRect, sizeCanvasForPage, snapshotFromSelectionContext, textRunRect, visitAnchorKeys, yrsIdToNumericId };