@deepseek-ai/dsh-session-format 0.1.3-alpha.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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/session-format/README.md
+README.md: d44a7091bc5840afcb5d1e73f594284c3d5c8206
+README.zh.md: f4b6acd8e0ba3c28a1b5088fc577e1b4289ca9a0

package/README.md

@@ -0,0 +1,112 @@
+---
+description: "Pure adjacent Session format planning, lossless JSON value checks, header-only migration, and physical codec dispatch."
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-session-format
+
+English | [中文](README.zh.md)
+
+## Summary
+
+`dsh-session-format` lets persistence code restore a current Session directly or compose a unique sequence of adjacent migrations while consuming physical rows once. A restore transfers caller-owned parsed values through stateful stages without intermediate artifact copies or freezing. Physical framing, compression, immutable generation naming, exclusive publication, and Cordis lifecycle behavior remain outside this library.
+
+## 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)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+### When to use it
+
+Use this library from persistence or format-catalog code that must classify a physical Session header, restore current logical values, or compose released adjacent migrations. It is not a Cordis plugin and has no profile mount row. No runtime invariant companion is published because each completed operation validates its result; decoder and transformer state belongs to one unfinished streaming restore and is never shared across restores.
+
+### Entry point
+
+```text
+const catalog = createSessionFormatCatalog({ currentVersion, codecs, currentEncoder, migrations, restoreCurrent, restoreTransformedCurrent, restoreCurrentHeader })
+const descriptor = catalog.readHeader(physicalHeader)
+const restore = catalog.createRestore(physicalHeader, { recovery: 'recoverable', validation: 'transformed' })
+for (const row of physicalRows) restore.decodeRow(row)
+const current = restore.finish()
+const headerRecord = catalog.encodeCurrentHeader(current.header, current.inheritedEventCount)
+const eventRecords = current.events.map(catalog.encodeCurrentEvent)
+```
+
+`createSessionFormatCatalog()` accepts one frozen codec per supported version, the current record encoder, one migration per adjacent version pair, and current artifact and header restorers. `readHeader()` returns a `current`, `migration-required`, `unsupported`, or `malformed` descriptor without reading events. Body readers create one restore, push each parsed physical row through `decodeRow()`, and call `finish()` once for a current artifact. Writers encode its header and events record by record.
+
+The `recovery` option selects strict row failure or recoverable suffix handling. `validation: 'current'` applies all installed current-format validation. `validation: 'transformed'` applies released current-format validation after historical migration, while already-current input receives only its codec's physical validation.
+
+The recoverable decoder returns the accepted logical prefix. A codec may drop one malformed or sequence-gapped row and its uncommitted suffix, but a later decoded `turn/end` makes the original issue fatal.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+The chain validates unique gap-free ordering at construction. The catalog composes one row decoder with stateful adjacent event transformers, retains only their bounded state and the final current events, and performs target validation at `finish()`; only the caller decides whether and how to publish that result.
+
+| File | Role |
+|---|---|
+| [`src/chain.ts`](src/chain.ts) | Adjacent plan construction and current bypass |
+| [`src/catalog.ts`](src/catalog.ts) | Physical version dispatch and header classification |
+| [`src/json.ts`](src/json.ts) | Detached lossless JSON snapshots and common coordinate checks |
+| [`src/filename.ts`](src/filename.ts) | Canonical `session[.vN].jsonl` basename shared by persistence, export, and fixtures |
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+- [Released v0 to v1 edge](../session-format-v0-to-v1/README.md) — frozen historical decoding and identity conversion.
+- [Static catalog](../session-format-catalog/README.md) — first-party codec and migration assembly.
+- [JSONL persistence](../session-persistence-jsonl/README.md) — durable framing and generation publication.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+### Session restoration
+
+#### What the model sees
+
+Nothing directly. Consumers reconstruct model history from the validated current artifact through `deriveMessages()`.
+
+#### Token effect
+
+Zero direct tokens.
+
+#### KV Cache effect
+
+No direct effect. A migration that changes current history can change the cache identity owned by request reconstruction.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **Final current history remains resident** — streaming retains only bounded intermediate state, but the returned current event array and any required sequence-remap table remain O(event count).
+- **Adjacent integer versions only** — the library does not expose spans, stable event identities, or a general reference-rewrite algebra.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,112 @@
+---
+description: "纯函数式相邻 Session 格式规划、无损 JSON 值检查、仅标头迁移与物理编解码分派。"
+kind: "package-library"
+---
+
+# @deepseek-ai/dsh-session-format
+
+[English](README.md) | 中文
+
+## 概述
+
+`dsh-session-format` 让持久化代码可以直接还原当前 Session，或在只消费一次物理行的同时组合唯一的相邻迁移序列。一次还原会让调用方拥有的已解析值流经有状态 Stage，不复制或冻结中间 artifact。物理分帧、压缩、不可变 generation 命名、排他发布和 Cordis 生命周期行为不属于本库。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+### 何时使用
+
+当持久化或格式目录代码需要分类物理 Session header、还原当前逻辑值或组合已发布相邻迁移时，使用本库。它不是 Cordis 插件，也没有 profile 挂载行。它不发布运行时不变式伴生入口，因为每个已完成操作都会校验结果；decoder 与 transformer 状态只属于一次尚未完成的流式还原，绝不在多次还原间共享。
+
+### 入口
+
+```text
+const catalog = createSessionFormatCatalog({ currentVersion, codecs, currentEncoder, migrations, restoreCurrent, restoreTransformedCurrent, restoreCurrentHeader })
+const descriptor = catalog.readHeader(physicalHeader)
+const restore = catalog.createRestore(physicalHeader, { recovery: 'recoverable', validation: 'transformed' })
+for (const row of physicalRows) restore.decodeRow(row)
+const current = restore.finish()
+const headerRecord = catalog.encodeCurrentHeader(current.header, current.inheritedEventCount)
+const eventRecords = current.events.map(catalog.encodeCurrentEvent)
+```
+
+`createSessionFormatCatalog()` 接收每个受支持版本的一个冻结 codec、当前格式的逐记录 encoder、每组相邻版本的一个迁移，以及当前 artifact 与 header 还原器。`readHeader()` 在不读取事件的情况下返回 `current`、`migration-required`、`unsupported` 或 `malformed` 描述符。正文读取方创建一次 restore，把每个已解析物理行传给 `decodeRow()`，再调用一次 `finish()` 获得当前 artifact。写入方逐条编码其 header 与事件。
+
+`recovery` 选项决定严格拒绝故障行，还是执行可恢复后缀处理。`validation: 'current'` 会执行已安装 current 格式的全部校验。`validation: 'transformed'` 会在历史迁移后执行已发布 current 格式校验；已经是 current 的输入则只接受其 codec 的物理校验。
+
+可恢复解码器返回已接受的逻辑前缀。编解码器可以丢弃一个格式错误或序号不连续的行及其未提交后缀，但后续成功解码的 `turn/end` 会使原始问题成为致命错误。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+迁移链在构造时校验唯一且无缺口的顺序。Catalog 把一个行 decoder 与有状态的相邻事件 transformer 组合起来，只保留其有界状态与最终当前事件，并在 `finish()` 时执行目标校验；只有调用方决定是否发布该结果以及如何发布。
+
+| 文件 | 职责 |
+|---|---|
+| [`src/chain.ts`](src/chain.ts) | 相邻计划构造与当前格式绕过 |
+| [`src/catalog.ts`](src/catalog.ts) | 物理版本分派与标头分类 |
+| [`src/json.ts`](src/json.ts) | 分离的无损 JSON 快照与通用坐标校验 |
+| [`src/filename.ts`](src/filename.ts) | 持久化、导出与 fixture 共用的规范 `session[.vN].jsonl` 文件名 |
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+- [已发布 v0 到 v1 迁移边](../session-format-v0-to-v1/README.zh.md)——冻结的历史解码与恒等转换。
+- [静态目录](../session-format-catalog/README.zh.md)——第一方编解码器与迁移装配。
+- [JSONL 持久化](../session-persistence-jsonl/README.zh.md)——持久化分帧与代际发布。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+### Session 还原
+
+#### 模型看到什么
+
+没有直接内容。消费方通过 `deriveMessages()` 从经过校验的当前产物重建模型历史。
+
+#### Token 影响
+
+不直接产生 token。
+
+#### KV Cache 影响
+
+没有直接影响。迁移若改变当前历史，可能改变由请求重建逻辑拥有的缓存身份。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **最终当前历史仍常驻内存**——流式处理只保留有界中间状态，但返回的当前事件数组和必需的序号重映射表仍为 O(事件数)。
+- **仅支持相邻整数版本**——本库不暴露 span、稳定事件身份或通用引用重写代数。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,499 @@
+import { deepFreeze, snapshotJsonValue } from "@deepseek-ai/dsh-util-values";
+//#region lib/types/error.js
+/** Error raised when a durable Session artifact cannot be restored or migrated losslessly. */
+var SessionFormatError = class extends Error {
+	name = "SessionFormatError";
+};
+/** A readable artifact whose released source policy has no supported migration. */
+var SessionFormatUnsupportedMigrationError = class extends SessionFormatError {
+	name = "SessionFormatUnsupportedMigrationError";
+};
+//#endregion
+//#region lib/types/json.js
+/**
+* Test whether a value is a non-null, non-array object.
+* @param value - candidate value.
+* @returns whether the value is an object record.
+*/
+function isSessionFormatJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Require a non-negative safe integer without the JSON-unstable negative zero.
+* @param value - candidate count.
+* @param label - diagnostic subject.
+* @returns validated count.
+*/
+function sessionFormatCount(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0 || Object.is(value, -0)) throw new SessionFormatError(`${label} must be a non-negative safe integer`);
+	return value;
+}
+/**
+* Require a safe integer without the JSON-unstable negative zero.
+* @param value - candidate integer.
+* @param label - diagnostic subject.
+* @returns validated integer.
+*/
+function sessionFormatSafeInteger(value, label) {
+	if (!Number.isSafeInteger(value) || Object.is(value, -0)) throw new SessionFormatError(`${label} must be a safe integer`);
+	return value;
+}
+/**
+* Require a non-negative integral format version.
+* @param value - candidate version.
+* @param label - diagnostic subject.
+* @returns validated version.
+*/
+function sessionFormatVersion(value, label = "Session format version") {
+	return sessionFormatCount(value, label);
+}
+/**
+* Read only the version required for directional dispatch.
+* @param headerValue - untrusted physical header value.
+* @returns validated stored version.
+*/
+function inspectSessionFormatVersion(headerValue) {
+	if (!isSessionFormatJsonObject(headerValue)) throw new SessionFormatError("Session header must be a JSON object");
+	return sessionFormatVersion(headerValue["version"]);
+}
+/**
+* Detach and deeply freeze a caller-supplied lossless JSON value.
+* @param value - borrowed candidate.
+* @param label - diagnostic subject.
+* @returns an immutable detached JSON snapshot.
+*/
+function snapshotSessionFormatJson(value, label = "Session value") {
+	const snapshot = snapshotJsonValue(value);
+	if (snapshot === void 0) throw new SessionFormatError(`${label} is not lossless JSON`);
+	return deepFreeze(snapshot);
+}
+/**
+* Snapshot one logical header without inspecting an event body.
+* @param header - borrowed logical header.
+* @param label - diagnostic subject.
+* @returns immutable detached header.
+*/
+function snapshotSessionFormatHeader(header, label = "Session header") {
+	const snapshot = snapshotSessionFormatJson(header, label);
+	if (!isSessionFormatJsonObject(snapshot)) throw new SessionFormatError(`${label} must be a JSON object`);
+	inspectSessionFormatVersion(snapshot);
+	if (typeof snapshot["id"] !== "string") throw new SessionFormatError(`${label} id must be a string`);
+	sessionFormatCount(snapshot["createdAt"], `${label} createdAt`);
+	if (typeof snapshot["isSeeded"] !== "boolean") throw new SessionFormatError(`${label} isSeeded must be a boolean`);
+	sessionFormatCount(snapshot["delegationDepth"], `${label} delegationDepth`);
+	return snapshot;
+}
+//#endregion
+//#region lib/types/chain.js
+/**
+* Validate and freeze one adjacent migration declaration.
+* @param migration - named exact adjacent conversion.
+* @returns immutable validated declaration.
+*/
+function defineSessionFormatMigration(migration) {
+	if (typeof migration.name !== "string" || migration.name.length === 0) throw new SessionFormatError("Session migration name must be a non-empty string");
+	const from = sessionFormatVersion(migration.fromVersion, `${migration.name} fromVersion`);
+	if (sessionFormatVersion(migration.toVersion, `${migration.name} toVersion`) !== from + 1) throw new SessionFormatError(`${migration.name} must declare adjacent v${from}->v${from + 1}`);
+	return Object.freeze({ ...migration });
+}
+/**
+* Compile a unique, complete adjacent migration chain.
+* @param options - current version, adjacent declarations, and current restorer.
+* @returns immutable planner and streaming migration compiler.
+*/
+function createSessionFormatChain(options) {
+	return new CompiledSessionFormatChain(options);
+}
+var CompiledSessionFormatChain = class {
+	currentVersion;
+	migrations;
+	restoreCurrentHeader;
+	constructor(options) {
+		this.currentVersion = sessionFormatVersion(options.currentVersion, "current Session format version");
+		this.restoreCurrentHeader = options.restoreCurrentHeader;
+		const byFrom = /* @__PURE__ */ new Map();
+		const names = /* @__PURE__ */ new Set();
+		for (const candidate of options.migrations) {
+			const migration = defineSessionFormatMigration(candidate);
+			if (byFrom.has(migration.fromVersion)) throw new SessionFormatError(`Session migration v${migration.fromVersion}->v${migration.toVersion} is duplicated`);
+			if (names.has(migration.name)) throw new SessionFormatError(`Session migration name ${JSON.stringify(migration.name)} is duplicated`);
+			byFrom.set(migration.fromVersion, migration);
+			names.add(migration.name);
+		}
+		const ordered = [];
+		for (let version = 0; version < this.currentVersion; version += 1) {
+			const migration = byFrom.get(version);
+			if (migration === void 0) throw new SessionFormatUnsupportedMigrationError(`Session migration v${version}->v${version + 1} is missing`);
+			ordered.push(migration);
+		}
+		if (byFrom.size !== ordered.length) throw new SessionFormatError(`Session migration from v${[...byFrom.keys()].find((version) => version >= this.currentVersion)} does not lead to current v${this.currentVersion}`);
+		this.migrations = Object.freeze(ordered);
+	}
+	plan(fromVersion) {
+		const from = sessionFormatVersion(fromVersion, "stored Session format version");
+		if (from > this.currentVersion) throw new SessionFormatUnsupportedMigrationError(`stored Session uses newer format v${from}; this build writes v${this.currentVersion}`);
+		return Object.freeze(this.migrations.slice(from));
+	}
+	createStream(sourceHeader, sourceCut, output) {
+		let header = sourceHeader;
+		const validatedSourceCut = sessionFormatCount(sourceCut, "Session inherited event count");
+		let inheritedEventCount = validatedSourceCut;
+		const stages = [];
+		const plan = this.plan(header.version);
+		for (const [index, migration] of plan.entries()) {
+			const targetHeader = this.advanceHeader(migration, header);
+			let stage;
+			try {
+				stage = migration.createStage({
+					sourceHeader: header,
+					targetHeader,
+					sourceInheritedEventCount: inheritedEventCount,
+					sourceKind: index === 0 ? "decoded" : "transformed"
+				});
+			} catch (error) {
+				throwUnsupportedRefusal(migration, error);
+			}
+			header = targetHeader;
+			stages.push({
+				migration,
+				stage
+			});
+			if (index + 1 < plan.length) {
+				const targetCut = stage.headerInheritedEventCount;
+				if (targetCut === void 0) throw new SessionFormatError(`${migration.name} must expose its inherited cut before the next migration`);
+				inheritedEventCount = targetCut;
+			}
+		}
+		return new CompiledSessionFormatMigrationStream(header, validatedSourceCut, stages, output);
+	}
+	migrateHeader(source) {
+		let current = snapshotSessionFormatHeader(source, "stored Session header");
+		for (const migration of this.plan(current.version)) current = this.advanceHeader(migration, current);
+		current = snapshotSessionFormatHeader(this.restoreCurrentHeader(current), "current Session header restoration");
+		if (current.version !== this.currentVersion) throw new SessionFormatError(`current Session header restorer returned v${current.version}; expected v${this.currentVersion}`);
+		return current;
+	}
+	advanceHeader(migration, source) {
+		let target;
+		try {
+			target = migration.migrateHeader(snapshotSessionFormatHeader(source, `${migration.name} header input`));
+		} catch (error) {
+			throwUnsupportedRefusal(migration, error, "Session header");
+		}
+		const current = snapshotSessionFormatHeader(target, `${migration.name} header output`);
+		if (current.version !== migration.toVersion) throw new SessionFormatError(`${migration.name} header returned v${current.version}; expected v${migration.toVersion}`);
+		try {
+			migration.validateTargetHeader(current);
+		} catch (error) {
+			throwUnsupportedRefusal(migration, error, "Session header");
+		}
+		return current;
+	}
+};
+var ChainedMigrationContext = class {
+	entry;
+	output;
+	constructor(entry, output) {
+		this.entry = entry;
+		this.output = output;
+	}
+	emitEvent(event) {
+		try {
+			this.entry.stage.transformEvent(event, this.output);
+		} catch (error) {
+			throwUnsupportedRefusal(this.entry.migration, error);
+		}
+	}
+	emitRun(run) {
+		try {
+			this.entry.stage.transformRun(run, this.output);
+		} catch (error) {
+			throwUnsupportedRefusal(this.entry.migration, error);
+		}
+	}
+	finish() {
+		let targetCut;
+		try {
+			targetCut = this.entry.stage.finish(this.output);
+		} catch (error) {
+			throwUnsupportedRefusal(this.entry.migration, error);
+		}
+		if (this.entry.stage.headerInheritedEventCount !== void 0 && this.entry.stage.headerInheritedEventCount !== targetCut) throw new SessionFormatError(`${this.entry.migration.name} changed its predeclared inherited cut`);
+		return targetCut;
+	}
+};
+var CompiledSessionFormatMigrationStream = class {
+	header;
+	sourceInheritedEventCount;
+	input;
+	stages;
+	constructor(header, sourceInheritedEventCount, entries, output) {
+		this.header = header;
+		this.sourceInheritedEventCount = sourceInheritedEventCount;
+		const stages = new Array(entries.length);
+		let downstream = output;
+		for (const [offset, entry] of entries.toReversed().entries()) {
+			const context = new ChainedMigrationContext(entry, downstream);
+			stages[entries.length - offset - 1] = context;
+			downstream = context;
+		}
+		this.input = downstream;
+		this.stages = stages;
+	}
+	emitEvent(event) {
+		this.input.emitEvent(event);
+	}
+	emitRun(run) {
+		this.input.emitRun(run);
+	}
+	finish() {
+		let inheritedEventCount = this.sourceInheritedEventCount;
+		for (const stage of this.stages) inheritedEventCount = stage.finish();
+		return inheritedEventCount;
+	}
+};
+function throwUnsupportedRefusal(migration, error, subject = "Session") {
+	if (error instanceof SessionFormatUnsupportedMigrationError) throw error;
+	const detail = error instanceof Error ? error.message : String(error);
+	throw new SessionFormatUnsupportedMigrationError(`${migration.name} refuses this format v${migration.fromVersion} ${subject}: ${detail}`, { cause: error });
+}
+//#endregion
+//#region lib/types/context.js
+/** Migration output context that expands compact runs into retained events. */
+var SessionFormatEventCollector = class {
+	/** Events retained by this collector in source order. */
+	values = [];
+	/**
+	* Retain one settled event.
+	* @param event - settled event emitted by the upstream stage.
+	*/
+	emitEvent(event) {
+		this.values.push(event);
+	}
+	/**
+	* Expand one compact run directly into retained events.
+	* @param run - compact event run emitted by the upstream stage.
+	*/
+	emitRun(run) {
+		for (const event of run.expand()) this.values.push(event);
+	}
+};
+//#endregion
+//#region lib/types/catalog.js
+/**
+* Compile a build-static physical codec and adjacent migration catalog.
+* @param options - complete codecs, migrations, current version, and restorer.
+* @returns immutable physical dispatch and migration operations.
+*/
+function createSessionFormatCatalog(options) {
+	const chain = createSessionFormatChain(options);
+	const codecs = /* @__PURE__ */ new Map();
+	for (const codec of options.codecs) {
+		const version = sessionFormatVersion(codec.version, "Session format codec version");
+		if (codecs.has(version)) throw new SessionFormatError(`Session format codec v${version} is duplicated`);
+		codecs.set(version, Object.freeze({ ...codec }));
+	}
+	for (let version = 0; version <= chain.currentVersion; version += 1) if (!codecs.has(version)) throw new SessionFormatError(`Session format codec v${version} is missing`);
+	if (codecs.size !== chain.currentVersion + 1) throw new SessionFormatError(`Session format codec v${[...codecs.keys()].find((version) => version > chain.currentVersion)} is newer than current v${chain.currentVersion}`);
+	function readHeader(headerValue) {
+		let storedVersion;
+		try {
+			storedVersion = inspectSessionFormatVersion(headerValue);
+		} catch (error) {
+			return malformed(chain.currentVersion, error);
+		}
+		if (storedVersion > chain.currentVersion) return Object.freeze({
+			status: "unsupported",
+			storedVersion,
+			targetVersion: chain.currentVersion,
+			reason: `stored Session uses newer format v${storedVersion}; this build writes v${chain.currentVersion}`
+		});
+		const codec = codecs.get(storedVersion);
+		/* v8 ignore next -- construction proves every supported version has exactly one codec. */
+		if (codec === void 0) return Object.freeze({
+			status: "unsupported",
+			storedVersion,
+			targetVersion: chain.currentVersion,
+			reason: `this build has no Session format codec for v${storedVersion}`
+		});
+		try {
+			const decoded = snapshotSessionFormatHeader(codec.decodeHeader(headerValue), `format v${storedVersion} header`);
+			const header = chain.migrateHeader(decoded);
+			return Object.freeze({
+				status: storedVersion === chain.currentVersion ? "current" : "migration-required",
+				storedVersion,
+				targetVersion: chain.currentVersion,
+				header
+			});
+		} catch (error) {
+			if (error instanceof SessionFormatUnsupportedMigrationError) return Object.freeze({
+				status: "unsupported",
+				storedVersion,
+				targetVersion: chain.currentVersion,
+				reason: error.message
+			});
+			return malformed(chain.currentVersion, error, storedVersion);
+		}
+	}
+	function artifactCodec(headerValue) {
+		const storedVersion = inspectSessionFormatVersion(headerValue);
+		if (storedVersion > chain.currentVersion) throw new SessionFormatUnsupportedMigrationError(`stored Session uses newer format v${storedVersion}; this build writes v${chain.currentVersion}`);
+		const codec = codecs.get(storedVersion);
+		/* v8 ignore next -- construction proves every supported version has exactly one codec. */
+		if (codec === void 0) throw new SessionFormatUnsupportedMigrationError(`this build has no Session format codec for v${storedVersion}`);
+		return {
+			storedVersion,
+			codec
+		};
+	}
+	function encodeCurrentHeader(header, inheritedEventCount) {
+		if (inspectSessionFormatVersion(header) !== chain.currentVersion) throw new SessionFormatError(`encodeCurrent requires Session format v${chain.currentVersion}`);
+		const encoded = options.currentEncoder.encodeHeader(header, inheritedEventCount);
+		if (inspectSessionFormatVersion(encoded) !== chain.currentVersion) throw new SessionFormatError("current Session codec returned a non-current header");
+		return encoded;
+	}
+	function createRestore(headerValue, restoreOptions) {
+		const { storedVersion, codec } = artifactCodec(headerValue);
+		const decoder = codec.createDecoder(headerValue, restoreOptions.recovery);
+		const sourceCut = decoder.headerInheritedEventCount;
+		if (storedVersion === chain.currentVersion) return new CurrentSessionFormatRestore(decoder, sourceCut, restoreOptions.validation === "current" ? options.restoreCurrent : identityArtifact, chain.currentVersion);
+		const collector = new SessionFormatEventCollector();
+		return new MigratingSessionFormatRestore(decoder, sourceCut, chain.createStream(decoder.header, requiredHistoricalCut(storedVersion, sourceCut), collector), collector, restoreOptions.validation === "current" ? options.restoreCurrent : options.restoreTransformedCurrent, restoreOptions.validation, storedVersion, chain.currentVersion);
+	}
+	return Object.freeze({
+		currentVersion: chain.currentVersion,
+		readHeader,
+		createRestore,
+		encodeCurrentHeader,
+		encodeCurrentEvent: options.currentEncoder.encodeEvent.bind(options.currentEncoder)
+	});
+}
+var CurrentSessionFormatRestore = class {
+	decoder;
+	sourceInheritedEventCount;
+	restoreArtifact;
+	currentVersion;
+	header;
+	collector = new SessionFormatEventCollector();
+	constructor(decoder, sourceInheritedEventCount, restoreArtifact, currentVersion) {
+		this.decoder = decoder;
+		this.sourceInheritedEventCount = sourceInheritedEventCount;
+		this.restoreArtifact = restoreArtifact;
+		this.currentVersion = currentVersion;
+		this.header = decoder.header;
+	}
+	decodeRow(rowValue) {
+		this.decoder.decodeRow(rowValue, this.collector);
+	}
+	finish() {
+		const inheritedEventCount = finishDecoder(this.decoder, this.collector, this.sourceInheritedEventCount);
+		return restoreCurrentVersion(this.restoreArtifact({
+			header: this.header,
+			inheritedEventCount,
+			events: this.collector.values
+		}), this.currentVersion);
+	}
+};
+var MigratingSessionFormatRestore = class {
+	decoder;
+	sourceInheritedEventCount;
+	migration;
+	collector;
+	restoreArtifact;
+	validation;
+	sourceVersion;
+	currentVersion;
+	header;
+	constructor(decoder, sourceInheritedEventCount, migration, collector, restoreArtifact, validation, sourceVersion, currentVersion) {
+		this.decoder = decoder;
+		this.sourceInheritedEventCount = sourceInheritedEventCount;
+		this.migration = migration;
+		this.collector = collector;
+		this.restoreArtifact = restoreArtifact;
+		this.validation = validation;
+		this.sourceVersion = sourceVersion;
+		this.currentVersion = currentVersion;
+		this.header = migration.header;
+	}
+	decodeRow(rowValue) {
+		this.decoder.decodeRow(rowValue, this);
+	}
+	emitEvent(event) {
+		this.migration.emitEvent(event);
+	}
+	emitRun(run) {
+		this.migration.emitRun(run);
+	}
+	finish() {
+		finishDecoder(this.decoder, this, this.sourceInheritedEventCount);
+		const artifact = {
+			header: this.header,
+			inheritedEventCount: this.migration.finish(),
+			events: this.collector.values
+		};
+		let restored;
+		try {
+			restored = this.restoreArtifact(artifact);
+		} catch (error) {
+			if (this.validation === "current" || error instanceof SessionFormatUnsupportedMigrationError) throw error;
+			const detail = error instanceof Error ? error.message : String(error);
+			throw new SessionFormatUnsupportedMigrationError(`Session migration from v${this.sourceVersion} to v${this.currentVersion} refuses the transformed artifact: ${detail}`, { cause: error });
+		}
+		return restoreCurrentVersion(restored, this.currentVersion);
+	}
+};
+function finishDecoder(decoder, context, sourceInheritedEventCount) {
+	const inheritedEventCount = decoder.finish(context);
+	if (sourceInheritedEventCount !== void 0 && inheritedEventCount !== sourceInheritedEventCount) throw new SessionFormatError("streaming decoder changed its predeclared inherited cut");
+	return inheritedEventCount;
+}
+function restoreCurrentVersion(artifact, currentVersion) {
+	if (artifact.header.version !== currentVersion) throw new SessionFormatError(`current Session restorer returned v${artifact.header.version}; expected v${currentVersion}`);
+	return artifact;
+}
+function identityArtifact(artifact) {
+	return artifact;
+}
+function requiredHistoricalCut(version, cut) {
+	if (cut === void 0) throw new SessionFormatError(`format v${version} decoder must expose its inherited cut before migration`);
+	return cut;
+}
+function malformed(targetVersion, error, storedVersion) {
+	return Object.freeze({
+		status: "malformed",
+		...storedVersion === void 0 ? {} : { storedVersion },
+		targetVersion,
+		reason: error instanceof Error ? error.message : String(error)
+	});
+}
+//#endregion
+//#region lib/types/filename.js
+/** Canonical raw log basename shared by every generation-addressed Session artifact. */
+const CANONICAL_LOG_FILENAME = /^session(?:\.v([1-9][0-9]*))?\.jsonl$/u;
+/**
+* Name the raw JSONL log of one immutable Session format generation. Version
+* zero keeps the original `session.jsonl`; every later generation carries a
+* lowercase numeric `.vN` component before the `.jsonl` suffix.
+* @param version - non-negative safe integer Session format version.
+* @returns the canonical basename, without any compression suffix.
+*/
+function sessionFormatLogFilename(version) {
+	const generation = sessionFormatVersion(version, "Session log generation version");
+	return generation === 0 ? "session.jsonl" : `session.v${generation}.jsonl`;
+}
+/**
+* Read the generation named by one raw JSONL log basename. Temporary,
+* uppercase, leading-zero, `.v0`, and compression-suffixed names are not
+* canonical.
+* @param filename - one basename from a Session directory or archive.
+* @returns its Session format version, or `undefined` when the name is not canonical.
+*/
+function parseSessionFormatLogFilename(filename) {
+	const match = CANONICAL_LOG_FILENAME.exec(filename);
+	if (match === null) return void 0;
+	if (match[1] === void 0) return 0;
+	const version = Number(match[1]);
+	return Number.isSafeInteger(version) ? version : void 0;
+}
+//#endregion
+export { SessionFormatError, SessionFormatEventCollector, SessionFormatUnsupportedMigrationError, createSessionFormatCatalog, createSessionFormatChain, defineSessionFormatMigration, inspectSessionFormatVersion, isSessionFormatJsonObject, parseSessionFormatLogFilename, sessionFormatCount, sessionFormatLogFilename, sessionFormatSafeInteger, sessionFormatVersion, snapshotSessionFormatHeader, snapshotSessionFormatJson };

