svelte-streamdown 4.0.1 → 4.1.1

package/dist/Elements/fallbacks/CodeFallback.svelte.d.ts

@@ -2,6 +2,9 @@ import type { Tokens } from 'marked';
 type $$ComponentProps = {
     token: Tokens.Code;
     id: string;
+    /** The fence is still being streamed; nothing below it is final yet. */
+    incomplete?: boolean;
+    animate?: boolean;
 };
 declare const CodeFallback: import("svelte").Component<$$ComponentProps, {}, "">;
 type CodeFallback = ReturnType<typeof CodeFallback>;

package/dist/Elements/fallbacks/MermaidFallback.svelte

@@ -4,10 +4,13 @@
 
 	const {
 		token,
-		id
+		id,
+		incomplete = false
 	}: {
 		token: Tokens.Code;
 		id: string;
+		/** The fence is still being streamed; nothing below it is final yet. */
+		incomplete?: boolean;
 	} = $props();
 
 	const streamdown = useStreamdown();
@@ -19,7 +22,7 @@
 	const chart = $derived(token.text.replace(/\n+$/, ''));
 </script>
 
-<div data-streamdown-mermaid={id}>
+<div data-streamdown-mermaid={id} data-incomplete={incomplete || undefined}>
 	<div
 		style={streamdown.isMounted ? streamdown.animationBlockStyle : ''}
 		class={streamdown.theme.code.base}

package/dist/Elements/fallbacks/MermaidFallback.svelte.d.ts

@@ -2,6 +2,8 @@ import type { Tokens } from 'marked';
 type $$ComponentProps = {
     token: Tokens.Code;
     id: string;
+    /** The fence is still being streamed; nothing below it is final yet. */
+    incomplete?: boolean;
 };
 declare const MermaidFallback: import("svelte").Component<$$ComponentProps, {}, "">;
 type MermaidFallback = ReturnType<typeof MermaidFallback>;

package/dist/Elements/icons.js

