@mdzip/editor 1.3.21 → 1.4.4

package/dist/view.d.ts

@@ -2,6 +2,7 @@ import type { MdzWorkspace, MdzWorkspaceAsset } from '@mdzip/core-js';
 import { type MdzipAssetCache } from './asset-cache.js';
 import type { MdzipDocumentChangeEvent, MdzipEditorSnapshot, MdzipRemoveAssetOptions, MdzipWorkspaceOpenOptions } from './workspace.js';
 import { type MdzipEntryRenderer, type MdzipMarkdownRenderer, type MdzipMarkdownRenderExtension } from './rendering.js';
+import { type MdzipFrontMatterOptions } from './front-matter-extension.js';
 import type { MdzipWorkspaceSnapshot } from './workspace.js';
 export declare const DEFAULT_CODE_BLOCK_LANGUAGES: readonly MdzipCodeBlockLanguage[];
 export type MdzipWorkspaceLayout = 'preview' | 'source' | 'split';
@@ -38,6 +39,28 @@ export interface MdzipImageInsertDecision {
     position?: MdzipImagePosition;
 }
 export type MdzipImageInsertHandler = (request: MdzipImageInsertRequest) => MdzipImageInsertDecision | null | undefined | Promise<MdzipImageInsertDecision | null | undefined>;