package/lib/types/catalog.d.ts

@@ -0,0 +1,8 @@
+import type { SessionFormatCatalog, SessionFormatCatalogOptions } from './types.ts';
+/**
+ * Compile a build-static physical codec and adjacent migration catalog.
+ * @param options - complete codecs, migrations, current version, and restorer.
+ * @returns immutable physical dispatch and migration operations.
+ */
+export declare function createSessionFormatCatalog(options: SessionFormatCatalogOptions): SessionFormatCatalog;
+//# sourceMappingURL=catalog.d.ts.map

package/lib/types/chain.d.ts

@@ -0,0 +1,14 @@
+import type { SessionFormatChain, SessionFormatChainOptions, SessionFormatMigration } from './types.ts';
+/**
+ * Validate and freeze one adjacent migration declaration.
+ * @param migration - named exact adjacent conversion.
+ * @returns immutable validated declaration.
+ */
+export declare function defineSessionFormatMigration(migration: SessionFormatMigration): SessionFormatMigration;
+/**
+ * Compile a unique, complete adjacent migration chain.
+ * @param options - current version, adjacent declarations, and current restorer.
+ * @returns immutable planner and streaming migration compiler.
+ */
+export declare function createSessionFormatChain(options: SessionFormatChainOptions): SessionFormatChain;
+//# sourceMappingURL=chain.d.ts.map