@@ -4,6 +4,7 @@ export const copyIcon = createRawSnippet(() => {
         render: () => {
             return `
             <svg
+	aria-hidden="true"
 	xmlns="http://www.w3.org/2000/svg"
 	width="100%"
 	height="100%"
@@ -24,6 +25,7 @@ export const downloadIcon = createRawSnippet(() => {
     return {
         render: () => {
             return `<svg
+	aria-hidden="true"
 		xmlns="http://www.w3.org/2000/svg"
 		width="100%"
 		height="100%"
@@ -44,7 +46,8 @@ export const checkIcon = createRawSnippet(() => {
     return {
         render: () => {
             return `
-            <svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>
+            <svg
+	aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>
             `;
         }
     };
@@ -53,6 +56,7 @@ export const zoomInIcon = createRawSnippet(() => {
     return {
         render: () => `
 			<svg
+	aria-hidden="true"
 				width="100%"
 				height="100%"
 				viewBox="0 0 24 24"
@@ -75,6 +79,7 @@ export const zoomOutIcon = createRawSnippet(() => {
     return {
         render: () => `
 		<svg
+	aria-hidden="true"
 			width="100%"
 			height="100%"
 			viewBox="0 0 24 24"
@@ -96,6 +101,7 @@ export const fitViewIcon = createRawSnippet(() => {
     return {
         render: () => `
 		<svg
+	aria-hidden="true"
 			width="100%"
 			height="100%"
 			viewBox="0 0 24 24"
@@ -119,6 +125,7 @@ export const fullscreenIcon = createRawSnippet(() => {
     return {
         render: () => `
 		<svg
+	aria-hidden="true"
 			width="100%"
 			height="100%"
 			viewBox="0 0 24 24"
@@ -139,6 +146,7 @@ export const chevronRight = createRawSnippet(() => {
     return {
         render: () => `
 			<svg
+	aria-hidden="true"
 				xmlns="http://www.w3.org/2000/svg"
 				width="100%"
 				height="100%"
@@ -158,6 +166,7 @@ export const chevronLeft = createRawSnippet(() => {
     return {
         render: () => `
 			<svg
+	aria-hidden="true"
 				xmlns="http://www.w3.org/2000/svg"
 				width="100%"
 				height="100%"

package/dist/Elements/srOnly.d.ts

@@ -0,0 +1 @@
+export declare const srOnly = "position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;";

package/dist/Elements/srOnly.js

@@ -0,0 +1,3 @@
+// Visually hidden but announced. Inline rather than a theme class: a live region
+// must keep working in apps that do not ship Tailwind's `sr-only`.
+export const srOnly = 'position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0 0 0 0);white-space:nowrap;border:0;';

package/dist/Streamdown.svelte

@@ -1,8 +1,13 @@
 <script lang="ts" generics="Source extends Record<string, any> = Record<string, any>">
 	import Block from './Block.svelte';
-	import { StreamdownContext, type StreamdownProps } from './context.svelte.js';
+	import {
+		StreamdownContext,
+		defaultTranslations,
+		type StreamdownProps
+	} from './context.svelte.js';
 	import { mergeTheme, shadcnTheme } from './theme.js';
 	import { parseBlocks, createParseBlocksCache } from './marked/index.js';
+	import { hasUnclosedFence } from './utils/fence.js';
 
 	let {
 		content = '',
@@ -23,6 +28,8 @@
 		streamdown = $bindable(),
 		renderHtml,
 		controls,
+		codeBlockMaxHeight,
+		tableMaxHeight,
 		animation,
 		element = $bindable(),
 		icons,
@@ -48,6 +55,10 @@
 		mermaidConfig?.theme ? mermaidConfig.theme : darkMode.current ? 'dark' : 'default'
 	);
 
+	// Per-instance incremental state: append-only content updates re-lex only
+	// the last couple of blocks instead of the whole document.
+	const blocksCache = createParseBlocksCache();
+
 	streamdown = new StreamdownContext({
 		get element() {
 			return element;
@@ -70,6 +81,12 @@
 		get highlightTheme() {
 			return resolvedHighlightTheme;
 		},
+		get animateUpdate() {
+			// A streamed chunk keeps animating; a replacement or a bulk append (the
+			// demo's "Show All" is an append of 95% of the document) renders plain.
+			// The first parse stays animatable so `animateOnMount` keeps its meaning.
+			return blocksCache.lastUpdate !== 'bulk';
+		},
 		get snippets() {
 			return snippets;
 		},
@@ -94,7 +111,11 @@
 			return renderHtml;
 		},
 		get translations() {
-			return translations;
+			// Resolved once, like the theme, so components never fall back themselves.
+			return {
+				alert: { ...defaultTranslations.alert, ...translations?.alert },
+				controls: { ...defaultTranslations.controls, ...translations?.controls }
+			};
 		},
 		get highlightLanguages() {
 			return highlightLanguages;
@@ -123,19 +144,53 @@
 			};
 		},
 		get controls() {
-			const codeControls = controls?.code ?? true;
-			const mermaid = controls?.mermaid;
-			const isMermaidObject = typeof mermaid === 'object' && mermaid !== null;
-			const mermaidControls = isMermaidObject ? (mermaid.enabled ?? true) : (mermaid ?? true);
-			const mermaidMouseWheelZoom = isMermaidObject ? (mermaid.mouseWheelZoom ?? true) : true;
-			const tableControls = controls?.table ?? true;
+			// `controls` is sugar: `false` turns every control off, `true`/undefined
+			// turns them all on, and each section is a boolean or an object of the
+			// same shape. Flatten it once here so components stay boolean lookups.
+			const sections = typeof controls === 'object' && controls !== null ? controls : {};
+			const resolve = (section: boolean | Record<string, any> | undefined) => {
+				const config = typeof section === 'object' && section !== null ? section : {};
+				const enabled = controls === false || section === false ? false : (config.enabled ?? true);
+				const download = config.download;
+				return {
+					enabled,
+					copy: enabled && config.copy !== false,
+					download: enabled && download !== false,
+					filename:
+						typeof download === 'object' && download !== null ? download.filename : undefined
+				};
+			};
+			const code = resolve(sections.code);
+			const table = resolve(sections.table);
+			const mermaid = resolve(sections.mermaid);
+			const tableSection =
+				typeof sections.table === 'object' && sections.table ? sections.table : {};
+			const mermaidSection =
+				typeof sections.mermaid === 'object' && sections.mermaid ? sections.mermaid : {};
 			return {
-				code: codeControls,
-				mermaid: mermaidControls,
-				mermaidMouseWheelZoom,
-				table: tableControls
+				code: code.enabled,
+				codeCopy: code.copy,
+				codeDownload: code.download,
+				codeDownloadFilename: code.filename ?? 'file',
+				table: table.enabled,
+				tableCopy: table.copy,
+				tableDownload: table.download,
+				tableDownloadFilename: table.filename ?? 'table',
+				tableCsvSeparator: tableSection.csvSeparator ?? ',',
+				mermaid: mermaid.enabled,
+				mermaidDownload: mermaid.download,
+				mermaidDownloadFilename: mermaid.filename ?? 'diagram',
+				// Wheel zoom is a gesture, not a button: it stays on unless it is
+				// turned off explicitly or every control is.
+				mermaidMouseWheelZoom: controls !== false && mermaidSection.mouseWheelZoom !== false
 			};
 		},
+		get codeBlockMaxHeight() {
+			return codeBlockMaxHeight;
+		},
+		get tableMaxHeight() {
+			return tableMaxHeight;
+		},
 		get children() {
 			return children;
 		},
@@ -155,12 +210,15 @@
 
 	const id = $props.id();
 
-	// Per-instance incremental state: append-only content updates re-lex only
-	// the last couple of blocks instead of the whole document.
-	const blocksCache = createParseBlocksCache();
 	const blocks = $derived(
 		isStatic ? content : parseBlocks(content, streamdown.extensions, blocksCache)
 	);
+
+	// Only the tail of a live stream can be mid-fence — a static render is finished
+	// by definition. Computed once here, not per block or per token.
+	const lastBlockIncomplete = $derived(
+		!isStatic && blocks.length > 0 && hasUnclosedFence(blocks[blocks.length - 1])
+	);
 </script>
 
 <div bind:this={element} class={className}>
@@ -168,7 +226,11 @@
 		<Block static={isStatic} block={content} />
 	{:else}
 		{#each blocks as block, index (`${id}-block-${index}`)}
-			<Block static={isStatic} {block} />
+			<Block
+				static={isStatic}
+				{block}
+				incomplete={lastBlockIncomplete && index === blocks.length - 1}
+			/>
 		{/each}
 	{/if}
 </div>

package/dist/context.svelte.d.ts

@@ -4,16 +4,57 @@ import type { MermaidConfig } from 'mermaid';
 import type { KatexOptions } from 'katex';
 import type { HighlightTheme } from '@tanstack/highlight/theme';
 import type { LanguageDefinition } from '@tanstack/highlight';
+/**
+ * Every user-visible string the components render themselves. Nested by area,
+ * like the theme; `Streamdown` merges the `translations` prop over
+ * `defaultTranslations` once so components always read a complete object.
+ */
+export type Translations = {
+    alert: {
+        note: string;
+        tip: string;
+        warning: string;
+        caution: string;
+        important: string;
+    };
+    controls: {
+        copyCode: string;
+        copiedCode: string;
+        downloadCode: string;
+        copyTable: string;
+        copiedTable: string;
+        downloadTable: string;
+        tableFormatMarkdown: string;
+        tableFormatHtml: string;
+        tableFormatCsv: string;
+        tableFormatTsv: string;
+        downloadDiagram: string;
+        downloadDiagramPng: string;
+        downloadDiagramSvg: string;
+        downloadDiagramMmd: string;
+        zoomIn: string;
+        zoomOut: string;
+        resetView: string;
+        fullscreen: string;
+        exitFullscreen: string;
+        diagram: string;
+        previousCitation: string;
+        nextCitation: string;
+        blockedUrl: string;
+        imageBlocked: string;
+        imageNoDescription: string;
+        linkBlocked: string;
+    };
+};
+export declare const defaultTranslations: Translations;
 export interface StreamdownContext extends Omit<StreamdownProps, keyof Snippets | 'class' | 'theme' | 'highlightTheme' | 'inlineCitationsMode'> {
     snippets: Snippets;
     highlightTheme: HighlightTheme;
+    /** False while rendering a bulk update (a replacement or a paste-sized append); Block captures it per update. */
+    animateUpdate: boolean;
     theme: Theme;
-    controls: {
-        code: boolean;
-        mermaid: boolean;
-        mermaidMouseWheelZoom: boolean;
-        table: boolean;
-    };
+    translations: Translations;
+    controls: ResolvedControls;
     inlineCitationsMode: 'list' | 'carousel';
     animation: {
         enabled: boolean;
@@ -30,11 +71,13 @@ export declare class StreamdownContext<Source extends Record<string, any> = Reco
     constructor(props: Omit<StreamdownProps, keyof Snippets | 'class' | 'highlightTheme'> & {
         snippets: Snippets<Source>;
         highlightTheme: HighlightTheme;
+        animateUpdate: boolean;
     });
 }
 export declare const useStreamdown: () => StreamdownContext<Record<string, any>>;
-import type { AlertToken, MathToken, SubSupToken, TableToken, THead, TBody, TFoot, THeadRow, TRow, TD, TH, Extension, GenericToken, CitationToken, MdxToken } from './marked/index.js';
+import type { AlertToken, CodeToken, MathToken, SubSupToken, TableToken, THead, TBody, TFoot, THeadRow, TRow, TD, TH, Extension, GenericToken, CitationToken, MdxToken } from './marked/index.js';
 import type { Tokens } from 'marked';
+import type { CsvSeparator } from './utils/table-export.js';
 import type { ListItemToken, ListToken } from './marked/marked-list.js';
 import type { Footnote, FootnoteRef, FootnoteToken } from './marked/marked-footnotes.js';
 import type { DescriptionDetailToken, DescriptionListToken, DescriptionTermToken, DescriptionToken } from './marked/marked-dl.js';
@@ -89,9 +132,53 @@ export type Snippets<Source extends Record<string, any> = Record<string, any>> =
             key: string;
         } : K extends 'mdx' ? {
             props: Record<string, number | string | boolean | null | undefined>;
+        } : K extends 'code' | 'mermaid' ? {
+            /** The fence is still streaming: defer expensive work. */
+            incomplete: boolean;
         } : {})
     ]>;
 };
+/** `filename` is the base name; the extension comes from the format. */
+type DownloadControl<Token> = boolean | {
+    filename?: string | ((token: Token) => string);
+};
+export type CodeControls = boolean | {
+    enabled?: boolean;
+    copy?: boolean;
+    download?: DownloadControl<CodeToken>;
+};
+export type TableControls = boolean | {
+    enabled?: boolean;
+    copy?: boolean;
+    download?: DownloadControl<TableToken>;
+    csvSeparator?: CsvSeparator;
+};
+export type MermaidControls = boolean | {
+    enabled?: boolean;
+    download?: DownloadControl<CodeToken>;
+    mouseWheelZoom?: boolean;
+};
+export type Controls = boolean | {
+    code?: CodeControls;
+    table?: TableControls;
+    mermaid?: MermaidControls;
+};
+/** What `Streamdown.svelte` flattens `controls` into, so components stay dumb. */
+export type ResolvedControls = {
+    code: boolean;
+    codeCopy: boolean;
+    codeDownload: boolean;
+    codeDownloadFilename: string | ((token: CodeToken) => string);
+    table: boolean;
+    tableCopy: boolean;
+    tableDownload: boolean;
+    tableDownloadFilename: string | ((token: TableToken) => string);
+    tableCsvSeparator: CsvSeparator;
+    mermaid: boolean;
+    mermaidDownload: boolean;
+    mermaidDownloadFilename: string | ((token: CodeToken) => string);
+    mermaidMouseWheelZoom: boolean;
+};
 export type StreamdownProps<Source extends Record<string, any> = Record<string, any>> = {
     streamdown?: StreamdownContext;
     static?: boolean;
@@ -114,23 +201,13 @@ export type StreamdownProps<Source extends Record<string, any> = Record<string,
     highlightThemes?: Record<string, HighlightTheme>;
     mermaidConfig?: MermaidConfig;
     katexConfig?: KatexOptions | ((inline: boolean) => KatexOptions);
+    /** Partial overrides; unset keys fall back to `defaultTranslations`. */
     translations?: {
-        alert?: {
-            note?: string;
-            tip?: string;
-            warning?: string;
-            caution?: string;
-            important?: string;
-        };
-    };
-    controls?: {
-        code?: boolean;
-        mermaid?: boolean | {
-            enabled?: boolean;
-            mouseWheelZoom?: boolean;
-        };
-        table?: boolean;
+        [K in keyof Translations]?: Partial<Translations[K]>;
     };
+    controls?: Controls;
+    codeBlockMaxHeight?: string;
+    tableMaxHeight?: string;
     renderHtml?: boolean | ((token: Tokens.HTML | Tokens.Tag) => string);
     animation?: {
         animateOnMount?: boolean;
@@ -171,10 +248,14 @@ export type StreamdownProps<Source extends Record<string, any> = Record<string,
         code?: Component<{
             token: Tokens.Code;
             id: string;
+            incomplete: boolean;
+            animate: boolean;
         }, any, any>;
         mermaid?: Component<{
             token: Tokens.Code;
             id: string;
+            incomplete: boolean;
+            animate: boolean;
         }, any, any>;
         math?: Component<{
             token: MathToken;

package/dist/context.svelte.js

@@ -1,4 +1,42 @@
 import { getContext, onMount, setContext } from 'svelte';
+// Alert titles stay lowercase: the theme capitalizes them with CSS.
+export const defaultTranslations = {
+    alert: {
+        note: 'note',
+        tip: 'tip',
+        warning: 'warning',
+        caution: 'caution',
+        important: 'important'
+    },
+    controls: {
+        copyCode: 'Copy code',
+        copiedCode: 'Code copied',
+        downloadCode: 'Download code',
+        copyTable: 'Copy table',
+        copiedTable: 'Table copied',
+        downloadTable: 'Download table',
+        tableFormatMarkdown: 'Markdown',
+        tableFormatHtml: 'HTML',
+        tableFormatCsv: 'CSV',
+        tableFormatTsv: 'TSV',
+        downloadDiagram: 'Download diagram',
+        downloadDiagramPng: 'PNG',
+        downloadDiagramSvg: 'SVG',
+        downloadDiagramMmd: 'MMD',
+        zoomIn: 'Zoom in',
+        zoomOut: 'Zoom out',
+        resetView: 'Zoom to fit',
+        fullscreen: 'Expand diagram',
+        exitFullscreen: 'Collapse diagram',
+        diagram: 'Diagram',
+        previousCitation: 'Previous citation',
+        nextCitation: 'Next citation',
+        blockedUrl: 'Blocked URL',
+        imageBlocked: 'Image blocked',
+        imageNoDescription: 'No description',
+        linkBlocked: 'blocked'
+    }
+};
 export class StreamdownContext {
     footnotes = {
         refs: new Map(),

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { default as Streamdown } from './Streamdown.svelte';
-export { useStreamdown, type StreamdownProps } from './context.svelte.js';
+export { useStreamdown, defaultTranslations, type StreamdownProps, type Translations, type Controls, type CodeControls, type TableControls, type MermaidControls, type ResolvedControls } from './context.svelte.js';
+export { extractTableData, tableDataToCSV, tableDataToTSV, tableDataToMarkdown, tableDataToHTML, type TableData, type CsvSeparator } from './utils/table-export.js';
 export { theme, shadcnTheme, mergeTheme, type Theme } from './theme.js';
 export { type CodeToken, type Extension, type StreamdownToken, lex, parseBlocks } from './marked/index.js';
 export { parseIncompleteMarkdown, type Plugin, IncompleteMarkdownParser } from './utils/parse-incomplete-markdown.js';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { default as Streamdown } from './Streamdown.svelte';
-export { useStreamdown } from './context.svelte.js';
+export { useStreamdown, defaultTranslations } from './context.svelte.js';
+export { extractTableData, tableDataToCSV, tableDataToTSV, tableDataToMarkdown, tableDataToHTML } from './utils/table-export.js';
 export { theme, shadcnTheme, mergeTheme } from './theme.js';
 export { lex, parseBlocks } from './marked/index.js';
 export { parseIncompleteMarkdown, IncompleteMarkdownParser } from './utils/parse-incomplete-markdown.js';

package/dist/marked/index.d.ts

@@ -57,6 +57,12 @@ export type ParseBlocksCache = {
     keptBefore: number[];
     /** persistent list of kept raws; only its tail is rewritten on append */
     blocks: string[];
+    /**
+     * What kind of update the last call was. Rendering skips the streaming
+     * animation on a `bulk` one — a replacement, or an append far larger than any
+     * streamed chunk — where ~10k spans would otherwise all animate in one frame.
+     */
+    lastUpdate: 'first' | 'stream' | 'bulk';
 };
 export declare const createParseBlocksCache: () => ParseBlocksCache;
 export declare const parseBlocks: (markdown: string, extensions?: Extension[], cache?: ParseBlocksCache) => string[];

package/dist/marked/index.js

@@ -145,15 +145,17 @@ export const createParseBlocksCache = () => ({
     keep: [],
     offsets: [0],
     keptBefore: [0],
-    blocks: []
+    blocks: [],
+    lastUpdate: 'first'
 });
 // Number of trailing rendered blocks that stay "live" (re-lexed every chunk).
 // 2 covers constructs that merge backward as they stream in — e.g. a paragraph
 // line becoming a table once its delimiter row arrives, or a setext heading.
 const SEAL_SLACK = 2;
-// Spot checks over the sealed prefix per append (see `appendable`). The sealed
-// region was compared byte-for-byte while it was live, so this only has to catch
-// a caller that swapped in a different, longer document.
+// Stride spot checks over the sealed prefix per append (see `appendable`), on
+// top of the per-block-start probes. The sealed region was compared
+// byte-for-byte while it was live, so this only has to catch a caller that
+// swapped in a different, longer document.
 const SEAL_PROBES = 16;
 /**
  * A Lexer used only to slice a document into top-level block raws.
@@ -185,23 +187,37 @@ const blockTokensOf = (markdown, extensions) => new SplitLexer(getBlockOptions(e
  * Is `markdown` an append to `cache.content`?
  *
  * The live region [offset, cache.content.length) is compared exactly — that is
- * the only region whose segmentation can still change. The sealed prefix gets
- * SEAL_PROBES sampled character comparisons instead of a full scan: a complete
- * `markdown.startsWith(cache.content)` was 93% of parseBlocks' streaming cost
- * (676 ms of 727 ms over a 100 KB / 5028-chunk stream) and is the single reason
- * the append path was O(N) per chunk rather than O(tail).
+ * the only region whose segmentation can still change. The sealed prefix is only
+ * sampled, never scanned: a complete `markdown.startsWith(cache.content)` was
+ * 93% of parseBlocks' streaming cost (676 ms of 727 ms over a 100 KB /
+ * 5028-chunk stream) and is the single reason the append path was O(N) per chunk
+ * rather than O(tail).
+ *
+ * Two families of samples, both O(sealed blocks) and not O(sealed characters):
+ * the first character of every sealed block (`cache.offsets` already holds those
+ * positions), which catches any edit that moves a block boundary or rewrites a
+ * block's first character — the shape a real out-of-band edit takes; plus
+ * SEAL_PROBES evenly spaced characters, which catch a wholesale document swap.
+ * A same-length edit in the middle of a sealed block can still slip through; see
+ * the streaming contract in the README.
  *
  * Note this compares source against source, not source against `raws`: marked's
  * tokenizers normalize (e.g. the list tokenizer rewrites a trailing space as a
  * newline), so raws are not always literal slices of the input.
  */
-const appendable = (markdown, content, offset) => {
+const appendable = (markdown, cache, cut, offset) => {
+    const content = cache.content;
     for (let i = offset; i < content.length; i++) {
         if (markdown.charCodeAt(i) !== content.charCodeAt(i))
             return false;
     }
     if (offset === 0)
         return true;
+    for (let b = 0; b < cut; b++) {
+        const i = cache.offsets[b];
+        if (markdown.charCodeAt(i) !== content.charCodeAt(i))
+            return false;
+    }
     const step = offset > SEAL_PROBES ? offset / SEAL_PROBES : 1;
     for (let f = 0; f < offset; f += step) {
         const i = f | 0;
@@ -210,7 +226,23 @@ const appendable = (markdown, content, offset) => {
     }
     return markdown.charCodeAt(offset - 1) === content.charCodeAt(offset - 1);
 };
+// An append this large in a single update is a paste or a "show all", not a
+// streamed chunk. Real streams arrive in tens of characters, and even a client
+// that batches renders to one frame at ~1000 tokens/s adds a few hundred; the
+// harm — thousands of spans starting a CSS animation in the same frame — only
+// begins well past this. ponytail: heuristic; a prop if anyone needs to tune it.
+const BULK_APPEND_CHARS = 2048;
+const updateKind = (isAppend, previousLength, length) => {
+    if (!isAppend)
+        return previousLength === 0 ? 'first' : 'bulk';
+    return length - previousLength > BULK_APPEND_CHARS ? 'bulk' : 'stream';
+};
 export const parseBlocks = (markdown, extensions = [], cache) => {
+    // Whether this call extends the content the cache already described — decided
+    // by the same probe the fast path uses, so the contiguity fallback below still
+    // counts as an append for the animation's purposes.
+    let isAppend = false;
+    const previousLength = cache?.content.length ?? 0;
     if (cache && cache.content.length > 0 && markdown.length > cache.content.length) {
         // Append-only update: seal everything except the last SEAL_SLACK rendered
         // blocks and re-lex only the tail. offsets[] are prefix sums over raws, so
@@ -223,7 +255,8 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
                 liveBlocks++;
         }
         const offset = cache.offsets[cut];
-        if (appendable(markdown, cache.content, offset)) {
+        if (appendable(markdown, cache, cut, offset)) {
+            isAppend = true;
             const tailTokens = blockTokensOf(markdown.slice(offset), extensions);
             let tailLength = 0;
             for (const token of tailTokens)
@@ -253,6 +286,7 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
                     cache.keptBefore.push(kept);
                 }
                 cache.content = markdown;
+                cache.lastUpdate = updateKind(isAppend, previousLength, markdown.length);
                 // Copy out: callers (Svelte `$derived`, the perf harness) diff block
                 // lists by identity, so handing back the persistent array would read as
                 // "nothing changed". slice() is a memcpy with no per-element callback.
@@ -283,6 +317,7 @@ export const parseBlocks = (markdown, extensions = [], cache) => {
             }
             cache.keptBefore.push(kept);
         }
+        cache.lastUpdate = updateKind(isAppend, previousLength, markdown.length);
         // Only trust the cache for future appends if raws reconstruct the input.
         cache.content = pos === markdown.length ? markdown : '';
         return cache.blocks.slice();