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

package/lib/index.js

@@ -1,15 +1,17 @@
 import { Service } from "@deepseek-ai/cordis";
 import { isAbsolute } from "node:path";
-import { CallId, MessageId, assertNever, callConfigEquals, deepFreeze, freezeMessage } from "@deepseek-ai/dsh-llm";
+import { brandString } from "@deepseek-ai/dsh-brand";
+import { deepFreeze, snapshotJsonValue } from "@deepseek-ai/dsh-util-values";
 import { scopeOf, scopeTarget } from "@deepseek-ai/dsh-scope";
+import { callConfigEquals } from "@deepseek-ai/dsh-llm";
 //#region lib/types/types.js
 /**
 * Brand a string as a {@link SessionId}.
 * @param id - the raw session id string.
-* @returns the same string, branded (a compile-time cast — no runtime cost).
+* @returns the same string with the session-id brand.
 */
 function SessionId(id) {
-	return id;
+	return brandString(id);
 }
 /**
 * The on-disk session format version, stamped into every newly-written {@link SessionHeader}
@@ -36,175 +38,6 @@ function SessionId(id) {
 */
 const SESSION_FORMAT_VERSION = 0;
 //#endregion
-//#region lib/types/json.js
-/** Lossless-JSON validation and detached snapshots for durable session data. @module @deepseek-ai/dsh-session/json */
-/** Whether a realm-owned intrinsic prototype is backed by its native constructor. */
-function hasIntrinsicConstructor(prototype, name) {
-	const constructor = Object.getOwnPropertyDescriptor(prototype, "constructor")?.value;
-	if (typeof constructor !== "function") return false;
-	try {
-		return constructor.name === name && constructor.prototype === prototype && Function.prototype.toString.call(constructor) === `function ${name}() { [native code] }`;
-	} catch {
-		return false;
-	}
-}
-/** Whether a candidate is one realm's intrinsic `Object.prototype`. */
-function isIntrinsicObjectPrototype(value) {
-	return Object.getPrototypeOf(value) === null && hasIntrinsicConstructor(value, "Object");
-}
-/** Whether an array uses one realm's intrinsic `Array.prototype`, not a subclass or forged prototype. */
-function hasPlainArrayPrototype(value) {
-	const prototype = Object.getPrototypeOf(value);
-	if (!Array.isArray(prototype) || !hasIntrinsicConstructor(prototype, "Array")) return false;
-	const objectPrototype = Object.getPrototypeOf(prototype);
-	return typeof objectPrototype === "object" && objectPrototype !== null && isIntrinsicObjectPrototype(objectPrototype);
-}
-/** Whether an object is a plain or null-prototype record from any JavaScript realm. */
-function hasPlainObjectPrototype(value) {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || typeof prototype === "object" && isIntrinsicObjectPrototype(prototype);
-}
-/** Return every JSON-visible object key, or reject own data JSON would discard. */
-function enumerableStringKeys(value) {
-	const keys = Reflect.ownKeys(value);
-	if (keys.some((key) => typeof key !== "string" || !Object.prototype.propertyIsEnumerable.call(value, key))) return void 0;
-	return keys;
-}
-/** Validate lossless JSON iteratively, optionally materializing a detached snapshot. */
-function walkJsonValue(value, detach) {
-	const ancestors = /* @__PURE__ */ new Set();
-	let root;
-	const assign = (destination, item) => {
-		if (destination === void 0) return;
-		if (destination.kind === "root") root = item;
-		else if (destination.kind === "array") destination.target[destination.index] = item;
-		else Object.defineProperty(destination.target, destination.key, {
-			value: item,
-			enumerable: true,
-			configurable: true,
-			writable: true
-		});
-	};
-	const tasks = [{
-		kind: "visit",
-		value,
-		...detach ? { destination: { kind: "root" } } : {}
-	}];
-	for (let task = tasks.pop(); task !== void 0; task = tasks.pop()) {
-		if (task.kind === "leave") {
-			ancestors.delete(task.source);
-			continue;
-		}
-		if (task.kind === "array-item") {
-			if (!Object.prototype.hasOwnProperty.call(task.source, task.index)) return void 0;
-			tasks.push({
-				kind: "visit",
-				value: task.source[task.index],
-				...task.target === void 0 ? {} : { destination: {
-					kind: "array",
-					target: task.target,
-					index: task.index
-				} }
-			});
-			continue;
-		}
-		if (task.kind === "object-property") {
-			tasks.push({
-				kind: "visit",
-				value: task.source[task.key],
-				...task.target === void 0 ? {} : { destination: {
-					kind: "object",
-					target: task.target,
-					key: task.key
-				} }
-			});
-			continue;
-		}
-		const current = task.value;
-		if (current === null) {
-			assign(task.destination, null);
-			continue;
-		}
-		if (typeof current === "boolean" || typeof current === "string") {
-			assign(task.destination, current);
-			continue;
-		}
-		if (typeof current === "number") {
-			if (!Number.isFinite(current) || Object.is(current, -0)) return void 0;
-			assign(task.destination, current);
-			continue;
-		}
-		if (typeof current !== "object") return void 0;
-		if (ancestors.has(current)) return void 0;
-		if (Array.isArray(current)) {
-			if (!hasPlainArrayPrototype(current)) return void 0;
-			const length = current.length;
-			if (Reflect.ownKeys(current).length !== length + 1) return void 0;
-			const target = detach ? [] : void 0;
-			if (target !== void 0) assign(task.destination, target);
-			ancestors.add(current);
-			tasks.push({
-				kind: "leave",
-				source: current
-			});
-			for (let index = length - 1; index >= 0; index--) tasks.push({
-				kind: "array-item",
-				source: current,
-				index,
-				...target === void 0 ? {} : { target }
-			});
-			continue;
-		}
-		if (!hasPlainObjectPrototype(current)) return void 0;
-		const keys = enumerableStringKeys(current);
-		if (keys === void 0) return void 0;
-		const target = detach ? {} : void 0;
-		if (target !== void 0) assign(task.destination, target);
-		ancestors.add(current);
-		tasks.push({
-			kind: "leave",
-			source: current
-		});
-		for (let index = keys.length - 1; index >= 0; index--) {
-			const key = keys[index];
-			/* v8 ignore next -- the loop is bounded by the captured key count. */
-			if (key === void 0) return void 0;
-			tasks.push({
-				kind: "object-property",
-				source: current,
-				key,
-				...target === void 0 ? {} : { target }
-			});
-		}
-	}
-	return detach ? root : true;
-}
-/**
-* Validate and detach lossless JSON in one read per property, so a stateful
-* getter cannot change between validation and copying. Traversal is iterative,
-* so valid nesting is bounded by available memory rather than the JavaScript
-* call stack. Accepts ordinary arrays, plain or null-prototype objects, and JSON
-* scalars; rejects sparse, cyclic, exotic, negative-zero, and non-finite values.
-* Getter throws propagate.
-*
-* @param value - the candidate value to validate and detach.
-* @returns the detached snapshot, or `undefined` when the value is not
-*   losslessly JSON-serializable.
-*/
-function snapshotJsonValue(value) {
-	return walkJsonValue(value, true);
-}
-/**
-* Test the same lossless JSON boundary as {@link snapshotJsonValue} without
-* detaching it. Only own enumerable string properties participate; `toJSON`
-* is ignored and getters run, so persistence boundaries use the snapshotter.
-* @param value - the candidate event data to test.
-* @returns whether `value` survives JSON round-trip losslessly.
-*/
-function isJsonValue(value) {
-	return walkJsonValue(value, false) === true;
-}
-//#endregion
 //#region lib/types/surface.js
 /**
 * Surface layer on top of the session event log: an ordered view of events
@@ -666,8 +499,8 @@ function interruptedTurnClosers(events) {
 	const closers = [];
 	for (const [callId, { step, callSeq }] of pendingCalls) {
 		const started = callSeq !== void 0;
-		const message = freezeMessage({
-			id: MessageId(`interrupted-tool-result-${callId}-${seq}`),
+		const message = deepFreeze({
+			id: brandString(`interrupted-tool-result-${callId}-${seq}`),
 			role: "user",
 			source: {
 				kind: "tool",
@@ -726,21 +559,22 @@ function interruptedTurnClosers(events) {
 //#endregion
 //#region lib/types/chunk-rows.js
 /**
-* Lossless storage packing for `assistant/chunk` delta runs. Providers stream
+* Lossless row packing for `assistant/chunk` delta runs. Providers stream
 * token-sized deltas, so a log stores hundreds of near-identical event lines
 * whose JSON envelopes dwarf their payloads (~56× measured on a real DeepSeek
 * session). This module packs each run of consecutive same-block delta chunks
 * into ONE storage row — `text-chunks`, `reasoning-chunks`, or
 * `tool-call-chunks` — and expands rows back to the exact original events.
 *
-* Storage rows are a durable-encoding vocabulary, NOT session events: they
-* never enter `Session.events`, have no `SessionEventMap` entry, and use bare
-* (slash-less) type tags so a reader cannot confuse them with the event
-* taxonomy (precedent: the JSONL header line's `session` tag). The encoder
-* whitelists exact shapes — anything it does not fully recognize is stored
-* verbatim, so unknown fields or future chunk variants lose compression, never
-* data. The decoder validates before expanding and fails loud on a malformed
-* row-tagged value instead of silently dropping a whole run.
+* Packed rows are an encoding vocabulary, NOT session events: they never enter
+* `Session.events`, have no `SessionEventMap` entry, and use bare (slash-less)
+* type tags so a reader cannot confuse them with the event taxonomy
+* (precedent: the JSONL header line's `session` tag). Persistence and bounded
+* history transport both use the codec. The encoder whitelists exact shapes —
+* anything it does not fully recognize stays verbatim, so unknown fields or
+* future chunk variants lose compression, never data. The decoder validates
+* before expanding and fails loud on a malformed row-tagged value instead of
+* silently dropping a whole run.
 *
 * @module @deepseek-ai/dsh-session/chunk-rows
 */
