@prettier-ai/dsh-client-ui-trajectory 0.1.2-alpha.5 → 0.1.3-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-trajectory/README.md
-README.md: d947787c123fca77dc7978456f4cfdc4e99951bf
-README.zh.md: 3b281c6c1e90108d66f050e07a3b08208ed8c802
+README.md: 3f4509c4bcd282e2bc06ca3c00de5308783501b8
+README.zh.md: 75d00e677109c7fa60563d6fc60bac47a13ee006

package/README.md

@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-`dsh-client-ui-trajectory` is the Trajectory view of the dsh web client: it renders a turn-aware event ledger with selectable User, Assistant, Tool, and nested Subtool records, plus an interactive timing overview. Thick rules mark Turn boundaries, compact inline markers identify Steps, and selecting a record opens a local inspector for token usage, duration, Input, Output, Timing, and durable images from user, assistant, or tool content. The view is a pure consumer: it registers target-specific Event Definitions, a Trajectory view builder, and one tab in the conversation's `conversation.view` slot ring, and provides no service and declares no Context merge. Its typed `trajectory` locale namespace owns every product-authored ledger, timeline, inspector, tooltip, and accessibility phrase; event content, tool names, identifiers, and provider diagnostics remain verbatim data. Long ledgers open at the current tail, page older history on demand, and mount only the visible row window.
+`dsh-client-ui-trajectory` is the Trajectory view of the dsh web client: it renders a turn-aware event ledger with selectable User, Assistant, Tool, and nested Subtool records, plus an interactive timing overview. Thick rules mark Turn boundaries, compact inline markers identify Steps, and selecting a record opens a local inspector for token usage, duration, Input, Output, Timing, durable images, and file-attachment summaries from user, assistant, or tool content. The view is a pure consumer: it registers target-specific Event Definitions, a Trajectory view builder, and one tab in the conversation's `conversation.view` slot ring, and provides no service and declares no Context merge. Its typed `trajectory` locale namespace owns every product-authored ledger, timeline, inspector, tooltip, and accessibility phrase; event content, tool names, identifiers, and provider diagnostics remain verbatim data. Long ledgers open at the current tail, page older history on demand, and mount only the visible row window.
 
 ## Table of Contents
 
@@ -29,7 +29,7 @@ Open the Trajectory tab in the conversation's view ring to inspect agent activit
 
 ### Inspecting records
 
-Selection, timeline navigation, folding, and search cover the React-visible window. Request numbers and cumulative usage cover the complete resident snapshot. Selecting a record opens a local inspector for token usage, duration, Input, Output, Timing, and durable images. Image URLs use the Conversation-owned per-session cache, so Chat and Trajectory share one authorized read per attachment. A record without text labels its row with the image count. A standalone compaction request appears chronologically in its own `Between turns` section, while a numbered compaction remains inside its owning turn.
+Selection, timeline navigation, folding, and search cover the React-visible window. Request numbers and cumulative usage cover the complete resident snapshot. Selecting a record opens a local inspector for token usage, duration, Input, Output, Timing, and durable images. Image URLs use the Conversation-owned per-session cache, so Chat and Trajectory share one authorized read per attachment. A user record shows the generic-file count beside its text, while a record without text shows its image and file counts. A standalone compaction request appears chronologically in its own `Between turns` section, while a numbered compaction remains inside its owning turn.
 
 ### The timing overview
 
@@ -47,7 +47,7 @@ The view is a pure projection: Trajectory-owned Definitions assemble business re
 
 ### Virtual rows
 
-Long ledgers initially derive React data from 50 target Nodes ending at the mount-time tail. Later Nodes extend that anchored window without evicting its prefix, and the existing load control reveals earlier resident Nodes before requesting another Session page. Virtualization mounts only the visible row window plus a small overscan; request-only separators share the next measurable virtual item, while semantic row keys and ARIA indexes survive prepends. Content-only stream frames preserve virtual row keys and heights, reuse measurements, and do not issue repeated tail-scroll writes. Completed replies retain assembled blocks, timing, and usage in Trajectory target State, while the shared Session window keeps the raw Events.
+Long ledgers initially derive React data from 50 target Nodes ending at the mount-time tail. Later Nodes extend that anchored window without evicting its prefix, and the existing load control reveals earlier resident Nodes before requesting another Session page. Virtualization mounts only the visible row window plus a small overscan; request-only separators share the next measurable virtual item, while semantic row keys and ARIA indexes survive prepends. The virtualizer owns bottom following for structural appends; non-virtual ledgers use a direct tail-position write. Content-only stream frames preserve virtual row keys and heights, reuse measurements, and do not issue repeated tail-scroll writes. Completed replies retain assembled blocks, timing, and usage in Trajectory target State, while the shared Session window keeps the raw Events.
 
 ### Layout
 

