@deepseek-ai/dsh-session 0.2.2-alpha.3 → 0.2.2-rc.2

package/README.i18n.yaml

@@ -27,11 +27,11 @@
   en: c4bf3103b9762b6c
   zh: 369c734bb20de2ea
 /deepseek-ai-dsh-session/use-this-package/write-experimental-plugin-records:
-  en: 6c758f98535b734c
-  zh: ac54342937477f37
+  en: 002b8240caa0c57c
+  zh: e0954dd62913a944
 /deepseek-ai-dsh-session/use-this-package/fork-a-session:
-  en: 1c40d17a786059d3
-  zh: 81320ce118977c65
+  en: 4fcc9eb5c0278b51
+  zh: 2a26e81ebffbd9a6
 /deepseek-ai-dsh-session/use-this-package/flush-durable-state:
   en: 70a7673145c851ad
   zh: 0dd1667d9518993d

package/README.md

@@ -71,7 +71,7 @@ Session log positions use two numeric types. `SessionSeq` identifies an existing
 
 `appendPluginRecord(session, type, data)` appends one plugin record for a package under `packages/experimental/`; the `verify-plugin-record-callers` check rejects any other production caller in this repository. Plugins outside this repository must not call it either, although no repository check can inspect them.
 
-Declare each record in `PluginRecordMap` through `@deepseek-ai/dsh-session/types`, with a description and an explicit payload type annotation in the owning experimental package's `src/`. Names use `plugin:<owner>/<record>`, where `owner` is the suffix of the package name `@deepseek-ai/dsh-experimental-<owner>`; for example, `plugin:pi-extensions/entry`. TypeScript checks each name and payload against its declaration; the writer's runtime JSON snapshot rejects values that cannot be preserved losslessly. Put extension-defined or other dynamic names inside the payload of a declared record.
+Declare each record in `PluginRecordMap` through `@deepseek-ai/dsh-session/types`, with a description and an explicit payload type annotation in the owning experimental package's `src/`. Names use `plugin:<owner>/<record>`, where `owner` is the package name after removing the legacy `@deepseek-ai/dsh-experimental-` prefix when present, otherwise `@deepseek-ai/dsh-`; for example, `plugin:pi-extensions/entry`. TypeScript checks each name and payload against its declaration; the writer's runtime JSON snapshot rejects values that cannot be preserved losslessly. Put extension-defined or other dynamic names inside the payload of a declared record.
 
 The [experimental persistence catalog](../../../docs/experimental-persistence-catalog.md) lists current plugin-record declarations with their owners, descriptions, payload type annotations, and source files. These declarations remain separate from `SessionEventMap`, expanded persistence schemas, released type history, and `KNOWN_SESSION_EVENT_TYPES`. Records carry `ignorable: true`: a build that does not recognize one retains and skips it on read. Records never enter the model-visible surface. Resume and fork carry them with the rest of the log; Session format migration keeps them on a best-effort basis.
 
