dsh-smooth-stream 0.1.0

package/lib/client.js

@@ -0,0 +1,1288 @@
+window.__ModuleLoader__.load({
+	id: "dsh-smooth-stream",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react = require("react");
+		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+		let _deepseek_ai_dsh_client_ui_attachment = require("@deepseek-ai/dsh-client-ui-attachment");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region \0dsh-css:/Users/dzlin/work/project/dsh-smooth-stream/src/client/TypewriterAssistantNodeView.module.css.mjs
+		const css = ".I17U7q_root{min-width:0;color:var(--dsw-alias-label-primary);flex-direction:column;font-size:16px;line-height:28px;display:flex}.I17U7q_body{flex-direction:column;gap:16px;min-width:0;display:flex}.I17U7q_think{flex-direction:column;display:flex}.I17U7q_thinkRow{position:relative;overflow:hidden}.I17U7q_think[data-state=running] .I17U7q_thinkRow:after{content:\"\";inset-block:0;background:linear-gradient(90deg, transparent 0%, color-mix(in srgb, var(--dsw-alias-bg-base) 60%, transparent) 55%, transparent 100%);pointer-events:none;width:300px;animation:2.6s ease-out infinite I17U7q_dsh-smooth-stream-think-sweep;position:absolute;left:0}@keyframes I17U7q_dsh-smooth-stream-think-sweep{0%{left:-300px}90%,to{left:100%}}.I17U7q_thinkLeading{flex-shrink:0}.I17U7q_thinkChevron{color:var(--dsw-alias-label-secondary)}.I17U7q_thinkTitle{font-weight:400}.I17U7q_thinkSeparator{background:var(--dsw-alias-label-caption);border-radius:1px;flex:none;width:2px;height:2px;margin:0 8px}.I17U7q_thinkSummary{min-width:0;color:var(--dsw-alias-label-tertiary);text-overflow:ellipsis;white-space:nowrap;flex:auto;font-size:14px;line-height:24px;overflow:hidden}.I17U7q_thinkSummary[data-follow-end]{text-overflow:clip}.I17U7q_thinkBody{color:var(--dsw-alias-label-tertiary);white-space:pre-wrap;word-break:break-word;padding:4px 0 4px 22px;font-size:14px;line-height:24px}.I17U7q_disclosureRoot{flex-direction:column;width:100%;min-width:0;display:flex}.I17U7q_disclosureRow{cursor:pointer;align-items:center;min-width:0;height:24px;display:flex;position:relative;overflow:hidden}.I17U7q_disclosureLeading{width:16px;height:16px;color:var(--dsw-alias-label-tertiary);flex:none;justify-content:center;align-items:center;margin-right:6px;display:inline-flex;position:relative}.I17U7q_disclosureIconIdle{opacity:1;transition:opacity .1s;display:inline-flex}.I17U7q_disclosureChevronHover{opacity:0;margin:auto;transition:opacity .1s;position:absolute;inset:0}.I17U7q_disclosureRow:hover .I17U7q_disclosureIconIdle{opacity:0}.I17U7q_disclosureRow:hover .I17U7q_disclosureChevronHover{opacity:1}.I17U7q_disclosureTitle{color:var(--dsw-alias-label-secondary);flex:none;font-size:14px;line-height:24px}.I17U7q_disclosureContent{visibility:visible;transition:grid-template-rows var(--ds-transition-duration,.2s) var(--ds-ease-in-out,cubic-bezier(.4, 0, .2, 1)), visibility 0s;grid-template-rows:1fr;display:grid}.I17U7q_disclosureContent[data-collapsed]{visibility:hidden;transition:grid-template-rows var(--ds-transition-duration,.2s) var(--ds-ease-in-out,cubic-bezier(.4, 0, .2, 1)), visibility 0s var(--ds-transition-duration,.2s);grid-template-rows:0fr}.I17U7q_disclosureContent>*{min-height:0;overflow:hidden}@media (prefers-reduced-motion:reduce){.I17U7q_think[data-state=running] .I17U7q_thinkRow:after{animation:none}.I17U7q_disclosureContent,.I17U7q_disclosureContent[data-collapsed]{transition:none}}.I17U7q_stopped{background:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-tertiary);border-radius:6px;align-self:flex-start;padding:0 6px;font-size:11px;line-height:18px}.I17U7q_visuallyHidden{clip:rect(0 0 0 0);clip-path:inset(50%);white-space:nowrap;border:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.I17U7q_follow{min-width:0}@supports (text-box-trim:trim-both){.I17U7q_root :is(p,h1,h2,h3,h4,h5,h6,li,blockquote){text-box-trim:trim-both;text-box-edge:text}}";
+		const tagId = "dsh-smooth-stream/TypewriterAssistantNodeView.module.css";
+		if (typeof document !== "undefined") {
+			let tag = document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]");
+			if (tag === null) {
+				tag = document.createElement("style");
+				tag.dataset.plugin = "dsh-smooth-stream";
+				tag.dataset.pluginCss = tagId;
+				document.head.appendChild(tag);
+			}
+			tag.textContent = css;
+		}
+		var TypewriterAssistantNodeView_module_css_default = {
+			"disclosureChevronHover": "I17U7q_disclosureChevronHover",
+			"think": "I17U7q_think",
+			"thinkSeparator": "I17U7q_thinkSeparator",
+			"disclosureTitle": "I17U7q_disclosureTitle",
+			"thinkSummary": "I17U7q_thinkSummary",
+			"dsh-smooth-stream-think-sweep": "I17U7q_dsh-smooth-stream-think-sweep",
+			"disclosureRoot": "I17U7q_disclosureRoot",
+			"disclosureIconIdle": "I17U7q_disclosureIconIdle",
+			"disclosureContent": "I17U7q_disclosureContent",
+			"thinkLeading": "I17U7q_thinkLeading",
+			"thinkRow": "I17U7q_thinkRow",
+			"thinkChevron": "I17U7q_thinkChevron",
+			"disclosureRow": "I17U7q_disclosureRow",
+			"disclosureLeading": "I17U7q_disclosureLeading",
+			"thinkTitle": "I17U7q_thinkTitle",
+			"stopped": "I17U7q_stopped",
+			"thinkBody": "I17U7q_thinkBody",
+			"visuallyHidden": "I17U7q_visuallyHidden",
+			"body": "I17U7q_body",
+			"follow": "I17U7q_follow",
+			"root": "I17U7q_root"
+		};
+		//#endregion
+		//#region src/client/AnimatedDisclosure.tsx
+		/** Class-name join for optional overlay classes over the chrome defaults. */
+		function cx(...parts) {
+			return parts.filter((part) => part !== void 0 && part !== "").join(" ");
+		}
+		/**
+		* Render one disclosure header whose expanded body is height-animated.
+		* @param props - Visual content, controlled open state, and the toggle
+		* callback fired by row click and Enter/Space.
+		* @returns the animated disclosure row.
+		*/
+		function AnimatedDisclosure({ icon, title, open, onToggle, collapsedContent, children, rowClassName, leadingClassName, titleClassName, chevronClassName }) {
+			const toggleFromKeyboard = (event) => {
+				if (event.key !== "Enter" && event.key !== " ") return;
+				event.preventDefault();
+				onToggle();
+			};
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				className: TypewriterAssistantNodeView_module_css_default.disclosureRoot,
+				"data-open": open || void 0,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: cx(TypewriterAssistantNodeView_module_css_default.disclosureRow, rowClassName),
+					"data-disclosure-row": true,
+					"data-expandable": "",
+					role: "button",
+					tabIndex: 0,
+					"aria-expanded": open,
+					onClick: onToggle,
+					onKeyDown: toggleFromKeyboard,
+					children: [
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: cx(TypewriterAssistantNodeView_module_css_default.disclosureLeading, leadingClassName),
+							children: open ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutline14, { className: chevronClassName }) : /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+								className: TypewriterAssistantNodeView_module_css_default.disclosureIconIdle,
+								children: icon
+							}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconChevronDownOutline14, { className: cx(chevronClassName, TypewriterAssistantNodeView_module_css_default.disclosureChevronHover) })] })
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: cx(TypewriterAssistantNodeView_module_css_default.disclosureTitle, titleClassName),
+							children: title
+						}),
+						!open && collapsedContent
+					]
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+					className: TypewriterAssistantNodeView_module_css_default.disclosureContent,
+					"data-disclosure-content": true,
+					"data-collapsed": open ? void 0 : "",
+					children
+				})]
+			});
+		}
+		//#endregion
+		//#region src/client/useSmoothStreamContent.ts
+		/**
+		* Stream-smoothing reveal hook.
+		*
+		* Buffers the model's chunked text and reveals it at a cadence that tracks
+		* the observed arrival rate, so a long reply never dumps whole paragraphs at
+		* once and a fast stream never stutters. Port of lobe-ui's smoother: EMA
+		* arrival cps + chunk size, backlog pressure, commit-interval widening with
+		* tail length, and a flush-speed settle drain once the input idles. The
+		* reveal decision is the pure {@link computeRevealStep} for unit tests.
+		*
+		* `shouldHoldBack` is the performance guard's veto: while it returns true the
+		* loop keeps measuring but skips the DOM commit, so an offscreen reply never
+		* competes with visible frames when the frame rate is degraded.
+		*/
+		const PRESET_CONFIG = {
+			balanced: {
+				activeInputWindowMs: 220,
+				defaultCps: 80,
+				emaAlpha: .35,
+				flushCps: 180,
+				largeAppendChars: 120,
+				maxActiveCps: 360,
+				maxCps: 240,
+				maxFlushCps: 480,
+				minCommitIntervalMs: 16,
+				minCps: 24,
+				settleAfterMs: 280,
+				settleDrainMaxMs: 420,
+				settleDrainMinMs: 120,
+				targetBufferMs: 40
+			},
+			realtime: {
+				activeInputWindowMs: 140,
+				defaultCps: 120,
+				emaAlpha: .45,
+				flushCps: 240,
+				largeAppendChars: 180,
+				maxActiveCps: 480,
+				maxCps: 320,
+				maxFlushCps: 640,
+				minCommitIntervalMs: 16,
+				minCps: 32,
+				settleAfterMs: 200,
+				settleDrainMaxMs: 280,
+				settleDrainMinMs: 100,
+				targetBufferMs: 24
+			},
+			silky: {
+				activeInputWindowMs: 280,
+				defaultCps: 64,
+				emaAlpha: .28,
+				flushCps: 140,
+				largeAppendChars: 100,
+				maxActiveCps: 280,
+				maxCps: 180,
+				maxFlushCps: 400,
+				minCommitIntervalMs: 16,
+				minCps: 20,
+				settleAfterMs: 360,
+				settleDrainMaxMs: 520,
+				settleDrainMinMs: 160,
+				targetBufferMs: 56
+			}
+		};
+		const MAX_COMMIT_INTERVAL_MS = 16;
+		const QUEUE_FRAME_MS = 16.67;
+		const CATCHUP_SECONDS = .15;
+		const clamp$1 = (value, min, max) => {
+			return Math.min(max, Math.max(min, value));
+		};
+		/**
+		* Demo per-frame reveal: drain `backlog / 8` characters, at least 1, scaled
+		* by frame time. A small queue types one glyph per frame; a burst raises the
+		* step so the display does not fall behind.
+		* @param backlog - Unrevealed characters.
+		* @param dtMs - Frame delta in ms.
+		* @returns Characters to reveal this frame.
+		*/
+		function computeQueueReveal(backlog, dtMs) {
+			if (backlog <= 0 || dtMs <= 0) return 0;
+			return Math.min(backlog, Math.max(1, Math.ceil(backlog / 8 * (dtMs / QUEUE_FRAME_MS))));
+		}
+		/** Counts user-perceived characters (code points), not UTF-16 units. */
+		const countChars = (text) => {
+			let count = 0;
+			for (const char of text) count += 1;
+			return count;
+		};
+		/** Pure settle-drain decision shared by the frame loop and its tests. */
+		function computeSettleDrain(config, input) {
+			if (input.inputActive || !input.settling) return 0;
+			const overflowCps = Math.max(0, input.backlog - 300) * 1e3 / 2;
+			const drainTargetMs = clamp$1(input.backlog * 8, config.settleDrainMinMs, config.settleDrainMaxMs);
+			const settleCps = input.backlog * 1e3 / drainTargetMs;
+			return clamp$1(Math.max(settleCps, overflowCps), config.flushCps, config.maxFlushCps);
+		}
+		/**
+		* Drain rate multiplier once the input ends: leftover backlog reveals at
+		* this multiple of the steady rate, so the end never drags.
+		*/
+		const SETTLE_DRAIN_MULTIPLIER = 1.8;
+		/** Pure per-frame reveal decision shared by the loop and its tests. */
+		function computeRevealStep(config, input, dtSeconds) {
+			const trackedCps = Math.max(input.emaCps, input.arrivalCpsEma);
+			const baseCps = clamp$1(trackedCps, config.minCps, config.maxFlushCps);
+			const targetLagChars = input.inputActive ? Math.max(2, Math.round(baseCps * config.targetBufferMs / 1e3)) : 0;
+			let currentCps;
+			if (input.steadyCps !== void 0) currentCps = input.inputActive || input.settling ? clamp$1(input.steadyCps * (input.inputActive ? 1 : SETTLE_DRAIN_MULTIPLIER), config.minCps, config.maxFlushCps) : 0;
+			else if (input.inputActive) {
+				const overflow = Math.max(0, input.backlog - 32);
+				const catchup = overflow > 0 ? overflow / CATCHUP_SECONDS : 0;
+				currentCps = clamp$1(baseCps * 1.08 + catchup, config.minCps, config.maxFlushCps);
+			} else if (input.settling) currentCps = computeSettleDrain(config, input);
+			else {
+				const idleFlushCps = Math.max(config.flushCps, baseCps * 1.8, input.arrivalCpsEma * .8);
+				currentCps = clamp$1(idleFlushCps, config.flushCps, config.maxFlushCps);
+			}
+			const minRevealChars = input.inputActive ? 1 : 2;
+			return {
+				revealChars: Math.max(minRevealChars, Math.round(currentCps * dtSeconds)),
+				targetLagChars
+			};
+		}
+		/**
+		* Smooth a chunked content stream into a reveal-paced display string.
+		*
+		* @param content - The full accumulated input so far.
+		* @param options - Preset, guard, and steady-rate wiring.
+		* @returns The displayed content, revealed at the smoothed cadence.
+		*/
+		function useSmoothStreamContent(content, { enabled = true, preset = "balanced", shouldHoldBack, steadyCps, defaultCps, speedCpsRef } = {}) {
+			const config = PRESET_CONFIG[preset];
+			const seedCps = defaultCps ?? config.defaultCps;
+			const [displayedContent, setDisplayedContent] = (0, react.useState)(content);
+			const displayedContentRef = (0, react.useRef)(content);
+			const displayedCountRef = (0, react.useRef)(countChars(content));
+			const targetContentRef = (0, react.useRef)(content);
+			const targetCharsRef = (0, react.useRef)([...content]);
+			const targetCountRef = (0, react.useRef)(countChars(content));
+			const emaCpsRef = (0, react.useRef)(seedCps);
+			const lastInputTsRef = (0, react.useRef)(0);
+			const lastInputCountRef = (0, react.useRef)(countChars(content));
+			const chunkSizeEmaRef = (0, react.useRef)(1);
+			const arrivalCpsEmaRef = (0, react.useRef)(seedCps);
+			const rafRef = (0, react.useRef)(null);
+			const lastFrameTsRef = (0, react.useRef)(null);
+			const wakeTimerRef = (0, react.useRef)(null);
+			const holdBackRef = (0, react.useRef)(shouldHoldBack);
+			const speedOutRef = (0, react.useRef)(speedCpsRef);
+			speedOutRef.current = speedCpsRef;
+			(0, react.useEffect)(() => {
+				holdBackRef.current = shouldHoldBack;
+			}, [shouldHoldBack]);
+			const clearWakeTimer = (0, react.useCallback)(() => {
+				if (wakeTimerRef.current !== null) {
+					clearTimeout(wakeTimerRef.current);
+					wakeTimerRef.current = null;
+				}
+			}, []);
+			const stopFrameLoop = (0, react.useCallback)(() => {
+				if (rafRef.current !== null) {
+					cancelAnimationFrame(rafRef.current);
+					rafRef.current = null;
+				}
+				lastFrameTsRef.current = null;
+			}, []);
+			const stopScheduling = (0, react.useCallback)(() => {
+				stopFrameLoop();
+				clearWakeTimer();
+			}, [clearWakeTimer, stopFrameLoop]);
+			const startFrameLoopRef = (0, react.useRef)(() => {});
+			const scheduleFrameWake = (0, react.useCallback)((delayMs) => {
+				clearWakeTimer();
+				wakeTimerRef.current = setTimeout(() => {
+					wakeTimerRef.current = null;
+					startFrameLoopRef.current();
+				}, Math.max(1, Math.ceil(delayMs)));
+			}, [clearWakeTimer]);
+			const syncImmediate = (0, react.useCallback)((nextContent) => {
+				stopScheduling();
+				const chars = [...nextContent];
+				const now = performance.now();
+				targetContentRef.current = nextContent;
+				targetCharsRef.current = chars;
+				targetCountRef.current = chars.length;
+				displayedContentRef.current = nextContent;
+				displayedCountRef.current = chars.length;
+				setDisplayedContent(nextContent);
+				emaCpsRef.current = seedCps;
+				chunkSizeEmaRef.current = 1;
+				arrivalCpsEmaRef.current = seedCps;
+				lastInputTsRef.current = now;
+				lastInputCountRef.current = chars.length;
+			}, [seedCps, stopScheduling]);
+			const startFrameLoop = (0, react.useCallback)(() => {
+				clearWakeTimer();
+				if (rafRef.current !== null) return;
+				const tick = () => {
+					const targetCount = targetCountRef.current;
+					const displayedCount = displayedCountRef.current;
+					const backlog = targetCount - displayedCount;
+					if (backlog <= 0) {
+						stopFrameLoop();
+						return;
+					}
+					const now = performance.now();
+					if (lastFrameTsRef.current === null) {
+						lastFrameTsRef.current = now;
+						rafRef.current = requestAnimationFrame(tick);
+						return;
+					}
+					const commitIntervalMs = Math.min(MAX_COMMIT_INTERVAL_MS, config.minCommitIntervalMs);
+					const frameIntervalMs = Math.max(0, now - lastFrameTsRef.current);
+					if (frameIntervalMs < commitIntervalMs) {
+						rafRef.current = requestAnimationFrame(tick);
+						return;
+					}
+					const dtSeconds = Math.max(.001, Math.min(frameIntervalMs / 1e3, .12));
+					lastFrameTsRef.current = now;
+					const idleMs = now - lastInputTsRef.current;
+					const inputActive = idleMs <= config.activeInputWindowMs;
+					const settling = !inputActive && idleMs >= config.settleAfterMs;
+					let revealChars;
+					if (steadyCps !== void 0) {
+						const step = computeRevealStep(config, {
+							backlog,
+							chunkSizeEma: chunkSizeEmaRef.current,
+							arrivalCpsEma: arrivalCpsEmaRef.current,
+							emaCps: emaCpsRef.current,
+							inputActive,
+							settling,
+							steadyCps
+						}, dtSeconds);
+						revealChars = Math.min(step.revealChars, backlog);
+					} else revealChars = computeQueueReveal(backlog, frameIntervalMs);
+					if (holdBackRef.current?.() === true) {
+						rafRef.current = requestAnimationFrame(tick);
+						return;
+					}
+					const speedOut = speedOutRef.current;
+					if (speedOut !== void 0 && frameIntervalMs > 0) {
+						const instantCps = revealChars * 1e3 / frameIntervalMs;
+						speedOut.current = speedOut.current * .92 + instantCps * .08;
+					}
+					const nextCount = displayedCount + revealChars;
+					const segment = targetCharsRef.current.slice(displayedCount, nextCount).join("");
+					if (segment) {
+						const nextDisplayed = displayedContentRef.current + segment;
+						displayedContentRef.current = nextDisplayed;
+						displayedCountRef.current = nextCount;
+						setDisplayedContent(nextDisplayed);
+					} else {
+						displayedContentRef.current = targetContentRef.current;
+						displayedCountRef.current = targetCount;
+						setDisplayedContent(targetContentRef.current);
+					}
+					rafRef.current = requestAnimationFrame(tick);
+				};
+				rafRef.current = requestAnimationFrame(tick);
+			}, [
+				config,
+				scheduleFrameWake,
+				stopFrameLoop,
+				clearWakeTimer,
+				steadyCps
+			]);
+			(0, react.useEffect)(() => {
+				startFrameLoopRef.current = startFrameLoop;
+			}, [startFrameLoop]);
+			(0, react.useEffect)(() => {
+				if (!enabled) {
+					syncImmediate(content);
+					return;
+				}
+				const prevTargetContent = targetContentRef.current;
+				if (content === prevTargetContent) return;
+				const now = performance.now();
+				if (!content.startsWith(prevTargetContent)) {
+					syncImmediate(content);
+					return;
+				}
+				const appendedChars = [...content.slice(prevTargetContent.length)];
+				const appendedCount = appendedChars.length;
+				targetContentRef.current = content;
+				targetCharsRef.current.push(...appendedChars);
+				targetCountRef.current += appendedCount;
+				const hadSample = lastInputTsRef.current > 0;
+				const deltaChars = targetCountRef.current - lastInputCountRef.current;
+				const deltaMs = Math.max(1, now - lastInputTsRef.current);
+				if (hadSample && deltaChars > 0) {
+					const instantCps = deltaChars * 1e3 / deltaMs;
+					const normalizedInstantCps = clamp$1(instantCps, config.minCps, config.maxFlushCps * 3);
+					const chunkEmaAlpha = .45;
+					chunkSizeEmaRef.current = chunkSizeEmaRef.current * .55 + appendedCount * chunkEmaAlpha;
+					arrivalCpsEmaRef.current = arrivalCpsEmaRef.current * .55 + normalizedInstantCps * chunkEmaAlpha;
+					emaCpsRef.current = emaCpsRef.current * (1 - config.emaAlpha) + normalizedInstantCps * config.emaAlpha;
+				}
+				lastInputTsRef.current = now;
+				lastInputCountRef.current = targetCountRef.current;
+				startFrameLoop();
+			}, [
+				content,
+				enabled,
+				config,
+				startFrameLoop,
+				syncImmediate
+			]);
+			(0, react.useEffect)(() => {
+				return () => {
+					stopScheduling();
+				};
+			}, [stopScheduling]);
+			return displayedContent;
+		}
+		//#endregion
+		//#region src/client/useFpsGuard.ts
+		/**
+		* Performance guard for the streaming reveal.
+		*
+		* Feeds an EMA-smoothed frame-rate monitor from a rAF loop while streaming
+		* and tracks whether the reply is on-screen. The returned `shouldHoldBack`
+		* predicate is true only while the frame rate is below the threshold AND the
+		* reply is offscreen — exactly the spec's "skip offscreen DOM updates when
+		* FPS < 30" rule. The smoother consumes the predicate as its commit veto.
+		*/
+		const FPS_THRESHOLD = 30;
+		const FPS_ALPHA = .12;
+		const RECOVER_FRAMES = 6;
+		const MAX_FRAME_MS = 100;
+		function useFpsGuard(active) {
+			const fpsRef = (0, react.useRef)({
+				emaMs: 0,
+				lastMs: 0,
+				healthyRun: 0,
+				degraded: false
+			});
+			const visibleRef = (0, react.useRef)(true);
+			const elementRef = (0, react.useRef)(null);
+			(0, react.useEffect)(() => {
+				if (!active) return;
+				let rafId = 0;
+				const frame = (now) => {
+					rafId = requestAnimationFrame(frame);
+					const fps = fpsRef.current;
+					if (fps.lastMs === 0) {
+						fps.lastMs = now;
+						return;
+					}
+					const delta = Math.min(MAX_FRAME_MS, Math.max(1, now - fps.lastMs));
+					fps.lastMs = now;
+					fps.emaMs = fps.emaMs === 0 ? delta : fps.emaMs + FPS_ALPHA * (delta - fps.emaMs);
+					if (1e3 / fps.emaMs < FPS_THRESHOLD) {
+						fps.healthyRun = 0;
+						fps.degraded = true;
+					} else if (fps.degraded) {
+						fps.healthyRun += 1;
+						if (fps.healthyRun >= RECOVER_FRAMES) fps.degraded = false;
+					}
+				};
+				rafId = requestAnimationFrame(frame);
+				return () => {
+					cancelAnimationFrame(rafId);
+					fpsRef.current = {
+						emaMs: 0,
+						lastMs: 0,
+						healthyRun: 0,
+						degraded: false
+					};
+				};
+			}, [active]);
+			const ref = (0, react.useCallback)((element) => {
+				elementRef.current = element;
+			}, []);
+			(0, react.useEffect)(() => {
+				const element = elementRef.current;
+				if (element === null || typeof IntersectionObserver === "undefined") return;
+				const observer = new IntersectionObserver((entries) => {
+					for (const entry of entries) visibleRef.current = entry.isIntersecting;
+				}, { rootMargin: "120px 0px" });
+				observer.observe(element);
+				return () => observer.disconnect();
+			});
+			return {
+				ref,
+				shouldHoldBack: (0, react.useCallback)(() => {
+					return active && fpsRef.current.degraded && !visibleRef.current;
+				}, [active])
+			};
+		}
+		//#endregion
+		//#region src/client/teleprompterGlide.ts
+		/**
+		* Conversation-port follow while an assistant reply streams.
+		*
+		* The demo's damped-spring lerp is driven from a float `animatedH` — the
+		* smoothed content height — never from the rounded `scrollTop` the browser
+		* reports back. A wrap raises the content height by a line; if the engine
+		* were allowed to snap `scrollTop` to the new floor, the previous line would
+		* hop up in one frame. This overlay:
+		*
+		* - owns follow via `data-follow-owned` so ChatView does not snap;
+		* - sets `overflow-anchor: none` so CSS scroll-anchoring does not snap;
+		* - restores `animatedH` in a ResizeObserver (before paint) so a layout
+		*   pass cannot flash a snapped frame;
+		* - while the port has scroll room, writes the interpolated lag as
+		*   `translate3d` on `[data-chat-transcript]` (message rows only), so the
+		*   turn-status chrome stays pinned at the floor;
+		* - before the port has scroll room (content shorter than the viewport), the
+		*   same lag is a content-height lag written as a negative translate on
+		*   `[data-chat-turn-status]`, so the status label descends smoothly with
+		*   each wrap instead of hopping a line at a time.
+		*
+		* Handing the port back to the reader (unpin, or the owner going inactive)
+		* first writes the effective visual top (`engine - lag`) into `scrollTop`
+		* before clearing the transform, so the frame stays continuous. That write
+		* also lands in ChatView's observed-top ledger as reader input beyond
+		* `FOLLOW_THRESHOLD`, releasing its native snap-follow instead of fighting
+		* the gesture for the port.
+		*
+		* Unpin is a real gesture (wheel / touch / pointer / key) that leaves the
+		* floor; a `scrollTop` delta from our own write must not release the pin.
+		*/
+		/**
+		* Matches ChatView's `FOLLOW_OWNED_ATTR`. The overlay writes the last
+		* programmatic `scrollTop` here so ChatView yields snap-follow and does not
+		* treat the write as reader input.
+		*/
+		const FOLLOW_OWNED_ATTR = "data-follow-owned";
+		/** Floor / ceiling of the per-frame lerp fraction before the dt term. */
+		const FOLLOW_LERP_MIN = .05;
+		const FOLLOW_LERP_MAX = .25;
+		const FOLLOW_SPEED_FACTOR_MIN = .7;
+		const FOLLOW_SPEED_FACTOR_MAX = 2.2;
+		const GESTURE_EVENTS = [
+			"wheel",
+			"touchmove",
+			"pointerdown",
+			"keydown"
+		];
+		function clamp(value, min, max) {
+			return Math.min(max, Math.max(min, value));
+		}
+		/**
+		* One spring-lerp frame from the silky markdown demo.
+		* @param dtMs - Frame delta in ms.
+		* @param input - Current lag (from the float top, not the rounded engine top) and reveal-speed EMA.
+		* @returns The fractional advance and the lerp fraction.
+		*/
+		function computeFollowStep(dtMs, input) {
+			if (input.lag <= .1 || dtMs <= 0) return {
+				advancePx: 0,
+				lerpStep: 0
+			};
+			const speedFactor = clamp((input.speedEma > 0 ? input.speedEma : 35) / 35, FOLLOW_SPEED_FACTOR_MIN, FOLLOW_SPEED_FACTOR_MAX);
+			const lerpStep = clamp(input.lag / 160 * speedFactor, FOLLOW_LERP_MIN, FOLLOW_LERP_MAX) * (1 - Math.exp(-dtMs / 18));
+			return {
+				advancePx: input.lag * lerpStep,
+				lerpStep
+			};
+		}
+		/** The message-rows box the lag transform rides on, when the host has one. */
+		function shiftRootOf(port) {
+			return port.querySelector("[data-chat-transcript]");
+		}
+		/**
+		* Row wrappers that carry only messages/tools. Hosts without a transcript
+		* box keep the turn-status chrome as a sibling of the rows inside
+		* `[data-chat-flow]`, so shifting that whole flow would drag the chrome
+		* along; shifting the rows individually leaves every non-message sibling
+		* (turn status, steering bubbles) pinned while the text glides.
+		*
+		* Only the outermost rows are shifted: a tool call nests its subcalls as
+		* descendant `[data-chat-anchor-key]` rows, and writing the lag on each of
+		* them would double (or further multiply) the shift, tearing the subcalls
+		* away from their parent every frame. Descendants ride the parent's
+		* transform instead.
+		*/
+		function shiftRowsOf(port) {
+			return [...port.querySelectorAll("[data-chat-anchor-key]")].filter((row) => row.parentElement?.closest("[data-chat-anchor-key]") === null);
+		}
+		/** Element whose resize signals flow growth for the before-paint restore. */
+		function resizeProxyOf(port) {
+			return port.querySelector("[data-chat-transcript]") ?? port.querySelector("[data-chat-flow]");
+		}
+		/** True when the glide expresses its lag as transforms instead of engine top. */
+		function hasShiftSurface(port) {
+			return shiftRootOf(port) !== null || shiftRowsOf(port).length > 0;
+		}
+		function setShift(element, px, negative = false) {
+			const value = negative ? -px : px;
+			if (Math.abs(value) > .01) {
+				element.style.transform = `translate3d(0, ${value}px, 0)`;
+				element.style.willChange = "transform";
+			} else {
+				element.style.transform = "";
+				element.style.willChange = "";
+			}
+		}
+		/**
+		* The running-turn label. Before the port scrolls (content shorter than the
+		* viewport) the content-height lag has no `scrollTop` room to ride, so it is
+		* expressed as a negative translate on this sibling: the label descends
+		* smoothly with each wrap instead of hopping down a line at a time.
+		*/
+		function chromeShiftOf(port) {
+			return port.querySelector("[data-chat-turn-status]");
+		}
+		/**
+		* Render the single smoothed extent `animatedH`. Before the port scrolls
+		* (content shorter than the viewport) `animatedH` is clamped to the content
+		* height and the content-height lag rides a negative translate on the
+		* turn-status label; once the port has scroll room the engine is pinned at
+		* the floor and the lag rides `[data-chat-transcript]` (or each message row
+		* when the host has no transcript box) so the chrome stays put. Without any
+		* shift surface the engine itself carries the interpolated top.
+		*/
+		function applyVisual(port, animatedH) {
+			const contentHeight = Math.max(0, port.scrollHeight);
+			const floor = Math.max(0, contentHeight - port.clientHeight);
+			const extent = Math.min(contentHeight, Math.max(0, animatedH));
+			const lag = contentHeight - extent;
+			port.style.overflowAnchor = "none";
+			port.style.scrollBehavior = "auto";
+			const shiftRoot = shiftRootOf(port);
+			if (shiftRoot !== null) {
+				if (floor <= 0) {
+					port.scrollTop = 0;
+					port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
+					const chrome = chromeShiftOf(port);
+					if (chrome !== null) setShift(chrome, lag, true);
+					setShift(shiftRoot, 0);
+					return;
+				}
+				port.scrollTop = floor;
+				port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
+				setShift(shiftRoot, lag);
+				return;
+			}
+			const rows = shiftRowsOf(port);
+			if (rows.length > 0) {
+				if (floor <= 0) {
+					port.scrollTop = 0;
+					port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
+					const chrome = chromeShiftOf(port);
+					if (chrome !== null) setShift(chrome, lag, true);
+					for (const row of rows) setShift(row, 0);
+					return;
+				}
+				port.scrollTop = floor;
+				port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
+				for (const row of rows) setShift(row, lag);
+				return;
+			}
+			port.scrollTop = Math.min(floor, Math.max(0, extent));
+			port.setAttribute(FOLLOW_OWNED_ATTR, String(port.scrollTop));
+		}
+		function clearVisual(port) {
+			port.removeAttribute(FOLLOW_OWNED_ATTR);
+			port.style.overflowAnchor = "";
+			port.style.scrollBehavior = "";
+			const shiftRoot = shiftRootOf(port);
+			if (shiftRoot !== null) {
+				shiftRoot.style.transform = "";
+				shiftRoot.style.willChange = "";
+			} else for (const row of shiftRowsOf(port)) {
+				row.style.transform = "";
+				row.style.willChange = "";
+			}
+			const chrome = chromeShiftOf(port);
+			if (chrome !== null) {
+				chrome.style.transform = "";
+				chrome.style.willChange = "";
+			}
+		}
+		/** Live follow hosts per conversation port so one unmount does not clear another. */
+		const followOwners = /* @__PURE__ */ new WeakMap();
+		function acquireFollow(port) {
+			followOwners.set(port, (followOwners.get(port) ?? 0) + 1);
+		}
+		function releaseFollow(port) {
+			const next = (followOwners.get(port) ?? 1) - 1;
+			if (next <= 0) {
+				followOwners.delete(port);
+				return 0;
+			}
+			followOwners.set(port, next);
+			return next;
+		}
+		/**
+		* Own the conversation scrollport's bottom-follow while `active` is true.
+		*
+		* @param rootRef - An element inside the conversation scrollport.
+		* @param active - True while the reply is still revealing.
+		* @param speedCpsRef - Live reveal-rate EMA from the smoother.
+		*/
+		function useConversationFollow(rootRef, active, speedCpsRef) {
+			const activeRef = (0, react.useRef)(active);
+			(0, react.useEffect)(() => {
+				activeRef.current = active;
+			}, [active]);
+			(0, react.useEffect)(() => {
+				if (!active) return;
+				let rafId = 0;
+				let last = performance.now();
+				let following = true;
+				let primed = false;
+				let animatedH = 0;
+				let interacting = false;
+				let interactTimer = null;
+				let port = null;
+				let resize = null;
+				let holding = null;
+				let awayPx = 0;
+				const hold = (next) => {
+					if (holding === next) return;
+					if (holding !== null) releaseFollow(holding);
+					acquireFollow(next);
+					holding = next;
+				};
+				const drop = (next) => {
+					if (holding === next) {
+						releaseFollow(next);
+						holding = null;
+					}
+					clearVisual(next);
+				};
+				/**
+				* Give the reader the visual position the glide was showing before the
+				* transforms go away. While transforms carry the lag, the engine sits at
+				* the floor and the effective visual top is `engine - lag`; writing that
+				* keeps the handover frame-continuous, and the write shows up in
+				* ChatView's ledger as reader movement, disarming its snap-follow.
+				* Without a shift surface the engine already holds the interpolated top,
+				* so there is nothing to compensate.
+				*/
+				const handBackVisual = (next) => {
+					if (!hasShiftSurface(next)) return;
+					const floor = Math.max(0, next.scrollHeight - next.clientHeight);
+					if (floor <= 0) return;
+					const lag = Math.max(0, next.scrollHeight - animatedH);
+					next.scrollTop = Math.min(floor, Math.max(0, next.scrollTop - lag));
+				};
+				const markGesture = (event) => {
+					interacting = true;
+					if (event instanceof WheelEvent && event.deltaY < 0) awayPx += -event.deltaY;
+					else if (event.type === "touchmove" || event.type === "keydown") awayPx += 8;
+					if (interactTimer !== null) clearTimeout(interactTimer);
+					interactTimer = setTimeout(() => {
+						interacting = false;
+						interactTimer = null;
+						awayPx = 0;
+					}, 800);
+				};
+				const restoreBeforePaint = () => {
+					if (!following || port === null) return;
+					applyVisual(port, animatedH);
+				};
+				const bindPort = (next) => {
+					if (port === next) return;
+					if (port !== null) {
+						for (const name of GESTURE_EVENTS) port.removeEventListener(name, markGesture);
+						resize?.disconnect();
+					}
+					port = next;
+					for (const name of GESTURE_EVENTS) port.addEventListener(name, markGesture, { passive: true });
+					if (typeof ResizeObserver !== "undefined") {
+						resize = new ResizeObserver(restoreBeforePaint);
+						resize.observe(port);
+						const proxy = resizeProxyOf(port);
+						if (proxy !== null) resize.observe(proxy);
+					}
+				};
+				const frame = (now) => {
+					rafId = requestAnimationFrame(frame);
+					const dt = Math.min(50, now - last);
+					last = now;
+					const root = rootRef.current;
+					if (root === null) return;
+					const nextPort = root.closest("[data-conversation-scroll]");
+					if (nextPort === null) return;
+					bindPort(nextPort);
+					const reportedLag = Math.max(0, nextPort.scrollHeight - nextPort.clientHeight) - nextPort.scrollTop;
+					const extent = Math.min(nextPort.scrollHeight, Math.max(0, nextPort.scrollHeight - reportedLag));
+					if (!primed) {
+						animatedH = extent;
+						following = reportedLag <= 25;
+						if (following) {
+							hold(nextPort);
+							applyVisual(nextPort, animatedH);
+						}
+						primed = true;
+						return;
+					}
+					if (!following && !interacting && reportedLag <= 25) {
+						following = true;
+						animatedH = extent;
+						hold(nextPort);
+					} else if (following && interacting && awayPx >= 8) {
+						following = false;
+						awayPx = 0;
+						handBackVisual(nextPort);
+						animatedH = nextPort.scrollHeight;
+						drop(nextPort);
+					}
+					if (!activeRef.current || !following) return;
+					hold(nextPort);
+					const lag = nextPort.scrollHeight - animatedH;
+					const step = computeFollowStep(dt, {
+						lag,
+						speedEma: speedCpsRef.current
+					});
+					if (lag <= .1) animatedH = nextPort.scrollHeight;
+					else animatedH = Math.min(nextPort.scrollHeight, animatedH + step.advancePx);
+					applyVisual(nextPort, animatedH);
+				};
+				rafId = requestAnimationFrame(frame);
+				return () => {
+					cancelAnimationFrame(rafId);
+					if (interactTimer !== null) clearTimeout(interactTimer);
+					resize?.disconnect();
+					if (port !== null) for (const name of GESTURE_EVENTS) port.removeEventListener(name, markGesture);
+					const host = rootRef.current?.closest("[data-conversation-scroll]") ?? port;
+					if (host === null) return;
+					if (following) handBackVisual(host);
+					const remaining = holding === host ? releaseFollow(host) : followOwners.get(host) ?? 0;
+					holding = null;
+					if (remaining === 0) clearVisual(host);
+				};
+			}, [
+				active,
+				rootRef,
+				speedCpsRef
+			]);
+		}
+		//#endregion
+		//#region src/client/FollowHost.tsx
+		/**
+		* Document-flow host that owns conversation-port follow while `active`.
+		* Shared by assistant blocks and every other growing Chat row.
+		*/
+		function FollowHost({ active, speedCpsRef, children }) {
+			const rootRef = (0, react.useRef)(null);
+			useConversationFollow(rootRef, active, speedCpsRef);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				ref: rootRef,
+				className: TypewriterAssistantNodeView_module_css_default.follow,
+				children
+			});
+		}
+		//#endregion
+		//#region src/config.ts
+		/** Defaults shared by the Host schema and the client-side fallback. */
+		const DEFAULT_STREAM_CONFIG = {
+			mode: "typewriter",
+			preset: "balanced",
+			revealCharsPerSec: 80,
+			scrollSpeedPxPerSec: 48,
+			maxScrollSpeedPxPerSec: 1e3
+		};
+		/**
+		* Window global the Host writes into the served index HTML. The browser boot
+		* graph carries no per-entry config, so this inline script is the only
+		* Host-to-client configuration channel for a composed web plugin.
+		*/
+		const STREAM_BOOT_GLOBAL = "__DSH_SMOOTH_STREAM_CONFIG__";
+		//#endregion
+		//#region src/client/TypewriterAssistantNodeView.tsx
+		function usePrefersReducedMotion() {
+			const [reduced, setReduced] = (0, react.useState)(() => typeof window !== "undefined" && window.matchMedia?.("(prefers-reduced-motion: reduce)").matches === true);
+			(0, react.useEffect)(() => {
+				if (typeof window === "undefined" || window.matchMedia === void 0) return;
+				const query = window.matchMedia("(prefers-reduced-motion: reduce)");
+				const onChange = () => setReduced(query.matches);
+				query.addEventListener("change", onChange);
+				return () => query.removeEventListener("change", onChange);
+			}, []);
+			return reduced;
+		}
+		/**
+		* Smooth streaming text arm. While the reply runs, the accumulated source is
+		* revealed through the smoother at a rate that tracks the model's arrival
+		* and rendered by the Harness `MarkdownText`
+		* streaming arm (incremental parse, frozen non-tail blocks), so there is no
+		* raw-text tail and no text-to-markdown swap: the tree stays markdown
+		* throughout. The last text block owns conversation-port follow so wraps
+		* glide instead of snapping. Once the stream closes and the reveal queue
+		* drains, the settled full parse (KaTeX math, fence highlighting, file
+		* mentions) swaps in exactly once.
+		*/
+		function AnimatedMarkdownText({ text, codeLabels, fileMentions, streaming, announce, ownFollow, preset, shouldHoldBack }) {
+			const reduced = usePrefersReducedMotion();
+			const [typing, setTyping] = (0, react.useState)(streaming);
+			const speedCpsRef = (0, react.useRef)(35);
+			const displayed = useSmoothStreamContent(text, {
+				enabled: typing && !reduced,
+				preset,
+				shouldHoldBack,
+				speedCpsRef
+			});
+			const shown = reduced ? text : displayed;
+			const live = typing && !reduced;
+			(0, react.useEffect)(() => {
+				if (typing && !streaming && shown.length === text.length) setTyping(false);
+			}, [
+				shown,
+				streaming,
+				text,
+				typing
+			]);
+			if (live) return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [announce && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				className: TypewriterAssistantNodeView_module_css_default.visuallyHidden,
+				"aria-live": "polite",
+				children: text
+			}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
+				active: ownFollow,
+				speedCpsRef,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.MarkdownText, {
+					text: shown,
+					streaming: true,
+					codeLabels
+				})
+			})] });
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.MarkdownText, {
+				text,
+				codeLabels,
+				fileMentions
+			});
+		}
+		function imageLabels(t) {
+			return {
+				image: t("image.label"),
+				open: t("image.openOriginal"),
+				openNamed: (label) => t("image.openOriginalLabel", { label }),
+				loading: t("image.loading"),
+				loadFailed: t("image.loadFailed"),
+				lightbox: {
+					dialog: t("image.preview"),
+					close: t("image.closePreview")
+				}
+			};
+		}
+		function firstLine(text) {
+			const newline = text.indexOf("\n");
+			return newline === -1 ? text : text.slice(0, newline);
+		}
+		function latestLine(text) {
+			const visible = text.trimEnd();
+			const newline = visible.lastIndexOf("\n");
+			return newline === -1 ? visible : visible.slice(newline + 1);
+		}
+		/**
+		* Built-in Think disclosure with a smoothed `text` feed. Chevron and row
+		* click stay on the disclosure chrome, which the plugin's AnimatedDisclosure
+		* renders with a height-animated body (the harness primitive would mount and
+		* unmount it, which cannot glide). The row opens only while this block is
+		* the streaming tail and closes as soon as thinking ends — a later block,
+		* or the assistant node settling — not when the rest of the reply is
+		* still streaming.
+		*/
+		function AnimatedReasoning({ text, running, preset, shouldHoldBack, t }) {
+			const reduced = usePrefersReducedMotion();
+			const [expanded, setExpanded] = (0, react.useState)(running);
+			const summaryRef = (0, react.useRef)(null);
+			const speedCpsRef = (0, react.useRef)(35);
+			const displayed = useSmoothStreamContent(text, {
+				enabled: running && !reduced,
+				preset,
+				shouldHoldBack,
+				speedCpsRef
+			});
+			const shown = running && !reduced ? displayed : text;
+			const summary = running ? latestLine(shown) : firstLine(text);
+			(0, react.useEffect)(() => {
+				setExpanded(running);
+			}, [running]);
+			(0, react.useEffect)(() => {
+				const element = summaryRef.current;
+				if (element === null) return;
+				element.scrollLeft = running ? element.scrollWidth - element.clientWidth : 0;
+			}, [running, summary]);
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
+				active: running,
+				speedCpsRef,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					className: TypewriterAssistantNodeView_module_css_default.think,
+					"data-variant": "think",
+					"data-state": running ? "running" : "ok",
+					children: [running && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+						className: TypewriterAssistantNodeView_module_css_default.visuallyHidden,
+						children: t("row.running")
+					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)(AnimatedDisclosure, {
+						rowClassName: TypewriterAssistantNodeView_module_css_default.thinkRow,
+						leadingClassName: TypewriterAssistantNodeView_module_css_default.thinkLeading,
+						titleClassName: TypewriterAssistantNodeView_module_css_default.thinkTitle,
+						chevronClassName: TypewriterAssistantNodeView_module_css_default.thinkChevron,
+						icon: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconThinkOutline14, { size: 14 }),
+						title: "Think",
+						open: expanded,
+						onToggle: () => {
+							setExpanded((value) => !value);
+						},
+						collapsedContent: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: TypewriterAssistantNodeView_module_css_default.thinkSeparator,
+							"aria-hidden": true
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							ref: summaryRef,
+							className: TypewriterAssistantNodeView_module_css_default.thinkSummary,
+							"data-follow-end": running || void 0,
+							children: summary
+						})] }),
+						children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+							className: TypewriterAssistantNodeView_module_css_default.thinkBody,
+							children: shown
+						})
+					})]
+				})
+			});
+		}
+		/**
+		* Assistant node renderer for the typewriter overlay. Text observed while
+		* streaming is revealed by the smoother through the Harness Markdown
+		* renderer at a rate that tracks arrival. Reasoning blocks keep the
+		* built-in Think disclosure and only receive a smoothed text feed; the
+		* last text or reasoning block owns conversation-port follow so wraps
+		* glide. The FPS guard holds offscreen
+		* reveals when the frame rate is degraded. Settled text renders with the
+		* full Markdown pipeline.
+		*/
+		const TypewriterAssistantNodeView = (0, react.memo)(function TypewriterAssistantNodeView({ mode: _mode = DEFAULT_STREAM_CONFIG.mode, preset = DEFAULT_STREAM_CONFIG.preset, revealCharsPerSec: _revealCharsPerSec = DEFAULT_STREAM_CONFIG.revealCharsPerSec, scrollSpeedPxPerSec: _scrollSpeedPxPerSec = DEFAULT_STREAM_CONFIG.scrollSpeedPxPerSec, maxScrollSpeedPxPerSec: _maxScrollSpeedPxPerSec = DEFAULT_STREAM_CONFIG.maxScrollSpeedPxPerSec, node, useTurnData, openFile, loadImage, fileMentions, t }) {
+			const data = node.data;
+			const streaming = data.status === "running";
+			const { ref: guardRef, shouldHoldBack } = useFpsGuard(streaming);
+			const rootSpeedRef = (0, react.useRef)(35);
+			const turn = node.location.kind === "turn" || node.location.kind === "step" ? node.location.turn : void 0;
+			const tail = useTurnData("turn-tail");
+			const owner = (0, react.useMemo)(() => {
+				if (turn?.status !== "closed" || data.finalNode === void 0) return void 0;
+				if (tail?.closing?.finalNode.seq !== data.finalNode.seq) return void 0;
+				return {
+					turn,
+					seq: data.finalNode.seq,
+					openFile
+				};
+			}, [
+				data.finalNode,
+				openFile,
+				tail,
+				turn
+			]);
+			const mentions = (0, react.useMemo)(() => owner === void 0 ? void 0 : fileMentions(owner), [fileMentions, owner]);
+			const codeLabels = (0, react.useMemo)(() => ({
+				copyLabel: t("copy"),
+				copiedLabel: t("copied")
+			}), [t]);
+			const imageLoader = loadImage ?? (async () => {
+				throw new Error(t("image.serviceUnavailable"));
+			});
+			if (!(streaming || data.status === "interrupted" || data.blocks.some((block) => block.kind !== "tool-call"))) return null;
+			const rendered = [];
+			const last = data.blocks.length - 1;
+			let lastFollow = -1;
+			for (let index = 0; index < data.blocks.length; index += 1) {
+				const kind = data.blocks[index]?.kind;
+				if (kind === "text" || kind === "reasoning") lastFollow = index;
+			}
+			for (let index = 0; index < data.blocks.length; index += 1) {
+				const block = data.blocks[index];
+				if (block === void 0) continue;
+				switch (block.kind) {
+					case "text":
+						rendered.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AnimatedMarkdownText, {
+							text: block.text,
+							codeLabels,
+							fileMentions: mentions,
+							streaming,
+							announce: index === last,
+							ownFollow: !streaming && index === lastFollow,
+							preset,
+							shouldHoldBack
+						}, index));
+						break;
+					case "reasoning":
+						rendered.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(AnimatedReasoning, {
+							text: block.text,
+							running: streaming && index === last,
+							preset,
+							shouldHoldBack,
+							t
+						}, index));
+						break;
+					case "image": {
+						const start = index;
+						const group = [block];
+						while (index + 1 < data.blocks.length) {
+							const next = data.blocks[index + 1];
+							if (next === void 0 || next.kind !== "image") break;
+							group.push(next);
+							index += 1;
+						}
+						rendered.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_attachment.ImageGallery, {
+							images: group,
+							load: imageLoader,
+							align: "start",
+							labels: imageLabels(t)
+						}, start));
+						break;
+					}
+					case "tool-call": break;
+					case "other": rendered.push(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.JsonBlock, {
+						label: t("message.unknownBlock"),
+						payload: block.block,
+						truncatedLabel: (total) => t("json.truncated", { total })
+					}, index));
+				}
+			}
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				ref: guardRef,
+				className: TypewriterAssistantNodeView_module_css_default.root,
+				"data-streaming": streaming || void 0,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
+					active: streaming,
+					speedCpsRef: rootSpeedRef,
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						className: TypewriterAssistantNodeView_module_css_default.body,
+						children: [rendered, data.status === "interrupted" && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: TypewriterAssistantNodeView_module_css_default.stopped,
+							children: t("message.stopped")
+						})]
+					})
+				})
+			});
+		});
+		//#endregion
+		//#region src/client/TypewriterToolNodeView.tsx
+		/**
+		* True while a Chat node is still growing: an assistant/workflow `status:
+		* 'running'` payload, a Tool root that has not settled (`kind` absent), or a
+		* model-retry whose current attempt is still `scheduled`.
+		* @param node - The Chat node's view `node` prop.
+		* @returns whether this row should own conversation follow.
+		*/
+		function isGrowingChatNode(node) {
+			if (node === null || typeof node !== "object" || !("data" in node)) return false;
+			const data = node.data;
+			if (data === null || typeof data !== "object") return false;
+			if ("status" in data && data.status === "running") return true;
+			if ("root" in data) {
+				const root = data.root;
+				if (root !== null && typeof root === "object" && !("kind" in root)) return true;
+			}
+			if ("current" in data) {
+				const current = data.current;
+				if (current !== null && typeof current === "object" && "retryState" in current && current.retryState === "scheduled") return true;
+			}
+			return false;
+		}
+		/**
+		* Wrap a prior Chat node renderer so a growing row shares conversation
+		* follow. Presentation stays with the wrapped component; kit seats
+		* (`renderSlot`, locale, inject) pass through unchanged.
+		* @param Inner - The already-registered row component.
+		* @returns A follow-hosted row.
+		*/
+		function wrapFollowNodeView(Inner) {
+			return function TypewriterFollowNodeView(props) {
+				const speedCpsRef = (0, react.useRef)(35);
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FollowHost, {
+					active: isGrowingChatNode(props.node),
+					speedCpsRef,
+					children: (0, react.createElement)(Inner, props)
+				});
+			};
+		}
+		//#endregion
+		//#region src/client/index.ts
+		/** Cordis services required by the browser half. */
+		const inject = ["slots"];
+		const STREAM_MODES = ["typewriter", "teleprompter"];
+		const STREAM_PRESETS = [
+			"realtime",
+			"balanced",
+			"silky"
+		];
+		/** Human-authored rows stay on the built-in renderer; `assistant-step` is replaced. */
+		const SKIP_WRAP = /* @__PURE__ */ new Set([
+			"assistant-step",
+			"user",
+			"steering",
+			"command-input"
+		]);
+		/**
+		* Read the Host-bridged boot config. The inline script is produced by this
+		* plugin's Host half from a schema-validated value, so only the structural
+		* guarantees that could break between the two halves are re-checked: the
+		* global is absent when the client runs without its Host entry (defaults
+		* apply), and any present-but-malformed value fails loudly instead of
+		* rendering a half-configured view.
+		* @returns The resolved configuration for the assistant node view.
+		*/
+		function readBootConfig() {
+			const raw = globalThis[STREAM_BOOT_GLOBAL];
+			if (raw === void 0) {
+				console.info("[dsh-smooth-stream] no host config bridge; using defaults");
+				return DEFAULT_STREAM_CONFIG;
+			}
+			if (typeof raw !== "object" || raw === null || !STREAM_MODES.includes(raw.mode) || !STREAM_PRESETS.includes(raw.preset) || typeof raw.revealCharsPerSec !== "number" || typeof raw.scrollSpeedPxPerSec !== "number" || typeof raw.maxScrollSpeedPxPerSec !== "number") throw new Error(`[dsh-smooth-stream] malformed ${STREAM_BOOT_GLOBAL} boot global: ${JSON.stringify(raw)}`);
+			return raw;
+		}
+		/**
+		* Wrap every keyed Chat row except `assistant-step` in place. A second
+		* register with the same `children` table throws because the child slot is
+		* already declared, and only the winning entry receives `renderSlot`;
+		* swapping `entry.component` keeps the original children, locale, and inject
+		* seats. `assistant-step` is replaced below so text and Think use the
+		* typewriter reveal.
+		* @param ctx - Browser context carrying the slot registry.
+		* @returns Restorer that puts the original components back.
+		*/
+		function wrapGrowingChatRows(ctx) {
+			const restores = [];
+			const wrapped = /* @__PURE__ */ new WeakSet();
+			const wrapAll = () => {
+				for (const entry of ctx.slots.entries("conversation.chat.node")) {
+					const key = entry.options.key;
+					if (key === void 0 || SKIP_WRAP.has(key)) continue;
+					const current = entry.component;
+					if (typeof current !== "function" || wrapped.has(current)) continue;
+					const inner = current;
+					const next = wrapFollowNodeView(inner);
+					wrapped.add(next);
+					entry.component = next;
+					restores.push(() => {
+						if (entry.component === next) entry.component = inner;
+					});
+				}
+			};
+			wrapAll();
+			const off = ctx.on("slots/changed", (key) => {
+				if (key === "conversation.chat.node") wrapAll();
+			});
+			return () => {
+				off();
+				for (const restore of restores) restore();
+			};
+		}
+		/**
+		* Register the typewriter renderer after the conversation package declares the
+		* keyed Chat node seat. A lower priority shadows the built-in assistant row;
+		* every other growing row is wrapped in place so Tool cards, retries, and
+		* workflow runs share conversation follow. The Host-bridged configuration
+		* selects the render direction, smoothing preset, and glide speed.
+		* @param ctx - Browser context carrying the shared slot registry.
+		*/
+		function apply(ctx) {
+			const config = readBootConfig();
+			const configured = function StreamConfiguredView(props) {
+				return (0, react.createElement)(TypewriterAssistantNodeView, {
+					...props,
+					mode: config.mode,
+					preset: config.preset,
+					revealCharsPerSec: config.revealCharsPerSec,
+					scrollSpeedPxPerSec: config.scrollSpeedPxPerSec,
+					maxScrollSpeedPxPerSec: config.maxScrollSpeedPxPerSec
+				});
+			};
+			ctx.slots.inject("conversation.chat.node", () => {
+				const unwrap = wrapGrowingChatRows(ctx);
+				const unshadow = ctx.slots.register({
+					name: "conversation.chat.node",
+					key: "assistant-step",
+					priority: -100,
+					locale: "conversation",
+					registrant: "dsh-smooth-stream"
+				}, configured);
+				return () => {
+					unshadow();
+					unwrap();
+				};
+			});
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map