package/README.zh.md

@@ -9,7 +9,7 @@ kind: "package-reference"
 
 ## 概述
 
-`dsh-client-ui-trajectory` 是 dsh Web 客户端的 Trajectory 视图：它渲染按轮次组织的事件记录表，其中可选择用户、助手、工具与嵌套子工具记录，并带交互式时间概览。较粗的分割线标示轮次边界，紧凑的行内标记标识步骤；选择记录会打开局部检查器，查看 token 用量、耗时、输入、输出、计时，以及用户、助手或工具内容中的持久图片。该视图是纯消费方：它注册 target 专属 Event Definition、Trajectory view builder 以及对话 `conversation.view` slot 环中的一个视图标签页，不提供 service，也不声明 Context 合并。带类型的 `trajectory` locale namespace 拥有所有产品编写的 ledger、timeline、inspector、tooltip 与无障碍文案；事件内容、工具名称、标识符与 provider 诊断保持原始数据。长记录表打开时定位于当前尾部、按需加载更早历史，并且只挂载可见行窗口。
+`dsh-client-ui-trajectory` 是 dsh Web 客户端的 Trajectory 视图：它渲染按轮次组织的事件记录表，其中可选择用户、助手、工具与嵌套子工具记录，并带交互式时间概览。较粗的分割线标示轮次边界，紧凑的行内标记标识步骤；选择记录会打开局部检查器，查看 token 用量、耗时、输入、输出、计时，以及用户、助手或工具内容中的持久图片与文件附件摘要。该视图是纯消费方：它注册 target 专属 Event Definition、Trajectory view builder 以及对话 `conversation.view` slot 环中的一个视图标签页，不提供 service，也不声明 Context 合并。带类型的 `trajectory` locale namespace 拥有所有产品编写的 ledger、timeline、inspector、tooltip 与无障碍文案；事件内容、工具名称、标识符与 provider 诊断保持原始数据。长记录表打开时定位于当前尾部、按需加载更早历史，并且只挂载可见行窗口。
 
 ## 目录
 
@@ -29,7 +29,7 @@ kind: "package-reference"
 
 ### 检查记录
 
-选择、时间线导航、折叠与搜索只覆盖 React 可见窗口。请求编号与累计用量覆盖完整的驻留 snapshot。选择记录会打开局部检查器，查看 token 用量、耗时、输入、输出、计时与持久图片。图片 URL 使用 Conversation 拥有的逐会话缓存，因此 Chat 与 Trajectory 对每个附件共享一次已授权读取。没有文本的记录会用图片数量标记其行。独立运行的压缩请求会按时间顺序显示在自己的 `Between turns` 区段中，而带编号的压缩仍位于其所属轮次内。
+选择、时间线导航、折叠与搜索只覆盖 React 可见窗口。请求编号与累计用量覆盖完整的驻留 snapshot。选择记录会打开局部检查器，查看 token 用量、耗时、输入、输出、计时与持久图片。图片 URL 使用 Conversation 拥有的逐会话缓存，因此 Chat 与 Trajectory 对每个附件共享一次已授权读取。用户记录会在文本旁显示通用文件数量；记录没有文本时，则显示图片与文件数量。独立运行的压缩请求会按时间顺序显示在自己的 `Between turns` 区段中，而带编号的压缩仍位于其所属轮次内。
 
 ### 时间概览
 
@@ -47,7 +47,7 @@ kind: "package-reference"
 
 ### 虚拟行
 
