@novasamatech/statement-store 0.9.0 → 0.9.2

package/dist/session/session.spec.js

@@ -6,9 +6,10 @@ import { describe, expect, it, vi } from 'vitest';
 import { createInMemoryStatementStore } from '../adapter/inMemory.js';
 import { AccountFullError, ExpiryTooLowError } from '../adapter/types.js';
 import { createAccountId, createLocalSessionAccount, createRemoteSessionAccount } from '../model/sessionAccount.js';
+import { STATEMENT_OVERHEAD } from './core.js';
 import { DecodingError, UnknownError } from './error.js';
 import { StatementData } from './scale/statementData.js';
-import { STATEMENT_OVERHEAD, createSession } from './session.js';
+import { createSession } from './session.js';
 // Real signature work belongs in statementProver tests; this stub stamps a
 // non-empty proof so submitted statements are well-formed.
 const mockProver = {
@@ -160,11 +161,14 @@ describe('session', () => {
         it('queries the outgoing and incoming topics on creation', async () => {
             const { adapter } = makeSession();
             await delay();
-            // Two single-topic matchAll queries — one per topic (outgoing/incoming); they must differ.
-            const topics = adapter.queryStatements.mock.calls.map(([f]) => f.matchAll);
-            expect(topics).toHaveLength(2);
-            expect(topics.map(t => t.length)).toEqual([1, 1]);
-            expect(topics[0]).not.toEqual(topics[1]);
+            // Outgoing is our single publish topic (matchAll); incoming is matchAny because a
+            // multi-device session listens on one topic per peer device. Both carry exactly one
+            // topic here, and they must differ.
+            const filters = adapter.queryStatements.mock.calls.map(([f]) => f);
+            expect(filters).toHaveLength(2);
+            expect(filters[0].matchAll).toHaveLength(1);
+            expect(filters[1].matchAny).toHaveLength(1);
+            expect(filters[0].matchAll).not.toEqual(filters[1].matchAny);
         });
         it('seeds the expiry from the highest own statement expiry', async () => {
             const highExpiry = createExpiryFromDuration(7 * 24 * 60 * 60) + 9999n;
@@ -533,6 +537,18 @@ describe('session', () => {
             // One subscription: the incoming topic carries both peer requests and peer responses.
             expect(store.activeSubscriptions()).toBe(1);
         });
+        it('reopens the subscription when a subscriber returns after the last one left', async () => {
+            const { subscribeStatements } = capturingSubscribe();
+            const { session } = makeSession({ subscribeStatements });
+            await delay();
+            const unsubscribe = session.subscribe(rawCodec, vi.fn());
+            expect(subscribeStatements).toHaveBeenCalledTimes(1);
+            unsubscribe();
+            // The topic-set watcher and the store subscription must be torn down together —
+            // otherwise the session silently never listens again.
+            session.subscribe(rawCodec, vi.fn());
+            expect(subscribeStatements).toHaveBeenCalledTimes(2);
+        });
         it('tears down the subscription when the last subscriber leaves', () => {
             const store = createInMemoryStatementStore();
             const session = makeHost(store);

package/dist/session/stateMachine.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The session's transport decision logic as a pure reducer: {@link transition} maps a
+ * {@link SessionState} and a {@link SessionEvent} to the next state plus the
+ * {@link SessionEffect}s the driver must perform. It performs no I/O, mutates nothing it is
+ * given, and reads no clock — sizing and id generation arrive in {@link TransitionContext},
+ * so tests make both deterministic.
+ *
+ * The state is what base-spec.md §"Session State" defines: the phase, the outgoing request
+ * plus the queue behind it, and the incoming requests.
+ *
+ * Deliberate deviation from base-spec.md: `incomingRequests` is a map rather than the
+ * spec's single `IncomingRequest(A, B)`. The spec's model assumes the Application Layer
+ * answers synchronously; this SDK lets it answer whenever, so an older request has to stay
+ * answerable after a newer one arrives. It is local bookkeeping only — the wire is
+ * unaffected, since the shared response channel still exposes just the latest response.
+ */
+import type { ResponseStatus } from './scale/statementData.js';
+type QueuedMessage = {
+    encoded: Uint8Array;
+    tokens: string[];
+};
+type OutgoingRequest = {
+    requestIds: string[];
+    messages: Uint8Array[];
+    tokens: string[];
+};
+type IncomingRequest = {
+    responded: boolean;
+};
+export type SessionState = {
+    phase: 'initialization' | 'active' | 'failed';
+    initError: Error | null;
+    outgoingRequest: OutgoingRequest | null;
+    messageQueue: QueuedMessage[];
+    incomingRequests: Map<string, IncomingRequest>;
+};
+export type SessionEvent = 
+/** The application layer wants a message sent. */
+{
+    type: 'messageSubmitted';
+    encoded: Uint8Array;
+    token: string;
+}
+/** A peer request we had not seen before. */
+ | {
+    type: 'requestReceived';
+    requestId: string;
+}
+/** A peer response arrived on our outgoing batch. */
+ | {
+    type: 'responseReceived';
+    requestId: string;
+    responseCode: ResponseStatus;
+}
+/** A request submission exhausted its retries. */
+ | {
+    type: 'requestSubmitFailed';
+    requestId: string;
+    error: Error;
+}
+/** We answered an incoming request (marked before the submit, so concurrent callers dedupe). */
+ | {
+    type: 'responseSubmitted';
+    requestId: string;
+}
+/** That answer failed after retries — let a later peer retransmit be answered. */
+ | {
+    type: 'responseSubmitFailed';
+    requestId: string;
+}
+/**
+ * The statement budget may now hold a different number of messages — the peer's device
+ * roster changed, so the envelope grew or shrank. Re-evaluate what the queue can ship.
+ */
+ | {
+    type: 'capacityChanged';
+}
+/** Drop the live batch and everything queued behind it. */
+ | {
+    type: 'outgoingCleared';
+}
+/** An unacknowledged batch was found in the store during initialization. */
+ | {
+    type: 'outgoingRestored';
+    requestId: string;
+    messages: Uint8Array[];
+}
+/** An incoming request was found in the store during initialization. */
+ | {
+    type: 'incomingRestored';
+    requestId: string;
+    responded: boolean;
+}
+/** Initialization finished: go active and ship whatever the queue held. */
+ | {
+    type: 'activated';
+}
+/** Initialization failed terminally. */
+ | {
+    type: 'initFailed';
+    error: Error;
+};
+/** Work the driver must carry out. The reducer performs none of it. */
+export type SessionEffect = {
+    type: 'submitRequest';
+    requestId: string;
+    messages: Uint8Array[];
+} | {
+    type: 'resolveTokens';
+    tokens: string[];
+    requestId: string;
+    responseCode: ResponseStatus;
+} | {
+    type: 'rejectTokens';
+    tokens: string[];
+    error: Error;
+};
+export type TransitionContext = {
+    /** Whether these messages fit one statement — the body builder is the size oracle. */
+    fits: (messages: Uint8Array[]) => boolean;
+    newRequestId: () => string;
+};
+export type Transition = {
+    state: SessionState;
+    effects: SessionEffect[];
+};
+export declare function initialSessionState(): SessionState;
+export declare function incomingRequest(state: SessionState, requestId: string): IncomingRequest | undefined;
+/**
+ * The newest submission of the live batch: the id still worth retrying, and the one whose
+ * on-chain statement must be superseded to clear the batch. Null when nothing is in flight.
+ */
+export declare function liveRequestId(state: SessionState): string | null;
+export declare function transition(state: SessionState, event: SessionEvent, ctx: TransitionContext): Transition;
+export {};

package/dist/session/stateMachine.js

@@ -0,0 +1,203 @@
+/**
+ * The session's transport decision logic as a pure reducer: {@link transition} maps a
+ * {@link SessionState} and a {@link SessionEvent} to the next state plus the
+ * {@link SessionEffect}s the driver must perform. It performs no I/O, mutates nothing it is
+ * given, and reads no clock — sizing and id generation arrive in {@link TransitionContext},
+ * so tests make both deterministic.
+ *
+ * The state is what base-spec.md §"Session State" defines: the phase, the outgoing request
+ * plus the queue behind it, and the incoming requests.
+ *
+ * Deliberate deviation from base-spec.md: `incomingRequests` is a map rather than the
+ * spec's single `IncomingRequest(A, B)`. The spec's model assumes the Application Layer
+ * answers synchronously; this SDK lets it answer whenever, so an older request has to stay
+ * answerable after a newer one arrives. It is local bookkeeping only — the wire is
+ * unaffected, since the shared response channel still exposes just the latest response.
+ */
+import { toHex } from '@novasamatech/scale';
+export function initialSessionState() {
+    return {
+        phase: 'initialization',
+        initError: null,
+        outgoingRequest: null,
+        messageQueue: [],
+        incomingRequests: new Map(),
+    };
+}
+// ── selectors ────────────────────────────────────────────────────────────────
+// Reads the driver needs that are not transitions.
+export function incomingRequest(state, requestId) {
+    return state.incomingRequests.get(requestId);
+}
+/**
+ * The newest submission of the live batch: the id still worth retrying, and the one whose
+ * on-chain statement must be superseded to clear the batch. Null when nothing is in flight.
+ */
+export function liveRequestId(state) {
+    return state.outgoingRequest?.requestIds.at(-1) ?? null;
+}
+// ── internals ────────────────────────────────────────────────────────────────
+const nothing = (state) => ({ state, effects: [] });
+function withIncoming(state, requestId, value) {
+    return { ...state, incomingRequests: new Map(state.incomingRequests).set(requestId, value) };
+}
+/**
+ * Attach `token` to an identical message already in flight or queued, so the caller
+ * resolves on that message's response instead of the bytes going out twice.
+ * Returns null when nothing matches.
+ */
+function attachToDuplicate(state, encoded, token) {
+    const encodedHex = toHex(encoded);
+    const sameBytes = (m) => m.length === encoded.length && toHex(m) === encodedHex;
+    const outgoing = state.outgoingRequest;
+    if (outgoing?.messages.some(sameBytes)) {
+        return { ...state, outgoingRequest: { ...outgoing, tokens: [...outgoing.tokens, token] } };
+    }
+    // Only the first match takes the token; a later identical entry must not duplicate it.
+    const index = state.messageQueue.findIndex(entry => sameBytes(entry.encoded));
+    if (index === -1)
+        return null;
+    return {
+        ...state,
+        messageQueue: state.messageQueue.map((entry, i) => i === index ? { ...entry, tokens: [...entry.tokens, token] } : entry),
+    };
+}
+/** Start a batch, extend the live one, or park the message behind it. */
+function admit(state, encoded, tokens, ctx) {
+    const outgoing = state.outgoingRequest;
+    if (outgoing === null) {
+        const requestId = ctx.newRequestId();
+        const messages = [encoded];
+        return {
+            state: { ...state, outgoingRequest: { requestIds: [requestId], messages, tokens: [...tokens] } },
+            effects: [{ type: 'submitRequest', requestId, messages: [...messages] }],
+        };
+    }
+    const messages = [...outgoing.messages, encoded];
+    if (ctx.fits(messages)) {
+        const requestId = ctx.newRequestId();
+        return {
+            state: {
+                ...state,
+                outgoingRequest: {
+                    requestIds: [...outgoing.requestIds, requestId],
+                    messages,
+                    tokens: [...outgoing.tokens, ...tokens],
+                },
+            },
+            // The statement store keeps one statement per channel, so every submission must
+            // carry the FULL unacknowledged batch — an offline peer only ever sees the survivor.
+            effects: [{ type: 'submitRequest', requestId, messages: [...messages] }],
+        };
+    }
+    return { state: { ...state, messageQueue: [...state.messageQueue, { encoded, tokens }] }, effects: [] };
+}
+/**
+ * Move queue heads into the batch for as long as the budget allows. FIFO: a later message
+ * never overtakes one already waiting.
+ */
+function drain(state, ctx) {
+    let current = state;
+    const effects = [];
+    while (current.messageQueue.length > 0) {
+        const [head, ...rest] = current.messageQueue;
+        if (!head)
+            break;
+        // Recomputed per iteration; `admit` grows the batch as it goes.
+        if (current.outgoingRequest !== null && !ctx.fits([...current.outgoingRequest.messages, head.encoded]))
+            break;
+        const admitted = admit({ ...current, messageQueue: rest }, head.encoded, head.tokens, ctx);
+        current = admitted.state;
+        effects.push(...admitted.effects);
+    }
+    return { state: current, effects };
+}
+// ── reducer ──────────────────────────────────────────────────────────────────
+export function transition(state, event, ctx) {
+    switch (event.type) {
+        case 'messageSubmitted': {
+            const deduped = attachToDuplicate(state, event.encoded, event.token);
+            if (deduped)
+                return nothing(deduped);
+            // FIFO: never let a later (fitting) message overtake queued ones, and never submit
+            // before initialization has established the expiry floor.
+            if (state.phase === 'initialization' || state.messageQueue.length > 0) {
+                return nothing({
+                    ...state,
+                    messageQueue: [...state.messageQueue, { encoded: event.encoded, tokens: [event.token] }],
+                });
+            }
+            return admit(state, event.encoded, [event.token], ctx);
+        }
+        case 'requestReceived': {
+            if (state.incomingRequests.has(event.requestId))
+                return nothing(state);
+            return nothing(withIncoming(state, event.requestId, { responded: false }));
+        }
+        case 'responseReceived': {
+            const outgoing = state.outgoingRequest;
+            // Any id the batch was ever submitted under counts — an early response to a
+            // superseded retransmit still answers the same messages.
+            if (!outgoing?.requestIds.includes(event.requestId))
+                return nothing(state);
+            const drained = drain({ ...state, outgoingRequest: null }, ctx);
+            return {
+                state: drained.state,
+                effects: [
+                    {
+                        type: 'resolveTokens',
+                        tokens: outgoing.tokens,
+                        requestId: event.requestId,
+                        responseCode: event.responseCode,
+                    },
+                    ...drained.effects,
+                ],
+            };
+        }
+        case 'requestSubmitFailed': {
+            const outgoing = state.outgoingRequest;
+            // Superseded by a newer retransmit carrying the same tokens — that one owns the
+            // waiters now, so this failure is not the live batch's concern.
+            if (!outgoing || outgoing.requestIds.at(-1) !== event.requestId)
+                return nothing(state);
+            const drained = drain({ ...state, outgoingRequest: null }, ctx);
+            return {
+                state: drained.state,
+                effects: [{ type: 'rejectTokens', tokens: outgoing.tokens, error: event.error }, ...drained.effects],
+            };
+        }
+        case 'responseSubmitted': {
+            const incoming = state.incomingRequests.get(event.requestId);
+            if (!incoming)
+                return nothing(state);
+            return nothing(withIncoming(state, event.requestId, { responded: true }));
+        }
+        case 'responseSubmitFailed': {
+            const incoming = state.incomingRequests.get(event.requestId);
+            if (!incoming)
+                return nothing(state);
+            return nothing(withIncoming(state, event.requestId, { responded: false }));
+        }
+        case 'capacityChanged':
+            // Never before initialization has established the expiry floor; `activated` drains.
+            return state.phase === 'active' ? drain(state, ctx) : nothing(state);
+        case 'outgoingCleared':
+            return nothing({ ...state, outgoingRequest: null, messageQueue: [] });
+        case 'outgoingRestored':
+            return nothing({
+                ...state,
+                // Tokens from a previous run cannot be restored — nobody is awaiting them.
+                outgoingRequest: { requestIds: [event.requestId], messages: event.messages, tokens: [] },
+            });
+        case 'incomingRestored': {
+            // Don't clobber an entry a live delivery created while init was still awaiting.
+            if (state.incomingRequests.has(event.requestId))
+                return nothing(state);
+            return nothing(withIncoming(state, event.requestId, { responded: event.responded }));
+        }
+        case 'activated':
+            return drain({ ...state, phase: 'active' }, ctx);
+        case 'initFailed':
+            return nothing({ ...state, phase: 'failed', initError: event.error, messageQueue: [] });
+    }
+}

package/dist/session/stateMachine.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/session/stateMachine.spec.js

@@ -0,0 +1,276 @@
+import { describe, expect, it } from 'vitest';
+import { incomingRequest, initialSessionState, liveRequestId, transition } from './stateMachine.js';
+const msg = (text) => new TextEncoder().encode(text);
+/**
+ * `fits` counts messages rather than bytes, so a test can say "two per statement" and read
+ * as the batching rule it exercises. Ids are sequential for the same reason.
+ */
+function makeContext({ capacity = Infinity } = {}) {
+    let next = 0;
+    return {
+        fits: messages => messages.length <= capacity,
+        newRequestId: () => `r${(++next).toString()}`,
+    };
+}
+/** Fold a sequence of events, keeping only the effects of the LAST one. */
+function run(events, opts = {}) {
+    const ctx = makeContext(opts);
+    let state = opts.from ?? initialSessionState();
+    let effects = [];
+    for (const event of events) {
+        const result = transition(state, event, ctx);
+        state = result.state;
+        effects = result.effects;
+    }
+    return { state, effects };
+}
+const send = (text, token) => ({
+    type: 'messageSubmitted',
+    encoded: msg(text),
+    token,
+});
+const ACTIVATE = { type: 'activated' };
+const submits = (effects) => effects.filter(e => e.type === 'submitRequest');
+describe('session state machine', () => {
+    it('never mutates the state it is given', () => {
+        const before = initialSessionState();
+        const snapshot = { ...before, messageQueue: [...before.messageQueue] };
+        transition(before, send('a', 't1'), makeContext());
+        expect(before.messageQueue).toEqual(snapshot.messageQueue);
+        expect(before.outgoingRequest).toBeNull();
+    });
+    describe('phase', () => {
+        it('queues instead of submitting while initializing', () => {
+            const { state, effects } = run([send('a', 't1')]);
+            expect(state.phase).toBe('initialization');
+            expect(effects).toEqual([]);
+        });
+        it('drains what initialization queued once active', () => {
+            const { effects } = run([send('a', 't1'), send('b', 't2'), ACTIVATE]);
+            // Both ride one batch: the second extends the first, so the latest submission
+            // carries everything unacknowledged.
+            expect(submits(effects).at(-1)).toMatchObject({ messages: [msg('a'), msg('b')] });
+        });
+        it('records a terminal initialization failure', () => {
+            const error = new Error('init failed');
+            const { state } = run([send('a', 't1'), { type: 'initFailed', error }]);
+            expect(state.phase).toBe('failed');
+            expect(state.initError).toBe(error);
+            expect(state.messageQueue).toEqual([]);
+        });
+    });
+    describe('batching', () => {
+        it('submits the first message immediately', () => {
+            const { effects } = run([ACTIVATE, send('a', 't1')]);
+            expect(effects).toEqual([{ type: 'submitRequest', requestId: 'r1', messages: [msg('a')] }]);
+        });
+        // The store keeps one statement per channel, so each submission must carry every
+        // message the peer has not acknowledged — not just the newest one.
+        it('resubmits the whole unacknowledged batch when extending it', () => {
+            const { effects } = run([ACTIVATE, send('a', 't1'), send('b', 't2')]);
+            expect(effects).toEqual([{ type: 'submitRequest', requestId: 'r2', messages: [msg('a'), msg('b')] }]);
+        });
+        it('queues a message that does not fit the live batch', () => {
+            const { state, effects } = run([ACTIVATE, send('a', 't1'), send('b', 't2')], { capacity: 1 });
+            expect(effects).toEqual([]);
+            expect(state.messageQueue).toHaveLength(1);
+        });
+        it('keeps FIFO: a later fitting message never overtakes a queued one', () => {
+            const events = [ACTIVATE, send('a', 't1'), send('b', 't2'), send('c', 't3'), send('d', 't4')];
+            // Batch holds a+b; c and d both wait, even though d alone would fit.
+            const { state } = run(events, { capacity: 2 });
+            expect(state.messageQueue.map(e => e.tokens)).toEqual([['t3'], ['t4']]);
+            const { effects } = run([...events, { type: 'responseReceived', requestId: 'r2', responseCode: 'success' }], {
+                capacity: 2,
+            });
+            expect(submits(effects).at(-1)).toMatchObject({ messages: [msg('c'), msg('d')] });
+        });
+        it('snapshots the messages of each submission', () => {
+            const ctx = makeContext();
+            let state = transition(initialSessionState(), ACTIVATE, ctx).state;
+            const first = transition(state, send('a', 't1'), ctx);
+            state = first.state;
+            transition(state, send('b', 't2'), ctx);
+            // The earlier effect must not have grown along with the batch.
+            expect(first.effects).toEqual([{ type: 'submitRequest', requestId: 'r1', messages: [msg('a')] }]);
+        });
+    });
+    describe('deduplication', () => {
+        it('attaches a duplicate of an in-flight message instead of resending', () => {
+            const events = [ACTIVATE, send('a', 't1'), send('a', 't2')];
+            expect(run(events).effects).toEqual([]);
+            // Both tokens resolve on the one response.
+            const { effects } = run([...events, { type: 'responseReceived', requestId: 'r1', responseCode: 'success' }]);
+            expect(effects[0]).toMatchObject({ type: 'resolveTokens', tokens: ['t1', 't2'] });
+        });
+        it('attaches a duplicate of a queued message', () => {
+            const events = [ACTIVATE, send('a', 't1'), send('b', 't2'), send('b', 't3')];
+            const { state } = run(events, { capacity: 1 });
+            expect(state.messageQueue).toHaveLength(1);
+            expect(state.messageQueue[0].tokens).toEqual(['t2', 't3']);
+        });
+        it('gives the token to only one of two identical queued entries', () => {
+            // Two distinct queue entries can hold the same bytes when the first was queued
+            // before the second's dedup check could see it.
+            const seeded = {
+                ...initialSessionState(),
+                phase: 'active',
+                outgoingRequest: { requestIds: ['r0'], messages: [msg('x')], tokens: ['t0'] },
+                messageQueue: [
+                    { encoded: msg('dup'), tokens: ['t1'] },
+                    { encoded: msg('dup'), tokens: ['t2'] },
+                ],
+            };
+            const { state } = run([send('dup', 't3')], { capacity: 1, from: seeded });
+            expect(state.messageQueue.map(e => e.tokens)).toEqual([['t1', 't3'], ['t2']]);
+        });
+    });
+    describe('responses', () => {
+        it('resolves the batch tokens and drains the queue', () => {
+            const { effects } = run([
+                ACTIVATE,
+                send('a', 't1'),
+                send('b', 't2'),
+                { type: 'responseReceived', requestId: 'r1', responseCode: 'success' },
+            ], { capacity: 1 });
+            expect(effects[0]).toEqual({ type: 'resolveTokens', tokens: ['t1'], requestId: 'r1', responseCode: 'success' });
+            expect(submits(effects)).toHaveLength(1);
+        });
+        // A retransmit gives the batch a new id, but a response to any earlier id still
+        // answers the same messages and must not be dropped.
+        it('accepts a response to a superseded retransmit id', () => {
+            const { effects } = run([
+                ACTIVATE,
+                send('a', 't1'),
+                send('b', 't2'),
+                { type: 'responseReceived', requestId: 'r1', responseCode: 'success' },
+            ]);
+            expect(effects[0]).toMatchObject({ type: 'resolveTokens', tokens: ['t1', 't2'] });
+        });
+        it('ignores a response for an unknown request', () => {
+            const { effects } = run([
+                ACTIVATE,
+                send('a', 't1'),
+                { type: 'responseReceived', requestId: 'nope', responseCode: 'success' },
+            ]);
+            expect(effects).toEqual([]);
+        });
+        it('ignores a second response for an already-answered batch', () => {
+            const answered = { type: 'responseReceived', requestId: 'r1', responseCode: 'success' };
+            const { effects } = run([ACTIVATE, send('a', 't1'), answered, answered]);
+            expect(effects).toEqual([]);
+        });
+    });
+    describe('request submit failure', () => {
+        it('rejects the waiters of the live batch and drains', () => {
+            const error = new Error('store rejected');
+            const { effects } = run([ACTIVATE, send('a', 't1'), send('b', 't2'), { type: 'requestSubmitFailed', requestId: 'r1', error }], { capacity: 1 });
+            expect(effects[0]).toEqual({ type: 'rejectTokens', tokens: ['t1'], error });
+            expect(submits(effects)).toHaveLength(1);
+        });
+        // The newer retransmit carries the same tokens, so an older submission's failure is
+        // not the live batch's problem.
+        it('ignores the failure of a superseded submission', () => {
+            const { effects } = run([
+                ACTIVATE,
+                send('a', 't1'),
+                send('b', 't2'),
+                { type: 'requestSubmitFailed', requestId: 'r1', error: new Error('stale') },
+            ]);
+            expect(effects).toEqual([]);
+        });
+        it('tracks which submission is live', () => {
+            expect(liveRequestId(run([ACTIVATE, send('a', 't1')]).state)).toBe('r1');
+            // A retransmit takes over: only the newest id is still worth retrying.
+            expect(liveRequestId(run([ACTIVATE, send('a', 't1'), send('b', 't2')]).state)).toBe('r2');
+        });
+    });
+    describe('capacity changes', () => {
+        it('ships what the queue can now hold when the budget grows', () => {
+            // Queued at capacity 1, then re-evaluated once two fit.
+            const ctx = makeContext();
+            let capacity = 1;
+            const sizing = { ...ctx, fits: messages => messages.length <= capacity };
+            let state = transition(initialSessionState(), ACTIVATE, sizing).state;
+            state = transition(state, send('a', 't1'), sizing).state;
+            state = transition(state, send('b', 't2'), sizing).state;
+            expect(state.messageQueue).toHaveLength(1);
+            capacity = 2;
+            const result = transition(state, { type: 'capacityChanged' }, sizing);
+            expect(submits(result.effects).at(-1)).toMatchObject({ messages: [msg('a'), msg('b')] });
+            expect(result.state.messageQueue).toEqual([]);
+        });
+        it('does not ship anything before initialization completes', () => {
+            const { effects, state } = run([send('a', 't1'), { type: 'capacityChanged' }]);
+            expect(effects).toEqual([]);
+            expect(state.messageQueue).toHaveLength(1);
+        });
+    });
+    describe('clearing the outgoing batch', () => {
+        it('reports the id to supersede and drops the batch and queue', () => {
+            const built = run([ACTIVATE, send('a', 't1'), send('b', 't2')], { capacity: 1 });
+            expect(liveRequestId(built.state)).toBe('r1');
+            const { state } = run([{ type: 'outgoingCleared' }], { capacity: 1, from: built.state });
+            expect(state.outgoingRequest).toBeNull();
+            expect(state.messageQueue).toEqual([]);
+            expect(liveRequestId(state)).toBeNull();
+        });
+        it('reports nothing to supersede when nothing is in flight', () => {
+            expect(liveRequestId(initialSessionState())).toBeNull();
+        });
+    });
+    describe('restore', () => {
+        it('adopts an unacknowledged batch found in the store', () => {
+            const { effects } = run([
+                { type: 'outgoingRestored', requestId: 'old', messages: [msg('a')] },
+                ACTIVATE,
+                send('b', 't1'),
+            ]);
+            // A new message extends the restored batch rather than replacing it.
+            expect(effects).toEqual([{ type: 'submitRequest', requestId: 'r1', messages: [msg('a'), msg('b')] }]);
+        });
+        it('answers a restored batch by its original id, resolving no tokens', () => {
+            const { effects } = run([
+                { type: 'outgoingRestored', requestId: 'old', messages: [msg('a')] },
+                ACTIVATE,
+                { type: 'responseReceived', requestId: 'old', responseCode: 'success' },
+            ]);
+            expect(effects).toEqual([{ type: 'resolveTokens', tokens: [], requestId: 'old', responseCode: 'success' }]);
+        });
+        it('does not clobber an incoming request a live delivery already tracked', () => {
+            const { state } = run([
+                { type: 'requestReceived', requestId: 'req' },
+                { type: 'incomingRestored', requestId: 'req', responded: true },
+            ]);
+            expect(incomingRequest(state, 'req')).toEqual({ responded: false });
+        });
+    });
+    describe('incoming requests', () => {
+        it('tracks a request once', () => {
+            const { state } = run([{ type: 'requestReceived', requestId: 'req' }]);
+            expect(incomingRequest(state, 'req')).toEqual({ responded: false });
+            expect(incomingRequest(state, 'nope')).toBeUndefined();
+        });
+        // An async responder must still be able to answer an older request after a newer one
+        // arrives — the reason this is a map and not the spec's single value.
+        it('keeps an older request answerable after a newer one arrives', () => {
+            const { state } = run([
+                { type: 'requestReceived', requestId: 'a' },
+                { type: 'requestReceived', requestId: 'b' },
+            ]);
+            expect(incomingRequest(state, 'a')).toEqual({ responded: false });
+            expect(incomingRequest(state, 'b')).toEqual({ responded: false });
+        });
+        it('marks a request answered, and rolls back when the answer fails', () => {
+            const tracked = { type: 'requestReceived', requestId: 'req' };
+            const answered = run([tracked, { type: 'responseSubmitted', requestId: 'req' }]);
+            expect(incomingRequest(answered.state, 'req')).toEqual({ responded: true });
+            const rolledBack = run([{ type: 'responseSubmitFailed', requestId: 'req' }], { from: answered.state });
+            expect(incomingRequest(rolledBack.state, 'req')).toEqual({ responded: false });
+        });
+        it('ignores answer bookkeeping for an untracked request', () => {
+            const { state } = run([{ type: 'responseSubmitted', requestId: 'ghost' }]);
+            expect(incomingRequest(state, 'ghost')).toBeUndefined();
+        });
+    });
+});