@@ -83,6 +83,8 @@ The [experimental persistence catalog](../../../docs/experimental-persistence-ca
 
 The logical `SessionHeader.isSeeded` field reports whether fork history exists without exposing a positional integer. `Session.inheritedEventCount` retains the exact checked `SessionLogOffset`; `ownEvents()` returns events at and after that cut, and `isOwnSeq(seq)` accepts only an existing child-owned position. A low-level seeded constructor must supply an explicit `seed` and `inheritedEventCount` because the constructor seed can contain child-owned setup events after the inherited prefix.
 
+`session.append(type, data, ...opts)` appends one event and returns that event. `session.append(inputs)` accepts a readonly array of positional `[type, data, ...opts]` tuples (`SessionEventInput`) and returns the committed events in input order; an empty array appends nothing. Array admission validates every candidate and synchronous dispatch before changing the log or message surface, so observers read the complete committed group. Persistence listeners retain their own durability rules; array admission alone does not guarantee crash-atomic storage.
+
 ### Flush durable state
 
 `ctx.sessions.flush(session)` dispatches the awaited durability checkpoint: every persistence listener flushes and the call settles after all of them. A producer that needs an immediate durability barrier awaits it instead of assuming the write-behind drained.

package/README.zh.md

@@ -71,7 +71,7 @@ session.deriveMessages()         // the derived model history
 
 `appendPluginRecord(session, type, data)` 为 `packages/experimental/` 下的包追加一条插件记录；`verify-plugin-record-callers` 检查拒绝本仓库中任何其他生产调用方。本仓库之外的插件同样不得调用它，尽管仓库检查无法检查它们。
 
-在所属实验性包的 `src/` 中，通过 `@deepseek-ai/dsh-session/types` 的 `PluginRecordMap` 为每条记录声明描述与显式 payload 类型注解。名称使用 `plugin:<owner>/<record>`，其中 `owner` 是包名 `@deepseek-ai/dsh-experimental-<owner>` 的后缀；例如 `plugin:pi-extensions/entry`。TypeScript 按声明检查每个名称与 payload；写入方运行时的 JSON 快照拒绝无法无损保留的值。扩展自定义名称或其他动态名称放在已声明记录的 payload 中。
+在所属实验性包的 `src/` 中，通过 `@deepseek-ai/dsh-session/types` 的 `PluginRecordMap` 为每条记录声明描述与显式 payload 类型注解。名称使用 `plugin:<owner>/<record>`，其中 `owner` 是包名去掉前缀后的部分：带旧前缀时去掉 `@deepseek-ai/dsh-experimental-`，否则去掉 `@deepseek-ai/dsh-`；例如 `plugin:pi-extensions/entry`。TypeScript 按声明检查每个名称与 payload；写入方运行时的 JSON 快照拒绝无法无损保留的值。扩展自定义名称或其他动态名称放在已声明记录的 payload 中。
 
 [实验性持久化目录](../../../docs/experimental-persistence-catalog.zh.md)列出当前插件记录声明及其所属包、描述、payload 类型注解与源文件。这些声明与 `SessionEventMap`、展开的持久化 schema、已发布类型历史及 `KNOWN_SESSION_EVENT_TYPES` 分开。记录带有 `ignorable: true`：不认识某条记录的构建在读取时保留并跳过它。记录从不进入模型可见的 surface。resume 与 fork 随日志其余部分一起携带它们；Session 格式迁移以尽力而为的方式保留它们。
 
@@ -83,6 +83,8 @@ session.deriveMessages()         // the derived model history
 
 逻辑 `SessionHeader.isSeeded` 字段报告是否存在 fork 历史，而不公开位置整数。`Session.inheritedEventCount` 保留经过校验的精确 `SessionLogOffset`；`ownEvents()` 返回从该切点开始的事件，`isOwnSeq(seq)` 只接受已存在且由子会话拥有的位置。底层带 seed 构造必须显式提供 `seed` 与 `inheritedEventCount`，因为构造 seed 可以在继承前缀之后包含子会话自有的设置事件。
 
+`session.append(type, data, ...opts)` 追加一个事件并返回该事件。`session.append(inputs)` 接受位置参数元组 `[type, data, ...opts]`（`SessionEventInput`）的只读数组，并按输入顺序返回已提交事件；空数组不追加任何内容。数组准入会在改变日志或surface前验证所有候选和同步分发，因此观察者读取完整的已提交组。持久化监听器保留各自的持久性规则；仅数组准入不保证进程崩溃时整组存储的原子性。
+
 ### 刷新持久状态
 
 `ctx.sessions.flush(session)` 分发需等待完成的持久性检查点：每个持久化监听器都会刷新，调用在所有监听器结算后完成。需要立即持久性屏障的生产方应等待它，而不是假定延后写入已经排空。

package/lib/index.js

@@ -123,6 +123,7 @@ const KNOWN_SESSION_EVENT_TYPES = new Set([
 	"team/member",
 	"team/message/delivered",
 	"team/message/queued",
+	"team/mode",
 	"team/task",
 	"todo/write",
 	"tool-workflow/agent-end",
@@ -331,12 +332,12 @@ function assertSourceEventReferences(event, shadowedSeqs) {
 	if (missing.length > 0) throw new Error(`surface replace: sourceEventSeqs must include every shadowed surface node; missing ${missing.join(", ")}`);
 }
 /** Resolve tool additions against their immutable historical request header. */
-function assertDeveloperHeader(event, events, baseSeq) {
+function assertDeveloperHeader(event, read) {
 	if (event.type !== "developer/message") return;
 	validateSessionEventData(event, `developer/message at seq ${event.seq}`);
 	if (event.data.headerSeq === void 0) return;
 	const headerSeq = event.data.headerSeq;
-	const headerEvent = events[headerSeq - baseSeq];
+	const headerEvent = read(headerSeq);
 	if (headerSeq >= event.seq || headerEvent?.type !== "request/header") throw new Error("developer/message headerSeq must reference an earlier request/header");
 	for (const block of event.data.message.content) {
 		if (block.type !== "tool-addition") continue;
@@ -391,11 +392,11 @@ function isDeepEqualJson(a, b) {
 	return aKeys.every((key) => Object.hasOwn(b, key) && isDeepEqualJson(a[key], bRecord[key]));
 }
 /** Restrict a tool-result replacement to one current result's content. */
-function assertToolResultRewrite(event, shadowedSeqs, events, baseSeq) {
+function assertToolResultRewrite(event, shadowedSeqs, read) {
 	if (event.type !== "tool/result") return;
 	if (shadowedSeqs.length !== 1) throw new Error("tool/result surface replacement must rewrite exactly one current node");
 	for (const originalSeq of shadowedSeqs) {
-		const original = events[originalSeq - baseSeq];
+		const original = read(originalSeq);
 		if (original?.type !== "tool/result") throw new Error("tool/result surface replacement must target a current tool/result");
 		const originalRest = { ...original.data };
 		const replacementRest = { ...event.data };
@@ -416,27 +417,36 @@ function assertToolResultRewrite(event, shadowedSeqs, events, baseSeq) {
 * exactly that node; later system nodes carry no protection and a compaction
 * range may shadow them.
 */
-function assertSystemHeadRewrite(event, state, startIdx, shadowedSeqs, events, baseSeq) {
+function assertSystemHeadRewrite(event, state, startIdx, shadowedSeqs, read) {
 	if (startIdx !== 0) return;
-	if (events[state.nodes[0] - baseSeq]?.type !== "system/message") return;
+	if (read(state.nodes[0])?.type !== "system/message") return;
 	if (event.type !== "system/message" || shadowedSeqs.length !== 1) throw new Error("surface replace: node 0 holds the system prompt and may be rewritten only by a system/message over exactly that node");
 }
 /** Validate one event at its replay boundary and prepare its atomic fold transition. */
-function planSurfaceEvent(state, event, expectedSeq, events, baseSeq, projections) {
+function planSurfaceEvent(state, event, expectedSeq, events, baseSeq, projections, candidates) {
 	if (event.seq !== expectedSeq) throw new Error(`session event seq ${event.seq} is not contiguous; expected ${expectedSeq}`);
 	const surfaceOp = validateSurfaceMetadata(event);
-	assertDeveloperHeader(event, events, baseSeq);
-	const projection = projections.find((item) => item.type === event.type);
-	if (projection !== void 0) return {
-		kind: "project",
-		projection,
-		messages: projection.project(event, {
-			nodes: state.nodes,
-			events,
-			baseSeq,
-			messages: state.projectedMessages
-		})
+	const read = (seq) => {
+		const index = seq - baseSeq;
+		return index < events.length ? events[index] : candidates?.[index - events.length];
 	};
+	assertDeveloperHeader(event, read);
+	const projection = projections.find((item) => item.type === event.type);
+	if (projection !== void 0) {
+		let projectionEvents;
+		return {
+			kind: "project",
+			projection,
+			messages: projection.project(event, {
+				nodes: state.nodes,
+				get events() {
+					return candidates === void 0 ? events : projectionEvents ??= [...events, ...candidates];
+				},
+				baseSeq,
+				messages: state.projectedMessages
+			})
+		};
+	}
 	if (MESSAGE_PROJECTION_EVENT_TYPES.has(event.type)) throw new Error(`session event "${event.type}" requires a message projection; load its owning plugin or supply its projection definition`);
 	if (surfaceOp === void 0) return;
 	if (surfaceOp === "append") return {
@@ -445,8 +455,8 @@ function planSurfaceEvent(state, event, expectedSeq, events, baseSeq, projection
 	};
 	const range = replacementRange(state, surfaceOp);
 	assertSourceEventReferences(event, range.shadowedSeqs);
-	assertToolResultRewrite(event, range.shadowedSeqs, events, baseSeq);
-	assertSystemHeadRewrite(event, state, range.startIdx, range.shadowedSeqs, events, baseSeq);
+	assertToolResultRewrite(event, range.shadowedSeqs, read);
+	assertSystemHeadRewrite(event, state, range.startIdx, range.shadowedSeqs, read);
 	return {
 		kind: "replace",
 		seq: event.seq,
@@ -535,6 +545,40 @@ var SurfaceManager = class {
 			plan: planSurfaceEvent(this._state, event, expectedSeq, this.log, this.baseSeq, this.projections)
 		};
 	}
+	/**
+	* Validate consecutive candidates against an isolated surface fold.
+	* @param events - candidates immediately following the committed log.
+	* @returns a callback adopting the validated fold after all candidates enter the log.
+	*/
+	prepareBatch(events) {
+		this._assertProjections();
+		if (this._lastProcessedSeq < this.baseSeq + this.log.length - 1) this._processDelta();
+		const lastProcessedSeq = SessionSeq(this.baseSeq + this.log.length + events.length - 1);
+		if (events.every((event) => (event.surfaceOp === void 0 || event.surfaceOp === "append") && !this.projections.some((projection) => projection.type === event.type))) {
+			const plans = events.map((event, index) => planSurfaceEvent(this._state, event, SessionSeq(this.baseSeq + this.log.length + index), this.log, this.baseSeq, this.projections, events));
+			return () => {
+				for (const plan of plans) applySurfacePlan(this._state, plan);
+				this._lastProcessedSeq = lastProcessedSeq;
+				this._pendingPlan = void 0;
+			};
+		}
+		const state = {
+			...this._state,
+			nodes: [...this._state.nodes],
+			projectedMessages: new Map(this._state.projectedMessages),
+			projections: new Set(this._state.projections)
+		};
+		const plans = events.map((event, index) => {
+			const plan = planSurfaceEvent(state, event, SessionSeq(this.baseSeq + this.log.length + index), this.log, this.baseSeq, this.projections, events);
+			applySurfacePlan(state, plan);
+			return plan;
+		});
+		return () => {
+			for (const plan of plans) applySurfacePlan(this._state, plan);
+			this._lastProcessedSeq = lastProcessedSeq;
+			this._pendingPlan = void 0;
+		};
+	}
 	/** Monotonic count of folded positional replacements. */
 	get replaceGeneration() {
 		this._assertProjections();
@@ -1315,6 +1359,36 @@ function pluginRecordOf(event) {
 		data: event.data
 	};
 }
+/** Copy live append inputs before sequence assignment. */
+function snapshotAppend(type, data, opts, subject) {
+	const surfaceOp = opts?.surfaceOp;
+	const sourceEventSeqs = opts?.sourceEventSeqs;
+	const dataSnapshot = snapshotJsonValue(data);
+	if (dataSnapshot === void 0) throw new Error(`${subject} carries non-JSON-serializable data`);
+	const surface = snapshotJsonValue({
+		...sourceEventSeqs === void 0 ? {} : { sourceEventSeqs },
+		...surfaceOp === void 0 ? {} : { surfaceOp }
+	});
+	if (surface === void 0) throw new Error(`${subject} carries non-JSON-serializable surface metadata`);
+	return {
+		type,
+		data: dataSnapshot,
+		surface
+	};
+}
+/** Construct and validate one live event from detached inputs. */
+function createAppendEvent(snapshot, seq) {
+	const { type, data, surface } = snapshot;
+	const event = deepFreeze({
+		type,
+		seq,
+		time: Date.now(),
+		data,
+		...surface
+	});
+	validateSessionEventData(event, `session event "${type}" at seq ${seq}`);
+	return event;
+}
 /**
 * An event-sourced session: an append-only log of {@link SessionEvent}s.
 *
@@ -1325,6 +1399,7 @@ function pluginRecordOf(event) {
 */
 var Session = class Session {
 	log = [];
+	batchPublication;
 	/** Single incremental owner of surface acceptance and projection state. */
 	surfaceManager;
 	/** The ordered surface over this session's event log. */
@@ -1479,71 +1554,68 @@ var Session = class Session {
 	get seq() {
 		return SessionLogOffset(this.log.length);
 	}
-	/**
-	* Append one typed event to the log and synchronously notify observers via
-	* the store-owned, module-private publication hooks. The hot path never blocks
-	* on I/O — persistence plugins buffer asynchronously. Once the event enters
-	* the log, the append is committed: observer failures are logged and
-	* contained per listener, so they do not change the return value or prevent
-	* later listeners from observing the same accepted event.
-	* Independent Sessions append without notifying store observers. Once a store
-	* prepares or enters the instance, writes require a completed creation
-	* announcement and remain disabled after removal.
-	*
-	* @param type - The event type (key of {@link SessionEventMap}).
-	* @param data - The event payload; must be JSON-serializable.
-	* @param opts - Surface metadata: `surfaceOp` controls how the event enters
-	*   the ordered surface; `sourceEventSeqs` lists the seq numbers of earlier
-	*   events this one derives from. REQUIRED for
-	*   {@link SurfaceEventType} events (every message-producing event must
-	*   declare how it joins the surface, the sole source of derived model
-	*   history) and
-	*   rejected by the compiler for non-surface types like `turn/start` or
-	*   `assistant/attempt`. Assistant messages embed their exact provider
-	*   stream and cannot cite top-level source events.
-	* @returns the logged event — its assigned `seq`/`time` plus the SNAPSHOT of
-	*   `data` that entered the log, so reading `event.data` back sees the logged
-	*   value, never the caller's still-mutable input.
-	* @throws if a store-owned Session is unentered or its creation announcement
-	*   has not completed, or if `data` or surface
-	*   metadata is not losslessly JSON-serializable
-	*   (BigInt, function, symbol, undefined, negative zero, non-finite number,
-	*   circular reference, sparse array, or an exotic object such as
-	*   Map/Set/Date/class instance), or when the candidate violates the
-	*   request-header empty-field or tool-error consistency rules, or the
-	*   canonical surface contract (marker shape and eligibility, unique
-	*   earlier source-event references, positional replacement validity, and complete
-	*   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
-	*   a backend flush. A synchronous internal dispatch validation failure or an
-	*   append reentered while this acceptance/publication boundary is open also
-	*   rejects before the log changes.
-	*/
+	/** Current event while synchronously notifying a batch's observers. */
+	get currentBatchPublication() {
+		return this.batchPublication;
+	}
 	append(type, data, ...opts) {
+		if (typeof type !== "string") return this.#appendEvents(type);
 		this.publicationEntry();
-		const surfaceOpts = opts[0];
-		const surfaceMetadata = {
-			...surfaceOpts?.sourceEventSeqs === void 0 ? {} : { sourceEventSeqs: surfaceOpts.sourceEventSeqs },
-			...surfaceOpts?.surfaceOp === void 0 ? {} : { surfaceOp: surfaceOpts.surfaceOp }
-		};
-		const dataSnapshot = snapshotJsonValue(data);
-		if (dataSnapshot === void 0) throw new Error(`session event "${type}" carries non-JSON-serializable data`);
-		const surfaceMetadataSnapshot = snapshotJsonValue(surfaceMetadata);
-		if (surfaceMetadataSnapshot === void 0) throw new Error(`session event "${type}" carries non-JSON-serializable surface metadata`);
+		const snapshot = snapshotAppend(type, data, opts[0], `session event "${type}"`);
 		const entry = this.publicationEntry();
-		const event = deepFreeze({
-			type,
-			seq: SessionSeq(this.log.length),
-			time: Date.now(),
-			data: dataSnapshot,
-			...surfaceMetadataSnapshot
-		});
-		validateSessionEventData(event, `session event "${type}" at seq ${event.seq}`);
+		const event = createAppendEvent(snapshot, SessionSeq(this.log.length));
 		this.commit(event, entry);
 		return event;
 	}
+	/**
+	* Validate and publish consecutive events together. Observers see the complete log.
+	* @param inputs - event payloads and surface intents in commit order.
+	* @returns immutable committed events in the same order.
+	* @throws before changing the log if any candidate or synchronous dispatch validation fails.
+	*/
+	#appendEvents(inputs) {
+		this.publicationEntry();
+		if (inputs.length === 0) return [];
+		const snapshots = Array.from({ length: inputs.length }, (_, index) => {
+			const input = inputs.at(index);
+			if (input === void 0) throw new Error(`session batch has an empty member at index ${index}`);
+			const [type, data, surfaceOpts] = input;
+			return snapshotAppend(type, data, surfaceOpts, `session batch member ${index} ("${type}")`);
+		});
+		const entry = this.publicationEntry();
+		const startSeq = this.log.length;
+		const events = snapshots.map((snapshot, index) => createAppendEvent(snapshot, SessionSeq(startSeq + index)));
+		const acceptSurface = this.surfaceManager.prepareBatch(events);
+		if (entry !== void 0) entry.appending = true;
+		try {
+			const publications = entry === void 0 ? [] : events.map((event) => {
+				const args = [this, event];
+				return {
+					event,
+					args,
+					callbacks: collectSessionCallbacks(entry.emitCtx, [
+						entry.carrier,
+						"session/event",
+						...args
+					])
+				};
+			});
+			for (const event of events) this.log.push(event);
+			this.eventsSnapshot = void 0;
+			acceptSurface();
+			if (entry !== void 0) for (const { event, args, callbacks } of publications) {
+				this.batchPublication = event;
+				invokeContainedSessionObservers(entry.emitCtx, "session/event", entry.id, args, callbacks);
+			}
+		} finally {
+			this.batchPublication = void 0;
+			if (entry !== void 0) {
+				entry.appending = false;
+				if (entry.detachRequested) entry.detach();
+			}
+		}
+		return events;
+	}
 	static {
 		commitPluginRecord = (session, type, data) => session.#appendRecord(type, data);
 	}

package/lib/types/fork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork.d.ts","sourceRoot":"","sources":["../../src/fork.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,IAAI,cAAc,EAAE,MAAM,YAAY,CAAA;AAE5E;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,EAAE,QAAQ,EAAE,cAAc,GAAG,YAAY,EAAE,CASvG"}

package/lib/types/fork.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fork.js","sourceRoot":"","sources":["../../src/fork.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAGvC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,MAA+B,EAAE,QAAwB;IACrF,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAA;IAC5C,MAAM,CAAC,IAAI,CAAC;QACV,IAAI,EAAE,kBAAkB,EAAE,GAAG,EAAE,UAAU,CAAC,QAAQ,GAAG,CAAC,CAAC;QACvD,6GAA6G;QAC7G,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAE,CAAC,IAAI;QAC5B,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE;KAC1B,CAAC,CAAA;IACF,OAAO,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAA;AACnE,CAAC"}

package/lib/types/index.d.ts

@@ -10,7 +10,7 @@ import type { Scoped } from '@deepseek-ai/dsh-scope';
 import type { Message } from '@deepseek-ai/dsh-llm';
 import { SessionLogOffset, SessionSeq } from './types.ts';
 import type { TypertLookup } from '@deepseek-ai/dsh-typert-protocol';
-import type { CreateSessionOptions, EpochHeader, PluginRecord, PluginRecordMap, PluginRecordType, PrepareSessionOptions, RequestContext, SessionEvent, SessionEventMap, SessionEventType, SessionHeader, SessionId, SessionSeedEventState, SurfaceIntent, SurfaceEventType } from './types.ts';
+import type { CreateSessionOptions, EpochHeader, PluginRecord, PluginRecordMap, PluginRecordType, PrepareSessionOptions, RequestContext, SessionEvent, SessionEventInput, SessionEventMap, SessionEventType, SessionHeader, SessionId, SessionSeedEventState, SurfaceIntent, SurfaceEventType } from './types.ts';
 import type { SessionSurface, SessionMessageProjection } from './surface.ts';
 import type { ToolHistory } from '@deepseek-ai/dsh-llm';
 export { buildForkSeed } from './fork.ts';
@@ -54,6 +54,9 @@ declare module '@deepseek-ai/cordis' {
          * Post-commit, fire-and-forget append feed. The listener snapshot resolves
          * before the log push, but callbacks run after it; observer failures are
          * logged and contained without making the committed append fail.
+         * Array append commits every member before publishing them in order;
+         * `session.seq` and `session.surface` already include the complete batch.
+         * `session.currentBatchPublication` identifies the member being delivered.
          * Scope-filtered dispatch (`@deepseek-ai/dsh-scope`): agent-scoped listeners
          * receive only events from sessions entered through that agent's context.
          * @param session - the session whose log grew.
@@ -139,6 +142,7 @@ export declare function pluginRecordOf(event: SessionEvent): PluginRecord | unde
 export declare class Session {
     #private;
     private log;
+    private batchPublication;
     /** Single incremental owner of surface acceptance and projection state. */
     private readonly surfaceManager;
     /** The ordered surface over this session's event log. */
@@ -241,6 +245,18 @@ export declare class Session {
     isOwnSeq(seq: SessionSeq): boolean;
     /** The next event's sequence number — always the log length (the `seq = log.length` contiguity contract). */
     get seq(): SessionLogOffset;
+    /** Current event while synchronously notifying a batch's observers. */
+    get currentBatchPublication(): SessionEvent | undefined;
+    /**
+     * Append consecutive events together after validating every candidate and dispatch.
+     * Observers read the complete committed log and final message surface.
+     * Listener registration changes during publication take effect on the next append.
+     * Persistence listeners retain their own durability rules.
+     * @param inputs - event payloads and surface intents in commit order. An empty array records no events.
+     * @returns immutable committed events in the same order.
+     * @throws if the Session cannot accept writes, including an empty append, or any candidate or synchronous dispatch validation fails.
+     */
+    append(inputs: readonly SessionEventInput[]): readonly SessionEvent[];
     /**
      * Append one typed event to the log and synchronously notify observers via
      * the store-owned, module-private publication hooks. The hot path never blocks

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/lib/types/index.js

@@ -397,6 +397,28 @@ export function pluginRecordOf(event) {
         return undefined;
     return { type, seq: event.seq, time: event.time, data: event.data };
 }
+/** Copy live append inputs before sequence assignment. */
+function snapshotAppend(type, data, opts, subject) {
+    const surfaceOp = opts?.surfaceOp;
+    const sourceEventSeqs = opts?.sourceEventSeqs;
+    const dataSnapshot = snapshotJsonValue(data);
+    if (dataSnapshot === undefined)
+        throw new Error(`${subject} carries non-JSON-serializable data`);
+    const surface = snapshotJsonValue({
+        ...sourceEventSeqs === undefined ? {} : { sourceEventSeqs },
+        ...surfaceOp === undefined ? {} : { surfaceOp },
+    });
+    if (surface === undefined)
+        throw new Error(`${subject} carries non-JSON-serializable surface metadata`);
+    return { type, data: dataSnapshot, surface };
+}
+/** Construct and validate one live event from detached inputs. */
+function createAppendEvent(snapshot, seq) {
+    const { type, data, surface } = snapshot;
+    const event = deepFreeze({ type, seq, time: Date.now(), data, ...surface });
+    validateSessionEventData(event, `session event "${type}" at seq ${seq}`);
+    return event;
+}
 /**
  * An event-sourced session: an append-only log of {@link SessionEvent}s.
  *
@@ -407,6 +429,7 @@ export function pluginRecordOf(event) {
  */
 export class Session {
     log = [];
+    batchPublication;
     /** Single incremental owner of surface acceptance and projection state. */
     surfaceManager;
     /** The ordered surface over this session's event log. */
@@ -600,76 +623,72 @@ export class Session {
     get seq() {
         return SessionLogOffset(this.log.length);
     }
-    /**
-     * Append one typed event to the log and synchronously notify observers via
-     * the store-owned, module-private publication hooks. The hot path never blocks
-     * on I/O — persistence plugins buffer asynchronously. Once the event enters
-     * the log, the append is committed: observer failures are logged and
-     * contained per listener, so they do not change the return value or prevent
-     * later listeners from observing the same accepted event.
-     * Independent Sessions append without notifying store observers. Once a store
-     * prepares or enters the instance, writes require a completed creation
-     * announcement and remain disabled after removal.
-     *
-     * @param type - The event type (key of {@link SessionEventMap}).
-     * @param data - The event payload; must be JSON-serializable.
-     * @param opts - Surface metadata: `surfaceOp` controls how the event enters
-     *   the ordered surface; `sourceEventSeqs` lists the seq numbers of earlier
-     *   events this one derives from. REQUIRED for
-     *   {@link SurfaceEventType} events (every message-producing event must
-     *   declare how it joins the surface, the sole source of derived model
-     *   history) and
-     *   rejected by the compiler for non-surface types like `turn/start` or
-     *   `assistant/attempt`. Assistant messages embed their exact provider
-     *   stream and cannot cite top-level source events.
-     * @returns the logged event — its assigned `seq`/`time` plus the SNAPSHOT of
-     *   `data` that entered the log, so reading `event.data` back sees the logged
-     *   value, never the caller's still-mutable input.
-     * @throws if a store-owned Session is unentered or its creation announcement
-     *   has not completed, or if `data` or surface
-     *   metadata is not losslessly JSON-serializable
-     *   (BigInt, function, symbol, undefined, negative zero, non-finite number,
-     *   circular reference, sparse array, or an exotic object such as
-     *   Map/Set/Date/class instance), or when the candidate violates the
-     *   request-header empty-field or tool-error consistency rules, or the
-     *   canonical surface contract (marker shape and eligibility, unique
-     *   earlier source-event references, positional replacement validity, and complete
-     *   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
-     *   a backend flush. A synchronous internal dispatch validation failure or an
-     *   append reentered while this acceptance/publication boundary is open also
-     *   rejects before the log changes.
-     */
+    /** Current event while synchronously notifying a batch's observers. */
+    get currentBatchPublication() {
+        return this.batchPublication;
+    }
     append(type, data, ...opts) {
+        if (typeof type !== 'string')
+            return this.#appendEvents(type);
         this.publicationEntry();
-        const surfaceOpts = opts[0];
-        const surfaceMetadata = {
-            ...surfaceOpts?.sourceEventSeqs === undefined ? {} : { sourceEventSeqs: surfaceOpts.sourceEventSeqs },
-            ...surfaceOpts?.surfaceOp === undefined ? {} : { surfaceOp: surfaceOpts.surfaceOp },
-        };
-        const dataSnapshot = snapshotJsonValue(data);
-        if (dataSnapshot === undefined) {
-            throw new Error(`session event "${type}" carries non-JSON-serializable data`);
-        }
-        const surfaceMetadataSnapshot = snapshotJsonValue(surfaceMetadata);
-        if (surfaceMetadataSnapshot === undefined) {
-            throw new Error(`session event "${type}" carries non-JSON-serializable surface metadata`);
-        }
+        const snapshot = snapshotAppend(type, data, opts[0], `session event "${type}"`);
         // Payload getters can detach the Session while the snapshots are read.
         const entry = this.publicationEntry();
-        const event = deepFreeze({
-            type,
-            seq: SessionSeq(this.log.length),
-            time: Date.now(),
-            data: dataSnapshot,
-            ...surfaceMetadataSnapshot,
-        });
-        validateSessionEventData(event, `session event "${type}" at seq ${event.seq}`);
+        const event = createAppendEvent(snapshot, SessionSeq(this.log.length));
         this.commit(event, entry);
         return event;
     }
+    /**
+     * Validate and publish consecutive events together. Observers see the complete log.
+     * @param inputs - event payloads and surface intents in commit order.
+     * @returns immutable committed events in the same order.
+     * @throws before changing the log if any candidate or synchronous dispatch validation fails.
+     */
+    #appendEvents(inputs) {
+        this.publicationEntry();
+        if (inputs.length === 0)
+            return [];
+        const snapshots = Array.from({ length: inputs.length }, (_, index) => {
+            const input = inputs.at(index);
+            if (input === undefined)
+                throw new Error(`session batch has an empty member at index ${index}`);
+            const [type, data, surfaceOpts] = input;
+            return snapshotAppend(type, data, surfaceOpts, `session batch member ${index} ("${type}")`);
+        });
+        // Payload getters may append to or detach the Session.
+        const entry = this.publicationEntry();
+        const startSeq = this.log.length;
+        const events = snapshots.map((snapshot, index) => createAppendEvent(snapshot, SessionSeq(startSeq + index)));
+        const acceptSurface = this.surfaceManager.prepareBatch(events);
+        if (entry !== undefined)
+            entry.appending = true;
+        try {
+            const publications = entry === undefined ? [] : events.map((event) => {
+                const args = [this, event];
+                const callbacks = collectSessionCallbacks(entry.emitCtx, [entry.carrier, 'session/event', ...args]);
+                return { event, args, callbacks };
+            });
+            for (const event of events)
+                this.log.push(event);
+            this.eventsSnapshot = undefined;
+            acceptSurface();
+            if (entry !== undefined) {
+                for (const { event, args, callbacks } of publications) {
+                    this.batchPublication = event;
+                    invokeContainedSessionObservers(entry.emitCtx, 'session/event', entry.id, args, callbacks);
+                }
+            }
+        }
+        finally {
+            this.batchPublication = undefined;
+            if (entry !== undefined) {
+                entry.appending = false;
+                if (entry.detachRequested)
+                    entry.detach();
+            }
+        }
+        return events;
+    }
     static {
         commitPluginRecord = (session, type, data) => session.#appendRecord(type, data);
     }