npm - @deepseek-ai/dsh-session-log-export - Versions diffs - 0.1.1-rc.2 → 0.1.2-alpha.2 - Mend

@deepseek-ai/dsh-session-log-export 0.1.1-rc.2 → 0.1.2-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/README.i18n.yaml +2 -2
package/README.md +105 -14
package/README.zh.md +107 -16
package/lib/client.js +6 -4
package/lib/index.js +416 -5
package/lib/invariant.js +4 -1
package/lib/types/archive.d.ts +106 -0
package/lib/types/client/Dialog.d.ts +2 -1
package/lib/types/client/controller.d.ts +2 -1
package/lib/types/client/index.d.ts +1 -1
package/lib/types/client/locales.d.ts +1 -0
package/lib/types/index.d.ts +17 -3
package/package.json +28 -22

package/README.i18n.yaml CHANGED Viewed

@@ -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/session-query/session-log-export/README.md
-README.md: f3625338e85a38ab279c5fa4700a7a9e1124cfb3
-README.zh.md: 101f0bb41c7296916b72a82186dae74b1b576e7f
+README.md: a46bcdcd6fa6dda8997b3ed07f0ae789d8e3471d
+README.zh.md: 348f6c09c8c5de4e8fe7f779b6d0fd4f662e8e34

package/README.md CHANGED Viewed

@@ -1,31 +1,103 @@
+---
+description: "Web Session-log ZIP export: Host streaming, the authenticated download route, the Session Header action, and the /export command."
+kind: "package-reference"
+---
 # @deepseek-ai/dsh-session-log-export
 English | [中文](README.zh.md)
-Web Session-log download control over the host-streamed ZIP endpoint owned by `dsh-host-apiproxy`. The Host half registers `/export`; the browser half owns a 111×32 `Session log` action in the Session Header, one download controller, and one modal shared by that button and the slash command. ZIP generation, raw JSONL/zstd reads, descendants, attachments, backpressure, and HTTP error semantics remain owned by the [ApiProxy download implementation](../../host/apiproxy/README.md).
+## Summary
-## Command contract
+`dsh-session-log-export` lets the Web interface download a session's full history: a `Session log` button in the Session Header and an `/export` slash command both hand the session tree — the session, its sub-sessions, and attachments — to the browser as a ZIP download. The package owns the Host archive stream, its authenticated Fetch route, and the browser controls and feedback. The browser chooses the download destination. Setup and usage come first; implementation details follow.
-| Input | Result |
-|---|---|
-| `/export` | Record a human-command lifecycle; the submitting browser receives the local execution acknowledgment and downloads `GET /api/session.export?sessionId=<id>&includeDescendants=true`. |
-| `/export <path>` | Return an error. Browser downloads choose their destination through the browser's ordinary download behavior. |
+## Table of Contents
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+-----
-The command is mounted only by the Web bundle. The local `command/executed` acknowledgment triggers the slash download only after a successful `/export` result in the browser that submitted it; other tabs still render the durable command row without repeating the browser side effect. The Header button calls the same controller directly. Both entry paths issue a `HEAD` preflight, then hand the GET URL to the browser download manager without buffering the ZIP in JavaScript; they share in-flight collapsing, cancellation of the preflight on plugin disposal, preparation-error handling, browser save behavior, and the same Modal.
+<a id="use-this-package"></a>
+## Use this package
-The Host download endpoint flushes a live root Session before `readRaw`, so a slash-triggered ZIP includes the `command/run` and `command/done` pair whose acknowledgment started the download. Cold persisted Sessions require no flush.
+Use this package when the Web bundle should let users export a session log. It requires Connection, the command registry, Session query and persistence, and attachments. Mount the plugin, then click `Session log` in the Session Header or type `/export`; the browser downloads `dsh-session-<id>.zip`.
-The modal reports preparation, download start, or failure. Closing it does not cancel an in-flight download and does not reopen it when that operation later settles. One Session admits one active download at a time; repeated gestures share that operation.
+### When to choose it
-## Composition
+Choose it for a Web deployment that needs user-facing session export with a visible download dialog. Avoid it when a programmatic or Host-side export is needed: this package produces a browser download, not a Host path write, and it requires a persistence backend that stores a per-session raw artifact (the shipped JSONL backend supports plaintext and zstd; SQLite export is not supported).
+### Composition
 ```yaml
 - id: session-log-download
   name: '@deepseek-ai/dsh-session-log-export'
 ```
