From a415c3572cae2d75c834554db8036a38ffe1dd84 Mon Sep 17 00:00:00 2001 From: Hypatia May Date: Thu, 30 Jul 2026 19:26:55 +0800 Subject: [PATCH] refactor(compact): name compaction entry state --- packages/compact/compact-basic/src/region.ts | 83 +++++++++++--------- 1 file changed, 47 insertions(+), 36 deletions(-) diff --git a/packages/compact/compact-basic/src/region.ts b/packages/compact/compact-basic/src/region.ts index c1331d6d66..2132081557 100644 --- a/packages/compact/compact-basic/src/region.ts +++ b/packages/compact/compact-basic/src/region.ts @@ -56,10 +56,10 @@ interface CompactionTransactionOptions { readonly flush?: () => Promise } -interface TurnTail { - readonly turn: number | null - readonly compactionStart: SessionEvent<'compact/start'> | undefined - readonly endSeedSeq: number | undefined +interface CompactionEntryState { + readonly openTurn: number | null + readonly unmatchedCompactionStart: SessionEvent<'compact/start'> | undefined + readonly latestEndSeedSeq: number | undefined } /** @@ -155,20 +155,24 @@ export async function compactSurfaceRegion( ): Promise { if (options.owner === null) signal?.throwIfAborted() const selection = validateSurfaceRegion(session, start, end) - const tail = inspectTurnTail(session.events) - assertCompactionInactive(tail.compactionStart, tail.endSeedSeq, 'compaction') + const entryState = inspectCompactionEntryState(session.events) + assertCompactionInactive( + entryState.unmatchedCompactionStart, + entryState.latestEndSeedSeq, + 'compaction', + ) let owner: number | null if (options.owner === null) { - if (tail.turn !== null) { + if (entryState.openTurn !== null) { throw new ManualCompactionError('busy', 'manual compaction: the session already has an open turn') } owner = null } else { - if (tail.turn === null) { + if (entryState.openTurn === null) { throw new Error('compactRegion: no open turn — automatic compaction events must be enclosed in a turn') } - owner = tail.turn + owner = entryState.openTurn } const startEvent = session.append('compact/start', { turn: owner }) @@ -257,17 +261,18 @@ function throwManualFailure(failure: TransactionFailure): never { /** * Reject a durable unmatched compaction marker unless a later constructor-seed * boundary proves that its owner belongs to an earlier session lifecycle. - * @param compactionStart - latest unmatched opening marker, if any. - * @param endSeedSeq - newest constructor-seed boundary, if any. + * @param unmatchedCompactionStart - latest unmatched opening marker, if any. + * @param latestEndSeedSeq - newest constructor-seed boundary, if any. * @param stage - operation label included in the busy diagnostic. */ function assertCompactionInactive( - compactionStart: SessionEvent<'compact/start'> | undefined, - endSeedSeq: number | undefined, + unmatchedCompactionStart: SessionEvent<'compact/start'> | undefined, + latestEndSeedSeq: number | undefined, stage: string, ): void { - if (compactionStart === undefined - || (endSeedSeq !== undefined && endSeedSeq > compactionStart.seq)) return + if (unmatchedCompactionStart === undefined + || (latestEndSeedSeq !== undefined + && latestEndSeedSeq > unmatchedCompactionStart.seq)) return throw new ManualCompactionError( 'busy', `${stage}: compaction already in progress; the session compaction lock is already active`, @@ -280,8 +285,12 @@ function assertCompactionInactive( * @param stage - operation label included in the busy diagnostic. */ export function assertNoActiveCompaction(session: Session, stage: string): void { - const tail = inspectTurnTail(session.events) - assertCompactionInactive(tail.compactionStart, tail.endSeedSeq, stage) + const entryState = inspectCompactionEntryState(session.events) + assertCompactionInactive( + entryState.unmatchedCompactionStart, + entryState.latestEndSeedSeq, + stage, + ) } /** Validate one requested surface-position span before asynchronous work begins. */ @@ -474,36 +483,38 @@ function buildSummarizationInput( } } -/** Inspect turn state, unmatched compaction, and newest seed boundary independently. */ -function inspectTurnTail(events: readonly SessionEvent[]): TurnTail { - let turn: number | null = null - let turnStateKnown = false - let compactionStart: SessionEvent<'compact/start'> | undefined - let compactionStateKnown = false - let endSeedSeq: number | undefined +/** Inspect open-turn, unmatched-compaction, and latest seed-boundary state independently. */ +function inspectCompactionEntryState(events: readonly SessionEvent[]): CompactionEntryState { + let openTurn: number | null = null + let openTurnStateKnown = false + let unmatchedCompactionStart: SessionEvent<'compact/start'> | undefined + let compactionEntryStateKnown = false + let latestEndSeedSeq: number | undefined for (let index = events.length - 1; index >= 0; index -= 1) { // oxlint-disable-next-line typescript/no-non-null-assertion const event = events[index]! - if (endSeedSeq === undefined && event.type === 'session/end-seed') { - endSeedSeq = event.seq + if (latestEndSeedSeq === undefined && event.type === 'session/end-seed') { + latestEndSeedSeq = event.seq } - if (!compactionStateKnown) { + if (!compactionEntryStateKnown) { if (event.type === 'compact/start') { - compactionStart = event - compactionStateKnown = true + unmatchedCompactionStart = event + compactionEntryStateKnown = true } else if (event.type === 'compact/end') { - compactionStateKnown = true + compactionEntryStateKnown = true } } - if (!turnStateKnown) { + if (!openTurnStateKnown) { if (event.type === 'turn/start') { - turn = event.data.turn - turnStateKnown = true + openTurn = event.data.turn + openTurnStateKnown = true } else if (event.type === 'turn/end') { - turnStateKnown = true + openTurnStateKnown = true } } - if (turnStateKnown && compactionStateKnown && endSeedSeq !== undefined) break + if (openTurnStateKnown + && compactionEntryStateKnown + && latestEndSeedSeq !== undefined) break } - return { turn, compactionStart, endSeedSeq } + return { openTurn, unmatchedCompactionStart, latestEndSeedSeq } }