package/lib/types/context.d.ts

@@ -0,0 +1,17 @@
+import type { SessionFormatEvent, SessionFormatEventRun, SessionFormatMigrationContext } from './types.ts';
+/** Migration output context that expands compact runs into retained events. */
+export declare class SessionFormatEventCollector implements SessionFormatMigrationContext {
+    /** Events retained by this collector in source order. */
+    readonly values: SessionFormatEvent[];
+    /**
+     * Retain one settled event.
+     * @param event - settled event emitted by the upstream stage.
+     */
+    emitEvent(event: SessionFormatEvent): void;
+    /**
+     * Expand one compact run directly into retained events.
+     * @param run - compact event run emitted by the upstream stage.
+     */
+    emitRun(run: SessionFormatEventRun): void;
+}
+//# sourceMappingURL=context.d.ts.map

package/lib/types/error.d.ts

@@ -0,0 +1,9 @@
+/** Error raised when a durable Session artifact cannot be restored or migrated losslessly. */
+export declare class SessionFormatError extends Error {
+    readonly name: string;
+}
+/** A readable artifact whose released source policy has no supported migration. */
+export declare class SessionFormatUnsupportedMigrationError extends SessionFormatError {
+    readonly name = "SessionFormatUnsupportedMigrationError";
+}
+//# sourceMappingURL=error.d.ts.map

