@namzu/sdk 49.0.0 → 50.0.0

package/src/store/session/memory.ts

@@ -17,7 +17,7 @@ import {
 	TenantIsolationError,
 } from '../../session/errors.js'
 import { SessionAlreadySummarizedError } from '../../session/summary/errors.js'
-import type { SessionId, TenantId } from '../../types/ids/index.js'
+import type { SessionId, TenantId, TurnId } from '../../types/ids/index.js'
 import type { Project, ProjectStatus } from '../../types/project/entity.js'
 import type { Session } from '../../types/session/entity.js'
 import type { ProjectId, SubSessionId, TopicId } from '../../types/session/ids.js'
@@ -34,6 +34,7 @@ import type { SessionSummaryRef } from '../../types/summary/ref.js'
 import {
 	asProjectId,
 	asTenantId,
+	asTurnId,
 	generateProjectId,
 	generateSessionId,
 	generateSubSessionId,
@@ -62,6 +63,10 @@ interface SummaryRecord {
 	summary: SessionSummaryRef
 }
 
+function summaryKey(sessionId: SessionId, turnId?: TurnId): string {
+	return JSON.stringify([sessionId, turnId === undefined ? null : asTurnId(turnId)])
+}
+
 /**
  * Non-terminal statuses from which {@link InMemorySessionStore.recordSummary}
  * flips the owning session to `'idle'` as part of the atomic materialize +
@@ -75,10 +80,12 @@ const SUMMARY_TERMINAL_FLIP_STATUSES: ReadonlySet<Session['status']> = new Set([
 ])
 
 export class InMemorySessionStore implements SessionStore {
+	readonly supportsInvocationSummaries: boolean = true
+	readonly supportsOwnerVersionCas: boolean = true
 	private readonly projects = new Map<ProjectId, ProjectRecord>()
 	private readonly sessions = new Map<SessionId, SessionRecord>()
 	private readonly subSessions = new Map<SubSessionId, SubSessionRecord>()
-	private readonly summaries = new Map<SessionId, SummaryRecord>()
+	private readonly summaries = new Map<string, SummaryRecord>()
 
 	/** Hydrate existing Project snapshots without minting replacement identities. */
 	constructor(projects: readonly Project[] = []) {
@@ -364,7 +371,9 @@ export class InMemorySessionStore implements SessionStore {
 		}
 
 		this.sessions.delete(sessionId)
-		this.summaries.delete(sessionId)
+		for (const [key, record] of this.summaries) {
+			if (record.summary.sessionRef === sessionId) this.summaries.delete(key)
+		}
 	}
 
 	// SubSession CRUD ---------------------------------------------------------
@@ -460,6 +469,7 @@ export class InMemorySessionStore implements SessionStore {
 	async recordSummary(
 		summary: SessionSummaryRef & { materializedBy: 'kernel' },
 		tenantId: TenantId,
+		expectedOwnerVersion?: number,
 	): Promise<void> {
 		if (summary.tenantId !== tenantId) {
 			throw new TenantIsolationError({
@@ -472,11 +482,22 @@ export class InMemorySessionStore implements SessionStore {
 			throw new Error(`Session ${summary.sessionRef} not found`)
 		}
 		this.assertTenant(sessionRecord.tenantId, tenantId, `session(${summary.sessionRef})`)
+		if (
+			expectedOwnerVersion !== undefined &&
+			sessionRecord.session.ownerVersion !== expectedOwnerVersion
+		) {
+			throw new StaleSessionError({
+				sessionId: summary.sessionRef,
+				expectedVersion: expectedOwnerVersion,
+				actualVersion: sessionRecord.session.ownerVersion,
+			})
+		}
 
 		// Atomic within the call: summary persist + session status flip commit
 		// together. An existing summary with the same id is the recovery path —
 		// idempotently replay the status flip without duplicating the record.
-		const existing = this.summaries.get(summary.sessionRef)
+		const key = summaryKey(summary.sessionRef, summary.turnRef)
+		const existing = this.summaries.get(key)
 		if (existing && existing.summary.id !== summary.id) {
 			throw new SessionAlreadySummarizedError({
 				sessionId: summary.sessionRef,
@@ -485,7 +506,7 @@ export class InMemorySessionStore implements SessionStore {
 		}
 
 		if (!existing) {
-			this.summaries.set(summary.sessionRef, { tenantId, summary })
+			this.summaries.set(key, { tenantId, summary })
 		}
 
 		if (SUMMARY_TERMINAL_FLIP_STATUSES.has(sessionRecord.session.status)) {
@@ -500,8 +521,12 @@ export class InMemorySessionStore implements SessionStore {
 		}
 	}
 
-	async getSummary(sessionId: SessionId, tenantId: TenantId): Promise<SessionSummaryRef | null> {
-		const record = this.summaries.get(sessionId)
+	async getSummary(
+		sessionId: SessionId,
+		tenantId: TenantId,
+		turnId?: TurnId,
+	): Promise<SessionSummaryRef | null> {
+		const record = this.summaries.get(summaryKey(sessionId, turnId))
 		if (!record) return null
 		this.assertTenant(record.tenantId, tenantId, `summary(${record.summary.id})`)
 		return record.summary

package/src/store/session-log/core.ts

@@ -18,6 +18,8 @@ import {
 	type TurnSettlement,
 } from '../../types/session/turn.js'
 import { generateRecordId } from '../../utils/id.js'
+import { cloneJsonValue } from '../../utils/json-snapshot.js'
+import { STRUCTURED_RESULT_MAX_BYTES } from '../../utils/structured-result-json.js'
 import {
 	LineSplitter,
 	type LogBytes,
@@ -28,6 +30,7 @@ import {
 } from './chain.js'
 import {
 	type ActiveTurnRecord,
+	MESSAGES_WITHDRAWN_DETAIL,
 	SessionTurnState,
 	TurnRuleError,
 	foldSessionMessages,
@@ -47,7 +50,7 @@ import {
 	StaleSessionLeaseError,
 	isLeaseLive,
 } from './lease.js'
-import type { SpillRef, SpillStore } from './spill.js'
+import type { SpillReadOptions, SpillRef, SpillStore } from './spill.js'
 
 // ─── public types ─────────────────────────────────────────────────────────
 
@@ -122,6 +125,16 @@ export interface BeginTurnOptions {
 	readonly abandonInterrupted?: boolean
 }
 
+export interface AbandonTurnLogOptions {
+	/**
+	 * The caller hands the turn's messages back to the person (a client that
+	 * puts the prompt back in its message box). The fold then leaves them out
+	 * of the next turn's context; the records stay in the log. Absent: the
+	 * abandoned turn's messages remain in the context, as they always have.
+	 */
+	readonly withdrawMessages?: boolean
+}
+
 export interface ActiveTurnOptions {
 	/** The lease the caller holds; the default asks the store for the current one. */
 	readonly lease?: SessionLease
@@ -175,8 +188,18 @@ export interface SessionLog {
 		draft: TurnStartedDraft,
 		options?: BeginTurnOptions,
 	): Promise<SessionLogEntry>
-	/** Close a paused or interrupted turn with `turn_failed{failure.code:'abandoned'}`. */
-	abandonTurn(lease: SessionLease, turnId: TurnId, reason: string): Promise<SessionLogEntry>
+	/**
+	 * Close a paused or interrupted turn with `turn_failed{failure.code:'abandoned'}`.
+	 * With `withdrawMessages` the closing record also says so
+	 * ({@link MESSAGES_WITHDRAWN_DETAIL}), and the fold then leaves the turn's
+	 * messages out of the context the next turn carries. The records stay.
+	 */
+	abandonTurn(
+		lease: SessionLease,
+		turnId: TurnId,
+		reason: string,
+		options?: AbandonTurnLogOptions,
+	): Promise<SessionLogEntry>
 	/** The active turn, if any, and whether it is running, paused or interrupted. */
 	activeTurn(options?: ActiveTurnOptions): Promise<ActiveTurn | null>
 
@@ -186,7 +209,7 @@ export interface SessionLog {
 	readAll(options?: ReadSessionLogOptions): Promise<SessionLogRead>
 	/** The folded conversation (spec §4.5), spills read back. */
 	messages(options?: { readonly throughSeq?: number }): Promise<Message[]>
-	readSpill(ref: SpillRef): Promise<string>
+	readSpill(ref: SpillRef, options?: SpillReadOptions): Promise<string>
 }
 
 /** A draft that is not a valid session record once enveloped. */
@@ -227,6 +250,12 @@ export interface SessionLogCoreOptions {
 	 * bytes spills its body first. Default {@link SESSION_RECORD_MAX_BYTES}.
 	 */
 	readonly spillAboveBytes?: number
+	/**
+	 * Spill screened structured tool JSON and accepted structured output when
+	 * their record exceeds spillAboveBytes. Default false preserves inline
+	 * records. Each JSON body is limited to STRUCTURED_RESULT_MAX_BYTES.
+	 */
+	readonly structuredResultSpilling?: boolean
 	/**
 	 * Which appends are fsynced. `boundaries` (the default): the records
 	 * others depend on — `session_started`, the turn lifecycle, checkpoints
@@ -285,6 +314,7 @@ export class SessionLogCore implements SessionLog {
 	readonly #spills: SpillStore
 	readonly #now: () => number
 	readonly #spillAbove: number
+	readonly #structuredResultSpilling: boolean
 	readonly #sync: 'boundaries' | 'all' | 'none'
 	readonly #mutex = new Mutex()
 
@@ -303,6 +333,13 @@ export class SessionLogCore implements SessionLog {
 		this.#medium = options.medium
 		this.#leases = options.leases
 		this.#spills = options.spills
+		if (
+			options.structuredResultSpilling !== undefined &&
+			typeof options.structuredResultSpilling !== 'boolean'
+		) {
+			throw new TypeError('structuredResultSpilling must be a boolean')
+		}
+		this.#structuredResultSpilling = options.structuredResultSpilling ?? false
 		this.#now = options.now ?? Date.now
 		this.#spillAbove = Math.min(
 			options.spillAboveBytes ?? SESSION_RECORD_MAX_BYTES,
@@ -499,7 +536,12 @@ export class SessionLogCore implements SessionLog {
 		})
 	}
 
-	abandonTurn(lease: SessionLease, turnId: TurnId, reason: string): Promise<SessionLogEntry> {
+	abandonTurn(
+		lease: SessionLease,
+		turnId: TurnId,
+		reason: string,
+		options: AbandonTurnLogOptions = {},
+	): Promise<SessionLogEntry> {
 		return this.#mutex.run(async () => {
 			await this.#requireCurrent(lease)
 			await this.#catchUp()
@@ -512,7 +554,15 @@ export class SessionLogCore implements SessionLog {
 			if (state === 'running') {
 				throw new TurnInProgressError({ sessionId: this.sessionId, activeTurnId: turnId, state })
 			}
-			return this.#write(lease, this.#failedDraft(active, 'abandoned', reason))
+			return this.#write(
+				lease,
+				this.#failedDraft(
+					active,
+					'abandoned',
+					reason,
+					options.withdrawMessages ? { [MESSAGES_WITHDRAWN_DETAIL]: true } : undefined,
+				),
+			)
 		})
 	}
 
@@ -521,7 +571,12 @@ export class SessionLogCore implements SessionLog {
 		return active.ownerGen === fence ? 'running' : 'interrupted'
 	}
 
-	#failedDraft(active: ActiveTurnRecord, code: string, message: string): SessionRecordDraft {
+	#failedDraft(
+		active: ActiveTurnRecord,
+		code: string,
+		message: string,
+		details?: Record<string, unknown>,
+	): SessionRecordDraft {
 		const settlement: TurnSettlement = {
 			status: 'failed',
 			iterations: 0,
@@ -536,7 +591,7 @@ export class SessionLogCore implements SessionLog {
 			type: 'turn_failed',
 			turnId: active.turnId,
 			error: message,
-			failure: { code, message, retryable: false },
+			failure: { code, message, retryable: false, ...(details ? { details } : {}) },
 			settlement,
 		} as SessionRecordDraft
 	}
@@ -591,7 +646,10 @@ export class SessionLogCore implements SessionLog {
 		return entry
 	}
 
-	async #spillIfLarge(candidate: Record<string, unknown>): Promise<Record<string, unknown>> {
+	async #spillIfLarge(original: Record<string, unknown>): Promise<Record<string, unknown>> {
+		const candidate = this.#structuredResultSpilling
+			? await this.#spillStructuredResults(original)
+			: original
 		const type = candidate.type
 		if (
 			type !== 'message' &&
@@ -639,6 +697,55 @@ export class SessionLogCore implements SessionLog {
 		return { ...candidate, content: preview, spill: ref }
 	}
 
+	async #spillStructuredResults(
+		candidate: Record<string, unknown>,
+	): Promise<Record<string, unknown>> {
+		const hasCandidate =
+			candidate.type === 'tool_completed' && candidate.structuredResultJson !== undefined
+		const settlement =
+			candidate.type === 'turn_completed'
+				? (candidate.settlement as Record<string, unknown> | undefined)
+				: undefined
+		const hasOutput = settlement?.structuredOutput !== undefined
+		if (!hasCandidate && !hasOutput) return candidate
+		// Check the original classification before removing any inline evidence.
+		// Otherwise spilling could hide malformed or contradictory metadata.
+		const parsed = SessionRecordSchema.safeParse(candidate)
+		if (!parsed.success) throw new InvalidSessionRecordError(parsed.error.message)
+		if (
+			hasOutput &&
+			(settlement?.status !== 'completed' || settlement.resultSource !== 'structured_output')
+		) {
+			throw new InvalidSessionRecordError(
+				'Only a completed structured_output settlement can retain structured output.',
+			)
+		}
+		let json: string
+		try {
+			json = hasCandidate
+				? (candidate.structuredResultJson as string)
+				: JSON.stringify(cloneJsonValue(settlement?.structuredOutput, false))
+		} catch (error) {
+			throw new InvalidSessionRecordError(`Structured result must be JSON-safe: ${String(error)}`)
+		}
+		const size = Buffer.byteLength(`${JSON.stringify(candidate)}\n`, 'utf8')
+		if (size <= this.#spillAbove) return candidate
+		if (Buffer.byteLength(json, 'utf8') > STRUCTURED_RESULT_MAX_BYTES) {
+			throw new InvalidSessionRecordError(
+				`Structured result exceeds ${STRUCTURED_RESULT_MAX_BYTES} bytes.`,
+			)
+		}
+		// Separate from model-preview spills and from other bodies in this record.
+		const field = hasCandidate ? 'structuredResult' : 'structuredOutput'
+		const ref = await this.#spills.write(`record:${String(candidate.id)}:${field}`, 'text', json)
+		if (hasCandidate) {
+			const { structuredResultJson: _json, ...rest } = candidate
+			return { ...rest, structuredResultSpill: ref }
+		}
+		const { structuredOutput: _output, ...rest } = settlement as Record<string, unknown>
+		return { ...candidate, settlement: rest, structuredOutputSpill: ref }
+	}
+
 	// ── reads ──
 
 	activeTurn(options: ActiveTurnOptions = {}): Promise<ActiveTurn | null> {
@@ -686,8 +793,8 @@ export class SessionLogCore implements SessionLog {
 		})
 	}
 
-	readSpill(ref: SpillRef): Promise<string> {
-		return this.#spills.read(ref)
+	readSpill(ref: SpillRef, options?: SpillReadOptions): Promise<string> {
+		return this.#spills.read(ref, options)
 	}
 }
 

package/src/store/session-log/disk.ts

@@ -133,7 +133,10 @@ export class DiskLogMedium implements LogMedium {
 }
 
 export interface DiskSessionLogOptions
-	extends Pick<SessionLogCoreOptions, 'now' | 'spillAboveBytes' | 'sync'> {
+	extends Pick<
+		SessionLogCoreOptions,
+		'now' | 'spillAboveBytes' | 'structuredResultSpilling' | 'sync'
+	> {
 	readonly sessionId: SessionId
 	/** `<session-id>.jsonl`. */
 	readonly file: string
@@ -168,6 +171,7 @@ export class DiskSessionLog extends SessionLogCore {
 			spills: new DiskSpillStore(options.sessionDir, options.now),
 			now: options.now,
 			spillAboveBytes: options.spillAboveBytes,
+			structuredResultSpilling: options.structuredResultSpilling,
 			sync: options.sync,
 		})
 		this.file = options.file
@@ -184,7 +188,10 @@ export class DiskSessionLog extends SessionLogCore {
 	static at(
 		paths: SessionPaths,
 		locator: SessionLocator,
-		options: Pick<SessionLogCoreOptions, 'now' | 'spillAboveBytes' | 'sync'> = {},
+		options: Pick<
+			SessionLogCoreOptions,
+			'now' | 'spillAboveBytes' | 'structuredResultSpilling' | 'sync'
+		> = {},
 	): DiskSessionLog {
 		return new DiskSessionLog({
 			...options,

package/src/store/session-log/fold.ts

@@ -47,6 +47,14 @@ export function withMessageId<M extends Message>(message: M, id: MessageId | und
 	return { ...message, id }
 }
 
+/**
+ * The key in an `abandoned` `turn_failed`'s `failure.details` that withdraws
+ * the turn's messages from the fold. A detail, not a record field: a log that
+ * carries it still validates for a reader that predates it, which then keeps
+ * the messages, as it always did.
+ */
+export const MESSAGES_WITHDRAWN_DETAIL = 'messagesWithdrawn'
+
 /** One message of the folded context. */
 export interface FoldedMessage {
 	/** Absent for a compaction summary message, which has no record of its own. */
@@ -61,6 +69,7 @@ export interface FoldedMessage {
 }
 
 interface Slot {
+	turnId?: TurnId
 	messageId?: MessageId
 	seq: number
 	message: Message
@@ -128,6 +137,12 @@ export class SessionMessageFold {
 			case 'compaction':
 				this.#compaction(record as CompactionRecord)
 				return
+			case 'turn_failed': {
+				const failure = record.failure
+				if (failure?.code === 'abandoned' && failure.details?.[MESSAGES_WITHDRAWN_DETAIL] === true)
+					this.#withdraw(record.turnId)
+				return
+			}
 			default:
 				return
 		}
@@ -137,6 +152,7 @@ export class SessionMessageFold {
 		const replaced = this.#replacements.get(record.messageId)
 		const existing = this.#byId.get(record.messageId)
 		const slot: Slot = {
+			turnId: record.turnId,
 			messageId: record.messageId,
 			seq: record.seq,
 			message: replaced?.message ?? record.content,
@@ -163,6 +179,12 @@ export class SessionMessageFold {
 		this.#byId.set(record.messageId, slot)
 	}
 
+	/** An abandoned turn handed back to the person: its messages leave the context. */
+	#withdraw(turnId: TurnId): void {
+		this.#slots = this.#slots.filter((slot) => slot.turnId !== turnId)
+		for (const [id, slot] of this.#byId) if (slot.turnId === turnId) this.#byId.delete(id)
+	}
+
 	#compaction(record: CompactionRecord): void {
 		const [, toSeq] = record.replacesSeqRange
 		const keep = new Set<string>([...record.keptMessageIds, ...(record.pinned ?? [])])

package/src/store/session-log/index.ts

@@ -19,6 +19,7 @@ export {
 export {
 	type ActiveTurn,
 	type ActiveTurnOptions,
+	type AbandonTurnLogOptions,
 	type BeginTurnOptions,
 	InvalidSessionRecordError,
 	type LogMedium,
@@ -51,6 +52,7 @@ export {
 	type SpilledSummary,
 	SpillUnavailableError,
 	TurnRuleError,
+	MESSAGES_WITHDRAWN_DETAIL,
 	foldSessionMessages,
 	withMessageId,
 } from './fold.js'
@@ -83,7 +85,10 @@ export {
 	SPILL_DIR,
 	SpillIntegrityError,
 	type SpillManifest,
+	type SpillReadOptions,
 	type SpillRef,
 	type SpillStore,
 	spillFileName,
 } from './spill.js'
+export { readStructuredOutput, type StructuredResultReadOptions } from './structured-result.js'
+export { STRUCTURED_RESULT_MAX_BYTES } from '../../utils/structured-result-json.js'

package/src/store/session-log/memory.ts

@@ -63,7 +63,7 @@ export class InMemoryLogMedium implements LogMedium {
 }
 
 export interface InMemorySessionLogOptions
-	extends Pick<SessionLogCoreOptions, 'now' | 'spillAboveBytes'> {
+	extends Pick<SessionLogCoreOptions, 'now' | 'spillAboveBytes' | 'structuredResultSpilling'> {
 	readonly sessionId: SessionId
 	/**
 	 * Share storage with another instance, as a second process would see one
@@ -91,6 +91,7 @@ export class InMemorySessionLog extends SessionLogCore {
 			spills,
 			now: options.now,
 			spillAboveBytes: options.spillAboveBytes,
+			structuredResultSpilling: options.structuredResultSpilling,
 			sync: 'none',
 		})
 		this.medium = medium

package/src/store/session-log/spill.ts

@@ -2,6 +2,8 @@ import { createHash, randomBytes } from 'node:crypto'
 import { type FileHandle, link, mkdir, open, readFile, rename, unlink } from 'node:fs/promises'
 import { dirname, isAbsolute, join, normalize, sep } from 'node:path'
 
+import { decode, openEvidence, readBytes, stamp } from '../evidence/io.js'
+
 /**
  * Content too large for one record, written beside the log before the record
  * that names it.
@@ -183,7 +185,52 @@ async function durableCreateFile(target: string, content: string): Promise<boole
 /** Where spills are kept. The disk log uses files; the in-memory log a map. */
 export interface SpillStore {
 	write(key: string, content: SpillManifest['content'], text: string): Promise<SpillRef>
-	read(ref: SpillRef): Promise<string>
+	read(ref: SpillRef, options?: SpillReadOptions): Promise<string>
+}
+
+/** Optional bounds for full-body spill reads; omitted limits preserve legacy reads. */
+export interface SpillReadOptions {
+	/** Maximum UTF-8 body bytes. Must be a nonnegative safe integer. */
+	readonly maxBytes?: number
+	/** Stops waiting at I/O boundaries and prevents publication of a cancelled read. */
+	readonly signal?: AbortSignal
+}
+
+function checkedReadLimit(ref: SpillRef, options?: SpillReadOptions): number | undefined {
+	options?.signal?.throwIfAborted()
+	const maxBytes = options?.maxBytes
+	if (maxBytes === undefined) return undefined
+	if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) {
+		throw new RangeError('SpillReadOptions.maxBytes must be a nonnegative safe integer.')
+	}
+	if (!Number.isSafeInteger(ref.bytes) || ref.bytes < 0) {
+		throw new SpillIntegrityError(
+			ref.path,
+			`Spill ${ref.path} has an invalid declared byte length.`,
+		)
+	}
+	if (ref.bytes > maxBytes) {
+		throw new SpillIntegrityError(
+			ref.path,
+			`Spill ${ref.path} declares ${ref.bytes} bytes, exceeding the ${maxBytes}-byte read limit.`,
+		)
+	}
+	return maxBytes
+}
+
+function checkActualReadSize(ref: SpillRef, bytes: number, maxBytes: number): void {
+	if (bytes > maxBytes) {
+		throw new SpillIntegrityError(
+			ref.path,
+			`Spill ${ref.path} is ${bytes} bytes, exceeding the ${maxBytes}-byte read limit.`,
+		)
+	}
+	if (bytes !== ref.bytes) {
+		throw new SpillIntegrityError(
+			ref.path,
+			`Spill ${ref.path} is ${bytes} bytes; its record says ${ref.bytes}.`,
+		)
+	}
 }
 
 function checkRelative(path: string): string {
@@ -262,19 +309,50 @@ export class DiskSpillStore implements SpillStore {
 		return ref
 	}
 
-	async read(ref: SpillRef): Promise<string> {
+	async read(ref: SpillRef, options?: SpillReadOptions): Promise<string> {
+		const maxBytes = checkedReadLimit(ref, options)
 		const path = join(this.sessionDir, checkRelative(ref.path))
 		let text: string
 		try {
-			text = await readFile(path, 'utf8')
+			options?.signal?.throwIfAborted()
+			if (maxBytes === undefined) {
+				text = await readFile(path, { encoding: 'utf8', signal: options?.signal })
+			} else {
+				// Reject links and special files before allocating a body buffer. The
+				// same narrow I/O primitives protect retained evidence readers.
+				const handle = await openEvidence(path)
+				try {
+					options?.signal?.throwIfAborted()
+					const before = await handle.stat()
+					checkActualReadSize(ref, before.size, maxBytes)
+					const bytes = await readBytes(handle, 0, before.size, {
+						bytes: 0,
+						limit: maxBytes,
+						signal: options?.signal,
+					})
+					options?.signal?.throwIfAborted()
+					if (stamp(before) !== stamp(await handle.stat())) {
+						throw new SpillIntegrityError(ref.path, `Spill ${ref.path} changed while reading.`)
+					}
+					options?.signal?.throwIfAborted()
+					text = decode(bytes)
+				} finally {
+					await handle.close()
+				}
+			}
 		} catch (error) {
+			options?.signal?.throwIfAborted()
+			if (error instanceof SpillIntegrityError) throw error
 			throw new SpillIntegrityError(
 				ref.path,
 				`Spill ${ref.path} cannot be read (${(error as NodeJS.ErrnoException).code ?? 'error'}). Refusing rather than folding a message the log cannot vouch for.`,
 				{ cause: error },
 			)
 		}
-		return verify(ref, text)
+		options?.signal?.throwIfAborted()
+		const verified = verify(ref, text)
+		options?.signal?.throwIfAborted()
+		return verified
 	}
 }
 
@@ -301,11 +379,16 @@ export class InMemorySpillStore implements SpillStore {
 		return ref
 	}
 
-	async read(ref: SpillRef): Promise<string> {
+	async read(ref: SpillRef, options?: SpillReadOptions): Promise<string> {
+		const maxBytes = checkedReadLimit(ref, options)
 		const text = this.#files.get(checkRelative(ref.path).split(sep).join('/'))
 		if (text === undefined) {
 			throw new SpillIntegrityError(ref.path, `Spill ${ref.path} does not exist.`)
 		}
-		return verify(ref, text)
+		if (maxBytes !== undefined) checkActualReadSize(ref, Buffer.byteLength(text, 'utf8'), maxBytes)
+		options?.signal?.throwIfAborted()
+		const verified = verify(ref, text)
+		options?.signal?.throwIfAborted()
+		return verified
 	}
 }