@@ -844,7 +678,7 @@ function buildRow(kind, run) {
 			...envelope,
 			data: {
 				...base,
-				id: CallId(call.id),
+				id: brandString(call.id),
 				...Object.hasOwn(call, "name") ? { name: call.name } : {},
 				args: run.map((event) => event.data.chunk.argumentsDelta)
 			}
@@ -961,7 +795,7 @@ function validateRow(value, tag) {
 		])) malformed(tag, "data must be exactly {turn, step, index, dt, texts}");
 		payload = validateRunData(tag, data, "texts");
 	}
-	if (!Number.isSafeInteger(value.seq0 + payload.length - 1)) malformed(tag, "member seqs must stay safe integers");
+	if (payload.length - 1 > Number.MAX_SAFE_INTEGER - value.seq0) malformed(tag, "member seqs must stay safe integers");
 	let time = value.time0;
 	for (const gap of data.dt) {
 		time += gap;
@@ -1001,8 +835,8 @@ function expandRow(row) {
 					argumentsDelta: members[k]
 				};
 				break;
-			/* v8 ignore next 2 -- validateRow only returns the three row tags */
-			default: return assertNever(row, "chunk-rows expandRow");
+			/* v8 ignore next 4 -- validateRow only returns the three row tags */
+			default: throw new Error(`chunk-rows received unsupported row ${String(row)}`);
 		}
 		events.push({
 			type: "assistant/chunk",
@@ -1048,8 +882,11 @@ function decodeStorageRecord(value) {
 * in `./types.ts`): such a log was likely written by a newer harness, and
 * silently skipping a required event would reconstruct a wrong session.
 * Downstream (out-of-repo) plugin events are outside this list by
-* construction; a registration surface for them is deferred until such a
-* consumer exists.
+* construction. The persisted `SessionEvent.ignorable` marker is the
+* compatibility mechanism; event-name registration was rejected because
+* it does not classify omission safety and would make reads
+* composition-dependent. The rationale is in
+* `.agents/notes/implemented/architecture/2026-08-30-retain-ignorable-external-session-events.md`.
 */
 const KNOWN_SESSION_EVENT_TYPES = new Set([
 	"agent-preset/selected",
@@ -1071,18 +908,21 @@ const KNOWN_SESSION_EVENT_TYPES = new Set([
 	"hook/result",
 	"llm/retry",
 	"llm/retry-started",
+	"model/selection",
 	"permission/preset",
 	"plan/mode",
 	"request/context",
 	"request/header",
 	"sandbox/mode",
 	"schedule/change",
+	"session-log-deepseek/delivery-accepted",
 	"session/end-seed",
 	"session/title",
 	"session/title-llm-request",
 	"step/end",
 	"step/start",
 	"subagent/descriptor",
+	"subagent/model-selection-policy",
 	"team/member",
 	"team/message/delivered",
 	"team/message/queued",
@@ -1102,6 +942,62 @@ const KNOWN_SESSION_EVENT_TYPES = new Set([
 	"web/deepseek-search-llm-request"
 ]);
 //#endregion
+//#region lib/types/seq-ranges.js
+/** Lossless range encoding for JSONL `sourceEventSeqs` arrays. */
+function isStrictlyIncreasing(values) {
+	return values.every((value, index) => index === 0 || value > values[index - 1]);
+}
+/**
+* Replace profitable consecutive runs with inclusive pairs.
+* @param values - validated in-memory source sequences.
+* @returns a lossless JSON storage form.
+*/
+function encodeSeqRanges(values) {
+	if (!isStrictlyIncreasing(values)) return [...values];
+	const encoded = [];
+	for (let start = 0; start < values.length;) {
+		let end = start;
+		while (end + 1 < values.length && values[end + 1] === values[end] + 1) end += 1;
+		if (end - start >= 2) encoded.push([values[start], values[end]]);
+		else for (let index = start; index <= end; index += 1) encoded.push(values[index]);
+		start = end + 1;
+	}
+	return encoded;
+}
+/**
+* Expand a JSON storage-form source sequence array.
+* @param value - parsed storage value.
+* @param maxEntries - largest list permitted by the owning event.
+* @returns the in-memory source sequences.
+*/
+function decodeSeqRanges(value, maxEntries = Number.MAX_SAFE_INTEGER) {
+	if (!Array.isArray(value)) throw new TypeError("sourceEventSeqs must be an array");
+	const decoded = [];
+	let hasRange = false;
+	for (const entry of value) {
+		if (typeof entry === "number") {
+			assertSeq(entry);
+			if (decoded.length >= maxEntries) throw new TypeError("sourceEventSeqs exceeds its event sequence");
+			decoded.push(entry);
+			continue;
+		}
+		if (!Array.isArray(entry) || entry.length !== 2) throw new TypeError("sourceEventSeqs range entries must be [start, end] pairs");
+		const start = entry[0];
+		const end = entry[1];
+		assertSeq(start);
+		assertSeq(end);
+		if (end < start) throw new TypeError("sourceEventSeqs ranges require start <= end");
+		if (end - start + 1 > maxEntries - decoded.length) throw new TypeError("sourceEventSeqs range exceeds its event sequence");
+		for (let seq = start; seq <= end; seq += 1) decoded.push(seq);
+		hasRange = true;
+	}
+	if (hasRange && !isStrictlyIncreasing(decoded)) throw new TypeError("sourceEventSeqs ranges must be strictly increasing");
+	return decoded;
+}
+function assertSeq(value) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new TypeError("sourceEventSeqs must contain non-negative safe integers");
+}
+//#endregion
 //#region lib/types/index.js
 /**
 * Event-sourced session service: append-only session log, in-memory store, and
@@ -1433,7 +1329,7 @@ var Session = class Session {
 	*   Map/Set/Date/class instance), or when the candidate violates the
 	*   canonical surface contract (marker shape and eligibility, unique
 	*   earlier source-event references, positional replacement validity, and complete
-	*   shadowed-node coverage). One recursive pass reads, validates, and
+	*   shadowed-node coverage). One iterative pass reads, validates, and
 	*   copies each nested value once, so a stateful getter cannot supply one value
 	*   to validation and another to storage. The event log is the durable source
 	*   of truth, so a bad event fails at the append site rather than later during
@@ -1648,9 +1544,9 @@ var SessionStore = class extends Service {
 	prepare(id, options) {
 		let sessionId;
 		if (id === void 0) do
-			sessionId = SessionId(`session-${++this.counter}`);
+			sessionId = brandString(`session-${++this.counter}`);
 		while (this.store.has(sessionId));
-		else sessionId = SessionId(id);
+		else sessionId = brandString(id);
 		if (this.store.has(sessionId)) throw new Error(`session "${sessionId}" already exists`);
 		if (options?.seedSource === "persistence") return Session.fromRestore(sessionId, options.seed, options.meta);
 		const seed = options?.seed;
@@ -1887,4 +1783,4 @@ var SessionStore = class extends Service {
 	}
 };
 //#endregion
-export { KNOWN_SESSION_EVENT_TYPES, SESSION_FORMAT_VERSION, Session, SessionForkError, SessionId, SessionPreparation, SessionStore, SessionStore as default, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN, adoptSessionEvent, canonicalHeader, decodeStorageRecord, deriveEventMessage, foldRequestHeader, foldSurface, headerEquals, interruptedTurnClosers, isAppendSurfaceEvent, isJsonValue, isReplacementSurfaceEvent, isSurfaceEligibleType, isSurfaceEvent, packChunkRuns, snapshotJsonValue, snapshotSessionEvent };
+export { KNOWN_SESSION_EVENT_TYPES, SESSION_FORMAT_VERSION, Session, SessionForkError, SessionId, SessionPreparation, SessionStore, SessionStore as default, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN, adoptSessionEvent, canonicalHeader, decodeSeqRanges, decodeStorageRecord, deriveEventMessage, encodeSeqRanges, foldRequestHeader, foldSurface, headerEquals, interruptedTurnClosers, isAppendSurfaceEvent, isReplacementSurfaceEvent, isSurfaceEligibleType, isSurfaceEvent, packChunkRuns, snapshotSessionEvent };

package/lib/invariant.js

@@ -1,4 +1,5 @@
-import { assertNever } from "@deepseek-ai/dsh-llm";
+import { assertNever } from "@deepseek-ai/dsh-util-values";
+import "@deepseek-ai/dsh-brand";
 //#endregion
 //#region lib/types/invariant.js
 /**
@@ -79,7 +80,6 @@ function validateEvent(trace, event, fail) {
 		}
 		case "user/message": break;
 		case "session/end-seed": break;
-		case "todo/write":
 		case "request/header":
 		case "request/context":
 			if (trace.openTurn === null) fail(`${event.type} appended outside any open turn (core execution events must be turn-enclosed)`);

package/lib/types/chunk-rows.d.ts

@@ -1,23 +1,24 @@
 /**
- * Lossless storage packing for `assistant/chunk` delta runs. Providers stream
+ * Lossless row packing for `assistant/chunk` delta runs. Providers stream
  * token-sized deltas, so a log stores hundreds of near-identical event lines
  * whose JSON envelopes dwarf their payloads (~56× measured on a real DeepSeek
  * session). This module packs each run of consecutive same-block delta chunks
  * into ONE storage row — `text-chunks`, `reasoning-chunks`, or
  * `tool-call-chunks` — and expands rows back to the exact original events.
  *
- * Storage rows are a durable-encoding vocabulary, NOT session events: they
- * never enter `Session.events`, have no `SessionEventMap` entry, and use bare
- * (slash-less) type tags so a reader cannot confuse them with the event
- * taxonomy (precedent: the JSONL header line's `session` tag). The encoder
- * whitelists exact shapes — anything it does not fully recognize is stored
- * verbatim, so unknown fields or future chunk variants lose compression, never
- * data. The decoder validates before expanding and fails loud on a malformed
- * row-tagged value instead of silently dropping a whole run.
+ * Packed rows are an encoding vocabulary, NOT session events: they never enter
+ * `Session.events`, have no `SessionEventMap` entry, and use bare (slash-less)
+ * type tags so a reader cannot confuse them with the event taxonomy
+ * (precedent: the JSONL header line's `session` tag). Persistence and bounded
+ * history transport both use the codec. The encoder whitelists exact shapes —
+ * anything it does not fully recognize stays verbatim, so unknown fields or
+ * future chunk variants lose compression, never data. The decoder validates
+ * before expanding and fails loud on a malformed row-tagged value instead of
+ * silently dropping a whole run.
  *
  * @module @deepseek-ai/dsh-session/chunk-rows
  */
-import { CallId } from '@deepseek-ai/dsh-llm';
+import type { ToolCallId } from '@deepseek-ai/dsh-llm/brand';
 import type { SessionEvent } from './types.ts';
 /**
  * Fields shared by every packed run: placement, block correlation, and member
@@ -39,7 +40,7 @@ interface TextRunData extends RunDataBase {
 }
 /** Payload of a `tool-call-chunks` row: the run-constant call identity plus each member's raw arguments fragment. */
 interface ToolCallRunData extends RunDataBase {
-    id: CallId;
+    id: ToolCallId;
     /** Present iff every member carried it, with one uniform value (a mixed run never packs). */
     name?: string;
     args: string[];
@@ -67,6 +68,18 @@ export type ChunkRow = {
 };
 /** One durable log line's JSON value: a session event verbatim, or a packed chunk row. */
 export type StorageRecord = SessionEvent | ChunkRow;
+/**
+ * Test whether an encoded record is a packed chunk row rather than a Session event.
+ * @param record - one persistence or bounded-history encoding record.
+ * @returns Whether the record is a packed chunk row.
+ */
+export declare function isChunkRow(record: StorageRecord): record is ChunkRow;
+/**
+ * Number of logical Session events represented by one packed row.
+ * @param row - validated or encoder-produced packed row.
+ * @returns Count of consecutive chunk events in the row.
+ */
+export declare function chunkRowLength(row: ChunkRow): number;
 /**
  * Pack an event batch for storage: each run of at least {@link MIN_RUN}
  * consecutive whitelisted same-kind, same-block delta chunk events becomes one

package/lib/types/chunk-rows.js

@@ -1,23 +1,42 @@
 /**
- * Lossless storage packing for `assistant/chunk` delta runs. Providers stream
+ * Lossless row packing for `assistant/chunk` delta runs. Providers stream
  * token-sized deltas, so a log stores hundreds of near-identical event lines
  * whose JSON envelopes dwarf their payloads (~56× measured on a real DeepSeek
  * session). This module packs each run of consecutive same-block delta chunks
  * into ONE storage row — `text-chunks`, `reasoning-chunks`, or
  * `tool-call-chunks` — and expands rows back to the exact original events.
  *
- * Storage rows are a durable-encoding vocabulary, NOT session events: they
- * never enter `Session.events`, have no `SessionEventMap` entry, and use bare
- * (slash-less) type tags so a reader cannot confuse them with the event
- * taxonomy (precedent: the JSONL header line's `session` tag). The encoder
- * whitelists exact shapes — anything it does not fully recognize is stored
- * verbatim, so unknown fields or future chunk variants lose compression, never
- * data. The decoder validates before expanding and fails loud on a malformed
- * row-tagged value instead of silently dropping a whole run.
+ * Packed rows are an encoding vocabulary, NOT session events: they never enter
+ * `Session.events`, have no `SessionEventMap` entry, and use bare (slash-less)
+ * type tags so a reader cannot confuse them with the event taxonomy
+ * (precedent: the JSONL header line's `session` tag). Persistence and bounded
+ * history transport both use the codec. The encoder whitelists exact shapes —
+ * anything it does not fully recognize stays verbatim, so unknown fields or
+ * future chunk variants lose compression, never data. The decoder validates
+ * before expanding and fails loud on a malformed row-tagged value instead of
+ * silently dropping a whole run.
  *
  * @module @deepseek-ai/dsh-session/chunk-rows
  */
-import { CallId, assertNever } from '@deepseek-ai/dsh-llm';
+import { brandString } from '@deepseek-ai/dsh-brand';
+/**
+ * Test whether an encoded record is a packed chunk row rather than a Session event.
+ * @param record - one persistence or bounded-history encoding record.
+ * @returns Whether the record is a packed chunk row.
+ */
+export function isChunkRow(record) {
+    return record.type === 'text-chunks'
+        || record.type === 'reasoning-chunks'
+        || record.type === 'tool-call-chunks';
+}
+/**
+ * Number of logical Session events represented by one packed row.
+ * @param row - validated or encoder-produced packed row.
+ * @returns Count of consecutive chunk events in the row.
+ */
+export function chunkRowLength(row) {
+    return row.type === 'tool-call-chunks' ? row.data.args.length : row.data.texts.length;
+}
 /**
  * Minimum members before a run packs. Below it a row's envelope rivals the
  * event lines it replaces. A format constant, not a tunable: both layouts
@@ -120,7 +139,7 @@ function buildRow(kind, run) {
             ...envelope,
             data: {
                 ...base,
-                id: CallId(call.id),
+                id: brandString(call.id),
                 ...Object.hasOwn(call, 'name') ? { name: call.name } : {},
                 args: run.map(event => event.data.chunk.argumentsDelta),
             },
@@ -231,7 +250,7 @@ function validateRow(value, tag) {
     // outside any encoder's image: float arithmetic would round it to a
     // different number than exact arithmetic, a silent corruption. Within safe
     // range every step is exact, so the first departure is always caught.
-    if (!Number.isSafeInteger(value.seq0 + payload.length - 1)) {
+    if (payload.length - 1 > Number.MAX_SAFE_INTEGER - value.seq0) {
         malformed(tag, 'member seqs must stay safe integers');
     }
     let time = value.time0;
@@ -267,9 +286,11 @@ function expandRow(row) {
                     argumentsDelta: members[k],
                 };
                 break;
-            /* v8 ignore next 2 -- validateRow only returns the three row tags */
-            default:
-                return assertNever(row, 'chunk-rows expandRow');
+            /* v8 ignore next 4 -- validateRow only returns the three row tags */
+            default: {
+                const unreachable = row;
+                throw new Error(`chunk-rows received unsupported row ${String(unreachable)}`);
+            }
         }
         events.push({
             type: 'assistant/chunk',

package/lib/types/index.d.ts

@@ -8,16 +8,13 @@
 import { Context, Service } from '@deepseek-ai/cordis';
 import type { Scoped } from '@deepseek-ai/dsh-scope';
 import type { Message } from '@deepseek-ai/dsh-llm';
-import { SessionId } from './types.ts';
 import type { TypertLookup } from '@deepseek-ai/dsh-typert-protocol';
-import type { CreateSessionOptions, EpochHeader, PrepareSessionOptions, RequestContext, SessionEvent, SessionEventMap, SessionEventType, SessionHeader, SurfaceIntent, SurfaceEventType } from './types.ts';
+import type { CreateSessionOptions, EpochHeader, PrepareSessionOptions, RequestContext, SessionEvent, SessionEventMap, SessionEventType, SessionHeader, SessionId, SurfaceIntent, SurfaceEventType } from './types.ts';
 import type { SessionSurface } from './surface.ts';
 export * from './types.ts';
 export { SessionPreparation } from './preparation.ts';
 export type { SessionPreparationOptions } from './preparation.ts';
 export type { AssistantMessage, ToolResultMessage, UserMessage } from '@deepseek-ai/dsh-llm';
-export { isJsonValue, snapshotJsonValue } from './json.ts';
-export type { JsonValue } from './json.ts';
 export { interruptedTurnClosers, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from './repair.ts';
 export { decodeStorageRecord, packChunkRuns } from './chunk-rows.ts';
 export type { ChunkRow, StorageRecord } from './chunk-rows.ts';
@@ -201,7 +198,7 @@ export declare class Session {
      *   Map/Set/Date/class instance), or when the candidate violates the
      *   canonical surface contract (marker shape and eligibility, unique
      *   earlier source-event references, positional replacement validity, and complete
-     *   shadowed-node coverage). One recursive pass reads, validates, and
+     *   shadowed-node coverage). One iterative pass reads, validates, and
      *   copies each nested value once, so a stateful getter cannot supply one value
      *   to validation and another to storage. The event log is the durable source
      *   of truth, so a bad event fails at the append site rather than later during
@@ -414,5 +411,6 @@ export declare class SessionStore extends Service {
     private _forkSeed;
     private _resolveForkSource;
 }
+export { decodeSeqRanges, encodeSeqRanges } from './seq-ranges.ts';
 export default SessionStore;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -7,15 +7,14 @@
  */
 import { Service } from '@deepseek-ai/cordis';
 import { isAbsolute } from 'node:path';
-import { deepFreeze } from '@deepseek-ai/dsh-llm';
+import { brandString } from '@deepseek-ai/dsh-brand';
+import { deepFreeze, snapshotJsonValue } from '@deepseek-ai/dsh-util-values';
 import { scopeOf, scopeTarget } from '@deepseek-ai/dsh-scope';
-import { SESSION_FORMAT_VERSION, SessionId } from "./types.js";
-import { snapshotJsonValue } from "./json.js";
+import { SESSION_FORMAT_VERSION } from "./types.js";
 import { deriveEventMessage, SurfaceManager } from "./surface.js";
 import { foldRequestHeader } from "./request-header.js";
 export * from "./types.js";
 export { SessionPreparation } from "./preparation.js";
-export { isJsonValue, snapshotJsonValue } from "./json.js";
 export { interruptedTurnClosers, TOOL_NOT_STARTED, TOOL_OUTCOME_UNKNOWN } from "./repair.js";
 export { decodeStorageRecord, packChunkRuns } from "./chunk-rows.js";
 export { deriveEventMessage, foldSurface, isAppendSurfaceEvent, isReplacementSurfaceEvent, isSurfaceEvent, isSurfaceEligibleType } from "./surface.js";
@@ -473,7 +472,7 @@ export class Session {
      *   Map/Set/Date/class instance), or when the candidate violates the
      *   canonical surface contract (marker shape and eligibility, unique
      *   earlier source-event references, positional replacement validity, and complete
-     *   shadowed-node coverage). One recursive pass reads, validates, and
+     *   shadowed-node coverage). One iterative pass reads, validates, and
      *   copies each nested value once, so a stateful getter cannot supply one value
      *   to validation and another to storage. The event log is the durable source
      *   of truth, so a bad event fails at the append site rather than later during
@@ -716,11 +715,11 @@ export class SessionStore extends Service {
         let sessionId;
         if (id === undefined) {
             do
-                sessionId = SessionId(`session-${++this.counter}`);
+                sessionId = brandString(`session-${++this.counter}`);
             while (this.store.has(sessionId));
         }
         else {
-            sessionId = SessionId(id);
+            sessionId = brandString(id);
         }
         if (this.store.has(sessionId))
             throw new Error(`session "${sessionId}" already exists`);
@@ -995,5 +994,6 @@ export class SessionStore extends Service {
         return source;
     }
 }
+export { decodeSeqRanges, encodeSeqRanges } from "./seq-ranges.js";
 export default SessionStore;
 //# sourceMappingURL=index.js.map

package/lib/types/invariant.js

@@ -4,7 +4,7 @@
  *
  * @module @deepseek-ai/dsh-session/invariant
  */
-import { assertNever } from '@deepseek-ai/dsh-llm';
+import { assertNever } from '@deepseek-ai/dsh-util-values';
 import { TOOL_NOT_STARTED } from "./repair.js";
 const PACKAGE_NAME = '@deepseek-ai/dsh-session';
 /** Cordis companion plugin name. */
@@ -108,7 +108,6 @@ function validateEvent(trace, event, fail) {
         case 'session/end-seed':
             // Unconstrained: an unbalanced seed legally puts it inside an open turn.
             break;
-        case 'todo/write':
         case 'request/header':
         case 'request/context': {
             if (trace.openTurn === null) {