package/lib/types/filename.d.ts

@@ -0,0 +1,18 @@
+/** Canonical raw log basename shared by every generation-addressed Session artifact. */
+/**
+ * Name the raw JSONL log of one immutable Session format generation. Version
+ * zero keeps the original `session.jsonl`; every later generation carries a
+ * lowercase numeric `.vN` component before the `.jsonl` suffix.
+ * @param version - non-negative safe integer Session format version.
+ * @returns the canonical basename, without any compression suffix.
+ */
+export declare function sessionFormatLogFilename(version: number): string;
+/**
+ * Read the generation named by one raw JSONL log basename. Temporary,
+ * uppercase, leading-zero, `.v0`, and compression-suffixed names are not
+ * canonical.
+ * @param filename - one basename from a Session directory or archive.
+ * @returns its Session format version, or `undefined` when the name is not canonical.
+ */
+export declare function parseSessionFormatLogFilename(filename: string): number | undefined;
+//# sourceMappingURL=filename.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+/** Pure adjacent streaming Session format migration machinery. */
+export * from './chain.ts';
+export * from './catalog.ts';
+export * from './context.ts';
+export * from './error.ts';
+export * from './filename.ts';
+export * from './json.ts';
+export * from './types.ts';
+//# sourceMappingURL=index.d.ts.map

