Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { describe, expect, it } from 'vitest'
import {
INITIAL_SYNCHRONIZED_OUTPUT_LATCH_STATE,
SYNCHRONIZED_OUTPUT_END_SEQUENCE,
SYNCHRONIZED_OUTPUT_START_SEQUENCE,
advanceDroppedSynchronizedOutputLatch,
resolveSynchronizedOutputSafeSplit,
scanSynchronizedOutput
} from './terminal-synchronized-output-scan'
const OPEN = SYNCHRONIZED_OUTPUT_START_SEQUENCE
const CLOSE = SYNCHRONIZED_OUTPUT_END_SEQUENCE
describe('advanceDroppedSynchronizedOutputLatch', () => {
it('releases the latch when the dropped span ended mid-frame', () => {
// The dropped close never reaches xterm, freezing repaint until its 1s forced flush.
const result = advanceDroppedSynchronizedOutputLatch(
`${OPEN}rows`,
INITIAL_SYNCHRONIZED_OUTPUT_LATCH_STATE
)
expect(result.state.active).toBe(true)
expect(result.data).toBe(CLOSE)
})
it('emits nothing when the dropped span closed its own frame', () => {
const result = advanceDroppedSynchronizedOutputLatch(
`${OPEN}rows${CLOSE}`,
INITIAL_SYNCHRONIZED_OUTPUT_LATCH_STATE
)
expect(result.state.active).toBe(false)
expect(result.data).toBe('')
})
it('carries an open latch across successive dropped chunks', () => {
const first = advanceDroppedSynchronizedOutputLatch(
`${OPEN}a`,
INITIAL_SYNCHRONIZED_OUTPUT_LATCH_STATE
)
const second = advanceDroppedSynchronizedOutputLatch('b', first.state)
expect(second.state.active).toBe(true)
expect(second.data).toBe(CLOSE)
const third = advanceDroppedSynchronizedOutputLatch(CLOSE, second.state)
expect(third.state.active).toBe(false)
expect(third.data).toBe('')
})
it('stitches a close marker split across dropped chunks', () => {
const head = CLOSE.slice(0, 4)
const tail = CLOSE.slice(4)
const first = advanceDroppedSynchronizedOutputLatch(
`${OPEN}rows${head}`,
INITIAL_SYNCHRONIZED_OUTPUT_LATCH_STATE
)
expect(first.state.active).toBe(true)
const second = advanceDroppedSynchronizedOutputLatch(tail, first.state)
expect(second.state.active).toBe(false)
expect(second.data).toBe('')
})
})
describe('resolveSynchronizedOutputSafeSplit', () => {
it('splits after a completed frame rather than inside the next one', () => {
const data = `${OPEN}aaaa${CLOSE}${OPEN}bbbbbbbbbb${CLOSE}`
const limit = data.indexOf('bbb')
const splitAt = resolveSynchronizedOutputSafeSplit(data, limit)
// Everything delivered must leave the latch closed.
expect(scanSynchronizedOutput(data.slice(0, splitAt), '', false).active).toBe(false)
expect(splitAt).toBe(`${OPEN}aaaa${CLOSE}`.length)
})
it('never severs the close marker itself', () => {
const data = `${OPEN}aaaa${CLOSE}tail`
// Limit lands in the middle of the 8-byte close sequence.
const limit = `${OPEN}aaaa`.length + 4
const splitAt = resolveSynchronizedOutputSafeSplit(data, limit)
expect(splitAt).toBeLessThanOrEqual(limit)
expect(data.slice(0, splitAt).endsWith('\x1b')).toBe(false)
// The remainder must still contain a complete, parseable close.
expect(data.slice(splitAt)).toContain(CLOSE)
})
it('falls back to the limit when one frame is longer than the window', () => {
const data = `${OPEN}${'x'.repeat(100)}${CLOSE}`
expect(resolveSynchronizedOutputSafeSplit(data, 20)).toBe(20)
})
})