@artenx/dshb 0.1.21 → 0.1.23

package/lib/{session-sync-EdfwUON5.js → session-sync-C0uoizyB.js}

@@ -4,10 +4,10 @@ import "./core/workspace-instructions.js";
 import { i as deepFreeze, r as brandString } from "./lib-gdtU_WKT.js";
 import { SyncSessionJournalStore } from "./core/sync/session-journal.js";
 import { MAX_SYNC_TRANSFER_BYTES } from "./core/sync/protocol.js";
-import { tmpdir } from "node:os";
-import { constants, mkdirSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { chmodSync, closeSync, constants, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, normalize, posix, resolve } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import "@deepseek-ai/cordis";
 import { lstat, mkdir, open, realpath, unlink } from "node:fs/promises";
 //#region ../../node_modules/@deepseek-ai/dsh-session/lib/index.js
@@ -392,9 +392,105 @@ function assertContiguous(id, events, cursor) {
 	for (const [index, event] of events.entries()) if (event.seq !== cursor + index) throw new Error(`append seq mismatch for "${id}": expected ${cursor + index} at index ${index}, got ${event.seq}`);
 }
 //#endregion
+//#region src/core/sync/export-cache.ts
+const MAX_EXPORT_CACHE_FILE_BYTES = 8388608;
+function cacheHome(home) {
+	return home ?? process.env.DSH_HOME ?? join(homedir(), ".dsh");
+}
+function atomicWrite(file, content) {
+	const dir = dirname(file);
+	mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	const temporary = `${file}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+	let fd;
+	try {
+		fd = openSync(temporary, "wx", 384);
+		writeFileSync(fd, content, "utf8");
+		fsyncSync(fd);
+		closeSync(fd);
+		fd = void 0;
+		renameSync(temporary, file);
+		chmodSync(file, 384);
+	} catch (error) {
+		if (fd !== void 0) closeSync(fd);
+		try {
+			unlinkSync(temporary);
+		} catch {}
+		throw error;
+	}
+}
+function validRevision(value) {
+	return isRecord$1(value) && isNonNegativeSafeInteger(value.physicalTimeMs) && isNonNegativeSafeInteger(value.logicalCounter) && typeof value.writerInstanceId === "string" && !!value.writerInstanceId;
+}
+function validEntry(value) {
+	if (!isRecord$1(value) || typeof value.fingerprint !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.fingerprint) || !isRecord$1(value.metadata) || typeof value.metadata.contentDigest !== "string" || !validRevision(value.metadata.revision) || !isNonNegativeSafeInteger(value.eventCount) || typeof value.eventDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.eventDigest) || !isNonNegativeSafeInteger(value.inheritedEventCount)) return false;
+	return true;
+}
+var SyncSessionExportCacheStore = class {
+	filePath;
+	data;
+	dirty = false;
+	constructor(home) {
+		this.filePath = join(cacheHome(home), "dshb", "sync-export-cache.json");
+	}
+	get(key) {
+		return this.load().entries[key];
+	}
+	set(key, entry) {
+		if (!validEntry(entry)) return;
+		this.load().entries[key] = entry;
+		this.dirty = true;
+	}
+	delete(key) {
+		if (!(key in this.load().entries)) return;
+		delete this.load().entries[key];
+		this.dirty = true;
+	}
+	flush() {
+		if (!this.dirty || !this.data) return;
+		this.dirty = false;
+		try {
+			atomicWrite(this.filePath, `${JSON.stringify(this.data)}\n`);
+		} catch {
+			this.dirty = true;
+		}
+	}
+	entries() {
+		return Object.entries(this.load().entries);
+	}
+	load() {
+		if (this.data) return this.data;
+		let restored = {
+			version: 1,
+			entries: {}
+		};
+		try {
+			const raw = readFileSync(this.filePath, "utf8");
+			if (raw.length <= MAX_EXPORT_CACHE_FILE_BYTES) {
+				const parsed = JSON.parse(raw);
+				if (isRecord$1(parsed) && parsed.version === 1 && isRecord$1(parsed.entries)) {
+					const entries = {};
+					for (const [key, entry] of Object.entries(parsed.entries)) if (/^\[".+?",(null|".*?")\]$/.test(key) && validEntry(entry)) entries[key] = entry;
+					restored = {
+						version: 1,
+						entries
+					};
+				}
+			}
+		} catch {}
+		this.data = restored;
+		return restored;
+	}
+};
+//#endregion
 //#region src/core/sync/session-sync.ts
 const SESSION_READ_PAGE_SIZE = 256;
 const MAX_SYNC_SESSIONS = 1e4;
+const MAX_MANIFEST_PAYLOAD_CACHE_BYTES = 4194304;
+const MAX_MANIFEST_PAYLOAD_CACHE_COUNT = 8;
+const SESSION_EXPORT_CACHE_VERSION = 1;
 const SPILL_META_VERSION = 1;
 const SPILL_ARTIFACT_META_KEY = "@deepseek-ai/dsh-spill";
 const LEGACY_LOCAL_SPILL_HINT = "Use read with offset/limit, or grep this path to search within it.";
@@ -408,6 +504,27 @@ var SyncSessionError = class extends Error {
 		this.name = "SyncSessionError";
 	}
 };
+async function readStableSessionMetadata(persistence, sessionId, firstSnapshot) {
+	const handle = await persistence.open(sessionId, "read");
+	try {
+		const snapshot = await persistence.stat(sessionId);
+		if (!snapshot || snapshot.formatStatus === "migration-required") return void 0;
+		try {
+			if (canonicalJson(firstSnapshot.revision) !== canonicalJson(snapshot.revision) || canonicalJson(firstSnapshot.header) !== canonicalJson(snapshot.header) || canonicalJson(handle.header) !== canonicalJson(snapshot.header)) return void 0;
+		} catch {
+			return;
+		}
+		const inheritedEventCount = Number(handle.inheritedEventCount);
+		if (!Number.isSafeInteger(inheritedEventCount) || inheritedEventCount < 0) return void 0;
+		return {
+			snapshot,
+			header: handle.header,
+			inheritedEventCount
+		};
+	} finally {
+		await handle.close();
+	}
+}
 function spillSessionDirectoryName(sessionId) {
 	return `session-${createHash("sha256").update(sessionId).digest("hex").slice(0, 12)}`;
 }
@@ -770,6 +887,9 @@ function sessionEventDigest(header, inheritedEventCount, events, workspace, inst
 		} : void 0
 	}));
 }
+function sessionEventListDigest(events) {
+	return sha256(canonicalJson(events));
+}
 function sessionStateDigest(workspace, workspacePosition, archived, pinned) {
 	return sha256(canonicalJson({
 		workspace: {
@@ -786,6 +906,70 @@ function sessionStateDigest(workspace, workspacePosition, archived, pinned) {
 		pinned
 	}));
 }
+function sessionExportFingerprint(input) {
+	if (input.revision === void 0) return void 0;
+	try {
+		return sha256(canonicalJson({
+			version: SESSION_EXPORT_CACHE_VERSION,
+			...input
+		}));
+	} catch {
+		return;
+	}
+}
+function sessionExportCacheKey(sessionId, branchId) {
+	return JSON.stringify([sessionId, branchId ?? null]);
+}
+function estimateJsonBytes(value, limit) {
+	const active = /* @__PURE__ */ new WeakSet();
+	const measure = (item) => {
+		if (item === null) return 4;
+		if (typeof item === "string") {
+			const bytes = Buffer.byteLength(item, "utf8");
+			return bytes > limit / 6 ? limit + 1 : bytes * 6 + 2;
+		}
+		if (typeof item === "number") return Number.isFinite(item) ? String(item).length : 4;
+		if (typeof item === "boolean") return item ? 4 : 5;
+		if (item === void 0 || typeof item === "function" || typeof item === "symbol") return 4;
+		if (typeof item === "bigint") return limit + 1;
+		if (Array.isArray(item)) {
+			if (active.has(item)) return limit + 1;
+			active.add(item);
+			let bytes = 2;
+			for (let index = 0; index < item.length; index += 1) {
+				if (index > 0) bytes += 1;
+				bytes += measure(item[index]);
+				if (bytes > limit) break;
+			}
+			active.delete(item);
+			return bytes;
+		}
+		if (typeof item === "object") {
+			if (active.has(item)) return limit + 1;
+			const prototype = Object.getPrototypeOf(item);
+			if (prototype !== Object.prototype && prototype !== null) return limit + 1;
+			active.add(item);
+			let bytes = 2;
+			let first = true;
+			for (const [key, child] of Object.entries(item)) {
+				if (child === void 0 || typeof child === "function" || typeof child === "symbol") continue;
+				if (!first) bytes += 1;
+				first = false;
+				bytes += Buffer.byteLength(key, "utf8") * 6 + 3 + measure(child);
+				if (bytes > limit) break;
+			}
+			active.delete(item);
+			return bytes;
+		}
+		return limit + 1;
+	};
+	try {
+		const bytes = measure(value);
+		return bytes <= limit ? bytes : void 0;
+	} catch {
+		return;
+	}
+}
 function planSessionTransfers(direction, localEntries, remoteEntries) {
 	const toLocal = [];
 	const toRemote = [];
@@ -852,15 +1036,65 @@ async function collectBytes(stream, maxBytes = MAX_SYNC_TRANSFER_BYTES) {
 async function* oneChunk(data) {
 	yield data;
 }
-function findSessionRecordByLocalId(state, localSessionId) {
-	return Object.values(state.records).filter((metadata) => metadata.kind === "session" && metadata.localEntityId === localSessionId).sort((a, b) => compareSyncRevision(b.revision, a.revision))[0];
+function createSessionStateIndex(state) {
+	const index = {
+		state,
+		recordsByLocalId: /* @__PURE__ */ new Map(),
+		workspacesByLocalId: /* @__PURE__ */ new Map(),
+		archivesByLocalSessionId: /* @__PURE__ */ new Map()
+	};
+	for (const metadata of Object.values(state.records)) {
+		if (metadata.kind !== "session") continue;
+		const current = index.recordsByLocalId.get(metadata.localEntityId);
+		if (!current || compareSyncRevision(metadata.revision, current.revision) > 0) index.recordsByLocalId.set(metadata.localEntityId, metadata);
+	}
+	for (const mapping of Object.values(state.workspaces)) {
+		const mappings = index.workspacesByLocalId.get(mapping.localWorkspaceId) ?? [];
+		mappings.push(mapping);
+		index.workspacesByLocalId.set(mapping.localWorkspaceId, mappings);
+	}
+	for (const archive of Object.values(state.archives)) if (!index.archivesByLocalSessionId.has(archive.localSessionId)) index.archivesByLocalSessionId.set(archive.localSessionId, archive);
+	return index;
 }
-function findSessionOriginByLocalId(state, localSessionId) {
-	const metadata = findSessionRecordByLocalId(state, localSessionId);
-	return metadata ? {
-		originInstanceId: metadata.originInstanceId,
-		originEntityId: metadata.originEntityId
-	} : void 0;
+function indexSessionRecord(index, metadata) {
+	const key = sessionOriginKey(metadata);
+	const previous = index.state.records[key];
+	if (previous && previous.localEntityId !== metadata.localEntityId && index.recordsByLocalId.get(previous.localEntityId) === previous) {
+		delete index.state.records[key];
+		index.recordsByLocalId.delete(previous.localEntityId);
+		for (const candidate of Object.values(index.state.records)) {
+			if (candidate.kind !== "session" || candidate.localEntityId !== previous.localEntityId) continue;
+			const current = index.recordsByLocalId.get(previous.localEntityId);
+			if (!current || compareSyncRevision(candidate.revision, current.revision) > 0) index.recordsByLocalId.set(previous.localEntityId, candidate);
+		}
+	}
+	index.state.records[key] = metadata;
+	const current = index.recordsByLocalId.get(metadata.localEntityId);
+	if (current === previous || !current || compareSyncRevision(metadata.revision, current.revision) > 0) index.recordsByLocalId.set(metadata.localEntityId, metadata);
+}
+function indexWorkspaceMapping(index, key, mapping) {
+	const previous = index.state.workspaces[key];
+	if (previous) {
+		const mappings = index.workspacesByLocalId.get(previous.localWorkspaceId);
+		const previousIndex = mappings?.findIndex((item) => syncWorkspaceKey(item.originInstanceId, item.originWorkspaceId, item.remotePath) === key) ?? -1;
+		if (mappings && previousIndex !== -1 && previous.localWorkspaceId === mapping.localWorkspaceId) {
+			index.state.workspaces[key] = mapping;
+			mappings[previousIndex] = mapping;
+			return;
+		}
+		if (mappings && previousIndex !== -1) mappings.splice(previousIndex, 1);
+		if (mappings?.length === 0) index.workspacesByLocalId.delete(previous.localWorkspaceId);
+	}
+	index.state.workspaces[key] = mapping;
+	const mappings = index.workspacesByLocalId.get(mapping.localWorkspaceId) ?? [];
+	mappings.push(mapping);
+	index.workspacesByLocalId.set(mapping.localWorkspaceId, mappings);
+}
+function indexArchive(index, previousBranchId, archive) {
+	delete index.state.archives[previousBranchId];
+	index.state.archives[archive.branchId] = archive;
+	index.archivesByLocalSessionId.clear();
+	for (const entry of Object.values(index.state.archives)) if (!index.archivesByLocalSessionId.has(entry.localSessionId)) index.archivesByLocalSessionId.set(entry.localSessionId, entry);
 }
 function workspaceDigest(workspace) {
 	return sha256(canonicalJson(workspace));
@@ -879,14 +1113,27 @@ function validateObjectPayload(object) {
 	if (object.kind === "spill" && isRecord$1(object.reference) && isRecord$1(object.reference.owner) && typeof object.reference.owner.sessionId === "string" && isRecord$1(object.reference.ref) && typeof object.reference.ref.locator === "string" && object.id === spillKey(object.reference)) return object;
 	throw new SyncSessionError("object-invalid", "session object kind or reference is invalid");
 }
+function validateEventDelta(value) {
+	if (!isRecord$1(value) || !isNonNegativeSafeInteger(value.baseEventCount) || typeof value.baseEventDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.baseEventDigest) || !isNonNegativeSafeInteger(value.baseInheritedEventCount) || !isNonNegativeSafeInteger(value.fullEventCount) || value.fullEventCount < value.baseEventCount || typeof value.fullEventDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(value.fullEventDigest)) throw new SyncSessionError("manifest-invalid", "session event delta metadata is invalid");
+	return {
+		baseEventCount: value.baseEventCount,
+		baseEventDigest: value.baseEventDigest,
+		baseInheritedEventCount: value.baseInheritedEventCount,
+		fullEventCount: value.fullEventCount,
+		fullEventDigest: value.fullEventDigest
+	};
+}
 function validateEntry(entry) {
 	if (!isRecord$1(entry) || !isRecord$1(entry.metadata) || entry.metadata.kind !== "session") throw new SyncSessionError("manifest-invalid", "session entry metadata is invalid");
 	const metadata = entry.metadata;
 	if (typeof metadata.originInstanceId !== "string" || !metadata.originInstanceId || metadata.originInstanceId.length > 512 || /[\u0000-\u001f\u007f]/.test(metadata.originInstanceId) || typeof metadata.originEntityId !== "string" || !metadata.originEntityId || metadata.originEntityId.length > 512 || /[\u0000-\u001f\u007f]/.test(metadata.originEntityId) || typeof metadata.localEntityId !== "string" || !metadata.localEntityId || metadata.localEntityId.length > 512 || /[\u0000-\u001f\u007f]/.test(metadata.localEntityId) || typeof metadata.contentDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(metadata.contentDigest) || !metadata.revision || !isNonNegativeSafeInteger(metadata.revision.physicalTimeMs) || !isNonNegativeSafeInteger(metadata.revision.logicalCounter) || typeof metadata.revision.writerInstanceId !== "string" || !metadata.revision.writerInstanceId || /[\u0000-\u001f\u007f]/.test(metadata.revision.writerInstanceId)) throw new SyncSessionError("manifest-invalid", "session entry metadata fields are invalid");
 	if (metadata.stateDigest !== void 0 && !/^sha256:[a-f0-9]{64}$/.test(metadata.stateDigest)) throw new SyncSessionError("manifest-invalid", "session state digest is invalid");
+	if (metadata.deleted !== void 0 && typeof metadata.deleted !== "boolean") throw new SyncSessionError("manifest-invalid", "session tombstone flag is invalid");
 	if (entry.branchId !== void 0 && (typeof entry.branchId !== "string" || !/^b-[a-f0-9]{32}$/.test(entry.branchId))) throw new SyncSessionError("manifest-invalid", "session branch ID is invalid");
 	if (metadata.workspaceOrigin !== void 0) validateOrigin(metadata.workspaceOrigin);
+	const eventDelta = entry.eventDelta === void 0 ? void 0 : validateEventDelta(entry.eventDelta);
 	if (metadata.deleted) {
+		if (eventDelta) throw new SyncSessionError("manifest-invalid", "session tombstones cannot carry event deltas");
 		if (metadata.contentDigest !== sessionTombstoneDigest(metadata)) throw new SyncSessionError("manifest-invalid", "session tombstone digest is invalid");
 		return {
 			metadata,
@@ -896,11 +1143,19 @@ function validateEntry(entry) {
 	const workspace = isRecord$1(entry.workspace) ? entry.workspace : void 0;
 	const workspaceRevision = workspace && isRecord$1(workspace.revision) ? workspace.revision : void 0;
 	if (typeof entry.sourceLocalSessionId !== "string" || !isRecord$1(entry.header) || typeof entry.inheritedEventCount !== "number" || !Number.isSafeInteger(entry.inheritedEventCount) || entry.inheritedEventCount < 0 || !Array.isArray(entry.events) || !workspace || !Array.isArray(entry.objects) || typeof workspace.originInstanceId !== "string" || typeof workspace.originWorkspaceId !== "string" || !isRecord$1(workspace.nodeOrigin) || typeof workspace.nodeOrigin.originInstanceId !== "string" || typeof workspace.nodeOrigin.originEntityId !== "string" || typeof workspace.remotePath !== "string" || !posix.isAbsolute(workspace.remotePath) || posix.normalize(workspace.remotePath) !== workspace.remotePath || typeof workspace.title !== "string" || typeof workspace.contentDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(workspace.contentDigest) || !workspaceRevision || !isNonNegativeSafeInteger(workspaceRevision.physicalTimeMs) || !isNonNegativeSafeInteger(workspaceRevision.logicalCounter) || typeof workspaceRevision.writerInstanceId !== "string" || typeof entry.workspacePosition !== "number" || !Number.isSafeInteger(entry.workspacePosition) || entry.workspacePosition < 0 || typeof entry.archived !== "boolean" || typeof entry.pinned !== "boolean") throw new SyncSessionError("manifest-invalid", "active session entry fields are invalid");
+	if (eventDelta && (entry.branchId !== void 0 || entry.archived)) throw new SyncSessionError("manifest-invalid", "archives cannot use event tail deltas");
 	if (entry.events.length > MAX_SYNC_SESSIONS * 100) throw new SyncSessionError("manifest-invalid", "session event count exceeds limit");
 	const header = entry.header;
 	if (header.version !== 4 || header.id !== entry.sourceLocalSessionId) throw new SyncSessionError("session-format", "session header format or id is invalid");
-	const events = validateStoredEvents(header, structuredClone(entry.events));
-	assertContiguous(header.id, events, 0);
+	let events;
+	if (eventDelta) {
+		if (eventDelta.baseInheritedEventCount !== entry.inheritedEventCount || eventDelta.fullEventCount > MAX_SYNC_SESSIONS * 100 || eventDelta.fullEventCount - eventDelta.baseEventCount !== entry.events.length) throw new SyncSessionError("manifest-invalid", "session event delta counts are inconsistent");
+		events = structuredClone(entry.events);
+		for (let index = 0; index < events.length; index += 1) if (!isNonNegativeSafeInteger(events[index]?.seq) || events[index]?.seq !== eventDelta.baseEventCount + index) throw new SyncSessionError("manifest-invalid", "session event delta sequence is invalid");
+	} else {
+		events = validateStoredEvents(header, structuredClone(entry.events));
+		assertContiguous(header.id, events, 0);
+	}
 	const objects = entry.objects.map(validateObjectPayload);
 	if (new Set(objects.map((object) => object.id)).size !== objects.length) throw new SyncSessionError("manifest-invalid", "session entry contains duplicate objects");
 	const workspaceValue = workspace;
@@ -918,9 +1173,11 @@ function validateEntry(entry) {
 	for (const ref of attachments.files) referencedObjects.add(attachmentKey("file", ref));
 	for (const reference of [...spillReferences(events), ...legacySpillReferences(events, String(header.id))]) referencedObjects.add(spillKey(reference));
 	const objectIds = new Set(objects.map((object) => object.id));
-	if ([...referencedObjects].some((id) => !objectIds.has(id)) || [...objectIds].some((id) => !referencedObjects.has(id))) throw new SyncSessionError("manifest-invalid", "session object references and payloads do not match");
+	if ([...referencedObjects].some((id) => !objectIds.has(id)) || !eventDelta && [...objectIds].some((id) => !referencedObjects.has(id))) throw new SyncSessionError("manifest-invalid", "session object references and payloads do not match");
 	const parentOrigin = entry.parentOrigin === void 0 ? void 0 : validateOrigin(entry.parentOrigin);
-	if (sessionEventDigest(header, entry.inheritedEventCount, events, workspaceValue, instructionSnapshot, objects, parentOrigin) !== metadata.contentDigest) throw new SyncSessionError("manifest-invalid", "session content digest is invalid");
+	if (!eventDelta) {
+		if (sessionEventDigest(header, entry.inheritedEventCount, events, workspaceValue, instructionSnapshot, objects, parentOrigin) !== metadata.contentDigest) throw new SyncSessionError("manifest-invalid", "session content digest is invalid");
+	}
 	if (metadata.stateDigest !== sessionStateDigest(workspaceValue, entry.workspacePosition, entry.archived, entry.pinned)) throw new SyncSessionError("manifest-invalid", "session state digest is invalid");
 	return {
 		metadata,
@@ -935,21 +1192,54 @@ function validateEntry(entry) {
 		pinned: entry.pinned,
 		...instructionSnapshot ? { instructionSnapshot } : {},
 		events,
-		objects
+		objects,
+		...eventDelta ? { eventDelta } : {}
+	};
+}
+function validateManifestEntry(entry) {
+	if (!isRecord$1(entry) || !isRecord$1(entry.metadata) || entry.metadata.kind !== "session") throw new SyncSessionError("manifest-invalid", "session manifest entry metadata is invalid");
+	const metadata = entry.metadata;
+	if (typeof metadata.originInstanceId !== "string" || !metadata.originInstanceId || metadata.originInstanceId.length > 512 || /[\u0000-\u001f\u007f]/.test(metadata.originInstanceId) || typeof metadata.originEntityId !== "string" || !metadata.originEntityId || metadata.originEntityId.length > 512 || /[\u0000-\u001f\u007f]/.test(metadata.originEntityId) || typeof metadata.localEntityId !== "string" || !metadata.localEntityId || metadata.localEntityId.length > 512 || /[\u0000-\u001f\u007f]/.test(metadata.localEntityId) || typeof metadata.contentDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(metadata.contentDigest) || !metadata.revision || !isNonNegativeSafeInteger(metadata.revision.physicalTimeMs) || !isNonNegativeSafeInteger(metadata.revision.logicalCounter) || typeof metadata.revision.writerInstanceId !== "string" || !metadata.revision.writerInstanceId || /[\u0000-\u001f\u007f]/.test(metadata.revision.writerInstanceId)) throw new SyncSessionError("manifest-invalid", "session manifest metadata fields are invalid");
+	if (metadata.stateDigest !== void 0 && !/^sha256:[a-f0-9]{64}$/.test(metadata.stateDigest)) throw new SyncSessionError("manifest-invalid", "session manifest state digest is invalid");
+	if (metadata.deleted !== void 0 && typeof metadata.deleted !== "boolean") throw new SyncSessionError("manifest-invalid", "session manifest tombstone flag is invalid");
+	const hasEventCount = entry.eventCount !== void 0;
+	const hasEventDigest = entry.eventDigest !== void 0;
+	const hasInheritedEventCount = entry.inheritedEventCount !== void 0;
+	if (hasEventCount || hasEventDigest || hasInheritedEventCount) {
+		if (!hasEventCount || !hasEventDigest || !hasInheritedEventCount || metadata.deleted || !isNonNegativeSafeInteger(entry.eventCount) || entry.eventCount > MAX_SYNC_SESSIONS * 100 || typeof entry.eventDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(entry.eventDigest) || !isNonNegativeSafeInteger(entry.inheritedEventCount) || entry.inheritedEventCount > entry.eventCount) throw new SyncSessionError("manifest-invalid", "session event summary is invalid");
+	}
+	if (entry.branchId !== void 0 && (typeof entry.branchId !== "string" || !/^b-[a-f0-9]{32}$/.test(entry.branchId))) throw new SyncSessionError("manifest-invalid", "session manifest branch ID is invalid");
+	if (metadata.workspaceOrigin !== void 0) validateOrigin(metadata.workspaceOrigin);
+	if (metadata.deleted && metadata.contentDigest !== sessionTombstoneDigest(metadata)) throw new SyncSessionError("manifest-invalid", "session manifest tombstone digest is invalid");
+	return {
+		metadata,
+		...entry.branchId ? { branchId: entry.branchId } : {},
+		...hasEventCount ? { eventCount: entry.eventCount } : {},
+		...hasEventDigest ? { eventDigest: entry.eventDigest } : {},
+		...hasInheritedEventCount ? { inheritedEventCount: entry.inheritedEventCount } : {}
 	};
 }
 function bundleDigest(bundle) {
+	const sharedObjects = new Map((bundle.objects ?? []).map((object) => [object.id, object]));
 	const manifest = bundle.entries.map((entry) => ({
 		key: entry.branchId ?? sessionOriginKey(entry.metadata),
 		revision: entry.metadata.revision,
 		contentDigest: entry.metadata.contentDigest,
 		stateDigest: entry.metadata.stateDigest,
 		deleted: Boolean(entry.metadata.deleted),
-		objects: (entry.objects ?? []).map((object) => ({
+		objects: (entry.objects ?? (entry.sharedObjectIds ?? []).map((id) => {
+			const object = sharedObjects.get(id);
+			if (!object) throw new SyncSessionError("manifest-invalid", "session shared object id is unknown");
+			return object;
+		})).map((object) => ({
 			id: object.id,
 			digest: object.digest,
 			bytes: object.bytes
-		})).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+		})).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+		eventDelta: entry.eventDelta === void 0 ? void 0 : {
+			...entry.eventDelta,
+			suffixDigest: sessionEventListDigest(entry.events ?? [])
+		}
 	})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
 	const skipped = bundle.skipped.map((entry) => ({
 		sessionId: entry.sessionId,
@@ -961,12 +1251,36 @@ function bundleDigest(bundle) {
 		skipped
 	}));
 }
+function materializeSharedObjects(bundle) {
+	const shared = bundle.objects === void 0 ? /* @__PURE__ */ new Map() : new Map(bundle.objects.map((object) => {
+		const validated = validateObjectPayload(object);
+		return [validated.id, validated];
+	}));
+	if (shared.size !== (bundle.objects?.length ?? 0)) throw new SyncSessionError("manifest-invalid", "session bundle contains duplicate shared objects");
+	for (const entry of bundle.entries) {
+		if (!entry || typeof entry !== "object") continue;
+		if (entry.sharedObjectIds !== void 0 && (!Array.isArray(entry.sharedObjectIds) || new Set(entry.sharedObjectIds).size !== entry.sharedObjectIds.length || entry.sharedObjectIds.some((id) => !shared.has(id)))) throw new SyncSessionError("manifest-invalid", "session entry shared object references are invalid");
+	}
+	return shared;
+}
 function validateSyncSessionBundle(value) {
 	if (!isRecord$1(value) || value.protocolVersion !== 1 || typeof value.instanceId !== "string" || !/^i-[a-f0-9]{32}$/.test(value.instanceId) || !Array.isArray(value.entries) || typeof value.digest !== "string") throw new SyncSessionError("manifest-invalid", "session bundle header is invalid");
+	if (value.objects !== void 0 && (!Array.isArray(value.objects) || value.objects.some((object) => !isRecord$1(object)))) throw new SyncSessionError("manifest-invalid", "session bundle shared object table is invalid");
+	const sharedObjects = materializeSharedObjects({
+		...value.objects === void 0 ? {} : { objects: value.objects },
+		entries: value.entries
+	});
 	const skipped = value.skipped === void 0 ? [] : value.skipped;
 	if (!Array.isArray(skipped) || skipped.some((item) => !isRecord$1(item) || typeof item.sessionId !== "string" || typeof item.reason !== "string")) throw new SyncSessionError("manifest-invalid", "session bundle skip report is invalid");
 	if (value.entries.length > MAX_SYNC_SESSIONS) throw new SyncSessionError("manifest-invalid", "session bundle contains too many records");
-	const entries = value.entries.map(validateEntry);
+	const entries = value.entries.map((entry) => {
+		const materialized = { ...entry };
+		if (materialized.sharedObjectIds !== void 0) {
+			if (materialized.objects !== void 0) throw new SyncSessionError("manifest-invalid", "session entry cannot carry inline and shared objects");
+			materialized.objects = materialized.sharedObjectIds.map((id) => sharedObjects.get(id));
+		}
+		return validateEntry(materialized);
+	});
 	const keys = entries.map((entry) => entry.branchId ?? sessionOriginKey(entry.metadata));
 	if (new Set(keys).size !== keys.length) throw new SyncSessionError("manifest-invalid", "session bundle contains duplicate records");
 	const bundle = {
@@ -974,13 +1288,35 @@ function validateSyncSessionBundle(value) {
 		instanceId: value.instanceId,
 		entries,
 		skipped,
+		...value.objects === void 0 ? {} : { objects: value.objects },
 		digest: value.digest
 	};
 	if (bundleDigest(bundle) !== bundle.digest) throw new SyncSessionError("manifest-digest", "session bundle digest does not match");
 	if (Buffer.byteLength(JSON.stringify(bundle), "utf8") > 107374182400) throw new SyncSessionError("bundle-too-large", "session bundle exceeds the transfer limit");
 	return bundle;
 }
-function makeSyncSessionBundle(instanceId, entries, skipped = []) {
+function makeSyncSessionBundle(instanceId, entries, skipped = [], sharedObjects) {
+	if (sharedObjects !== void 0) {
+		const referencesShared = entries.some((entry) => (entry.objects?.length ?? 0) > 0 || entry.sharedObjectIds !== void 0);
+		const bundle = {
+			protocolVersion: 1,
+			instanceId,
+			entries: referencesShared ? entries.map((entry) => {
+				if (entry.objects === void 0) return entry;
+				const { objects, ...rest } = entry;
+				return {
+					...rest,
+					sharedObjectIds: objects.map((object) => object.id)
+				};
+			}) : entries,
+			skipped,
+			...referencesShared ? { objects: sharedObjects } : {},
+			digest: ""
+		};
+		bundle.digest = bundleDigest(bundle);
+		if (Buffer.byteLength(JSON.stringify(bundle), "utf8") > 107374182400) throw new SyncSessionError("bundle-too-large", "session bundle exceeds the transfer limit");
+		return bundle;
+	}
 	const bundle = {
 		protocolVersion: 1,
 		instanceId,
@@ -992,6 +1328,80 @@ function makeSyncSessionBundle(instanceId, entries, skipped = []) {
 	if (Buffer.byteLength(JSON.stringify(bundle), "utf8") > 107374182400) throw new SyncSessionError("bundle-too-large", "session bundle exceeds the transfer limit");
 	return bundle;
 }
+function syncSessionEntryKey(entry) {
+	return entry.branchId ?? sessionOriginKey(entry.metadata);
+}
+function withEventTail(entry, prefix) {
+	if (!prefix || entry.metadata.deleted || entry.branchId || !entry.events || entry.events.length === 0 || prefix.eventCount === 0 || prefix.eventCount > entry.events.length || prefix.inheritedEventCount !== entry.inheritedEventCount) return entry;
+	if (sessionEventListDigest(entry.events.slice(0, prefix.eventCount)) !== prefix.eventDigest) return entry;
+	const fullEventDigest = entry.eventDigest !== void 0 && entry.eventCount === entry.events.length ? entry.eventDigest : sessionEventListDigest(entry.events);
+	return {
+		...entry,
+		eventDelta: {
+			baseEventCount: prefix.eventCount,
+			baseEventDigest: prefix.eventDigest,
+			baseInheritedEventCount: prefix.inheritedEventCount,
+			fullEventCount: entry.events.length,
+			fullEventDigest
+		},
+		events: entry.events.slice(prefix.eventCount)
+	};
+}
+function sessionManifestDigest(manifest) {
+	const entries = manifest.entries.map((entry) => ({
+		key: syncSessionEntryKey(entry),
+		metadata: entry.metadata,
+		eventCount: entry.eventCount,
+		eventDigest: entry.eventDigest,
+		inheritedEventCount: entry.inheritedEventCount
+	})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	const skipped = manifest.skipped.map((entry) => ({
+		sessionId: entry.sessionId,
+		reason: entry.reason
+	})).sort((a, b) => a.sessionId < b.sessionId ? -1 : a.sessionId > b.sessionId ? 1 : 0);
+	return sha256(canonicalJson({
+		instanceId: manifest.instanceId,
+		entries,
+		skipped
+	}));
+}
+function makeSyncSessionManifest(instanceId, entries, skipped = []) {
+	const manifest = {
+		protocolVersion: 1,
+		instanceId,
+		entries: entries.map((entry) => ({
+			metadata: entry.metadata,
+			...entry.branchId ? { branchId: entry.branchId } : {},
+			...entry.eventCount === void 0 ? {} : { eventCount: entry.eventCount },
+			...entry.eventDigest === void 0 ? {} : { eventDigest: entry.eventDigest },
+			...entry.inheritedEventCount === void 0 ? {} : { inheritedEventCount: entry.inheritedEventCount }
+		})),
+		skipped,
+		digest: ""
+	};
+	manifest.digest = sessionManifestDigest(manifest);
+	if (Buffer.byteLength(JSON.stringify(manifest), "utf8") > 107374182400) throw new SyncSessionError("bundle-too-large", "session manifest exceeds the transfer limit");
+	return manifest;
+}
+function validateSyncSessionManifest(value) {
+	if (!isRecord$1(value) || value.protocolVersion !== 1 || typeof value.instanceId !== "string" || !/^i-[a-f0-9]{32}$/.test(value.instanceId) || !Array.isArray(value.entries) || typeof value.digest !== "string") throw new SyncSessionError("manifest-invalid", "session manifest header is invalid");
+	const skipped = value.skipped === void 0 ? [] : value.skipped;
+	if (!Array.isArray(skipped) || skipped.some((item) => !isRecord$1(item) || typeof item.sessionId !== "string" || typeof item.reason !== "string")) throw new SyncSessionError("manifest-invalid", "session manifest skip report is invalid");
+	if (value.entries.length > MAX_SYNC_SESSIONS) throw new SyncSessionError("manifest-invalid", "session manifest contains too many records");
+	const entries = value.entries.map(validateManifestEntry);
+	const keys = entries.map(syncSessionEntryKey);
+	if (new Set(keys).size !== keys.length) throw new SyncSessionError("manifest-invalid", "session manifest contains duplicate records");
+	const manifest = {
+		protocolVersion: 1,
+		instanceId: value.instanceId,
+		entries,
+		skipped,
+		digest: value.digest
+	};
+	if (sessionManifestDigest(manifest) !== manifest.digest) throw new SyncSessionError("manifest-digest", "session manifest digest does not match");
+	if (Buffer.byteLength(JSON.stringify(manifest), "utf8") > 107374182400) throw new SyncSessionError("bundle-too-large", "session manifest exceeds the transfer limit");
+	return manifest;
+}
 function emptyApplyResult() {
 	return {
 		created: 0,
@@ -1066,12 +1476,16 @@ function arrayBuffer(data) {
 	if (value.toString("base64") !== data) throw new SyncSessionError("object-invalid", "session object is not canonical base64");
 	return value;
 }
-function instructionsForSession(store, sessionId, state, preferredWorkspaceOrigin) {
+function instructionsForSession(store, sessionId, stateIndex, preferredWorkspaceOrigin) {
 	const snapshot = store.get(sessionId);
 	if (!snapshot) return void 0;
-	const workspaceMappings = snapshot.workspaceId ? Object.values(state.workspaces).filter((mapping) => mapping.localWorkspaceId === snapshot.workspaceId) : [];
+	const workspaceMappings = snapshot.workspaceId ? stateIndex.workspacesByLocalId.get(snapshot.workspaceId) ?? [] : [];
 	const workspaceMapping = preferredWorkspaceOrigin ? workspaceMappings.find((mapping) => mapping.originInstanceId === preferredWorkspaceOrigin.originInstanceId && mapping.originWorkspaceId === preferredWorkspaceOrigin.originEntityId) ?? (workspaceMappings.length === 1 ? workspaceMappings[0] : void 0) : workspaceMappings.length === 1 ? workspaceMappings[0] : void 0;
-	const inheritedFromOrigin = snapshot.inheritedFromSessionId ? findSessionOriginByLocalId(state, snapshot.inheritedFromSessionId) : void 0;
+	const inheritedFrom = snapshot.inheritedFromSessionId ? stateIndex.recordsByLocalId.get(snapshot.inheritedFromSessionId) : void 0;
+	const inheritedFromOrigin = inheritedFrom ? {
+		originInstanceId: inheritedFrom.originInstanceId,
+		originEntityId: inheritedFrom.originEntityId
+	} : void 0;
 	return {
 		text: snapshot.text,
 		capturedAt: snapshot.capturedAt,
@@ -1100,7 +1514,11 @@ var SyncSessionService = class {
 	journal;
 	now;
 	operationTail = Promise.resolve();
-	constructor(state, nodes, registry, bindings, getWorkspaces, getPersistence, getAttachments, getSpills, instructions, journal = new SyncSessionJournalStore(), now = Date.now) {
+	exportCache = /* @__PURE__ */ new Map();
+	exportCacheStore;
+	manifestPayloadCache = /* @__PURE__ */ new Map();
+	manifestPayloadCacheBytes = 0;
+	constructor(state, nodes, registry, bindings, getWorkspaces, getPersistence, getAttachments, getSpills, instructions, journal = new SyncSessionJournalStore(), now = Date.now, home) {
 		this.state = state;
 		this.nodes = nodes;
 		this.registry = registry;
@@ -1112,10 +1530,80 @@ var SyncSessionService = class {
 		this.instructions = instructions;
 		this.journal = journal;
 		this.now = now;
+		this.exportCacheStore = new SyncSessionExportCacheStore(home);
+		for (const [key, entry] of this.exportCacheStore.entries()) if (!this.exportCache.has(key)) this.exportCache.set(key, entry);
 	}
 	exportBundle() {
 		return this.serializeMutation(() => this.exportBundleNow());
 	}
+	exportManifest() {
+		return this.serializeMutation(async () => {
+			const payloadCache = {
+				instanceId: this.state.instanceId(),
+				entries: /* @__PURE__ */ new Map(),
+				bytes: 0
+			};
+			const bundle = await this.exportBundleNow({
+				manifestOnly: true,
+				payloadCache
+			});
+			const manifest = makeSyncSessionManifest(bundle.instanceId, bundle.entries, bundle.skipped);
+			this.rememberManifestPayloads(manifest.digest, payloadCache);
+			return manifest;
+		});
+	}
+	exportEntries(keys, manifestDigest, prefixes = [], options = {}) {
+		return this.serializeMutation(async () => {
+			if (keys.length > MAX_SYNC_SESSIONS || keys.some((key) => typeof key !== "string" || key.length > 2048) || new Set(keys).size !== keys.length) throw new SyncSessionError("manifest-invalid", "session entry selection is invalid");
+			if (manifestDigest !== void 0 && !/^sha256:[a-f0-9]{64}$/.test(manifestDigest)) throw new SyncSessionError("manifest-invalid", "session manifest digest is invalid");
+			const selectedKeys = new Set(keys);
+			const prefixesByKey = /* @__PURE__ */ new Map();
+			for (const prefix of prefixes) {
+				if (!selectedKeys.has(prefix.key) || prefixesByKey.has(prefix.key) || !isNonNegativeSafeInteger(prefix.eventCount) || prefix.eventCount > MAX_SYNC_SESSIONS * 100 || !/^sha256:[a-f0-9]{64}$/.test(prefix.eventDigest) || !isNonNegativeSafeInteger(prefix.inheritedEventCount) || prefix.inheritedEventCount > prefix.eventCount) throw new SyncSessionError("manifest-invalid", "session event prefix is invalid");
+				prefixesByKey.set(prefix.key, prefix);
+			}
+			let bundle;
+			const payloadCache = manifestDigest ? this.manifestPayloadCache.get(manifestDigest) : void 0;
+			if (payloadCache) {
+				const cachedEntries = keys.flatMap((key) => {
+					const entry = payloadCache.entries.get(key);
+					return entry ? [entry] : [];
+				});
+				const cachedKeys = new Set(cachedEntries.map(syncSessionEntryKey));
+				const missingKeys = keys.filter((key) => !cachedKeys.has(key));
+				const additional = missingKeys.length > 0 ? await this.exportBundleNow({ selectedKeys: new Set(missingKeys) }) : makeSyncSessionBundle(payloadCache.instanceId, []);
+				bundle = makeSyncSessionBundle(payloadCache.instanceId, [...cachedEntries, ...additional.entries], additional.skipped);
+			} else bundle = await this.exportBundleNow({
+				selectedKeys,
+				sharedObjects: options.sharedObjects === true
+			});
+			const withTails = bundle.entries.map((entry) => withEventTail(entry, prefixesByKey.get(syncSessionEntryKey(entry))));
+			if (bundle.objects !== void 0) return makeSyncSessionBundle(bundle.instanceId, withTails, bundle.skipped, bundle.objects);
+			const inlineEntries = withTails.map((entry) => {
+				if (entry.sharedObjectIds === void 0) return entry;
+				const { sharedObjectIds, ...rest } = entry;
+				return rest;
+			});
+			const sharedObjects = options.sharedObjects === true ? this.dedupeBundleObjects(inlineEntries) : void 0;
+			return makeSyncSessionBundle(bundle.instanceId, inlineEntries, bundle.skipped, sharedObjects);
+		});
+	}
+	rememberManifestPayloads(digest, payloads) {
+		if (payloads.entries.size === 0 || payloads.bytes > MAX_MANIFEST_PAYLOAD_CACHE_BYTES) return;
+		const previous = this.manifestPayloadCache.get(digest);
+		if (previous) {
+			this.manifestPayloadCacheBytes -= previous.bytes;
+			this.manifestPayloadCache.delete(digest);
+		}
+		while (this.manifestPayloadCache.size >= MAX_MANIFEST_PAYLOAD_CACHE_COUNT || this.manifestPayloadCacheBytes + payloads.bytes > MAX_MANIFEST_PAYLOAD_CACHE_BYTES) {
+			const oldest = this.manifestPayloadCache.entries().next().value;
+			if (!oldest) return;
+			this.manifestPayloadCache.delete(oldest[0]);
+			this.manifestPayloadCacheBytes -= oldest[1].bytes;
+		}
+		this.manifestPayloadCache.set(digest, payloads);
+		this.manifestPayloadCacheBytes += payloads.bytes;
+	}
 	applyBundle(value, sourceName, peerId = "p-000000000000000000000000", options = {}) {
 		return this.serializeMutation(() => this.applyBundleNow(value, sourceName, peerId, options));
 	}
@@ -1170,13 +1658,51 @@ var SyncSessionService = class {
 	restoreArchive(branchId) {
 		return this.serializeMutation(() => this.restoreArchiveNow(branchId));
 	}
-	async exportBundleNow() {
+	async reuseCachedManifestEntry(persistence, workspace, descriptor, workspacePosition, sessionId, firstSnapshot, pinned, current, stateIndex) {
+		if (!current || current.deleted || !current.workspaceOrigin) return void 0;
+		const cache = this.exportCache.get(sessionExportCacheKey(String(sessionId)));
+		if (!cache || cache.metadata.contentDigest !== current.contentDigest || cache.metadata.originInstanceId !== current.originInstanceId || cache.metadata.originEntityId !== current.originEntityId || current.workspaceOrigin.originInstanceId !== descriptor.originInstanceId || current.workspaceOrigin.originEntityId !== descriptor.originWorkspaceId || current.stateDigest !== sessionStateDigest(descriptor, workspacePosition, false, pinned)) return void 0;
+		const stable = await readStableSessionMetadata(persistence, sessionId, firstSnapshot);
+		if (!stable || !stable.header.cwd || posix.normalize(stable.header.cwd) !== posix.normalize(workspace.path)) return void 0;
+		const parentMetadata = stable.header.parentSession ? stateIndex.recordsByLocalId.get(String(stable.header.parentSession)) : void 0;
+		const parentOrigin = parentMetadata ? {
+			originInstanceId: parentMetadata.originInstanceId,
+			originEntityId: parentMetadata.originEntityId
+		} : void 0;
+		const instructionSnapshot = instructionsForSession(this.instructions, String(sessionId), stateIndex, {
+			originInstanceId: descriptor.originInstanceId,
+			originEntityId: descriptor.originWorkspaceId
+		});
+		const fingerprint = sessionExportFingerprint({
+			revision: stable.snapshot.revision,
+			header: stable.header,
+			inheritedEventCount: stable.inheritedEventCount,
+			workspace: descriptor,
+			instructionSnapshot,
+			parentOrigin
+		});
+		if (!fingerprint || fingerprint !== cache.fingerprint) return void 0;
+		return {
+			metadata: current,
+			eventCount: cache.eventCount,
+			eventDigest: cache.eventDigest,
+			inheritedEventCount: cache.inheritedEventCount
+		};
+	}
+	async exportBundleNow(options = {}) {
+		const { manifestOnly = false, selectedKeys, sharedObjects: useSharedObjects = false } = options;
 		const persistence = this.requirePersistence();
 		const workspaceRegistry = this.getWorkspaces();
 		if (!workspaceRegistry) throw new SyncSessionError("workspace-unavailable", "工作区注册表不可用");
 		await persistence.flush();
+		const stateIndex = createSessionStateIndex(this.state.read());
 		const instanceId = this.state.instanceId();
 		const bindings = this.bindings.list();
+		const bindingByMirrorPath = /* @__PURE__ */ new Map();
+		for (const binding of bindings) {
+			const key = normalize(binding.mirrorPath);
+			if (!bindingByMirrorPath.has(key)) bindingByMirrorPath.set(key, binding);
+		}
 		const workspaces = workspaceRegistry.list();
 		const archivedIds = new Set(workspaceRegistry.archivedSessionIds.map(String));
 		const pinnedIds = new Set((workspaceRegistry.pinnedSessionIds ?? []).map(String));
@@ -1184,10 +1710,33 @@ var SyncSessionService = class {
 		const skipped = [];
 		const eligibleLocalIds = /* @__PURE__ */ new Set();
 		const workspaceById = /* @__PURE__ */ new Map();
-		const archivedBranchSessionIds = new Set(Object.values(this.state.read().archives).map((archive) => archive.localSessionId));
+		const archivedBranchSessionIds = new Set(Object.values(stateIndex.state.archives).map((archive) => archive.localSessionId));
+		const objectCache = /* @__PURE__ */ new Map();
+		const descriptorCache = /* @__PURE__ */ new Map();
+		const getWorkspaceDescriptor = (workspace, binding, nodeOrigin, preferredOrigin) => {
+			const key = canonicalJson({
+				workspace: {
+					id: String(workspace.id),
+					path: workspace.path,
+					title: workspace.title
+				},
+				binding: {
+					mirrorPath: normalize(binding.mirrorPath),
+					nodeId: binding.nodeId,
+					remotePath: posix.normalize(binding.remotePath)
+				},
+				nodeOrigin,
+				preferredOrigin
+			});
+			const cached = descriptorCache.get(key);
+			if (cached) return cached;
+			const descriptor = this.workspaceDescriptor(workspace, binding, nodeOrigin, preferredOrigin, stateIndex);
+			descriptorCache.set(key, descriptor);
+			return descriptor;
+		};
 		for (const workspace of workspaces) {
 			workspaceById.set(String(workspace.id), workspace);
-			const binding = bindings.find((candidate) => normalize(candidate.mirrorPath) === workspaceCandidateKey(workspace));
+			const binding = bindingByMirrorPath.get(workspaceCandidateKey(workspace));
 			if (!binding) continue;
 			const node = this.registry.get(binding.nodeId);
 			if (!node || !isNodeRemoteType(node.type)) continue;
@@ -1196,15 +1745,43 @@ var SyncSessionService = class {
 			for (let position = 0; position < workspace.sessionIds.length; position += 1) {
 				const sessionId = String(workspace.sessionIds[position]);
 				if (archivedBranchSessionIds.has(sessionId)) continue;
-				const currentSession = findSessionRecordByLocalId(this.state.read(), sessionId);
+				const currentSession = stateIndex.recordsByLocalId.get(sessionId);
 				if (currentSession?.deleted) continue;
-				const descriptor = this.workspaceDescriptor(workspace, binding, nodeOrigin, currentSession?.workspaceOrigin);
+				const localKey = currentSession ? syncSessionEntryKey({ metadata: currentSession }) : syncRecordKey("session", {
+					originInstanceId: instanceId,
+					originEntityId: sessionId
+				});
+				if (selectedKeys && !selectedKeys.has(localKey)) continue;
+				const descriptor = getWorkspaceDescriptor(workspace, binding, nodeOrigin, currentSession?.workspaceOrigin);
 				const snapshot = await persistence.stat(SessionId(sessionId));
 				if (!snapshot) continue;
 				if (snapshot.formatStatus === "migration-required") throw new SyncSessionError("session-format", "会话格式需要由当前 DSH 版本迁移");
-				const entry = await this.exportSessionEntry(persistence, workspace, descriptor, position, SessionId(sessionId), snapshot, archivedIds.has(sessionId), pinnedIds.has(sessionId));
-				if (entry) {
-					entries.push(entry);
+				if (manifestOnly) {
+					const cached = await this.reuseCachedManifestEntry(persistence, workspace, descriptor, position, SessionId(sessionId), snapshot, pinnedIds.has(sessionId), currentSession, stateIndex);
+					if (cached) {
+						entries.push(cached);
+						eligibleLocalIds.add(sessionId);
+						continue;
+					}
+				}
+				const exported = await this.exportSessionEntry(persistence, workspace, descriptor, position, SessionId(sessionId), snapshot, archivedIds.has(sessionId), pinnedIds.has(sessionId), void 0, stateIndex, objectCache);
+				if (exported) {
+					const { entry } = exported;
+					if (manifestOnly && options.payloadCache) {
+						const key = syncSessionEntryKey(entry);
+						const size = estimateJsonBytes(entry, MAX_MANIFEST_PAYLOAD_CACHE_BYTES - options.payloadCache.bytes);
+						if (size !== void 0) {
+							options.payloadCache.entries.set(key, entry);
+							options.payloadCache.bytes += size;
+						}
+					}
+					entries.push(manifestOnly ? {
+						metadata: entry.metadata,
+						...entry.branchId ? { branchId: entry.branchId } : {},
+						eventCount: exported.eventCount,
+						eventDigest: exported.eventDigest,
+						inheritedEventCount: exported.inheritedEventCount
+					} : entry);
 					eligibleLocalIds.add(sessionId);
 				} else skipped.push({
 					sessionId,
@@ -1212,11 +1789,15 @@ var SyncSessionService = class {
 				});
 			}
 		}
-		const initial = this.state.read();
+		const initial = stateIndex.state;
 		for (const metadata of Object.values(initial.records)) {
 			if (metadata.kind !== "session" || archivedBranchSessionIds.has(metadata.localEntityId)) continue;
+			if (selectedKeys && !selectedKeys.has(syncSessionEntryKey({ metadata }))) continue;
 			if (metadata.deleted) {
 				entries.push({ metadata });
+				const tombstoneKey = sessionExportCacheKey(metadata.localEntityId);
+				this.exportCache.delete(tombstoneKey);
+				this.exportCacheStore.delete(tombstoneKey);
 				continue;
 			}
 			if (eligibleLocalIds.has(metadata.localEntityId)) continue;
@@ -1229,46 +1810,83 @@ var SyncSessionService = class {
 			this.state.update((state) => {
 				state.records[sessionOriginKey(metadata)] = tombstone;
 			});
+			indexSessionRecord(stateIndex, tombstone);
+			const tombstoneKey = sessionExportCacheKey(metadata.localEntityId);
+			this.exportCache.delete(tombstoneKey);
+			this.exportCacheStore.delete(tombstoneKey);
 			entries.push({ metadata: tombstone });
 		}
-		for (const archive of this.listArchives()) {
+		for (const archive of Object.values(stateIndex.state.archives)) {
+			if (selectedKeys && !selectedKeys.has(archive.branchId)) continue;
 			const workspace = archive.workspaceId ? workspaceById.get(archive.workspaceId) : void 0;
 			if (!workspace) continue;
-			const binding = bindings.find((candidate) => normalize(candidate.mirrorPath) === workspaceCandidateKey(workspace));
+			const binding = bindingByMirrorPath.get(workspaceCandidateKey(workspace));
 			const node = binding ? this.registry.get(binding.nodeId) : void 0;
 			if (!binding || !node || !isNodeRemoteType(node.type)) continue;
 			const nodeOrigin = this.nodes.originForLocalNode(node.id);
 			if (!nodeOrigin) continue;
-			const archivedMetadata = Object.values(this.state.read().archives).find((item) => item.localSessionId === archive.localSessionId);
-			const descriptor = this.workspaceDescriptor(workspace, binding, nodeOrigin, archivedMetadata?.workspaceOrigin);
+			const descriptor = getWorkspaceDescriptor(workspace, binding, nodeOrigin, stateIndex.archivesByLocalSessionId.get(archive.localSessionId)?.workspaceOrigin);
 			const snapshot = await persistence.stat(SessionId(archive.localSessionId));
 			if (!snapshot) continue;
-			const entry = await this.exportSessionEntry(persistence, workspace, descriptor, archive.workspacePosition, SessionId(archive.localSessionId), snapshot, true, false, archive);
-			if (entry) entries.push(entry);
-			else skipped.push({
+			const exported = await this.exportSessionEntry(persistence, workspace, descriptor, archive.workspacePosition, SessionId(archive.localSessionId), snapshot, true, false, archive, stateIndex, objectCache);
+			if (exported) {
+				const { entry } = exported;
+				if (manifestOnly && options.payloadCache) {
+					const key = syncSessionEntryKey(entry);
+					const size = estimateJsonBytes(entry, MAX_MANIFEST_PAYLOAD_CACHE_BYTES - options.payloadCache.bytes);
+					if (size !== void 0) {
+						options.payloadCache.entries.set(key, entry);
+						options.payloadCache.bytes += size;
+					}
+				}
+				entries.push(manifestOnly ? {
+					metadata: entry.metadata,
+					...entry.branchId ? { branchId: entry.branchId } : {},
+					eventCount: exported.eventCount,
+					eventDigest: exported.eventDigest,
+					inheritedEventCount: exported.inheritedEventCount
+				} : entry);
+			} else skipped.push({
 				sessionId: archive.localSessionId,
 				reason: "archive-workspace-cwd-mismatch"
 			});
 		}
-		return makeSyncSessionBundle(instanceId, entries, skipped);
+		const bundleSharedObjects = useSharedObjects && entries.some((entry) => (entry.objects?.length ?? 0) > 0) ? this.dedupeBundleObjects(entries) : void 0;
+		this.exportCacheStore.flush();
+		return makeSyncSessionBundle(instanceId, entries, skipped, bundleSharedObjects);
+	}
+	dedupeBundleObjects(entries) {
+		const shared = /* @__PURE__ */ new Map();
+		for (const entry of entries) for (const object of entry.objects ?? []) {
+			const current = shared.get(object.id);
+			if (current === void 0) shared.set(object.id, object);
+			else if (current.digest !== object.digest || current.bytes !== object.bytes) throw new SyncSessionError("object-invalid", "the same object id carries different payloads");
+		}
+		return [...shared.values()];
 	}
 	async applyBundleNow(value, sourceName, peerId, options, recoveryBatch) {
-		const bundle = validateSyncSessionBundle(value);
-		const pendingBatch = recoveryBatch ?? this.journal.findBatch(peerId, bundle.digest);
+		const transferredBundle = validateSyncSessionBundle(value);
+		const importedVia = recoveryBatch?.importedVia ?? options.importedVia ?? "peer";
+		if (importedVia !== "peer" && transferredBundle.entries.some((entry) => entry.eventDelta)) throw new SyncSessionError("manifest-invalid", "event tail deltas are only accepted from sync peers");
+		let pendingBatch = recoveryBatch ?? this.journal.findBatch(peerId, transferredBundle.digest);
+		if (pendingBatch && !transferredBundle.entries.some((entry) => entry.eventDelta) && (pendingBatch.bundleDigest !== transferredBundle.digest || pendingBatch.peerId !== peerId)) throw new SyncSessionError("journal-bundle-mismatch", "会话 journal batch 与 bundle 不匹配");
+		if (!pendingBatch) await this.exportBundleNow({ manifestOnly: true });
+		const bundle = await this.expandEventDeltas(transferredBundle);
+		pendingBatch ??= recoveryBatch ?? this.journal.findBatch(peerId, bundle.digest);
 		if (pendingBatch && (pendingBatch.bundleDigest !== bundle.digest || pendingBatch.peerId !== peerId)) throw new SyncSessionError("journal-bundle-mismatch", "会话 journal batch 与 bundle 不匹配");
-		const importedVia = pendingBatch?.importedVia ?? options.importedVia ?? "peer";
+		const resolvedImportedVia = pendingBatch?.importedVia ?? importedVia;
 		const allowSameInstance = pendingBatch?.allowSameInstance ?? options.allowSameInstance ?? false;
 		const localInstanceId = this.state.instanceId();
 		if (bundle.instanceId === localInstanceId && !allowSameInstance) throw new SyncSessionError("same-instance", "cannot import sessions from this instance");
-		if (!pendingBatch) await this.exportBundleNow();
 		this.preflightBundle(bundle, {
-			importedVia,
+			importedVia: resolvedImportedVia,
 			allowSameInstance
 		});
 		const safeSourceName = (pendingBatch?.sourceName ?? sourceName).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 128) || "sync peer";
 		const recordKeys = bundle.entries.map((entry) => entry.branchId ?? sessionOriginKey(entry.metadata));
-		const batchId = pendingBatch?.batchId ?? this.journal.beginWithBundle(peerId, safeSourceName, bundle.digest, recordKeys, bundle, new Date(this.now()).toISOString(), importedVia, allowSameInstance);
+		const batchId = pendingBatch?.batchId ?? this.journal.beginWithBundle(peerId, safeSourceName, bundle.digest, recordKeys, bundle, new Date(this.now()).toISOString(), resolvedImportedVia, allowSameInstance);
 		const result = emptyApplyResult();
+		const attachmentImportCache = /* @__PURE__ */ new Map();
 		result.skipped += bundle.skipped.length;
 		result.unmapped += bundle.skipped.length;
 		const workspaceOrders = /* @__PURE__ */ new Map();
@@ -1364,7 +1982,7 @@ var SyncSessionService = class {
 						continue;
 					}
 					if (!current.deleted && entry.metadata.contentDigest === current.contentDigest && await this.requirePersistence().stat(SessionId(current.localEntityId))) {
-						await this.applyMembershipOnly(entry, current, safeSourceName, entryWorkspace, importedVia);
+						await this.applyMembershipOnly(entry, current, safeSourceName, entryWorkspace, resolvedImportedVia);
 						result.updated += 1;
 						queueWorkspaceOrder(entryWorkspace.id, SessionId(current.localEntityId), entry.workspacePosition ?? 0);
 						continue;
@@ -1374,7 +1992,7 @@ var SyncSessionService = class {
 				let prepared;
 				if (preparedValue === void 0) {
 					try {
-						prepared = await this.prepareEntry(entry, safeSourceName, plannedSessionIds, entryWorkspace, importedVia);
+						prepared = await this.prepareEntry(entry, safeSourceName, plannedSessionIds, entryWorkspace, resolvedImportedVia, attachmentImportCache);
 					} catch (error) {
 						if (error instanceof SyncSessionError && error.code === "workspace-unmapped") {
 							result.skipped += 1;
@@ -1399,13 +2017,42 @@ var SyncSessionService = class {
 			}
 			await this.orderWorkspaceSessions(workspaceOrders);
 			this.journal.complete(batchId);
+			this.exportCacheStore.flush();
 			return result;
 		} catch (error) {
 			if (error instanceof SyncSessionError) throw error;
 			throw new SyncSessionError("session-apply-failed", "会话同步应用失败", error);
 		}
 	}
-	async prepareEntry(entry, sourceName, plannedSessionIds, workspace, importedVia) {
+	async expandEventDeltas(bundle) {
+		if (!bundle.entries.some((entry) => entry.eventDelta)) return bundle;
+		const persistence = this.requirePersistence();
+		const state = this.state.read();
+		const entries = [];
+		for (const entry of bundle.entries) {
+			const delta = entry.eventDelta;
+			if (!delta) {
+				entries.push(entry);
+				continue;
+			}
+			const current = state.records[sessionOriginKey(entry.metadata)];
+			if (!current || current.deleted) throw new SyncSessionError("session-delta-prefix", "event delta base session is missing");
+			const snapshot = await persistence.stat(SessionId(current.localEntityId));
+			if (!snapshot) throw new SyncSessionError("session-delta-prefix", "event delta base session is missing");
+			const stable = await this.readStableSession(persistence, SessionId(current.localEntityId), snapshot);
+			if (stable.events.length !== delta.baseEventCount || stable.inheritedEventCount !== delta.baseInheritedEventCount || sessionEventListDigest(stable.events) !== delta.baseEventDigest) throw new SyncSessionError("session-delta-prefix", "event delta base prefix no longer matches");
+			const events = [...stable.events, ...entry.events ?? []];
+			if (events.length !== delta.fullEventCount || sessionEventListDigest(events) !== delta.fullEventDigest) throw new SyncSessionError("manifest-invalid", "expanded event delta digest does not match");
+			const fullEntry = {
+				...entry,
+				events
+			};
+			delete fullEntry.eventDelta;
+			entries.push(fullEntry);
+		}
+		return validateSyncSessionBundle(makeSyncSessionBundle(bundle.instanceId, entries, bundle.skipped));
+	}
+	async prepareEntry(entry, sourceName, plannedSessionIds, workspace, importedVia, attachmentImportCache) {
 		if (!entry.header || !entry.events || !entry.workspace || !entry.objects) throw new SyncSessionError("manifest-invalid", "active session entry is incomplete");
 		const sessionId = entry.branchId ? archivedSessionId(entry.branchId) : importedSessionId(entry.metadata);
 		const sourceHeader = entry.header;
@@ -1430,7 +2077,7 @@ var SyncSessionService = class {
 				await handle.close();
 			}
 		}
-		const objectMap = await this.importObjects(entry.objects, sessionId);
+		const objectMap = await this.importObjects(entry.objects, sessionId, attachmentImportCache);
 		const validatedEvents = validateStoredEvents(header, this.rewriteEvents(entry.events, entry.objects, objectMap, sessionId, String(entry.header.id)));
 		assertContiguous(sessionId, validatedEvents, 0);
 		const instructionWorkspaceId = entry.instructionSnapshot?.workspaceOrigin ? this.localWorkspaceIdForOrigin(entry.instructionSnapshot.workspaceOrigin, entry.instructionSnapshot.workspaceRemotePath) : void 0;
@@ -1516,7 +2163,7 @@ var SyncSessionService = class {
 		if (!committedWorkspace) throw new SyncSessionError("workspace-unmapped", "目标实例没有对应的可用远程节点");
 		return committedWorkspace;
 	}
-	async importObjects(objects, sessionId) {
+	async importObjects(objects, sessionId, attachmentImportCache) {
 		const attachments = objects.some((object) => object.kind === "image" || object.kind === "file") ? this.getAttachments() : void 0;
 		const spills = objects.some((object) => object.kind === "spill" && !object.unavailable) ? this.getSpills() : void 0;
 		if (objects.some((object) => object.kind === "image" || object.kind === "file") && !attachments) throw new SyncSessionError("attachments-unavailable", "目标实例的附件存储服务不可用");
@@ -1524,6 +2171,13 @@ var SyncSessionService = class {
 		const output = /* @__PURE__ */ new Map();
 		for (const object of objects) {
 			if (object.kind === "spill" && object.unavailable) continue;
+			if (object.kind !== "spill") {
+				const cached = attachmentImportCache?.get(object.id);
+				if (cached) {
+					output.set(object.id, cached);
+					continue;
+				}
+			}
 			const data = arrayBuffer(object.data);
 			if (data.byteLength !== object.bytes || sha256(data) !== object.digest) throw new SyncSessionError("object-integrity", "session object failed digest validation");
 			if (object.kind === "image") {
@@ -1533,12 +2187,14 @@ var SyncSessionService = class {
 					...object.ref.name === void 0 ? {} : { name: object.ref.name }
 				});
 				output.set(object.id, ref);
+				attachmentImportCache?.set(object.id, ref);
 			} else if (object.kind === "file") {
 				const ref = await attachments.saveFileStream({
 					data: oneChunk(data),
 					name: object.ref.name
 				});
 				output.set(object.id, ref);
+				attachmentImportCache?.set(object.id, ref);
 			} else {
 				const ref = await saveSpillTransfer(spills, {
 					owner: { sessionId },
@@ -1930,10 +2586,11 @@ var SyncSessionService = class {
 		}
 		return existed !== void 0;
 	}
-	workspaceDescriptor(workspace, binding, nodeOrigin, preferredOrigin) {
-		const state = this.state.read();
-		const matchingMappings = Object.values(state.workspaces).filter((mapping) => mapping.localWorkspaceId === workspace.id && mapping.localNodeId === binding.nodeId && posix.normalize(mapping.remotePath) === posix.normalize(binding.remotePath));
-		const prior = (preferredOrigin ? Object.values(state.workspaces).find((mapping) => mapping.originInstanceId === preferredOrigin.originInstanceId && mapping.originWorkspaceId === preferredOrigin.originEntityId && mapping.localWorkspaceId === workspace.id && mapping.localNodeId === binding.nodeId) : void 0) ?? (matchingMappings.length === 1 ? matchingMappings[0] : void 0);
+	workspaceDescriptor(workspace, binding, nodeOrigin, preferredOrigin, stateIndex = createSessionStateIndex(this.state.read())) {
+		const state = stateIndex.state;
+		const workspaceMappings = stateIndex.workspacesByLocalId.get(String(workspace.id)) ?? [];
+		const matchingMappings = workspaceMappings.filter((mapping) => mapping.localNodeId === binding.nodeId && posix.normalize(mapping.remotePath) === posix.normalize(binding.remotePath));
+		const prior = (preferredOrigin ? workspaceMappings.find((mapping) => mapping.originInstanceId === preferredOrigin.originInstanceId && mapping.originWorkspaceId === preferredOrigin.originEntityId && mapping.localNodeId === binding.nodeId) : void 0) ?? (matchingMappings.length === 1 ? matchingMappings[0] : void 0);
 		const originInstanceId = preferredOrigin?.originInstanceId ?? prior?.originInstanceId ?? this.state.instanceId();
 		const originWorkspaceId = preferredOrigin?.originEntityId ?? prior?.originWorkspaceId ?? workspace.id;
 		const base = {
@@ -1948,35 +2605,52 @@ var SyncSessionService = class {
 		const current = state.workspaces[key];
 		const revision = current && current.contentDigest === digest ? current.revision : this.state.nextRevision(this.now());
 		const mapping = {
-			...base,
+			originInstanceId,
+			originWorkspaceId,
 			localWorkspaceId: workspace.id,
 			localPath: workspace.path,
 			localNodeId: binding.nodeId,
+			remotePath: base.remotePath,
+			title: workspace.title,
 			revision,
 			contentDigest: digest
 		};
-		this.state.update((draft) => {
-			draft.workspaces[key] = mapping;
-		});
+		if (!current || canonicalJson(current) !== canonicalJson(mapping)) {
+			this.state.update((draft) => {
+				draft.workspaces[key] = mapping;
+			});
+			indexWorkspaceMapping(stateIndex, key, mapping);
+		}
 		return {
 			...base,
 			revision,
 			contentDigest: digest
 		};
 	}
-	async exportSessionEntry(persistence, workspace, descriptor, workspacePosition, sessionId, firstSnapshot, archived, pinned, archive) {
-		const { header, inheritedEventCount, events } = await this.readStableSession(persistence, sessionId, firstSnapshot);
-		if (!header.cwd || posix.normalize(header.cwd) !== posix.normalize(workspace.path)) return void 0;
+	async exportSessionEntry(persistence, workspace, descriptor, workspacePosition, sessionId, firstSnapshot, archived, pinned, archive, stateIndex, objectCache) {
+		const { header, inheritedEventCount, events, revision: sourceRevision } = await this.readStableSession(persistence, sessionId, firstSnapshot);
 		const localSessionId = String(sessionId);
-		const state = this.state.read();
-		const parentOrigin = header.parentSession ? findSessionOriginByLocalId(state, String(header.parentSession)) : void 0;
-		const syncInstructions = instructionsForSession(this.instructions, String(sessionId), state, {
+		const cacheKey = sessionExportCacheKey(localSessionId);
+		if (!header.cwd || posix.normalize(header.cwd) !== posix.normalize(workspace.path)) {
+			this.exportCache.delete(cacheKey);
+			this.exportCacheStore.delete(cacheKey);
+			return;
+		}
+		const index = stateIndex ?? createSessionStateIndex(this.state.read());
+		const state = index.state;
+		const parentMetadata = header.parentSession ? index.recordsByLocalId.get(String(header.parentSession)) : void 0;
+		const parentOrigin = parentMetadata ? {
+			originInstanceId: parentMetadata.originInstanceId,
+			originEntityId: parentMetadata.originEntityId
+		} : void 0;
+		const syncInstructions = instructionsForSession(this.instructions, String(sessionId), index, {
 			originInstanceId: descriptor.originInstanceId,
 			originEntityId: descriptor.originWorkspaceId
 		});
-		const objects = await this.exportObjects(events, localSessionId);
+		const eventDigest = sessionEventListDigest(events);
+		const objects = await this.exportObjects(events, localSessionId, objectCache);
 		const digest = sessionEventDigest(header, inheritedEventCount, events, descriptor, syncInstructions, objects, parentOrigin);
-		const current = archive ? void 0 : findSessionRecordByLocalId(state, localSessionId) ?? state.records[syncRecordKey("session", {
+		const current = archive ? void 0 : index.recordsByLocalId.get(localSessionId) ?? state.records[syncRecordKey("session", {
 			originInstanceId: this.state.instanceId(),
 			originEntityId: localSessionId
 		})];
@@ -2015,6 +2689,7 @@ var SyncSessionService = class {
 					delete draft.archives[archive.branchId];
 					draft.archives[branchId] = updatedArchive;
 				});
+				indexArchive(index, archive.branchId, updatedArchive);
 				outputBranchId = branchId;
 			} else contentDigest = archive.contentDigest;
 		} else if (!current || current.contentDigest !== digest || current.deleted || workspaceOriginChanged || !current.workspaceOrigin || sessionStateChanged) revision = this.state.nextRevision(this.now());
@@ -2030,23 +2705,60 @@ var SyncSessionService = class {
 			...archive ? {} : current?.importedVia ? { importedVia: current.importedVia } : {},
 			...archive ? {} : current?.sourceName ? { sourceName: current.sourceName } : {}
 		};
-		if (!archive && (!current || current.contentDigest !== digest || current.deleted || workspaceOriginChanged || !current.workspaceOrigin || sessionStateChanged)) this.state.update((draft) => {
-			draft.records[sessionOriginKey(metadata)] = metadata;
-		});
+		if (!archive && (!current || current.contentDigest !== digest || current.deleted || workspaceOriginChanged || !current.workspaceOrigin || sessionStateChanged)) {
+			this.state.update((draft) => {
+				draft.records[sessionOriginKey(metadata)] = metadata;
+			});
+			indexSessionRecord(index, metadata);
+		}
+		if (!archive && !objects.some((object) => object.kind === "spill")) {
+			const fingerprint = sessionExportFingerprint({
+				revision: sourceRevision,
+				header,
+				inheritedEventCount,
+				workspace: descriptor,
+				instructionSnapshot: syncInstructions,
+				parentOrigin
+			});
+			if (fingerprint) {
+				const entry = {
+					fingerprint,
+					metadata,
+					eventCount: events.length,
+					eventDigest,
+					inheritedEventCount
+				};
+				this.exportCache.set(cacheKey, entry);
+				this.exportCacheStore.set(cacheKey, entry);
+			} else {
+				this.exportCache.delete(cacheKey);
+				this.exportCacheStore.delete(cacheKey);
+			}
+		} else {
+			this.exportCache.delete(cacheKey);
+			this.exportCacheStore.delete(cacheKey);
+		}
 		return {
-			metadata,
-			...outputBranchId ? { branchId: outputBranchId } : {},
-			sourceLocalSessionId: localSessionId,
-			header,
-			inheritedEventCount,
-			...parentOrigin ? { parentOrigin } : {},
-			workspace: descriptor,
-			workspacePosition,
-			archived,
-			pinned,
-			...syncInstructions ? { instructionSnapshot: syncInstructions } : {},
-			events: [...events],
-			objects
+			entry: {
+				metadata,
+				...outputBranchId ? { branchId: outputBranchId } : {},
+				sourceLocalSessionId: localSessionId,
+				header,
+				inheritedEventCount,
+				...parentOrigin ? { parentOrigin } : {},
+				workspace: descriptor,
+				workspacePosition,
+				archived,
+				pinned,
+				...syncInstructions ? { instructionSnapshot: syncInstructions } : {},
+				events: [...events],
+				objects,
+				eventCount: events.length,
+				eventDigest
+			},
+			eventCount: events.length,
+			eventDigest,
+			inheritedEventCount
 		};
 	}
 	async readStableSession(persistence, sessionId, firstSnapshot) {
@@ -2069,10 +2781,11 @@ var SyncSessionService = class {
 				assertContiguous(sessionId, validated, 0);
 				const after = await persistence.stat(sessionId);
 				if (!after) throw new SyncSessionError("session-missing", "会话在导出期间消失");
-				if (JSON.stringify(snapshot.revision) === JSON.stringify(after.revision)) return {
+				if (canonicalJson(snapshot.revision) === canonicalJson(after.revision) && canonicalJson(snapshot.header) === canonicalJson(after.header) && canonicalJson(handle.header) === canonicalJson(after.header)) return {
 					header: handle.header,
 					inheritedEventCount: Number(handle.inheritedEventCount),
-					events: [...validated]
+					events: [...validated],
+					revision: after.revision
 				};
 				snapshot = after;
 			} finally {
@@ -2081,7 +2794,7 @@ var SyncSessionService = class {
 		}
 		throw new SyncSessionError("session-changing", "会话在导出期间持续变化，请稍后重试");
 	}
-	async exportObjects(events, sessionId) {
+	async exportObjects(events, sessionId, objectCache) {
 		const attachments = attachmentReferences(events);
 		const spills = spillReferences(events);
 		const structuredSpills = new Set(spills.map(spillKey));
@@ -2090,27 +2803,43 @@ var SyncSessionService = class {
 		const attachmentStore = attachments.images.length + attachments.files.length > 0 ? this.getAttachments() : void 0;
 		if (attachments.images.length + attachments.files.length > 0 && !attachmentStore) throw new SyncSessionError("attachments-unavailable", "附件存储服务不可用");
 		for (const ref of attachments.images) {
+			const key = attachmentKey("image", ref);
+			const cached = objectCache?.get(key)?.object;
+			if (cached?.kind === "image" && canonicalJson(cached.ref) === canonicalJson(ref)) {
+				payloads.set(key, cached);
+				continue;
+			}
 			const stored = await attachmentStore.readImage(ref);
 			const digest = sha256(stored.data);
-			payloads.set(attachmentKey("image", ref), {
-				id: attachmentKey("image", ref),
+			const object = {
+				id: key,
 				kind: "image",
 				ref: stored.ref,
 				bytes: stored.data.byteLength,
 				digest,
 				data: Buffer.from(stored.data).toString("base64")
-			});
+			};
+			payloads.set(key, object);
+			objectCache?.set(key, { object });
 		}
 		for (const ref of attachments.files) {
+			const key = attachmentKey("file", ref);
+			const cached = objectCache?.get(key)?.object;
+			if (cached?.kind === "file" && canonicalJson(cached.ref) === canonicalJson(ref)) {
+				payloads.set(key, cached);
+				continue;
+			}
 			const data = await collectBytes(attachmentStore.readFileStream(ref));
-			payloads.set(attachmentKey("file", ref), {
-				id: attachmentKey("file", ref),
+			const object = {
+				id: key,
 				kind: "file",
 				ref,
 				bytes: data.byteLength,
 				digest: sha256(data),
 				data: data.toString("base64")
-			});
+			};
+			payloads.set(key, object);
+			objectCache?.set(key, { object });
 		}
 		if (spills.length > 0) {
 			const store = this.getSpills();
@@ -2120,6 +2849,12 @@ var SyncSessionService = class {
 					untransferred.push(reference);
 					continue;
 				}
+				const key = spillKey(reference);
+				const cached = objectCache?.get(key)?.object;
+				if (cached?.kind === "spill" && canonicalJson(cached.reference) === canonicalJson(reference) && (reference.ref.bytes === void 0 || cached.bytes === reference.ref.bytes)) {
+					payloads.set(key, cached);
+					continue;
+				}
 				try {
 					const data = await collectBytes(readSpillStream(store, reference));
 					if (reference.ref.bytes !== void 0 && data.byteLength !== reference.ref.bytes) {
@@ -2132,15 +2867,16 @@ var SyncSessionService = class {
 						untransferred.push(reference);
 						continue;
 					}
-					const key = spillKey(reference);
-					payloads.set(key, {
+					const object = {
 						id: key,
 						kind: "spill",
 						reference,
 						bytes: data.byteLength,
 						digest: sha256(data),
 						data: data.toString("base64")
-					});
+					};
+					payloads.set(key, object);
+					objectCache?.set(key, { object });
 				} catch {
 					untransferred.push(reference);
 				}
@@ -2172,6 +2908,6 @@ var SyncSessionService = class {
 	}
 };
 //#endregion
-export { validateSyncSessionBundle as a, planSessionTransfers as i, SyncSessionService as n, makeSyncSessionBundle as r, SyncSessionError as t };
+export { planSessionTransfers as a, validateSyncSessionBundle as c, makeSyncSessionManifest as i, validateSyncSessionManifest as l, SyncSessionService as n, sessionEventListDigest as o, makeSyncSessionBundle as r, syncSessionEntryKey as s, SyncSessionError as t };
 
-//# sourceMappingURL=session-sync-EdfwUON5.js.map
+//# sourceMappingURL=session-sync-C0uoizyB.js.map