package/lib/types/json.d.ts

@@ -0,0 +1,49 @@
+import type { SessionFormatHeader, SessionFormatJsonValue } from './types.ts';
+/**
+ * Test whether a value is a non-null, non-array object.
+ * @param value - candidate value.
+ * @returns whether the value is an object record.
+ */
+export declare function isSessionFormatJsonObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Require a non-negative safe integer without the JSON-unstable negative zero.
+ * @param value - candidate count.
+ * @param label - diagnostic subject.
+ * @returns validated count.
+ */
+export declare function sessionFormatCount(value: unknown, label: string): number;
+/**
+ * Require a safe integer without the JSON-unstable negative zero.
+ * @param value - candidate integer.
+ * @param label - diagnostic subject.
+ * @returns validated integer.
+ */
+export declare function sessionFormatSafeInteger(value: unknown, label: string): number;
+/**
+ * Require a non-negative integral format version.
+ * @param value - candidate version.
+ * @param label - diagnostic subject.
+ * @returns validated version.
+ */
+export declare function sessionFormatVersion(value: unknown, label?: string): number;
+/**
+ * Read only the version required for directional dispatch.
+ * @param headerValue - untrusted physical header value.
+ * @returns validated stored version.
+ */
+export declare function inspectSessionFormatVersion(headerValue: unknown): number;
+/**
+ * Detach and deeply freeze a caller-supplied lossless JSON value.
+ * @param value - borrowed candidate.
+ * @param label - diagnostic subject.
+ * @returns an immutable detached JSON snapshot.
+ */
+export declare function snapshotSessionFormatJson(value: unknown, label?: string): SessionFormatJsonValue;
+/**
+ * Snapshot one logical header without inspecting an event body.
+ * @param header - borrowed logical header.
+ * @param label - diagnostic subject.
+ * @returns immutable detached header.
+ */
+export declare function snapshotSessionFormatHeader(header: SessionFormatHeader, label?: string): SessionFormatHeader;
+//# sourceMappingURL=json.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,190 @@
+/** Scalar value admitted at the durable Session JSON boundary. */
+export type SessionFormatJsonPrimitive = null | boolean | number | string;
+/** Lossless JSON value admitted at the durable Session boundary. */
+export type SessionFormatJsonValue = SessionFormatJsonPrimitive | readonly SessionFormatJsonValue[] | SessionFormatJsonObject;
+/** Lossless JSON object admitted at the durable Session boundary. */
+export interface SessionFormatJsonObject {
+    readonly [key: string]: SessionFormatJsonValue;
+}
+/** Logical Session metadata shared by supported historical and current formats. */
+export interface SessionFormatHeader extends SessionFormatJsonObject {
+    readonly version: number;
+    readonly id: string;
+    readonly createdAt: number;
+    readonly cwd?: string;
+    readonly parentSession?: string;
+    readonly isSeeded: boolean;
+    readonly origin?: 'subagent';
+    readonly delegationDepth: number;
+    readonly agentPreset?: string;
+}
+/** One decoded logical Session event. */
+export interface SessionFormatEvent extends SessionFormatJsonObject {
+    readonly type: string;
+    readonly seq: number;
+    readonly time: number;
+    readonly data: SessionFormatJsonValue;
+}
+/** One detached complete logical Session artifact. */
+export interface SessionFormatArtifact {
+    readonly header: SessionFormatHeader;
+    /** Exact inherited prefix length, available only after a body read. */
+    readonly inheritedEventCount: number;
+    readonly events: readonly SessionFormatEvent[];
+}
+/** One independently maintained adjacent streaming migration. */
+export interface SessionFormatMigration {
+    readonly name: string;
+    readonly fromVersion: number;
+    readonly toVersion: number;
+    /** Convert one header without reading event bodies. */
+    migrateHeader(header: SessionFormatHeader): SessionFormatHeader;
+    /** Create the stateful body stage for one source artifact. */
+    createStage(input: SessionFormatMigrationStageInput): SessionFormatMigrationStage;
+    /** Refuse any header that the adjacent target writer cannot emit. */
+    validateTargetHeader(header: SessionFormatHeader): void;
+}
+/** Headers and inherited cut supplied when one adjacent body stage is created. */
+export interface SessionFormatMigrationStageInput {
+    /** Validated source metadata for this adjacent edge. */
+    readonly sourceHeader: SessionFormatHeader;
+    /** Validated target metadata produced by this edge's header migration. */
+    readonly targetHeader: SessionFormatHeader;
+    /** Exact inherited prefix length in source coordinates. */
+    readonly sourceInheritedEventCount: number;
+    /** Whether this edge consumes physical decode output or a prior migration's validated output. */
+    readonly sourceKind: 'decoded' | 'transformed';
+}
+/** Inputs that compile the unique complete migration chain. */
+export interface SessionFormatChainOptions {
+    readonly currentVersion: number;
+    readonly migrations: readonly SessionFormatMigration[];
+    /** Restore and validate a detached current header without reading event bodies. */
+    readonly restoreCurrentHeader: (header: SessionFormatHeader) => SessionFormatHeader;
+}
+/** Pure adjacent planner and streaming migration compiler. */
+export interface SessionFormatChain {
+    readonly currentVersion: number;
+    /** Compile the complete migration stage chain for one decoded source artifact. */
+    createStream(header: SessionFormatHeader, inheritedEventCount: number, context: SessionFormatMigrationContext): SessionFormatMigrationStream;
+    /** Convert only a supported header to the current logical representation. */
+    migrateHeader(header: SessionFormatHeader): SessionFormatHeader;
+}
+/** Physical-row failure policy selected once for one restore. */
+export type SessionFormatRecovery = 'strict' | 'recoverable';
+/** Pure physical JSON codec frozen with one released Session format. */
+export interface SessionFormatCodec {
+    readonly version: number;
+    /** Decode one physical header into body-independent logical metadata. */
+    decodeHeader(value: unknown): SessionFormatHeader;
+    /** Create one row-at-a-time decoder with an explicit failure policy. */
+    createDecoder(headerValue: unknown, recovery: SessionFormatRecovery): SessionFormatArtifactDecoder;
+}
+/** Stateful physical-row decoder used by streaming persistence restores. */
+export interface SessionFormatArtifactDecoder {
+    readonly header: SessionFormatHeader;
+    /** Inherited cut known before body decoding; current formats may derive it at EOF. */
+    readonly headerInheritedEventCount?: number;
+    /** Decode one physical row and synchronously emit its events or compact run. */
+    decodeRow(rowValue: unknown, context: SessionFormatMigrationContext): void;
+    /** Finish row validation and return the exact inherited cut. */
+    finish(context: SessionFormatMigrationContext): number;
+}
+/** Stateless physical record encoder for the installed current format. */
+export interface SessionFormatCurrentEncoder {
+    /** Encode the physical header record for one current artifact. */
+    encodeHeader(header: SessionFormatHeader, inheritedEventCount: number): SessionFormatJsonObject;
+    /** Encode one current logical event as one physical record. */
+    encodeEvent(event: SessionFormatEvent): SessionFormatJsonObject;
+}
+/** A codec-owned compact run that adjacent migrations may consume without expanding. */
+export interface SessionFormatEventRun {
+    readonly runType: string;
+    readonly firstSeq: number;
+    readonly eventCount: number;
+    /** Expand the run for a migration that has no direct handler. */
+    expand(): Iterable<SessionFormatEvent>;
+}
+/** Synchronous output channel owned by a compiled migration stream. */
+export interface SessionFormatMigrationContext {
+    /** Deliver one settled event to the next stage before returning. */
+    emitEvent(event: SessionFormatEvent): void;
+    /** Deliver one compact event run to the next stage before returning. */
+    emitRun(run: SessionFormatEventRun): void;
+}
+/** Stateful adjacent migration stage used by streaming persistence restores. */
+export interface SessionFormatMigrationStage {
+    /** Target inherited cut when it is unchanged and known before EOF. */
+    readonly headerInheritedEventCount?: number;
+    /** Transform one source event and synchronously emit every settled target item. */
+    transformEvent(event: SessionFormatEvent, context: SessionFormatMigrationContext): void;
+    /** Transform one compact source run without requiring an intermediate expansion array. */
+    transformRun(run: SessionFormatEventRun, context: SessionFormatMigrationContext): void;
+    /** Emit trailing target items and return the exact target inherited cut. */
+    finish(context: SessionFormatMigrationContext): number;
+}
+/** One composed migration chain that emits settled current events to its owner. */
+export interface SessionFormatMigrationStream extends SessionFormatMigrationContext {
+    readonly header: SessionFormatHeader;
+    /** Settle all migration stages and return the exact current inherited cut. */
+    finish(): number;
+}
+/** Header-only classification that never inspects event rows. */
+export type SessionFormatHeaderReadResult = {
+    readonly status: 'current' | 'migration-required';
+    readonly storedVersion: number;
+    readonly targetVersion: number;
+    /** Latest logical header. The exact inherited cut requires a body read. */
+    readonly header: SessionFormatHeader;
+} | {
+    readonly status: 'unsupported';
+    readonly storedVersion: number;
+    readonly targetVersion: number;
+    readonly reason: string;
+} | {
+    readonly status: 'malformed';
+    readonly storedVersion?: number;
+    readonly targetVersion: number;
+    readonly reason: string;
+};
+/** Inputs for a build-static physical codec and migration catalog. */
+export interface SessionFormatCatalogOptions extends SessionFormatChainOptions {
+    readonly codecs: readonly SessionFormatCodec[];
+    /** Restore and validate a complete current artifact. */
+    readonly restoreCurrent: (artifact: SessionFormatArtifact) => SessionFormatArtifact;
+    /** Encode current records without materializing an artifact-sized row array. */
+    readonly currentEncoder: SessionFormatCurrentEncoder;
+    /** Validate an exclusively owned transformed artifact without copying or freezing it. */
+    readonly restoreTransformedCurrent: (artifact: SessionFormatArtifact) => SessionFormatArtifact;
+}
+/** Policies applied by one physical-row restore. */
+export interface SessionFormatRestoreOptions {
+    readonly recovery: SessionFormatRecovery;
+    /**
+     * `current` applies all installed current-format validation. `transformed` applies
+     * released current-format validation only after migration; current input receives only codec validation.
+     */
+    readonly validation: 'transformed' | 'current';
+}
+/** Build-static physical dispatch and adjacent migration catalog. */
+export interface SessionFormatCatalog {
+    readonly currentVersion: number;
+    /** Classify and translate one header without reading event rows. */
+    readHeader(headerValue: unknown): SessionFormatHeaderReadResult;
+    /** Create one single-pass physical-row restore into current logical events. */
+    createRestore(headerValue: unknown, options: SessionFormatRestoreOptions): SessionFormatRestore;
+    /** Encode one current physical header record. */
+    encodeCurrentHeader(header: SessionFormatHeader, inheritedEventCount: number): SessionFormatJsonObject;
+    /** Encode one current physical event record. */
+    encodeCurrentEvent(event: SessionFormatEvent): SessionFormatJsonObject;
+}
+/** One caller-owned physical-row restore whose final value is a current logical artifact. */
+export interface SessionFormatRestore {
+    /** Current logical header available before body decoding. */
+    readonly header: SessionFormatHeader;
+    /** Decode one physical row in file order. */
+    decodeRow(rowValue: unknown): void;
+    /** Finish every decoder and migration stage and return the current artifact. */
+    finish(): SessionFormatArtifact;
+}
+//# sourceMappingURL=types.d.ts.map

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@deepseek-ai/dsh-session-format",
+  "description": "Streaming adjacent Session format migration machinery",
+  "version": "0.1.3-alpha.2",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/session/session-format"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@deepseek-ai/dsh-util-values": "^0.1.3-alpha.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2"
+  }
+}