-The Web bundle mounts the package beside `dsh-host-apiproxy`, `dsh-commands`, `dsh-client-ui-commands`, and `dsh-client-ui-conversation`. The package contributes its button and modal to the right-aligned `conversation.session.header.utilities` list, independently of the title-adjacent mode, Subagent, and Task entries in `conversation.session.header.actions`; Trajectory carries no export control.
+The Web bundle mounts the package with Connection, `dsh-commands`, `dsh-client-ui-commands`, and `dsh-client-ui-conversation`.
+### Configuration
+| Field | Default | Meaning |
+|---|---|---|
+| `compressionLevel` | `6` | DEFLATE level from 0 through 9 for each ZIP entry. |
+### Command contract
+| Input | Result |
+|---|---|
+| `/export` | Records a human-command lifecycle; the submitting browser downloads `GET /api/session.export?sessionId=<id>&includeDescendants=true` |
+| `/export <path>` | An error; browser downloads choose their destination through the browser's ordinary download behavior |
+### What to expect
+The dialog reports three phases: preparing, download started, or failed. Closing the dialog does not cancel an in-flight download, and the dialog does not reopen when that operation later settles. One session admits one active download at a time; repeated gestures share that operation. The export includes the live session's newest events: the host endpoint flushes a live root session before reading, so a slash-triggered ZIP includes the `command/run` and `command/done` pair that started the download; cold persisted sessions need no flush.
+### Failures
+The dialog shows a preparation error when the preflight fails before ZIP streaming starts — for example an unreachable or misconfigured host endpoint. A descendant or attachment read failure after the browser accepts the GET is reported by the browser download manager, not by the dialog.
+-----
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+<details>
+<summary>Implementation internals — click to expand</summary>
+This section explains how the package wires the export control and points at the code that realizes it; the observable behavior is fully covered in [Use this package](#use-this-package).
+### Design split
+The package has two halves. The Host half ([`src/index.ts`](src/index.ts)) registers the `/export` command and contributes the exact `GET`/`HEAD /api/session.export` Fetch route to Connection; [`src/archive.ts`](src/archive.ts) builds the bounded ZIP stream. The browser half ([`src/client/index.ts`](src/client/index.ts)) provides the shared download controller and UI, and observes `command/executed` so only the submitting browser starts a download.
+### Download flow
+Both entry paths issue a `HEAD` preflight to `GET /api/session.export?...`, then hand the GET URL to the browser download manager without buffering the ZIP in JavaScript. One controller owns one in-flight download per session, collapses concurrent gestures into that operation, and cancels the preflight on plugin disposal. Modal state lives in a snapshot store keyed by session, so the button and the command share one dialog per session.
+The Host route is a feature-owned exact Fetch contribution. Connection applies its Host/Origin and browser-session checks and bridges the streaming `Response`; this package owns query validation, live-session flushes, raw artifact and attachment reads, ZIP generation, and HTTP status semantics.
+</details>
+-----
+<a id="further-exploration"></a>
+## Further Exploration
+Read these pages when the package-level contract is not enough. They move from the Web control to the host endpoint and the surrounding command and session surfaces.
+- [dsh-client-connection](../../client/connection/README.md) — the authenticated Fetch-route carrier used by the Host endpoint.
+- [Commands subsystem reference](../../../docs/subsystems/commands.md) — the human-command registry the `/export` command registers on.
+- [dsh-client-ui-commands](../../client/ui-commands/README.md) — the browser command surface that renders and acknowledges `/export`.
+- [Session Query package map](../README.md) — the retrieval family this package belongs to.
+-----
+<a id="model-experience"></a>
 ## Model Experience
 ### Human `/export` control
@@ -44,6 +116,25 @@ None. The log-only command lifecycle and browser download do not change the deri
 ## Known Limitations and Deferred Work
-- The download endpoint requires a persistence backend with a per-Session raw artifact. The shipped JSONL backend supports plaintext and zstd artifacts; SQLite export is not included in this change.
-- This is a browser download, not a Host-path writer. The browser chooses the local destination; no Host path or native folder action is returned.
-- The preflight reports failures found before ZIP streaming starts. A descendant or attachment failure after the browser accepts the GET is reported by the browser download manager, not by the modal.
+<a id="known-limitations-and-deferred-work"></a>
+These limits define when this package is a poor fit or needs special operational care. They are current package constraints, not a task backlog.
+- **Requires a per-session raw artifact backend** — the download endpoint needs a persistence backend with a per-session raw artifact; the shipped JSONL backend supports plaintext and zstd, and SQLite export is not supported.
+- **Browser download, not a Host-path writer** — the browser chooses the local destination; no Host path or native folder action is returned.
+- **Preflight reports only pre-stream failures** — a descendant or attachment failure after the browser accepts the GET is reported by the browser download manager, not by the dialog.
+<a id="dev-note"></a>
+### Dev Note
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+This Dev Note is working context for maintainers: open design questions and directions that are not decided. It is explicitly non-authoritative — shipped behavior, limits, and accepted rationale live in the sections above, the package code, and the linked pages.
+#### Future: export destinations beyond the browser
+The download is deliberately browser-scoped; a Host-path or native folder export would need a new endpoint contract and a decision on where the ZIP lands.
+</details>

package/README.zh.md CHANGED Viewed

@@ -1,31 +1,103 @@
+---
+description: "Web 会话日志 ZIP 导出：Host 流式传输、认证下载路由、Session Header 操作与 /export 命令。"
+kind: "package-reference"
+---
 # @deepseek-ai/dsh-session-log-export
 [English](README.md) | 中文
-Web Session 日志下载控制，使用 `dsh-host-apiproxy` 拥有的 Host 流式 ZIP 端点。Host 半包注册 `/export`；浏览器半包在 Session Header 中提供 111×32 的 `Session log` 操作，以及一个供该按钮与斜杠命令共用的下载控制器和弹窗。ZIP 生成、原始 JSONL/zstd 读取、子 Session、附件、背压和 HTTP 错误语义仍由 [ApiProxy 下载实现](../../host/apiproxy/README.zh.md)负责。
+## 概述
-## 命令约定
+`dsh-session-log-export` 让 Web 界面可以下载会话的完整历史：Session Header 中的 `Session log` 按钮与 `/export` 斜杠命令都会把会话树——会话本身、其子会话与附件——作为 ZIP 交给浏览器下载。本包拥有 Host 归档流、经过认证的 Fetch 路由以及浏览器控制和反馈。下载目标位置由浏览器选择。设置与用法在前，随后说明实现细节。
-| 输入 | 结果 |
-|---|---|
-| `/export` | 记录一组用户命令生命周期；提交命令的浏览器收到本地执行确认后，下载 `GET /api/session.export?sessionId=<id>&includeDescendants=true`。 |
-| `/export <path>` | 返回错误。浏览器下载通过浏览器的普通下载行为选择目标位置。 |
+## 目录
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+-----
-该命令只由 Web bundle 挂载。只有 `/export` 返回成功时，本地 `command/executed` 确认才会在提交命令的浏览器中触发斜杠下载；其他标签页仍会渲染持久命令行，但不会重复执行浏览器副作用。Header 按钮直接调用同一个控制器。两种入口都会先发出 `HEAD` 预检，再把 GET URL 交给浏览器下载管理器，JavaScript 不会缓冲 ZIP；它们共用并发折叠、插件释放时取消预检、准备阶段错误处理、浏览器保存行为和同一个 Modal。
+<a id="use-this-package"></a>
+## 使用本包
-Host 下载端点会在 `readRaw` 前 flush 活动的根 Session，因此斜杠命令触发的 ZIP 会包含启动下载的 `command/run` 与 `command/done` 事件对。冷持久化 Session 不需要 flush。
+当 Web bundle 需要让用户导出会话日志时使用本包。它需要 Connection、命令注册表、Session 查询与持久化以及附件服务。挂载插件，然后点击 Session Header 中的 `Session log` 或输入 `/export`；浏览器会下载 `dsh-session-<id>.zip`。
-弹窗报告准备中、开始下载或失败。关闭弹窗不会取消正在进行的下载；该操作随后完成时也不会重新打开弹窗。每个 Session 同时只允许一项下载，重复操作会共用该任务。
+### 何时选择
-## 组合
+为需要带可见下载弹窗的用户级会话导出的 Web 部署选择它。需要程序化或 Host 侧导出时避免使用：本包产生的是浏览器下载，而非 Host 路径写入，并且它要求持久化后端保存逐会话原始产物（随附 JSONL 后端支持明文与 zstd；不支持 SQLite 导出）。
+### 组合
 ```yaml
 - id: session-log-download
   name: '@deepseek-ai/dsh-session-log-export'
 ```
-Web bundle 将本包与 `dsh-host-apiproxy`、`dsh-commands`、`dsh-client-ui-commands` 和 `dsh-client-ui-conversation` 一起挂载。本包把按钮和弹窗贡献到最右侧的 `conversation.session.header.utilities` 列表，与标题旁 `conversation.session.header.actions` 中的模式、Subagent 和 Task 配置项相互独立；Trajectory 不包含导出入口。
+Web bundle 将本包与 Connection、`dsh-commands`、`dsh-client-ui-commands` 和 `dsh-client-ui-conversation` 一起挂载。
+### 配置
+| 字段 | 默认值 | 含义 |
+|---|---|---|
+| `compressionLevel` | `6` | 每个 ZIP 条目的 DEFLATE 级别，范围为 0 到 9。 |
+### 命令约定
+| 输入 | 结果 |
+|---|---|
+| `/export` | 记录一组用户命令生命周期；提交命令的浏览器下载 `GET /api/session.export?sessionId=<id>&includeDescendants=true` |
+| `/export <path>` | 错误；浏览器下载通过浏览器的普通下载行为选择目标位置 |
+### 预期行为
+弹窗报告三个阶段：准备中、开始下载或失败。关闭弹窗不会取消正在进行的下载，该操作随后完成时弹窗也不会重新打开。每个会话同时只允许一项下载，重复操作共用该任务。导出包含实时会话的最新事件：Host 端点在读取前会 flush 活动的根会话，因此斜杠命令触发的 ZIP 会包含启动下载的 `command/run` 与 `command/done` 事件对；冷持久化会话不需要 flush。
+### 失败
+当 ZIP 流式传输开始前的预检失败时——例如 Host 端点不可达或配置错误——弹窗显示准备阶段错误。浏览器接受 GET 后发生的子会话或附件读取失败由浏览器下载管理器报告，不通过弹窗报告。
+-----
+<a id="understand-the-implementation"></a>
+## 理解实现
+<details>
+<summary>实现细节——点击展开</summary>
+本节解释本包如何接线导出控制，并指出实现它的代码位置；可观察行为已在[使用本包](#use-this-package)中完整说明。
+### 设计拆分
+本包有两个半包。Host 半包（[`src/index.ts`](src/index.ts)）注册 `/export` 命令，并向 Connection 贡献精确的 `GET`/`HEAD /api/session.export` Fetch 路由；[`src/archive.ts`](src/archive.ts) 构建有界 ZIP 流。浏览器半包（[`src/client/index.ts`](src/client/index.ts)）提供共享下载控制器和 UI，并观察 `command/executed`，因此只有提交命令的浏览器会启动下载。
+### 下载流程
+两条入口都会对 `GET /api/session.export?...` 发出 `HEAD` 预检，然后把 GET URL 交给浏览器下载管理器，JavaScript 不缓冲 ZIP。一个控制器按会话持有一项进行中的下载，把并发操作折叠进该任务，并在插件释放时取消预检。弹窗状态存放在按会话键控的快照存储中，因此按钮与命令按会话共享一个弹窗。
+Host 路由是业务拥有的精确 Fetch contribution。Connection 应用 Host/Origin 与浏览器会话检查并桥接流式 `Response`；本包拥有查询校验、活动会话 flush、原始产物与附件读取、ZIP 生成和 HTTP 状态语义。
+</details>
+-----
+<a id="further-exploration"></a>
+## 进一步探索
+当包级约定不够用时阅读以下页面。它们从 Web 控制逐步进入 Host 端点与周围的命令和会话表面。
+- [dsh-client-connection](../../client/connection/README.zh.md)——Host 端点使用的认证 Fetch 路由载体。
+- [命令子系统参考](../../../docs/subsystems/commands.zh.md)——`/export` 命令注册的用户命令注册表。
+- [dsh-client-ui-commands](../../client/ui-commands/README.zh.md)——渲染并确认 `/export` 的浏览器命令表面。
+- [会话查询包映射](../README.zh.md)——本包所属的检索能力家族。
+-----
+<a id="model-experience"></a>
 ## 模型体验
 ### 用户 `/export` 控制
@@ -40,10 +112,29 @@ Web bundle 将本包与 `dsh-host-apiproxy`、`dsh-commands`、`dsh-client-ui-co
 #### KV Cache 影响
-无。仅日志命令生命周期和浏览器下载不会改变派生请求前缀。
+无。仅日志命令生命周期与浏览器下载不会改变派生请求前缀。
+## 已知限制与延期工作
+<a id="known-limitations-and-deferred-work"></a>
+这些限制说明本包何时不合适，或何时需要特别的运维注意。它们是当前包约束，不是任务积压。
+- **要求逐会话原始产物后端**——下载端点需要带逐会话原始产物的持久化后端；随附 JSONL 后端支持明文与 zstd，不支持 SQLite 导出。
+- **浏览器下载，而非 Host 路径写入**——目标位置由浏览器选择；不会返回 Host 路径或原生文件夹操作。
+- **预检只报告流式传输前的失败**——浏览器接受 GET 后发生的子会话或附件读取失败由浏览器下载管理器报告，不通过弹窗报告。
+<a id="dev-note"></a>
+### 开发备注
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+本开发备注是维护者的工作上下文：开放设计问题与尚未决定的探索方向。它明确不具权威性——已交付的行为、限制与既定理由以上文、包代码和相关页面为准。
+#### 未来：浏览器之外的导出目标
-## 已知限制与暂缓事项
+下载刻意限定在浏览器范围；Host 路径或原生文件夹导出需要新的端点约定，并决定 ZIP 的落盘位置。
-- 下载端点要求持久化后端具有逐 Session 原始工件。随附 JSONL 后端支持明文和 zstd 工件；本次改动不包含 SQLite 导出。
-- 这是浏览器下载，不是 Host 路径写入。目标位置由浏览器选择，不会返回 Host 路径或原生文件夹操作。
-- 预检只报告 ZIP 开始流式传输前发现的失败。浏览器接受 GET 后发生的子 Session 或附件读取失败由浏览器下载管理器报告，不通过弹窗报告。
+</details>

package/lib/client.js CHANGED Viewed

@@ -4,7 +4,7 @@ window.__ModuleLoader__.load({
 		var module = { exports: {} };
 		var exports = module.exports;
 		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-		let _deepseek_ai_dsh_client_runtime_client = require("@deepseek-ai/dsh-client-runtime/client");
+		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
 		let react_jsx_runtime = require("react/jsx-runtime");
 		let _deepseek_ai_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
 		//#region lib/types/client/controller.js
@@ -42,7 +42,7 @@ window.__ModuleLoader__.load({
 			fetcher;
 			save;
 			/** uSES-safe state source shared by every Session-scoped modal contribution. */
-			store = (0, _deepseek_ai_dsh_client_runtime_client.createSnapshotStore)(INITIAL);
+			store = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)(INITIAL);
 			active = /* @__PURE__ */ new Map();
 			disposed = false;
 			/**
@@ -187,7 +187,7 @@ window.__ModuleLoader__.load({
 		* @returns the persistent Header action and Session-scoped dialog.
 		*/
 		function SessionLogDownloadHeaderAction(props) {
-			const { sessionId, useSessionLogDownload, request } = props;
+			const { sessionId, useSessionLogDownload, request, t } = props;
 			const busy = useSessionLogDownload((state) => state.bySession[String(sessionId)])?.status === "downloading";
 			return (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsxs)("button", {
 				type: "button",
@@ -197,7 +197,7 @@ window.__ModuleLoader__.load({
 				onClick: () => {
 					request(sessionId);
 				},
-				children: [(0, react_jsx_runtime.jsx)("span", { children: "Session log" }), (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconDownloadOutline16, { size: 12 })]
+				children: [(0, react_jsx_runtime.jsx)("span", { children: t("header.action") }), (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_primitives.IconDownloadOutline16, { size: 12 })]
 			}), (0, react_jsx_runtime.jsx)(SessionLogDownloadDialog, { ...props })] });
 		}
 		//#endregion
@@ -206,6 +206,7 @@ window.__ModuleLoader__.load({
 		const NS = "session-log-download";
 		/** Simplified-Chinese Session export strings. */
 		const zh = {
+			"header.action": "Session 日志",
 			"dialog.preparingTitle": "正在导出 Session",
 			"dialog.preparingDescription": "正在准备包含当前 Session、子 Session 和附件的 ZIP 文件。",
 			"dialog.successTitle": "Session 导出已开始下载",
@@ -216,6 +217,7 @@ window.__ModuleLoader__.load({
 		};
 		/** English Session export strings. */
 		const en = {
+			"header.action": "Session log",
 			"dialog.preparingTitle": "Exporting Session",
 			"dialog.preparingDescription": "Preparing a ZIP containing this Session, its sub-Sessions, and attachments.",
 			"dialog.successTitle": "Session download started",

package/lib/index.js CHANGED Viewed

@@ -1,16 +1,380 @@
+import Schema from "@deepseek-ai/schemastery";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { Zip, ZipDeflate } from "fflate";
+//#region lib/types/archive.js
+/**
+* Host-side session-log download: streams one ZIP archive whose files are the
+* sessions' stored artifact text verbatim plus every referenced media object.
+* The root artifact sits under its original base name (`session.jsonl`); each
+* subagent descendant under `subagents/<id>/<filename>`; each image referenced
+* by any included log under `media/<attachmentId>.<ext>` (content-addressed,
+* so one archive never duplicates a shared image). No manifest is written —
+* every file is byte-identical to the backend's durable artifact or attachment
+* store and self-describing through its own header line or media type. Before
+* each live session's artifact read, the SessionStore flush barrier makes the
+* current in-memory log durable; cold sessions need no barrier. Request abort
+* and response-consumer cancellation share one producer signal and terminate
+* the active compressor.
+* Compression runs on the host with fflate's streaming Zip API, so the archive
+* bytes are produced incrementally and the host never holds the whole archive
+* in one buffer; production waits for consumer pull whenever the response queue
+* reaches its byte high-water mark, so a slow consumer bounds accumulation to
+* the fixed 64 KiB response queue plus one synchronous fflate push.
+* @module
+*/
+/** Balanced default used when Session export configuration omits a compression level. */
+const DEFAULT_SESSION_LOG_COMPRESSION_LEVEL = 6;
+/**
+* Resolve the persistence, session-query, and attachment services a log export needs.
+* @param ctx - the composed host context.
+* @returns the export services (absent when the deployment does not mount them).
+*/
+function sessionLogExportDeps(ctx) {
+	return {
+		sessionQuery: ctx.get("sessionQuery"),
+		sessionPersistence: ctx.get("sessionPersistence"),
+		attachments: ctx.get("attachments"),
+		sessions: ctx.get("sessions")
+	};
+}
+/**
+* Flush one currently live session through the store's authoritative durability
+* barrier immediately before its raw artifact is read. A cold or absent id has
+* no in-memory work to flush.
+* @param deps - export services, including the optional live-session store.
+* @param id - the session whose artifact is about to be read.
+* @param signal - optional cancellation observed around the flush barrier.
+*/
+async function flushLiveSessionLog(deps, id, signal) {
+	signal?.throwIfAborted();
+	const sessions = deps.sessions;
+	if (sessions === void 0) return;
+	const session = sessions.get(id);
+	if (session === void 0) return;
+	await sessions.flush(session);
+	signal?.throwIfAborted();
+}
+/** Zip extension for each accepted raster media type. */
+const MEDIA_TYPE_EXTENSIONS = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"image/webp": "webp",
+	"image/gif": "gif"
+};
+/**
+* The zip path for one media object: content-addressed by the opaque
+* attachment id so shared images land once and the id in the log maps back to
+* the archive entry without a manifest.
+* @param ref - the durable reference from a session log.
+* @returns the archive path.
+*/
+function mediaEntryPath(ref) {
+	return `media/${String(ref.attachmentId)}.${MEDIA_TYPE_EXTENSIONS[ref.mediaType]}`;
+}
+/**
+* Collect every image reference inside one content array, descending into
+* nested tool results the way the live attachment route does.
+* @param content - an event content array (or nested tool-result content).
+* @param refs - the dedupe map being filled (keyed by attachment id).
+*/
+function collectImageRefs(content, refs) {
+	if (!Array.isArray(content)) return;
+	const pending = [];
+	for (const item of content) pending.push(item);
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (typeof value !== "object" || value === null || Array.isArray(value)) continue;
+		const block = value;
+		if (block.type === "image" && typeof block.attachment === "object" && block.attachment !== null) {
+			const ref = block.attachment;
+			refs.set(String(ref.attachmentId), ref);
+		}
+		if (Array.isArray(block.content)) for (const item of block.content) pending.push(item);
+	}
+}
+/**
+* Collect every image reference one session event carries, across the same
+* carriers the live attachment route scans (direct content, message content,
+* inserted messages, and completed assistant chunk blocks).
+* @param event - one parsed JSONL event object.
+* @param refs - the dedupe map being filled (keyed by attachment id).
+*/
+function collectEventImageRefs(event, refs) {
+	const data = event.data;
+	if (typeof data !== "object" || data === null) return;
+	const carrier = data;
+	collectImageRefs(carrier.content, refs);
+	if (carrier.message !== void 0) collectImageRefs(carrier.message.content, refs);
+	if (carrier.inserted !== void 0) for (const message of carrier.inserted) collectImageRefs(message.content, refs);
+	if (carrier.chunk?.type === "block-end") collectImageRefs([carrier.chunk.block], refs);
+}
+/**
+* Collect the distinct media references one stored artifact text names.
+* Lines that fail to parse cannot reference media and are skipped (the
+* artifact text itself is exported verbatim regardless).
+* @param content - the stored artifact text.
+* @returns the dedupe map keyed by attachment id.
+*/
+function imageRefsInArtifact(content) {
+	const refs = /* @__PURE__ */ new Map();
+	for (const line of content.split("\n")) {
+		if (line === "") continue;
+		let event;
+		try {
+			event = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		collectEventImageRefs(event, refs);
+	}
+	return refs;
+}
+/**
+* One safe zip path segment from an untrusted session id. Session ids are
+* host-controlled, but the brand allows any non-empty string, so `../`, dot
+* segments, and separator characters are neutralized before they can shape
+* archive entries. Distinct ids may collapse onto one segment (id collision
+* is impossible for the host-minted UUIDs, so no uniqueness suffix is kept).
+* @param id - the raw session id.
+* @returns a filesystem-safe single path segment.
+*/
+function safeSessionIdSegment(id) {
+	return id.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+/**
+* The export archive filename for one root session.
+* @param sessionId - the root session id (sanitized to one safe path segment).
+* @returns the attachment filename for the session's export archive.
+*/
+function sessionLogZipFilename(sessionId) {
+	return `dsh-session-${safeSessionIdSegment(sessionId)}.zip`;
+}
+/**
+* Yield the export entries in zip order: the preloaded root artifact first,
+* then every subagent descendant in lineage order (each flushed when live,
+* read from the persistence backend right before it is yielded, and dropped
+* after the consumer moves on), then every distinct media object referenced by any of
+* the included logs (read and verified from the attachment store, one archive
+* entry per attachment id). The host holds at most one descendant's artifact
+* text and one media object at a time beyond the root.
+* @param deps - the mounted export services (the caller answered 500 before this runs).
+* @param root - the already-read root artifact (read by the caller so the
+* missing-session path can answer cleanly before streaming starts).
+* @param sessionId - the root session id.
+* @param includeDescendants - whether to include every subagent descendant.
+* @param signal - optional cancellation forwarded to lineage, persistence, and attachment reads.
+* @returns the export entries in zip order.
+*/
+async function* sessionLogZipEntries(deps, root, sessionId, includeDescendants, signal) {
+	const media = /* @__PURE__ */ new Map();
+	const rememberMedia = (content) => {
+		for (const [id, ref] of imageRefsInArtifact(content)) media.set(id, ref);
+	};
+	rememberMedia(root.content);
+	yield {
+		path: root.filename,
+		content: root.content
+	};
+	if (includeDescendants) {
+		const seen = new Set([sessionId]);
+		const collect = async function* (nodes) {
+			for (const node of nodes) {
+				signal?.throwIfAborted();
+				const id = node.session.header.id;
+				if (seen.has(id)) continue;
+				seen.add(id);
+				await flushLiveSessionLog(deps, id, signal);
+				const raw = await deps.sessionPersistence.readRaw(id, signal);
+				signal?.throwIfAborted();
+				if (raw === void 0) throw new Error(`subagent "${id}" has no stored log artifact`);
+				rememberMedia(raw.content);
+				yield {
+					path: `subagents/${safeSessionIdSegment(id)}/${raw.filename}`,
+					content: raw.content
+				};
+				yield* collect(node.descendants);
+			}
+		};
+		const lineage = await deps.sessionQuery.traceSession(sessionId, signal);
+		signal?.throwIfAborted();
+		yield* collect(lineage.descendants);
+	}
+	for (const ref of media.values()) {
+		signal?.throwIfAborted();
+		const stored = await deps.attachments.readImage(ref, signal);
+		signal?.throwIfAborted();
+		yield {
+			path: mediaEntryPath(ref),
+			data: stored.data
+		};
+	}
+}
+/** How many code units of artifact text one zip push carries (bounded encode memory). */
+const PUSH_CHUNK_CODE_UNITS = 65536;
+/** How many bytes of media one zip push carries (bounded memory; images are already size-capped). */
+const PUSH_CHUNK_BYTES = 65536;
+/** Byte capacity retained by the response stream before ZIP production waits for pull. */
+const RESPONSE_HIGH_WATER_MARK_BYTES = 65536;
+/** One producer waiter released only when ReadableStream pull restores capacity. */
+var ResponseCapacityGate = class {
+	releasePending;
+	/**
+	* Wait until the response queue has positive byte capacity or cancellation wins.
+	* @param controller - response controller whose desired size owns capacity.
+	* @param signal - combined request/consumer cancellation.
+	*/
+	async wait(controller, signal) {
+		signal.throwIfAborted();
+		if (controller.desiredSize === null || controller.desiredSize > 0) return;
+		await new Promise((resolve) => {
+			const release = () => {
+				this.releasePending = void 0;
+				signal.removeEventListener("abort", release);
+				resolve();
+			};
+			this.releasePending = release;
+			signal.addEventListener("abort", release, { once: true });
+		});
+		signal.throwIfAborted();
+	}
+	/** Release the current producer waiter after a consumer pull. */
+	pulled() {
+		this.releasePending?.();
+	}
+};
+/**
+* Push one media object's bytes into a deflate stream in bounded chunks,
+* waiting for consumer capacity between chunks like the artifact path does.
+* @param deflate - the zip entry's deflate stream.
+* @param data - the stored image bytes.
+* @param controller - response queue controller.
+* @param capacity - pull-driven response-capacity gate.
+* @param signal - cancellation; throws when aborted.
+*/
+async function pushBinaryChunks(deflate, data, controller, capacity, signal) {
+	let offset = 0;
+	do {
+		signal.throwIfAborted();
+		const end = Math.min(offset + PUSH_CHUNK_BYTES, data.byteLength);
+		const finalChunk = end >= data.byteLength;
+		deflate.push(data.subarray(offset, end), finalChunk);
+		offset = end;
+		await capacity.wait(controller, signal);
+	} while (offset < data.byteLength);
+}
+/**
+* Push one artifact's text into a deflate stream in bounded chunks, never
+* splitting a surrogate pair across a chunk boundary (a lone high surrogate
+* re-encodes as U+FFFD and would silently corrupt the exported artifact).
+* @param deflate - the zip entry's deflate stream.
+* @param content - the artifact text verbatim.
+* @param controller - response queue controller.
+* @param capacity - pull-driven response-capacity gate.
+* @param signal - cancellation; throws when aborted.
+*/
+async function pushArtifactChunks(deflate, content, controller, capacity, signal) {
+	const encoder = new TextEncoder();
+	let offset = 0;
+	let finalChunk;
+	do {
+		signal.throwIfAborted();
+		let end = Math.min(offset + PUSH_CHUNK_CODE_UNITS, content.length);
+		if (end < content.length && end - offset > 1) {
+			const last = content.charCodeAt(end - 1);
+			if (last >= 55296 && last <= 56319) end -= 1;
+		}
+		finalChunk = end >= content.length;
+		deflate.push(encoder.encode(content.slice(offset, end)), finalChunk);
+		offset = end;
+		await capacity.wait(controller, signal);
+	} while (!finalChunk);
+}
+/**
+* Stream one session-log ZIP as a WHATWG ReadableStream. The root artifact is
+* read and validated by the caller before this is called (missing root or
+* missing services answer cleanly before any byte is produced); each entry is
+* then encoded and deflated in bounded chunks as it is produced, so the
+* archive bytes arrive incrementally. A descendant that fails to read errors
+* the stream (fail-loud, never silent under-export).
+* @param deps - the mounted export services (the caller answered 500 before this runs).
+* @param root - the already-read root artifact (first zip entry).
+* @param sessionId - the root session id.
+* @param includeDescendants - whether to include every subagent descendant.
+* @param compressionLevel - validated fflate DEFLATE level for every ZIP entry.
+* @param signal - request cancellation combined with response-consumer cancellation.
+* @returns the zip byte stream.
+*/
+function streamSessionLogZip(deps, root, sessionId, includeDescendants, compressionLevel, signal) {
+	const consumerAbort = new AbortController();
+	const producerSignal = AbortSignal.any([signal, consumerAbort.signal]);
+	let zip;
+	let zipTerminated = false;
+	const capacity = new ResponseCapacityGate();
+	const terminateZip = () => {
+		if (zip === void 0 || zipTerminated) return;
+		zipTerminated = true;
+		zip.terminate();
+	};
+	return new ReadableStream({
+		start(controller) {
+			const archive = new Zip((error, data, final) => {
+				/* v8 ignore next 3 -- fflate reports only internal zip failures, unreachable for valid inputs */
+				if (error) {
+					controller.error(error);
+					return;
+				}
+				/* v8 ignore next -- fflate may emit empty chunks; not controllable from tests */
+				if (data.byteLength > 0) controller.enqueue(data);
+				if (final) controller.close();
+			});
+			zip = archive;
+			(async () => {
+				try {
+					for await (const entry of sessionLogZipEntries(deps, root, sessionId, includeDescendants, producerSignal)) {
+						const deflate = new ZipDeflate(entry.path, { level: compressionLevel });
+						archive.add(deflate);
+						if ("content" in entry) await pushArtifactChunks(deflate, entry.content, controller, capacity, producerSignal);
+						else await pushBinaryChunks(deflate, entry.data, controller, capacity, producerSignal);
+					}
+					archive.end();
+				} catch (error) {
+					/* v8 ignore next -- typed backends reject with Error, and DOMException is one in Node */
+					terminateZip();
+					controller.error(error instanceof Error ? error : new Error(String(error)));
+				}
+			})();
+		},
+		pull() {
+			capacity.pulled();
+		},
+		cancel(reason) {
+			consumerAbort.abort(reason instanceof Error ? reason : /* @__PURE__ */ new Error("session log export stream cancelled"));
+			terminateZip();
+		}
+	}, {
+		highWaterMark: RESPONSE_HIGH_WATER_MARK_BYTES,
+		size: (chunk) => chunk.byteLength
+	});
+}
+//#endregion
 //#region lib/types/index.js
-/** Web Session-log download command over the host endpoint owned by ApiProxy. */
+/** Session-log download command and Host-owned streaming route. */
 const name = "session-log-download";
-const inject = ["commands"];
+const inject = ["commands", "connection"];
+/** Stable browser download path retained across the transport migration. */
+const SESSION_LOG_EXPORT_PATH = "/api/session.export";
+/** Validate Session-log archive configuration. */
+const Config = Schema.object({ compressionLevel: Schema.number().step(1).min(0).max(9).default(6) });
 const REQUESTED = {
 	kind: "success",
 	text: "Session log download requested."
 };
 /**
-* Register the Web-only `/export` command that the browser download plugin observes.
+* Register the Web-only `/export` command and authenticated ZIP download route.
 * @param ctx - Host context carrying the human-command registry.
+* @param config - resolved compression policy.
 */
-function apply(ctx) {
+function apply(ctx, config = {}) {
 	ctx.effect(() => ctx.commands.register({
 		name: "export",
 		description: "Download this Session log as a ZIP archive",
@@ -19,6 +383,53 @@ function apply(ctx) {
 			text: "The Web /export command does not accept a path."
 		})
 	}), "session-log-download: command");
+	connectionOf(ctx).fetch.register({
+		path: SESSION_LOG_EXPORT_PATH,
+		methods: ["GET", "HEAD"],
+		fetch: async (request) => {
+			const response = await sessionLogExportResponse(ctx, request, config.compressionLevel ?? 6);
+			if (request.method === "GET") return response;
+			await response.body?.cancel();
+			return new Response(null, {
+				status: response.status,
+				headers: response.headers
+			});
+		}
+	});
+}
+function connectionOf(ctx) {
+	return Reflect.get(ctx, "connection");
+}
+async function sessionLogExportResponse(ctx, request, compressionLevel) {
+	const url = new URL(request.url);
+	const query = Object.fromEntries(url.searchParams);
+	const sessionIdValue = query["sessionId"];
+	const descendantsValue = query["includeDescendants"];
+	if (sessionIdValue === void 0 || sessionIdValue.length === 0 || descendantsValue !== void 0 && descendantsValue !== "true" && descendantsValue !== "false") return new Response("missing or invalid sessionId query parameter", { status: 400 });
+	const sessionId = brandString(sessionIdValue);
+	const deps = sessionLogExportDeps(ctx);
+	if (deps.sessionQuery === void 0 || deps.sessionPersistence === void 0 || deps.attachments === void 0) return new Response("session log export is unavailable: missing session-query, session-persistence, or attachments service", { status: 500 });
+	if (!deps.sessionPersistence.supportsRawArtifacts) return new Response("session log export is unavailable: the persistence backend does not expose per-session raw artifacts", { status: 501 });
+	const ready = {
+		sessionQuery: deps.sessionQuery,
+		sessionPersistence: deps.sessionPersistence,
+		attachments: deps.attachments,
+		sessions: deps.sessions
+	};
+	let root;
+	try {
+		await flushLiveSessionLog(deps, sessionId, request.signal);
+		root = await deps.sessionPersistence.readRaw(sessionId, request.signal);
+		request.signal.throwIfAborted();
+	} catch {
+		request.signal.throwIfAborted();
+		return new Response("session log export failed to prepare the stored artifact", { status: 500 });
+	}
+	if (root === void 0) return new Response("session not found", { status: 404 });
+	return new Response(streamSessionLogZip(ready, root, sessionId, descendantsValue === "true", compressionLevel, request.signal), { headers: {
+		"content-type": "application/zip",
+		"content-disposition": `attachment; filename="${sessionLogZipFilename(sessionId)}"`
+	} });
 }
 //#endregion
-export { apply, inject, name };
+export { Config, DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, SESSION_LOG_EXPORT_PATH, apply, flushLiveSessionLog, inject, name, sessionLogExportDeps, sessionLogZipEntries, sessionLogZipFilename, streamSessionLogZip };

package/lib/invariant.js CHANGED Viewed

@@ -3,7 +3,10 @@
 const PACKAGE_NAME = "@deepseek-ai/dsh-session-log-export";
 const name = "session-export-invariant";
 const inject = ["invariants"];
-/** No runtime invariant: the command registry owns lifecycle pairing and ApiProxy owns ZIP integrity. */
+/**
+* No runtime invariant: Connection and the command registry own both
+* registrations, while each export reads authoritative Session services.
+*/
 const install = () => {};
 /**
 * Register this package's invariant companion.

package/lib/types/archive.d.ts ADDED Viewed

@@ -0,0 +1,106 @@
+/**
+ * Host-side session-log download: streams one ZIP archive whose files are the
+ * sessions' stored artifact text verbatim plus every referenced media object.
+ * The root artifact sits under its original base name (`session.jsonl`); each
+ * subagent descendant under `subagents/<id>/<filename>`; each image referenced
+ * by any included log under `media/<attachmentId>.<ext>` (content-addressed,
+ * so one archive never duplicates a shared image). No manifest is written —
+ * every file is byte-identical to the backend's durable artifact or attachment
+ * store and self-describing through its own header line or media type. Before
+ * each live session's artifact read, the SessionStore flush barrier makes the
+ * current in-memory log durable; cold sessions need no barrier. Request abort
+ * and response-consumer cancellation share one producer signal and terminate
+ * the active compressor.
+ * Compression runs on the host with fflate's streaming Zip API, so the archive
+ * bytes are produced incrementally and the host never holds the whole archive
+ * in one buffer; production waits for consumer pull whenever the response queue
+ * reaches its byte high-water mark, so a slow consumer bounds accumulation to
+ * the fixed 64 KiB response queue plus one synchronous fflate push.
+ * @module
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { SessionQueryEngine } from '@deepseek-ai/dsh-session-query';
+import type { SessionId, SessionStore } from '@deepseek-ai/dsh-session';
+import type { SessionPersistence, SessionRawArtifact } from '@deepseek-ai/dsh-session-persistence';
+/** Valid fflate DEFLATE levels accepted by session-log export. */
+export type SessionLogCompressionLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+/** Balanced default used when Session export configuration omits a compression level. */
+export declare const DEFAULT_SESSION_LOG_COMPRESSION_LEVEL: SessionLogCompressionLevel;
+/** The services a session-log export needs (the live-session store is optional). */
+export interface SessionLogExportDeps {
+    readonly sessionQuery: SessionQueryEngine | undefined;
+    readonly sessionPersistence: SessionPersistence | undefined;
+    readonly attachments: AttachmentStore | undefined;
+    readonly sessions: SessionStore | undefined;
+}
+/** The export services narrowed to the mounted ones streaming actually reads. */
+export interface SessionLogExportReady {
+    readonly sessionQuery: SessionQueryEngine;
+    readonly sessionPersistence: SessionPersistence;
+    readonly attachments: AttachmentStore;
+    readonly sessions: SessionStore | undefined;
+}
+/**
+ * Resolve the persistence, session-query, and attachment services a log export needs.
+ * @param ctx - the composed host context.
+ * @returns the export services (absent when the deployment does not mount them).
+ */
+export declare function sessionLogExportDeps(ctx: Context): SessionLogExportDeps;
+/**
+ * Flush one currently live session through the store's authoritative durability
+ * barrier immediately before its raw artifact is read. A cold or absent id has
+ * no in-memory work to flush.
+ * @param deps - export services, including the optional live-session store.
+ * @param id - the session whose artifact is about to be read.
+ * @param signal - optional cancellation observed around the flush barrier.
+ */
+export declare function flushLiveSessionLog(deps: Pick<SessionLogExportDeps, 'sessions'>, id: SessionId, signal?: AbortSignal): Promise<void>;
+/** One exported file: a stored artifact text or one referenced media object. */
+export type SessionLogZipEntry = {
+    readonly path: string;
+    readonly content: string;
+} | {
+    readonly path: string;
+    readonly data: Uint8Array;
+};
+/**
+ * The export archive filename for one root session.
+ * @param sessionId - the root session id (sanitized to one safe path segment).
+ * @returns the attachment filename for the session's export archive.
+ */
+export declare function sessionLogZipFilename(sessionId: string): string;
+/**
+ * Yield the export entries in zip order: the preloaded root artifact first,
+ * then every subagent descendant in lineage order (each flushed when live,
+ * read from the persistence backend right before it is yielded, and dropped
+ * after the consumer moves on), then every distinct media object referenced by any of
+ * the included logs (read and verified from the attachment store, one archive
+ * entry per attachment id). The host holds at most one descendant's artifact
+ * text and one media object at a time beyond the root.
+ * @param deps - the mounted export services (the caller answered 500 before this runs).
+ * @param root - the already-read root artifact (read by the caller so the
+ * missing-session path can answer cleanly before streaming starts).
+ * @param sessionId - the root session id.
+ * @param includeDescendants - whether to include every subagent descendant.
+ * @param signal - optional cancellation forwarded to lineage, persistence, and attachment reads.
+ * @returns the export entries in zip order.
+ */
+export declare function sessionLogZipEntries(deps: SessionLogExportReady, root: SessionRawArtifact, sessionId: SessionId, includeDescendants: boolean, signal?: AbortSignal): AsyncGenerator<SessionLogZipEntry>;
+/**
+ * Stream one session-log ZIP as a WHATWG ReadableStream. The root artifact is
+ * read and validated by the caller before this is called (missing root or
+ * missing services answer cleanly before any byte is produced); each entry is
+ * then encoded and deflated in bounded chunks as it is produced, so the
+ * archive bytes arrive incrementally. A descendant that fails to read errors
+ * the stream (fail-loud, never silent under-export).
+ * @param deps - the mounted export services (the caller answered 500 before this runs).
+ * @param root - the already-read root artifact (first zip entry).
+ * @param sessionId - the root session id.
+ * @param includeDescendants - whether to include every subagent descendant.
+ * @param compressionLevel - validated fflate DEFLATE level for every ZIP entry.
+ * @param signal - request cancellation combined with response-consumer cancellation.
+ * @returns the zip byte stream.
+ */
+export declare function streamSessionLogZip(deps: SessionLogExportReady, root: SessionRawArtifact, sessionId: SessionId, includeDescendants: boolean, compressionLevel: SessionLogCompressionLevel, signal: AbortSignal): ReadableStream<Uint8Array>;
+//# sourceMappingURL=archive.d.ts.map

package/lib/types/client/Dialog.d.ts CHANGED Viewed

@@ -1,4 +1,5 @@
-import type { ObservableSnapshot, SessionId } from '@deepseek-ai/dsh-client-runtime/client';
+import type { ObservableSnapshot } from '@deepseek-ai/dsh-client-store';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SessionLogDownloadState } from './controller.ts';
 import { NS } from './locales.ts';

package/lib/types/client/controller.d.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 /** Browser download state shared by the Session Header button and `/export`. */
-import { type SessionId, type SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import { type SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
 /** Download phases presented by the shared modal. */
 export type SessionLogDownloadStatus = 'downloading' | 'success' | 'error';
 /** One Session's current download-dialog state. */

package/lib/types/client/index.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 /** Browser plugin owning Session export download state and its shared modal. */
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import { SessionLogDownloadController } from './controller.ts';
 import { type SessionLogDownloadKey } from './locales.ts';
 declare module '@deepseek-ai/cordis' {

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

@@ -2,6 +2,7 @@
 export declare const NS = "session-log-download";
 /** Simplified-Chinese Session export strings. */
 export declare const zh: {
+    readonly 'header.action': "Session 日志";
     readonly 'dialog.preparingTitle': "正在导出 Session";
     readonly 'dialog.preparingDescription': "正在准备包含当前 Session、子 Session 和附件的 ZIP 文件。";
     readonly 'dialog.successTitle': "Session 导出已开始下载";

package/lib/types/index.d.ts CHANGED Viewed

@@ -1,10 +1,24 @@
-/** Web Session-log download command over the host endpoint owned by ApiProxy. */
+/** Session-log download command and Host-owned streaming route. */
 import type { Context } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { type SessionLogCompressionLevel } from './archive.ts';
+export { DEFAULT_SESSION_LOG_COMPRESSION_LEVEL, flushLiveSessionLog, sessionLogExportDeps, sessionLogZipEntries, sessionLogZipFilename, streamSessionLogZip, } from './archive.ts';
+export type { SessionLogCompressionLevel, SessionLogExportDeps, SessionLogExportReady, SessionLogZipEntry, } from './archive.ts';
 export declare const name = "session-log-download";
 export declare const inject: string[];
+/** Stable browser download path retained across the transport migration. */
+export declare const SESSION_LOG_EXPORT_PATH = "/api/session.export";
+/** Session-log archive policy. */
+export interface Config {
+    /** DEFLATE level for each ZIP entry. @default 6 */
+    readonly compressionLevel?: SessionLogCompressionLevel;
+}
+/** Validate Session-log archive configuration. */
+export declare const Config: Schema<Config>;
 /**
- * Register the Web-only `/export` command that the browser download plugin observes.
+ * Register the Web-only `/export` command and authenticated ZIP download route.
  * @param ctx - Host context carrying the human-command registry.
+ * @param config - resolved compression policy.
  */
-export declare function apply(ctx: Context): void;
+export declare function apply(ctx: Context, config?: Config): void;
 //# sourceMappingURL=index.d.ts.map

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-session-log-export",
   "description": "Web Session-log export command and shared download dialog",
-  "version": "0.1.1-rc.2",
+  "version": "0.1.2-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -36,38 +36,44 @@
     "lib/types/**/*.d.ts"
   ],
   "license": "MIT",
+  "dependencies": {
+    "fflate": "^0.8.2",
+    "@deepseek-ai/dsh-brand": "^0.1.2-alpha.2",
+    "@deepseek-ai/schemastery": "^3.18.2"
+  },
   "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-locale": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-commands": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-commands": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2"
   },
   "devDependencies": {
     "@types/react": "~18.3.1",
     "react": "^18.2.0",
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
-    "@deepseek-ai/dsh-agent": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-commands": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-commands": "^0.1.1-rc.2"
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.3",
+    "@deepseek-ai/dsh-attachment": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-agent": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-connection": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-commands": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-store": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-session": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-locale": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-commands": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-invariants": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session-query": "^0.1.2-alpha.2",
+    "@deepseek-ai/dsh-session": "^0.1.2-alpha.2"
   },
   "dsh": {
     "client": {
       "inject": [
         "@deepseek-ai/dsh-client-locale",
-        "@deepseek-ai/dsh-client-runtime",
         "@deepseek-ai/dsh-client-ui-commands",
-        "@deepseek-ai/dsh-client-ui-conversation"
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-session"
       ],
       "platform": "web"
     }