-长记录表最初只从挂载时尾部结束的 50 个 target Node 派生 React 数据。后续 Node 会扩展这个固定起点的窗口而不会逐出其前缀；现有加载控件会先显露更早的驻留 Node，再请求下一个 Session 页面。虚拟化只挂载可见行窗口加少量缓冲；仅含请求的分隔行并入下一个具备可测高度的虚拟项，语义行键与 ARIA 索引在向前补页后保持不变。仅含内容更新的流式帧会保持虚拟行的键与高度、复用测量结果，并且不会重复写入末尾滚动位置。已完成的回复会在 Trajectory target State 中保留组装后的 blocks、计时与用量，共享 Session 窗口则保留原始 Event。
+长记录表最初只从挂载时尾部结束的 50 个 target Node 派生 React 数据。后续 Node 会扩展这个固定起点的窗口而不会逐出其前缀；现有加载控件会先显露更早的驻留 Node，再请求下一个 Session 页面。虚拟化只挂载可见行窗口加少量缓冲；仅含请求的分隔行并入下一个具备可测高度的虚拟项，语义行键与 ARIA 索引在向前补页后保持不变。虚拟化器负责结构性追加后的底部跟随；非虚拟记录表会直接写入末尾位置。仅含内容更新的流式帧会保持虚拟行的键与高度、复用测量结果，并且不会重复写入末尾滚动位置。已完成的回复会在 Trajectory target State 中保留组装后的 blocks、计时与用量，共享 Session 窗口则保留原始 Event。
 
 ### 布局
 

package/lib/client.js