+/**
+ * Parsed from the image reference (Markdown or raw HTML) currently under an
+ * edit-affordance click.
+ */
+export interface MdzipImageEditRequest {
+    src: string;
+    altText: string;
+    width?: number;
+    height?: number;
+    position?: MdzipImagePosition;
+    /** Which form the image is currently written in. */
+    mode: MdzipImageInsertOutputMode;
+}
+/**
+ * Host-owned async UI for editing an existing image's alt/size/position.
+ * Invoked when the user clicks an existing image's edit affordance in the
+ * source editor; returning `null`/`undefined` cancels, leaving the image
+ * untouched. Reuses `MdzipImageInsertDecision` as its resolution shape.
+ * Fully opt-in: with no `imageEditHandler` set, no affordance ever appears
+ * and clicking an image does nothing — there is no built-in fallback dialog.
+ */
+export type MdzipImageEditHandler = (request: MdzipImageEditRequest) => MdzipImageInsertDecision | null | undefined | Promise<MdzipImageInsertDecision | null | undefined>;
 export type MdzipEditorCommand = 'bold' | 'italic' | 'strikethrough' | 'highlight' | 'paragraph' | `heading-${MdzipHeadingLevel}` | 'bullet-list' | 'ordered-list' | 'inline-code' | 'code-block' | 'blockquote' | 'insert-line-break' | 'link' | 'insert-image';
 export type MdzipConversionAction = {
     kind: 'navigation';
@@ -228,6 +251,19 @@ export interface MdzipWorkspaceViewOptions {
      * not (see {@link MdzipWorkspaceView.setPreviewMaxWidth}).
      */
     previewMaxWidth?: MdzipPreviewMaxWidth;
+    /**
+     * Opt-in: render+mount the preview in chunks near the viewport instead of
+     * the whole document at once. For very large documents (e.g. a chat
+     * export with thousands of message rows) this keeps first-paint cost
+     * proportional to what's visible instead of the whole document's size —
+     * `marked`/DOMPurify otherwise run once, synchronously, over the entire
+     * rendered HTML before anything is mounted, which can block the main
+     * thread for seconds on real-world large files. Defaults to `false`.
+     * Only takes effect with the default marked-based renderer — a
+     * host-supplied custom {@link MdzipMarkdownRenderer} has no token
+     * structure to chunk by, so this option is silently ignored for it.
+     */
+    progressiveTextRendering?: boolean;
     /**
      * Controls the progressive preview image reveal animation. Use `'off'` in
      * live-editing hosts to prevent images from pulsing/sliding. Use `'initial'`
@@ -248,6 +284,14 @@ export interface MdzipWorkspaceViewOptions {
      * the insertion cleanly.
      */
     imageInsertHandler?: MdzipImageInsertHandler;
+    /**
+     * Optional host-owned async UI for editing an existing image (alt/size/
+     * position), opened by clicking that image's edit affordance in the
+     * source editor. Unset by default — with no handler, no affordance
+     * appears at all; there is no built-in fallback dialog like
+     * `imageInsertMode: 'ask'` provides for insertion.
+     */
+    imageEditHandler?: MdzipImageEditHandler;
     /**
      * Languages offered in the context menu's Code Block submenu. Each entry's
      * `id` becomes the fence info string (e.g. ```` ```ts ````); an empty `id`
@@ -337,6 +381,14 @@ export interface MdzipWorkspaceViewOptions {
      * the fallback. Handles are destroyed on selection change and destroy().
      */
     entryRenderers?: readonly MdzipEntryRenderer[];
+    /**
+     * Controls how a leading `---`-delimited YAML front matter block renders
+     * in the preview — display (table/raw), the collapsible expander, and its
+     * label. Unlike `markdownExtensions` (which is entirely opt-in), front
+     * matter handling is always registered; this only configures it. See
+     * {@link MdzipFrontMatterOptions}.
+     */
+    frontMatter?: MdzipFrontMatterOptions;
 }
 /** Options accepted by {@link MdzipWorkspaceView.setRenderingOptions}. */
 export interface MdzipRenderingOptions {
@@ -344,6 +396,7 @@ export interface MdzipRenderingOptions {
     markdownRenderer?: MdzipMarkdownRenderer | null;
     markdownExtensions?: readonly MdzipMarkdownRenderExtension[];
     entryRenderers?: readonly MdzipEntryRenderer[];
+    frontMatter?: MdzipFrontMatterOptions;
 }
 export declare function resolveMdzipControlPolicy(controls: MdzipControlPreset | MdzipControlPolicy | undefined): MdzipResolvedControlPolicy;
 export declare class MdzipWorkspaceView {
@@ -354,6 +407,7 @@ export declare class MdzipWorkspaceView {
     private controlPolicy;
     private readonly navigationMode;
     private imageHydrationAnimation;
+    private readonly progressiveTextRendering;
     private toolbarDensity;
     private contentDensity;
     private previewMaxWidth;
@@ -368,6 +422,11 @@ export declare class MdzipWorkspaceView {
     private conversionAction;
     private imageInsertDialogState;
     private packFilesDialogState;
+    private chunkedRenderState;
+    private chunkHtmlCache;
+    private copyRenderDialogState;
+    private copyReadyState;
+    private copyRenderDoneState;
     private navPaneWidth;
     private splitRatio;
     private resizing;
@@ -384,6 +443,9 @@ export declare class MdzipWorkspaceView {
     private tooltipState;
     private tooltipShowTimer;
     private tooltipHideTimer;
+    private copyToastHideTimer;
+    private clipboardWriteTimeoutMs;
+    private clipboardFallbackWriteTimeoutMs;
     private cmEditor;
     private readonly readOnlyCompartment;
     private readonly lineNumbersCompartment;
@@ -392,8 +454,17 @@ export declare class MdzipWorkspaceView {
     private syncing;
     private lastSyncedEditorScrollTop;
     private lastSyncedPreviewScrollTop;
+    private lastContentChangeTime;
+    private static readonly SCROLL_SYNC_SETTLE_MS;
+    private lastEditorGestureTime;
+    private lastPreviewGestureTime;
+    private static readonly SCROLL_SYNC_GESTURE_WINDOW_MS;
+    private pendingPreviewScrollRestore;
+    private bottomDrainGeneration;
+    private scrollCatchUpState;
     private markdownRenderer?;
     private markdownExtensions;
+    private frontMatterOptions;
     private entryRenderers;
     private renderingService;
     private previewMemo;
@@ -462,6 +533,17 @@ export declare class MdzipWorkspaceView {
     private readonly elPackFilesModeProject;
     private readonly elPackFilesEntrySelect;
     private readonly elPackFilesConfirmBtn;
+    private readonly elCopyRenderDialog;
+    private readonly elCopyRenderHeading;
+    private readonly elCopyRenderProgressSection;
+    private readonly elCopyRenderProgressBar;
+    private readonly elCopyRenderProgressText;
+    private readonly elCopyRenderReadyText;
+    private readonly elCopyRenderDoneText;
+    private readonly elCopyRenderCancelBtn;
+    private readonly elCopyRenderReadyCancelBtn;
+    private readonly elCopyRenderConfirmBtn;
+    private readonly elCopyRenderDismissBtn;
     private readonly elNavMenu;
     private readonly elNameDialog;
     private readonly elNameDialogHeading;
@@ -473,6 +555,7 @@ export declare class MdzipWorkspaceView {
     private readonly elDeleteConfirmBtn;
     private readonly elReplaceInput;
     private readonly elTooltip;
+    private readonly elCopyToast;
     private readonly elEmptyState;
     constructor(container: HTMLElement, options?: MdzipWorkspaceViewOptions);
     /**
@@ -545,6 +628,26 @@ export declare class MdzipWorkspaceView {
      * renderer re-match.
      */
     setRenderingOptions(options: MdzipRenderingOptions): void;
+    /**
+     * The extensions actually handed to `MdzipRenderingService`: the front
+     * matter extension first (always on — see `frontMatterOptions`), then
+     * whatever extensions the host passed via `markdownExtensions`. A fresh
+     * front matter extension instance is created each time this runs (view
+     * construction, `setRenderingOptions`), which is fine — its per-render
+     * state lives in a `WeakMap` keyed by the render context, not on the
+     * extension instance across renders.
+     */
+    private pipelineMarkdownExtensions;
+    /**
+     * Chunking options combining every registered extension's
+     * {@link MdzipMarkdownRenderExtension.shouldIsolateChunk} — see that doc
+     * comment for why a token an extension owns needs its own chunk regardless
+     * of the size budget — with the same treatment built in for any token that
+     * embeds an image ({@link tokenEmbedsImage}'s doc comment), plus a forced
+     * chunk boundary at every heading ({@link tokenIsHeading}'s doc comment)
+     * so unrelated sections never share a chunk.
+     */
+    private chunkOptions;
     /**
      * Replaces the view control policy without recreating the workspace or
      * CodeMirror editor. In particular, `lineNumbers` is reconfigured through a
@@ -562,6 +665,7 @@ export declare class MdzipWorkspaceView {
      */
     setPreviewMaxWidth(value: MdzipPreviewMaxWidth | undefined): void;
     setImageInsertOptions(options: Pick<MdzipWorkspaceViewOptions, 'imageInsertMode' | 'imageInsertHandler'>): void;
+    setImageEditOptions(options: Pick<MdzipWorkspaceViewOptions, 'imageEditHandler'>): void;
     private applyDensityClasses;
     /**
      * Tears down all custom rendering state: aborts in-flight renders, destroys
@@ -572,6 +676,8 @@ export declare class MdzipWorkspaceView {
     private replaceAssetSession;
     private resetPreviewState;
     private destroyPreviewHandles;
+    /** True when `this.previewMemo` — and by extension `this.previewGeneration` — still represents `snapshot`: nothing that feeds the preview (path, pathType, text, colorScheme) has changed since it was last rendered. */
+    private previewMemoMatchesSnapshot;
     private updatePreview;
     private applyPreviewHtml;
     private shouldAnimateImageHydration;
@@ -583,6 +689,160 @@ export declare class MdzipWorkspaceView {
      * has resolved and had its final `src` assigned (or there are none).
      */
     private mountProgressivePreview;
+    /**
+     * Cheap, attribute-only pass over every `<img>` under `roots`: no DOM tree
+     * mutation. Archive-relative sources have their `src` stripped here
+     * (immediately, so the browser never fires a bad network request for the
+     * archive-relative path) and are returned for {@link hydrateImages};
+     * external/data/fragment sources are left untouched (just get their align
+     * class, if any — they never get a slot). Returns `[]` without touching
+     * anything when there's no asset session to resolve archive images
+     * against, matching `mountPreviewHtml`'s no-op image handling.
+     *
+     * An image this session has *already* resolved once (e.g. it was already
+     * on screen before an edit elsewhere caused its chunk to remount) is
+     * applied immediately here via `resolveKnownImage` — no slot, no loading
+     * class, no `hydrateImages`/`IntersectionObserver` round trip — instead of
+     * being handed to the async placeholder-then-swap path meant for an image
+     * that's genuinely being resolved for the first time. Skipping that path
+     * for a re-mount of an already-known image is what actually avoids the
+     * visible flash; still going through it (even instantly) briefly blanks
+     * the image, since a fresh `<img>` element never carries over its
+     * predecessor's already-resolved `src`.
+     */
+    private collectPendingImages;
+    /**
+     * Slot-wraps and resolves `pending` images (from {@link collectPendingImages}),
+     * only decompressing/resolving ones near the viewport up front — a
+     * document with a few hundred distinct embedded images would otherwise
+     * decompress and blob-URL every one of them synchronously, freezing the UI
+     * for as long as that takes. Falls back to eager resolution when
+     * IntersectionObserver isn't available (e.g. non-browser hosts). Calls
+     * `onSettled` once every image in `pending` has resolved (or immediately
+     * if `pending` is empty) — callers that want a single "hydrated" signal
+     * for a whole preview pass `pending` from every root at once; callers
+     * mounting one chunk among several within the same generation (see
+     * {@link mountChunkBatch}) pass a no-op instead, so the signal only fires
+     * once, for the batch it's semantically tied to.
+     */
+    private hydrateImages;
+    /**
+     * Opt-in (`progressiveTextRendering`) alternative to the whole-document
+     * `renderMarkdown()` path above: tokenizes the markdown once, then renders
+     * and mounts it in chunks near the viewport instead of all at once — see
+     * {@link mountChunkedPreview}. Only reachable when
+     * `renderingService.supportsChunking` is true (the default marked-based
+     * renderer); the caller already checked that.
+     */
+    private renderChunkedPreview;
+    /**
+     * Same-document, text-only-edit counterpart to {@link renderChunkedPreview}:
+     * tokenizes the new text, then reconciles against the *previous* render's
+     * records (`priorState`) instead of tearing everything down. Only reachable
+     * when `updatePreview` determined the prior chunked structure is still
+     * reuse-eligible (same path/pathType/colorScheme); the caller already
+     * checked that.
+     */
+    private reconcileChunkedPreview;
+    /** Destroys one chunk record's mounted DOM and handles (but not the record object itself). */
+    private teardownChunkRecord;
+    /**
+     * Diffs the new tokenize pass's chunks against `priorState.records` by
+     * source-text identity (`chunkSourceKey`) and reconciles: chunks in the
+     * matched leading/trailing run keep their existing DOM and handles
+     * untouched (never re-rendered, never re-mounted — see
+     * `chunkSourceKey`'s doc comment for why that matters for extensions like
+     * mermaid); only the "middle" range that actually changed is torn down and
+     * remounted. Uses prefix/suffix matching rather than a general LCS — a
+     * text editor's edits are localized, so this is both simpler and correct
+     * for the real-world case.
+     */
+    private applyChunkReconciliation;
+    /**
+     * Mounts a reconciliation's replacement "middle" range in full (uncapped —
+     * a single edit only ever touches 1-2 chunks in practice; see the plan's
+     * disclosed v1 risk for the pathological large-paste case), then carries
+     * forward however much of the surviving suffix was already mounted before
+     * reconciling, and re-arms the sentinel for whatever's still left.
+     */
+    private mountReconciledMiddle;
+    /**
+     * Groups tokens into chunks and mounts them: an initial batch synchronously
+     * (enough for a small document to behave exactly like the non-chunked
+     * path), then the rest as the user scrolls near a trailing sentinel
+     * element, via the same `IntersectionObserver` + time-budgeted-rAF pattern
+     * already used for image hydration — just for "need more text" instead of
+     * "need this image". `onAssetsHydrated` fires once for the initial batch's
+     * images only (not re-fired per later chunk) — `onPreviewRendered` still
+     * means "the initial batch is in the DOM", same intent as the non-chunked
+     * path, just proportional to the viewport instead of the whole document.
+     */
+    private mountChunkedPreview;
+    /**
+     * Mounts every chunk of a non-progressive (`progressiveTextRendering:
+     * false`) document up front — same end state as the old monolithic
+     * non-chunked path (the whole document mounted before `onPreviewRendered`
+     * fires), but yielding a frame between batches (mirroring
+     * `drainRemainingChunks`) instead of blocking the main thread for one
+     * giant synchronous render.
+     */
+    private mountAllChunksEagerly;
+    /**
+     * Updates `chunkedRenderState.cursor` after a batch mounts. A no-op if a
+     * newer render generation has already superseded this one. Deliberately
+     * never nulls `chunkedRenderState` out just because `cursor` reached
+     * `records.length` — the records stay alive for the whole generation so a
+     * later same-document edit can reconcile against them (see
+     * `applyChunkReconciliation`). Callers that need "is there still an
+     * unmounted lazy tail" (Copy All's instant path, the scroll-to-bottom fast
+     * path) check `cursor < records.length` directly instead of this field's
+     * truthiness.
+     */
+    private recordChunkProgress;
+    /**
+     * Renders+appends chunks starting at `startCursor` up to a char budget
+     * (enough for one screenful, roughly) *or* a wall-clock time budget,
+     * whichever comes first — char count alone is a poor proxy for cost on a
+     * document where some chunks are plain text and others are dense with
+     * `<img>` tags (parsing + sanitizing + inserting into an already-huge
+     * `elPreviewContent` gets measurably more expensive per chunk as an
+     * image-heavy document's accumulated DOM grows); the time budget catches
+     * what the char budget alone misses. Mounts extensions/code-block controls
+     * for exactly the chunks it appended (never re-scanning earlier ones), and
+     * returns the cursor to resume from plus those chunks' roots (for the
+     * caller to run `collectPendingImages` on). Shared by every caller that
+     * mounts chunk batches — the initial batch, every later sentinel-triggered
+     * continuation, and Copy All's drain — image hydration itself is *not*
+     * included here; see {@link mountChunkBatch} and
+     * {@link drainRemainingChunks} for the two different ways callers pace it.
+     */
+    private renderAndMountChunkBatch;
+    /**
+     * `renderAndMountChunkBatch` plus its own immediate, independent
+     * `hydrateImages` pass — the shape every caller except Copy All's drain
+     * wants: mount a batch, then hydrate whatever images it contained,
+     * decoupled from mounting the next batch. Scroll-paced callers (the
+     * initial batch, every sentinel continuation) are naturally rate-limited
+     * by how fast the user scrolls, so one independent hydration loop per
+     * batch never has a chance to pile up against another.
+     */
+    private mountChunkBatch;
+    /**
+     * Wraps one chunk's rendered HTML in a mount boundary and appends it (or,
+     * given `beforeNode`, splices it in ahead of that still-attached node —
+     * used by reconciliation to insert a replacement chunk ahead of a
+     * surviving mounted suffix). See the `.mdzip-chunk` CSS rules for why.
+     */
+    private appendChunkHtml;
+    /**
+     * Appends a trailing sentinel and mounts the next chunk batch once it's
+     * within `rootMargin` of the viewport — a larger margin than images'
+     * (`hydrateImages`' 600px) since keeping text ahead of scroll is cheap
+     * relative to keeping images ahead. Re-arms itself after each batch until
+     * every chunk is mounted. Falls back to mounting everything immediately
+     * when IntersectionObserver isn't available, matching `hydrateImages`.
+     */
+    private armChunkSentinel;
     /**
      * Reveals a collapsed image slot. Flushing layout before toggling the class
      * lets the `0fr -> 1fr` grid transition run from the collapsed state instead
@@ -601,6 +861,13 @@ export declare class MdzipWorkspaceView {
      */
     private attachImageLoadHandlers;
     private reportImageLoadFailure;
+    /**
+     * `root` scopes extension `mount()` calls to a specific chunk instead of
+     * the whole preview — used by chunked rendering (see
+     * {@link mountChunkedPreview}), where extensions run once per newly
+     * appended chunk rather than once over the whole document. Defaults to
+     * the whole preview content, matching the non-chunked path exactly.
+     */
     private mountPreviewExtensions;
     /**
      * Built-in preview affordances for rendered code blocks: a language-name
@@ -611,6 +878,9 @@ export declare class MdzipWorkspaceView {
      * extension) — every consumer gets this automatically, gated by policy
      * rather than opt-in wiring. Runs after `mountPreviewExtensions` so any
      * extension-provided `pre > code` blocks already exist in the DOM. See #29.
+     *
+     * `root` scopes the scan to a specific chunk instead of the whole preview
+     * — see {@link mountPreviewExtensions} for why.
      */
     private mountCodeBlockControls;
     /**
@@ -621,6 +891,8 @@ export declare class MdzipWorkspaceView {
      */
     private enhanceCodeBlock;
     private firePreviewRendered;
+    /** See `pendingPreviewScrollRestore`'s doc comment. */
+    private restorePendingPreviewScroll;
     private fireAssetsHydrated;
     private flushRenderedWaiters;
     /**
@@ -656,6 +928,8 @@ export declare class MdzipWorkspaceView {
     private showTooltipForElementNow;
     private showTooltip;
     private hideTooltip;
+    /** Briefly shows a status message (e.g. "Text copied to clipboard") near the bottom of the view, auto-hiding after a couple of seconds. */
+    private showCopyToast;
     private save;
     private downloadSavedBlob;
     private saveTitle;
@@ -688,6 +962,13 @@ export declare class MdzipWorkspaceView {
     private handlePaste;
     private insertImageFile;
     private insertImageBytes;
+    /**
+     * Handles a click on an existing image's edit affordance (see
+     * `imageEditAffordanceField`/the `click` domEventHandler in
+     * createCmEditor). Only reachable when `imageEditHandler` is set — the
+     * click handler that dispatches the affordance already gates on that.
+     */
+    private openImageEditFlow;
     private resolveImageInsertDecision;
     private openImageInsertDialog;
     private resolveImageInsertDialog;
@@ -698,8 +979,126 @@ export declare class MdzipWorkspaceView {
     private handleEditorMenuAction;
     private previewMenuItems;
     private handlePreviewMenuAction;
+    /**
+     * Shows the copy confirmation either as a brief auto-hiding toast (an
+     * instant copy — nothing for the user to have looked away from) or, if
+     * the render dialog was showing, by switching that same dialog into a
+     * dismissable "done" state instead of hiding it — a copy that took long
+     * enough to need a progress dialog shouldn't end in a 2-second toast the
+     * user may not be looking at. `outcome` null means there was nothing to
+     * copy (empty selection) — silently clean up the dialog if one was
+     * showing, no confirmation needed. An `error` outcome carries the actual
+     * failure text inline (`onFailed` is a host callback with no guaranteed
+     * visible surface — this component has no other way to guarantee the
+     * user ever sees why it failed).
+     */
+    private finishCopyNotification;
+    /** Switches the render dialog into its "ready to copy" state, holding `perform` until the user clicks Copy — see `copyReadyState` for why the write can't just happen automatically here. */
+    private armCopyReady;
+    /** Runs the held write from `copyReadyState` — called directly from the dialog's Copy button click, which is what makes the write's own user-activation check pass. */
+    private performReadyCopy;
+    /**
+     * Races `promise` against a timer, rejecting with `timeoutMessage` if the
+     * timer wins. The async Clipboard API has no built-in timeout, and a
+     * write large enough to strain a real OS clipboard (a document with
+     * thousands of embedded images can build a HTML payload well over
+     * 100MB) can apparently hang indefinitely on some machines rather than
+     * rejecting — without this, that leaves the operation permanently
+     * pending, and the progress dialog never resolves into either a done or
+     * a failure state.
+     */
+    private withTimeout;
+    /** Writes `text` to the clipboard. Returns null if there was nothing to copy (a true no-op, not a failure); otherwise a success message or the failure text (also reported via `onFailed`, but that's a host callback with no guaranteed visible surface — the caller needs the text itself to show the user). */
     private copyPreviewSelection;
-    private selectAllPreviewContent;
+    /** Syncs just the copy-render dialog's progress bar/text from `copyRenderDialogState` — see `copyAllPreviewContent` for why this bypasses `render()`. No-op while the dialog isn't showing. */
+    private updateCopyRenderDialogProgress;
+    /**
+     * Copies the entire rendered document as plain text (same fidelity as
+     * `copyPreviewSelection` — no HTML, no `ClipboardItem`), regardless of how
+     * much of it is currently mounted under progressive rendering. If
+     * everything's already mounted (small doc, eager/non-progressive mount, or
+     * the user already scrolled through it) this is instant —
+     * `chunkedRenderState` is either null (no markdown open, or a non-default
+     * renderer) or has nothing left to mount (`cursor >= records.length`) in
+     * exactly that case. Otherwise it force-drains the rest first, showing a
+     * cancelable progress dialog once the wait clears a short debounce so fast
+     * documents never flicker it into view.
+     */
+    private copyAllPreviewContent;
+    /**
+     * Renders the *entire* current document to one HTML string, independent
+     * of whatever's mounted in `elPreviewContent` — no DOM reads or writes.
+     * Copy All with Images needs pristine `<img src="original/path">` markup
+     * to hand to `MdzipAssetSession.rewriteHtmlEmbeddingImages`, and an
+     * already-mounted, possibly-hydrated `<img>` in the live preview may have
+     * had its `src` swapped for a `blob:` URL or stripped entirely pending lazy
+     * load — either way the original archive path is gone. Time-budgeted and
+     * yielded like `renderAndMountChunkBatch`, for the same reason: some
+     * chunks cost far more to render+sanitize than others. Extension `mount()`
+     * hooks are not run — they render into a live DOM (e.g. mermaid diagrams
+     * turning marked-up code fences into SVG), which this never touches, so a
+     * mermaid diagram will paste as its pre-render markup, not a rendered
+     * diagram. Only reachable when `renderingService.supportsChunking` is
+     * true; the caller checks that first.
+     */
+    private renderFullDocumentHtml;
+    /**
+     * Like `copyAllPreviewContent`, but writes a rich `text/html` clipboard
+     * representation (alongside the same `text/plain` fallback) with every
+     * archive image re-embedded as a self-contained `data:` URL — the format
+     * an external app like Word needs, since this document's own `blob:` URLs
+     * only resolve inside this tab. Two phases share one debounced, cancelable
+     * dialog: render the document fresh (`renderFullDocumentHtml`), then embed
+     * its images (`rewriteHtmlEmbeddingImages`). Falls back to
+     * `copyAllPreviewContent`'s plain-text-only behavior when there's no
+     * default renderer to re-render from (a host-supplied custom renderer,
+     * the same escape hatch `progressiveTextRendering` already has) — or, if
+     * the clipboard rejects the rich write for any reason (unsupported
+     * browser, payload too large), falls back to a plain-text write so the
+     * user still gets *something* rather than nothing.
+     */
+    private copyAllWithImagesPreviewContent;
+    /**
+     * Writes an HTML+plain-text `ClipboardItem` when the browser supports it,
+     * falling back to a plain-text-only `writeText` (same as
+     * `copyPreviewSelection`, which reports itself as "Plain text") when it
+     * doesn't, or if the rich write itself throws (e.g. a payload too large
+     * for the OS clipboard) — either way the user ends up with *something* on
+     * their clipboard rather than nothing. Returns the confirmation message
+     * for the caller to show (see `finishCopyNotification`), naming the
+     * actual MIME type that ended up on the clipboard ("HTML" for a
+     * successful rich write, "Plain text" for the fallback) so the user knows
+     * what they're about to paste — `imageCount` only adds to the "HTML"
+     * wording, since even a rich write with zero images is still HTML, not
+     * plain text.
+     */
+    private writeRichClipboard;
+    /**
+     * Mounts every chunk from `state.cursor` onward, yielding to a fresh
+     * animation frame between batches (unlike the sentinel path's rAF-time-
+     * budgeted-per-batch loop, this has no viewport to wait on — it has to
+     * plow through the whole rest of the document, so the explicit yield is
+     * what keeps a huge draw from locking up the tab while it does). Stops
+     * early if `signal` aborts, a newer render generation supersedes this one,
+     * or the chunk state's own render context aborts.
+     *
+     * Deliberately uses `renderAndMountChunkBatch` instead of `mountChunkBatch`
+     * and defers image hydration until the whole drain finishes, running it
+     * once over every image the drain mounted, instead of once per batch:
+     * Copy All only needs the mounted chunks' *text* (`elPreviewContent
+     * .textContent`, which images never contribute to), so there's no reason
+     * to wait on `hydrateImages`' async image resolution at all here — and
+     * racing through batches as fast as this loop can while each one fires
+     * its own independent, un-awaited `hydrateImages` background loop (as
+     * `mountChunkBatch` does for the scroll-paced callers, where that's fine —
+     * scrolling naturally rate-limits how many can ever be in flight at once)
+     * lets dozens of those loops pile up concurrently on an image-heavy
+     * document, each spending its own `CHUNK_BUDGET_MS` in the same frame —
+     * measured 100-200ms frame gaps on a 15,000-image document. One combined
+     * pass over every image at the end avoids the pile-up entirely, without
+     * making Copy All wait on it.
+     */
+    private drainRemainingChunks;
     private insertCodeBlock;
     private clearSelectionFormatting;
     private editorClipboard;
@@ -758,5 +1157,26 @@ export declare class MdzipWorkspaceView {
     private validLayoutForSnapshot;
     private syncScrollFromPreview;
     private syncScrollToPreview;
+    /**
+     * Handles syncScrollToPreview's bottom edge when the preview still has
+     * unmounted chunks: force-mounts the rest (same drain Copy All uses) so
+     * the preview's scrollHeight reflects the whole document, then jumps to
+     * its real bottom — instead of the ordinary ratio-based jump, which would
+     * only land at the bottom of whatever was mounted the instant the sync
+     * fired. Re-checks that the editor is still at its bottom and the document
+     * hasn't changed before applying the jump, since the drain can take long
+     * enough on a huge document for either to no longer hold.
+     *
+     * On the most extreme real documents this drain has been measured at
+     * ~106s (thousands of chunks, tens of thousands of images each needing a
+     * real DOM slot + IntersectionObserver registration) — long enough that a
+     * silent wait looks indistinguishable from a frozen preview pane. Past a
+     * short debounce (so ordinary documents never see it), a small status
+     * toast shows progress, reusing the same element Copy All's confirmation
+     * messages use.
+     */
+    private syncScrollToPreviewBottom;
+    /** Syncs the catch-up toast's text from `scrollCatchUpState`, bypassing `render()` — see `updateCopyRenderDialogProgress` for why. No-op while the toast isn't showing. */
+    private updateScrollCatchUpToast;
 }
 //# sourceMappingURL=view.d.ts.map