@@ -216,6 +216,7 @@ window.__ModuleLoader__.load({
 			"layout.compacted": "上下文已压缩",
 			"layout.toolCallOnly": "仅工具调用",
 			"layout.imageOnly": "图片 ×{count}",
+			"layout.fileAttachments": "文件 ×{count}",
 			"layout.initialSystemPrompt": "初始系统提示词",
 			"layout.systemPromptUpdated": "系统提示词已更新",
 			"layout.toolsUpdated": "工具已更新",
@@ -393,6 +394,7 @@ window.__ModuleLoader__.load({
 			"layout.compacted": "Context compacted",
 			"layout.toolCallOnly": "Tool call only",
 			"layout.imageOnly": "Images ×{count}",
+			"layout.fileAttachments": "Files ×{count}",
 			"layout.initialSystemPrompt": "Initial System Prompt",
 			"layout.systemPromptUpdated": "System Prompt Updated",
 			"layout.toolsUpdated": "Tools Updated",
@@ -400,6 +402,345 @@ window.__ModuleLoader__.load({
 			"layout.compactionInterrupted": "Compaction was interrupted before completion."
 		};
 		//#endregion
+		//#region ../../util/values/src/index.ts
+		/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
+		function hasIntrinsicConstructor(prototype, name) {
+			const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
+			if (typeof constructor !== "function") return false;
+			try {
+				return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
+			} catch {
+				return false;
+			}
+		}
+		/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
+		function isIntrinsicObjectPrototype(value) {
+			return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
+		}
+		/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
+		function hasPlainArrayPrototype(value) {
+			const prototype = Object.getPrototypeOf(value);
+			if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
+			const objectPrototype = Object.getPrototypeOf(prototype);
+			return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
+		}
+		/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
+		function hasPlainObjectPrototype(value) {
+			const prototype = Object.getPrototypeOf(value);
+			return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
+		}
+		/** Return every JSON-visible object key, or reject own data JSON would discard. */
+		function enumerableStringKeys(value) {
+			const keys = Reflect.ownKeys(value);
+			if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
+			return keys;
+		}
+		/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
+		function walkJsonValue(value, detach) {
+			const ancestors = /* @__PURE__ */ new Set();
+			let root;
+			const assign = (destination, item) => {
+				if (destination === void 0) return;
+				if (destination.kind === "root") root = item;
+				else if (destination.kind === "array") destination.target[destination.index] = item;
+				else Object.defineProperty(destination.target, destination.key, {
+					value: item,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			};
+			const tasks = [{
+				kind: "visit",
+				value,
+				...detach ? { destination: { kind: "root" } } : {}
+			}];
+			for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
+				if (task.kind === "leave") {
+					ancestors.delete(task.source);
+					continue;
+				}
+				if (task.kind === "array-item") {
+					if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
+					tasks.push({
+						kind: "visit",
+						value: task.source[task.index],
+						...task.target === void 0 ? {} : { destination: {
+							kind: "array",
+							target: task.target,
+							index: task.index
+						} }
+					});
+					continue;
+				}
+				if (task.kind === "object-property") {
+					tasks.push({
+						kind: "visit",
+						value: task.source[task.key],
+						...task.target === void 0 ? {} : { destination: {
+							kind: "object",
+							target: task.target,
+							key: task.key
+						} }
+					});
+					continue;
+				}
+				const current = task.value;
+				if (current === null) {
+					assign(task.destination, null);
+					continue;
+				}
+				if (typeof current === "boolean" || typeof current === "string") {
+					assign(task.destination, current);
+					continue;
+				}
+				if (typeof current === "number") {
+					if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
+					assign(task.destination, current);
+					continue;
+				}
+				if (typeof current !== "object") return void 0;
+				if (ancestors.has(current)) return void 0;
+				if (Array.isArray(current)) {
+					if (!hasPlainArrayPrototype(current)) return void 0;
+					const length = current.length;
+					if (Reflect.ownKeys(current).length !== length + 1) return void 0;
+					const target = detach ? [] : void 0;
+					if (target !== void 0) assign(task.destination, target);
+					ancestors.add(current);
+					tasks.push({
+						kind: "leave",
+						source: current
+					});
+					for (let index = length - 1; index >= 0; index--) tasks.push({
+						kind: "array-item",
+						source: current,
+						index,
+						...target === void 0 ? {} : { target }
+					});
+					continue;
+				}
+				if (!hasPlainObjectPrototype(current)) return void 0;
+				const keys = enumerableStringKeys(current);
+				if (keys === void 0) return void 0;
+				const target = detach ? {} : void 0;
+				if (target !== void 0) assign(task.destination, target);
+				ancestors.add(current);
+				tasks.push({
+					kind: "leave",
+					source: current
+				});
+				for (let index = keys.length - 1; index >= 0; index--) {
+					const key = keys[index];
+					/* v8 ignore next -- the loop is bounded by the captured key count. */
+					if (key === void 0) return void 0;
+					tasks.push({
+						kind: "object-property",
+						source: current,
+						key,
+						...target === void 0 ? {} : { target }
+					});
+				}
+			}
+			return detach ? root : true;
+		}
+		/**
+		* Validate and detach lossless JSON in one read per property.
+		* @param value - candidate value to validate and detach.
+		* @returns the detached snapshot, or `undefined` when the value is not losslessly JSON-serializable.
+		*/
+		function snapshotJsonValue(value) {
+			return walkJsonValue(value, true);
+		}
+		/**
+		* Deep-freeze an object graph in place while leaving live AbortSignal objects mutable.
+		* @param value - value to freeze.
+		* @returns the same value after every reachable enumerable child is frozen.
+		*/
+		function deepFreeze(value) {
+			const seen = /* @__PURE__ */ new WeakSet();
+			const pending = [{
+				kind: "visit",
+				node: value
+			}];
+			while (pending.length > 0) {
+				const task = pending.pop();
+				/* v8 ignore next -- the loop condition guarantees one pending task. */
+				if (task === void 0) continue;
+				if (task.kind === "property") {
+					pending.push({
+						kind: "visit",
+						node: task.source[task.key]
+					});
+					continue;
+				}
+				const node = task.node;
+				if (node === null || typeof node !== "object") continue;
+				if (node instanceof AbortSignal) continue;
+				if (seen.has(node)) continue;
+				seen.add(node);
+				Object.freeze(node);
+				const keys = Object.keys(node);
+				for (let index = keys.length - 1; index >= 0; index--) {
+					const key = keys[index];
+					/* v8 ignore next -- the loop is bounded by the captured key count. */
+					if (key === void 0) continue;
+					pending.push({
+						kind: "property",
+						source: node,
+						key
+					});
+				}
+			}
+			return value;
+		}
+		//#endregion
+		//#region ../../llm/llm/src/assistant-stream.ts
+		/** Lossless compact representation of one model-stream attempt. */
+		function safeTime(value) {
+			if (!Number.isSafeInteger(value)) throw new TypeError(`Assistant stream time must be a safe integer, got ${String(value)}`);
+			return value;
+		}
+		function safeIndex(value, label) {
+			if (!Number.isSafeInteger(value) || value < 0 || Object.is(value, -0)) throw new TypeError(`${label} index must be a non-negative safe integer`);
+			return value;
+		}
+		function snapshotChunk(chunk) {
+			const snapshot = snapshotJsonValue(chunk);
+			if (snapshot === void 0) throw new TypeError("Assistant stream chunk must be losslessly JSON-serializable");
+			return snapshot;
+		}
+		/**
+		* Expand compact records into the exact timed chunk sequence.
+		* @param stream - compact records from one durable Assistant settlement.
+		* @returns detached timed chunks with every original delta boundary preserved.
+		* @throws {TypeError} when a record or reconstructed timestamp is invalid.
+		*/
+		function expandAssistantStream(stream) {
+			const chunks = [];
+			for (const candidate of stream) {
+				const record = validateRecord(candidate);
+				if (record.type === "chunk") {
+					chunks.push({
+						time: record.time,
+						chunk: record.chunk
+					});
+					continue;
+				}
+				const members = record.type === "tool-call-chunks" ? record.args : record.texts;
+				let time = record.time0;
+				for (let index = 0; index < members.length; index += 1) {
+					if (index > 0) time += record.dt[index - 1];
+					let chunk;
+					if (record.type === "text-chunks") chunk = {
+						type: "text-delta",
+						index: record.index,
+						text: members[index]
+					};
+					else if (record.type === "reasoning-chunks") chunk = {
+						type: "reasoning-delta",
+						index: record.index,
+						text: members[index]
+					};
+					else chunk = {
+						type: "tool-call-delta",
+						index: record.index,
+						id: record.id,
+						...Object.hasOwn(record, "name") ? { name: record.name } : {},
+						argumentsDelta: members[index]
+					};
+					chunks.push({
+						time,
+						chunk
+					});
+				}
+			}
+			return chunks;
+		}
+		function validateRecord(value) {
+			if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Assistant stream record must be an object");
+			const record = value;
+			switch (record.type) {
+				case "text-chunks":
+				case "reasoning-chunks": {
+					exactKeys(record, [
+						"type",
+						"time0",
+						"index",
+						"dt",
+						"texts"
+					], record.type);
+					const texts = stringArray(record.texts, `${record.type} texts`);
+					if (texts.length === 0) throw new TypeError(`${record.type} texts must be non-empty`);
+					validateRun(record, texts.length, record.type);
+					return record;
+				}
+				case "tool-call-chunks": {
+					exactKeys(record, Object.hasOwn(record, "name") ? [
+						"type",
+						"time0",
+						"index",
+						"dt",
+						"id",
+						"name",
+						"args"
+					] : [
+						"type",
+						"time0",
+						"index",
+						"dt",
+						"id",
+						"args"
+					], record.type);
+					const args = stringArray(record.args, "tool-call-chunks args");
+					if (args.length === 0) throw new TypeError("tool-call-chunks args must be non-empty");
+					if (typeof record.id !== "string" || record.id.length === 0) throw new TypeError("tool-call-chunks id must be a non-empty string");
+					if (record.name !== void 0 && (typeof record.name !== "string" || record.name.length === 0)) throw new TypeError("tool-call-chunks name must be a non-empty string");
+					validateRun(record, args.length, record.type);
+					return record;
+				}
+				case "chunk": {
+					exactKeys(record, [
+						"type",
+						"time",
+						"chunk"
+					], "chunk");
+					const time = safeTime(record.time);
+					if (typeof record.chunk !== "object" || record.chunk === null || Array.isArray(record.chunk)) throw new TypeError("Assistant stream raw chunk must be a lossless JSON object");
+					let chunk;
+					try {
+						chunk = snapshotChunk(record.chunk);
+					} catch (error) {
+						throw new TypeError("Assistant stream raw chunk must be a lossless JSON object", { cause: error });
+					}
+					return deepFreeze({
+						type: "chunk",
+						time,
+						chunk
+					});
+				}
+				default: throw new TypeError(`Unsupported Assistant stream record ${JSON.stringify(record.type)}`);
+			}
+		}
+		function validateRun(record, members, label) {
+			safeTime(record.time0);
+			safeIndex(record.index, label);
+			if (!Array.isArray(record.dt) || record.dt.some((value) => !Number.isSafeInteger(value))) throw new TypeError(`${label} dt must contain safe integers`);
+			if (record.dt.length !== members - 1) throw new TypeError(`${label} dt length must be one less than its members`);
+			let time = record.time0;
+			for (const gap of record.dt) {
+				time += gap;
+				if (!Number.isSafeInteger(time)) throw new TypeError(`${label} member times must stay safe integers`);
+			}
+		}
+		function stringArray(value, label) {
+			if (!Array.isArray(value) || value.some((member) => typeof member !== "string")) throw new TypeError(`${label} must be a string array`);
+			return value;
+		}
+		function exactKeys(record, keys, label) {
+			if (Object.keys(record).length !== keys.length || !keys.every((key) => Object.hasOwn(record, key))) throw new TypeError(`${label} Assistant stream record must contain exactly ${keys.join(", ")}`);
+		}
+		//#endregion
 		//#region lib/types/client/trajectory-definition-common.js
 		/**
 		* Wrap one contribution in the Engine-owned target envelope.
@@ -597,9 +938,6 @@ window.__ModuleLoader__.load({
 		}
 		//#endregion
 		//#region lib/types/client/trajectory-assistant-definition.js
-		function isChunkRunEvent(event) {
-			return event.type === "chunkrow/text-chunks" || event.type === "chunkrow/reasoning-chunks" || event.type === "chunkrow/tool-call-chunks";
-		}
 		function initialState(turn, step, startSeq, startTime, started) {
 			return {
 				turn,
@@ -647,9 +985,7 @@ window.__ModuleLoader__.load({
 				...current?.reasoningTokens === void 0 && next.reasoningTokens === void 0 ? {} : { reasoningTokens: (current?.reasoningTokens ?? 0) + (next.reasoningTokens ?? 0) }
 			};
 		}
-		function updateChunk(state, match) {
-			if (match.event.type !== "assistant/chunk") return state;
-			const chunk = match.event.data.chunk;
+		function updateChunk(state, chunk, seq, time) {
 			if (chunk.type === "usage") return {
 				...state,
 				sawChunk: true,
@@ -719,79 +1055,16 @@ window.__ModuleLoader__.load({
 				blocks,
 				visibleBlocks,
 				...visibleBlocks > 0 && state.firstVisibleSeq === void 0 ? {
-					firstVisibleSeq: match.event.seq,
-					firstVisibleTime: match.event.time
+					firstVisibleSeq: seq,
+					firstVisibleTime: time
 				} : {},
-				...isTokenDelta(chunk) && state.firstTokenTime === void 0 ? { firstTokenTime: match.event.time } : {}
+				...isTokenDelta(chunk) && state.firstTokenTime === void 0 ? { firstTokenTime: time } : {}
 			};
 		}
-		function chunkRunBoundaries(event, needsToken, needsVisible, visibleFromStart) {
-			const fragments = event.type === "chunkrow/tool-call-chunks" ? event.data.args : event.data.texts;
-			const nameStartsToken = event.type === "chunkrow/tool-call-chunks" && Object.hasOwn(event.data, "name");
-			let firstTokenTime;
-			let firstVisible;
-			let time = event.time;
-			for (let index = 0; index < fragments.length; index++) {
-				const fragment = fragments[index];
-				if (needsToken && firstTokenTime === void 0 && (nameStartsToken || fragment !== "")) firstTokenTime = time;
-				if (needsVisible && firstVisible === void 0 && (visibleFromStart || event.type !== "chunkrow/tool-call-chunks" && fragment.trim() !== "")) firstVisible = {
-					seq: event.seq + index,
-					time
-				};
-				if ((!needsToken || firstTokenTime !== void 0) && (!needsVisible || firstVisible !== void 0)) break;
-				time += event.data.dt[index] ?? 0;
-			}
-			return {
-				firstTokenTime,
-				firstVisible
-			};
-		}
-		function updateChunkRun(state, event) {
-			const blocks = [...state.blocks];
-			const previous = blocks[event.data.index];
-			const previousVisible = blockIsVisible(previous);
-			let visibleFromStart = state.visibleBlocks - Number(previousVisible) > 0;
-			if (event.type === "chunkrow/text-chunks") {
-				const text = previous?.kind === "text" ? previous.text : "";
-				visibleFromStart ||= text.trim() !== "";
-				blocks[event.data.index] = {
-					kind: "text",
-					text: text + event.data.texts.join("")
-				};
-			} else if (event.type === "chunkrow/reasoning-chunks") {
-				const text = previous?.kind === "reasoning" ? previous.text : "";
-				visibleFromStart ||= text.trim() !== "";
-				blocks[event.data.index] = {
-					kind: "reasoning",
-					text: text + event.data.texts.join("")
-				};
-			} else {
-				const base = previous?.kind === "tool-call" ? previous : {
-					kind: "tool-call",
-					callId: "",
-					name: "",
-					argsRaw: ""
-				};
-				blocks[event.data.index] = {
-					kind: "tool-call",
-					callId: base.callId || String(event.data.id),
-					name: Object.hasOwn(event.data, "name") ? event.data.name : base.name,
-					argsRaw: base.argsRaw + event.data.args.join("")
-				};
-			}
-			const boundaries = chunkRunBoundaries(event, state.firstTokenTime === void 0, state.firstVisibleSeq === void 0, visibleFromStart);
-			const visibleBlocks = state.visibleBlocks - Number(previousVisible) + Number(blockIsVisible(blocks[event.data.index]));
-			return {
-				...state,
-				sawChunk: true,
-				blocks,
-				visibleBlocks,
-				...boundaries.firstVisible === void 0 ? {} : {
-					firstVisibleSeq: boundaries.firstVisible.seq,
-					firstVisibleTime: boundaries.firstVisible.time
-				},
-				...boundaries.firstTokenTime === void 0 ? {} : { firstTokenTime: boundaries.firstTokenTime }
-			};
+		function updateEmbedded(state, event) {
+			let next = state;
+			for (const member of expandAssistantStream(event.data.stream)) next = updateChunk(next, member.chunk, event.seq, member.time);
+			return next;
 		}
 		function closedBoundary(context) {
 			if (context.state?.stepEnd?.event.type === "step/end") return context.state.stepEnd.event;
@@ -802,17 +1075,14 @@ window.__ModuleLoader__.load({
 		function fallbackState$1(context) {
 			let state;
 			for (const match of context.matches) {
-				if (isChunkRunEvent(match.event)) {
-					state ??= initialState(match.event.data.turn, match.event.data.step, match.event.seq, match.event.time, false);
-					state = updateChunkRun(state, match.event);
-					continue;
-				}
 				const event = match.event;
-				if (event.type === "assistant/chunk") {
+				if (event.type === "assistant/live-chunk") {
 					state ??= initialState(event.data.turn, event.data.step, event.seq, event.time, false);
-					state = updateChunk(state, match);
-				} else if (event.type === "assistant/message") {
+					state = updateChunk(state, event.data.chunk, event.seq, event.time);
+				} else if (event.type === "assistant/message" || event.type === "assistant/attempt") {
 					state ??= initialState(event.data.turn, event.data.step, event.seq, event.time, false);
+					state = updateEmbedded(state, event);
+					if (event.type === "assistant/attempt") continue;
 					const blocks = toAssistantBlocks(event.data.message.content);
 					state = {
 						...state,
@@ -901,11 +1171,7 @@ window.__ModuleLoader__.load({
 					id: `${event.data.turn}:${event.data.step}`,
 					role: "start"
 				};
-				if (event.type === "assistant/chunk" || event.type === "assistant/message" || event.type === "llm/retry" || event.type === "step/end") return {
-					id: `${event.data.turn}:${event.data.step}`,
-					role: "update"
-				};
-				if (isChunkRunEvent(event)) return {
+				if (event.type === "assistant/live-chunk" || event.type === "assistant/message" || event.type === "assistant/attempt" || event.type === "llm/retry" || event.type === "step/end") return {
 					id: `${event.data.turn}:${event.data.step}`,
 					role: "update"
 				};
@@ -916,16 +1182,17 @@ window.__ModuleLoader__.load({
 				return initialState(match.event.data.turn, match.event.data.step, match.event.seq, match.event.time, true);
 			},
 			update: (context, match) => {
-				if (isChunkRunEvent(match.event)) return updateChunkRun(context.state, match.event);
-				if (match.event.type === "assistant/chunk") return updateChunk(context.state, match);
+				if (match.event.type === "assistant/live-chunk") return updateChunk(context.state, match.event.data.chunk, match.event.seq, match.event.time);
+				if (match.event.type === "assistant/attempt") return updateEmbedded(context.state, match.event);
 				if (match.event.type === "assistant/message") {
+					const streamed = updateEmbedded(context.state, match.event);
 					const blocks = toAssistantBlocks(match.event.data.message.content);
 					return {
-						...context.state,
+						...streamed,
 						blocks,
 						visibleBlocks: countVisibleBlocks(blocks),
 						final: match,
-						usage: context.state.usage ?? match.event.data.usage
+						usage: streamed.usage ?? match.event.data.usage
 					};
 				}
 				if (match.event.type === "step/end") return {
@@ -950,8 +1217,7 @@ window.__ModuleLoader__.load({
 			},
 			publication: (match) => {
 				if (match.event.type === "step/start") return "none";
-				if (isChunkRunEvent(match.event)) return "animation-frame";
-				if (match.event.type !== "assistant/chunk") return "immediate";
+				if (match.event.type !== "assistant/live-chunk") return "immediate";
 				const type = match.event.data.chunk.type;
 				return type === "usage" || type === "finish" ? "none" : "animation-frame";
 			},
@@ -5082,7 +5348,8 @@ window.__ModuleLoader__.load({
 				anchorTo: "end",
 				overscan: VIRTUAL_OVERSCAN_ROWS,
 				scrollMargin: virtualScrollMargin,
-				scrollEndThreshold: BOTTOM_FOLLOW_THRESHOLD_PX
+				scrollEndThreshold: BOTTOM_FOLLOW_THRESHOLD_PX,
+				followOnAppend: "auto"
 			});
 			const virtualIndexByRecordId = (0, react.useMemo)(() => {
 				const indexes = /* @__PURE__ */ new Map();
@@ -5339,8 +5606,7 @@ window.__ModuleLoader__.load({
 					return;
 				}
 				if (!followsTableTail.current) return;
-				if (virtualizationEnabled) rowVirtualizer.scrollToEnd({ behavior: "auto" });
-				else pane.scrollTop = pane.scrollHeight;
+				if (!virtualizationEnabled) pane.scrollTop = pane.scrollHeight;
 			}, [
 				historyLoading,
 				historyStartSeq,
@@ -6859,8 +7125,9 @@ window.__ModuleLoader__.load({
 			const preview = previewContent(node.content);
 			const previewMarkdown = preview === "" ? void 0 : preview;
 			const images = imageBlockCount(node.content);
+			const files = fileBlockCount(node.content);
 			return {
-				text: previewMarkdown === void 0 && images > 0 ? t("layout.imageOnly", { count: images }) : "",
+				text: [previewMarkdown === void 0 && images > 0 ? t("layout.imageOnly", { count: images }) : void 0, files > 0 ? t("layout.fileAttachments", { count: files }) : void 0].filter((value) => value !== void 0).join(" · "),
 				...previewMarkdown === void 0 ? {} : { previewMarkdown },
 				sourceSeq: node.seq,
 				messageSource: node.source,
@@ -7431,6 +7698,9 @@ window.__ModuleLoader__.load({
 		function imageBlockCount(content) {
 			return content.filter((block) => block.type === "image").length;
 		}
+		function fileBlockCount(content) {
+			return content.filter((block) => block.type === "file").length;
+		}
 		function stringifySourceValue(value) {
 			return JSON.stringify(value, null, 2) || String(value);
 		}

package/lib/types/client/locales.d.ts

@@ -172,6 +172,7 @@ export declare const zh: {
     readonly 'layout.compacted': "上下文已压缩";
     readonly 'layout.toolCallOnly': "仅工具调用";
     readonly 'layout.imageOnly': "图片 ×{count}";
+    readonly 'layout.fileAttachments': "文件 ×{count}";
     readonly 'layout.initialSystemPrompt': "初始系统提示词";
     readonly 'layout.systemPromptUpdated': "系统提示词已更新";
     readonly 'layout.toolsUpdated': "工具已更新";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prettier-ai/dsh-client-ui-trajectory",
   "description": "Trajectory event ledger with an interactive timing overview: pure-consumer plugin registering into the conversation ViewMap (no service)",
-  "version": "0.1.2-alpha.5",
+  "version": "0.1.3-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -50,23 +50,23 @@
     "@types/react-dom": "~18.3.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "@prettier-ai/dsh-agent": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-test-runtime": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-ui-primitives": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-ui-conversation": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-locale": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-compaction": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-ui-slots": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-tools": "^0.1.2-alpha.5",
+    "@prettier-ai/dsh-agent": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-ui-primitives": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-locale": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-ui-conversation": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-ui-slots": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-test-runtime": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-compaction": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-tools": "^0.1.3-alpha.1",
     "@prettier-ai/cordis": "^4.0.2",
-    "@prettier-ai/dsh-client-store": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-session": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-ui-renderer": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-api-session-controller": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-ui-chat": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-client-ui-session": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-attachment": "^0.1.2-alpha.5",
-    "@prettier-ai/dsh-llm": "^0.1.2-alpha.5"
+    "@prettier-ai/dsh-client-store": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-ui-chat": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-api-session-controller": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-ui-session": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-llm": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-attachment": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-session": "^0.1.3-alpha.1",
+    "@prettier-ai/dsh-client-ui-renderer": "^0.1.3-alpha.1"
   },
   "files": [
     "lib/index.js",