@beeuni/sdk 0.1.0

package/dist/core/session/wire-id-unwrap.js

@@ -0,0 +1,15 @@
+import { WIRE_ID_TIME_MASK, WIRE_ID_TIME_SCALE } from './wire-message-id.js';
+const WIRE_ID_TIME_SPAN = WIRE_ID_TIME_MASK + BigInt(1);
+const HALF_SPAN = WIRE_ID_TIME_SPAN / BigInt(2);
+export function absoluteWireIdClockAt(ms) {
+    return BigInt(Math.trunc(ms)) * WIRE_ID_TIME_SCALE;
+}
+export function unwrapWireIdClock(clock, anchor) {
+    const base = anchor - (anchor & WIRE_ID_TIME_MASK);
+    let unwrapped = base + clock;
+    if (unwrapped - anchor > HALF_SPAN)
+        unwrapped -= WIRE_ID_TIME_SPAN;
+    else if (anchor - unwrapped > HALF_SPAN)
+        unwrapped += WIRE_ID_TIME_SPAN;
+    return unwrapped;
+}

package/dist/core/session/wire-message-id.d.ts

@@ -0,0 +1,27 @@
+export declare const WIRE_ID_TIME_SCALE: bigint;
+export declare const WIRE_ID_TIME_MASK: bigint;
+export declare const WIRE_ID_CLOCK_TOLERANCE: bigint;
+export declare const WIRE_ID_BACKDATE_MS: number;
+export declare const WIRE_MESSAGE_ID: RegExp;
+export declare function wireIdClock(id: string | null | undefined): bigint | null;
+export declare function wireIdClockAt(ms: number): bigint;
+export declare function wireIdClockDelta(clock: bigint, reference: bigint): bigint;
+export declare function maxWireIdClock(clocks: Iterable<bigint | null | undefined>): bigint | null;
+export declare function isWireIdAheadOf(id: string, nowMs: number): boolean;
+export declare function newestWireIdClock(ids: Iterable<string | null | undefined>, nowMs?: number): bigint | null;
+export interface MintedWireMessageId {
+    id: string;
+    time: bigint;
+}
+export interface MintWireMessageIdAboveInput {
+    nowMs: number;
+    newestKnownTime?: bigint | null;
+    backdateMs?: number;
+    random?: () => number;
+}
+export declare function mintWireMessageIdAbove(input: MintWireMessageIdAboveInput): MintedWireMessageId;
+export interface MintWireMessageIdOptions {
+    nowMs?: number;
+    after?: Iterable<string | null | undefined>;
+}
+export declare function mintWireMessageId(options?: MintWireMessageIdOptions): string;

package/dist/core/session/wire-message-id.js

@@ -0,0 +1,88 @@
+export const WIRE_ID_TIME_SCALE = BigInt(0x1000);
+export const WIRE_ID_TIME_MASK = BigInt(0xffffffffffff);
+const WIRE_ID_TIME_SPAN = WIRE_ID_TIME_MASK + BigInt(1);
+const HALF_SPAN = WIRE_ID_TIME_SPAN / BigInt(2);
+export const WIRE_ID_CLOCK_TOLERANCE = BigInt(60 * 60 * 1000) * WIRE_ID_TIME_SCALE;
+export const WIRE_ID_BACKDATE_MS = 2 * 60 * 1000;
+export const WIRE_MESSAGE_ID = /^msg_[0-9a-f]{12}[A-Za-z0-9]{14}$/;
+const WIRE_ID_CLOCK = /^msg_([0-9a-f]{12})/;
+const BASE62 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+export function wireIdClock(id) {
+    const match = WIRE_ID_CLOCK.exec(id ?? '');
+    return match ? BigInt(`0x${match[1]}`) : null;
+}
+export function wireIdClockAt(ms) {
+    return (BigInt(Math.trunc(ms)) * WIRE_ID_TIME_SCALE) & WIRE_ID_TIME_MASK;
+}
+export function wireIdClockDelta(clock, reference) {
+    let delta = (clock - reference) & WIRE_ID_TIME_MASK;
+    if (delta >= HALF_SPAN)
+        delta -= WIRE_ID_TIME_SPAN;
+    return delta;
+}
+export function maxWireIdClock(clocks) {
+    let newest = null;
+    for (const clock of clocks) {
+        if (clock === null || clock === undefined)
+            continue;
+        if (newest === null || wireIdClockDelta(clock, newest) > BigInt(0))
+            newest = clock;
+    }
+    return newest;
+}
+export function isWireIdAheadOf(id, nowMs) {
+    const clock = wireIdClock(id);
+    if (clock === null)
+        return false;
+    return wireIdClockDelta(clock, wireIdClockAt(nowMs)) > WIRE_ID_CLOCK_TOLERANCE;
+}
+export function newestWireIdClock(ids, nowMs) {
+    const now = nowMs === undefined ? null : wireIdClockAt(nowMs);
+    return newestClockWhere(ids, (clock) => now === null || wireIdClockDelta(clock, now) <= WIRE_ID_CLOCK_TOLERANCE);
+}
+function newestClockWhere(ids, keep) {
+    const kept = [];
+    for (const id of ids) {
+        const clock = wireIdClock(id);
+        if (clock !== null && keep(clock))
+            kept.push(clock);
+    }
+    return maxWireIdClock(kept);
+}
+function cryptoTail() {
+    let tail = '';
+    const bytes = new Uint8Array(32);
+    while (tail.length < 14) {
+        crypto.getRandomValues(bytes);
+        for (const b of bytes)
+            if (b < 248 && tail.length < 14)
+                tail += BASE62[b % 62];
+    }
+    return tail;
+}
+export function mintWireMessageIdAbove(input) {
+    const random = input.random;
+    let time = wireIdClockAt(input.nowMs - (input.backdateMs ?? WIRE_ID_BACKDATE_MS));
+    const floor = input.newestKnownTime ?? null;
+    if (floor !== null) {
+        const ahead = wireIdClockDelta(floor, time);
+        if (ahead >= BigInt(0) && ahead <= WIRE_ID_CLOCK_TOLERANCE)
+            time = (floor + BigInt(1)) & WIRE_ID_TIME_MASK;
+    }
+    let tail = '';
+    if (random)
+        for (let i = 0; i < 14; i++)
+            tail += BASE62[Math.min(61, Math.floor(random() * 62))];
+    else
+        tail = cryptoTail();
+    return { id: `msg_${time.toString(16).padStart(12, '0')}${tail}`, time };
+}
+export function mintWireMessageId(options = {}) {
+    const nowMs = options.nowMs ?? Date.now();
+    const backdated = wireIdClockAt(nowMs - WIRE_ID_BACKDATE_MS);
+    const newest = newestClockWhere(options.after ?? [], (clock) => {
+        const ahead = wireIdClockDelta(clock, backdated);
+        return ahead >= BigInt(0) && ahead <= WIRE_ID_CLOCK_TOLERANCE;
+    });
+    return mintWireMessageIdAbove({ nowMs, newestKnownTime: newest }).id;
+}

package/dist/core/session/working-evidence.d.ts

@@ -0,0 +1,13 @@
+import { type WorkingInputs } from './working.js';
+export declare function workingEvidence({ optimistic, abort, inbox, server, stream, activity, nowMs, }: WorkingInputs): {
+    receiptLive: boolean;
+    receiptTurnId: string | null;
+    serverFloor: number;
+    streamFloor: number;
+    abortLive: boolean;
+    abortFloor: number;
+    serverFresh: boolean;
+    streamFresh: boolean;
+    inboxFresh: boolean;
+    activityFresh: boolean;
+};

package/dist/core/session/working-evidence.js

@@ -0,0 +1,25 @@
+import { INBOX_OBSERVATION_MAX_MS, OPTIMISTIC_ABORT_MAX_MS, OPTIMISTIC_RECEIPT_MAX_MS, SERVER_OBSERVATION_MAX_MS, STREAM_OBSERVATION_MAX_MS, } from './working.js';
+export function workingEvidence({ optimistic, abort, inbox, server, stream, activity, nowMs, }) {
+    const receiptLive = !!optimistic && nowMs - optimistic.atMs < OPTIMISTIC_RECEIPT_MAX_MS;
+    const abortLive = !!abort && nowMs - abort.atMs < OPTIMISTIC_ABORT_MAX_MS;
+    return {
+        receiptLive,
+        receiptTurnId: optimistic
+            ? optimistic.turnId === undefined
+                ? optimistic.messageId
+                : optimistic.turnId
+            : null,
+        serverFloor: receiptLive
+            ? (optimistic?.acceptedAtMs ?? Number.POSITIVE_INFINITY)
+            : Number.NEGATIVE_INFINITY,
+        streamFloor: receiptLive ? optimistic?.atMs : Number.NEGATIVE_INFINITY,
+        abortLive,
+        abortFloor: abortLive
+            ? (abort?.settledAtMs ?? Number.POSITIVE_INFINITY)
+            : Number.NEGATIVE_INFINITY,
+        serverFresh: !!server && nowMs - server.atMs <= SERVER_OBSERVATION_MAX_MS,
+        streamFresh: !!stream && nowMs - stream.atMs <= STREAM_OBSERVATION_MAX_MS,
+        inboxFresh: !!inbox && nowMs - inbox.atMs <= INBOX_OBSERVATION_MAX_MS,
+        activityFresh: !!activity && nowMs - activity.atMs <= STREAM_OBSERVATION_MAX_MS,
+    };
+}

package/dist/core/session/working-project.d.ts

@@ -0,0 +1,2 @@
+import type { WorkingInputs, WorkingProjection } from './working.js';
+export declare function decideWorking(inputs: WorkingInputs): WorkingProjection;

package/dist/core/session/working-project.js

@@ -0,0 +1,145 @@
+import { workingEvidence } from './working-evidence.js';
+import { endedByRuntime } from './working-runtime.js';
+import { instant } from './working-time.js';
+function runtimeActivity(inputs, evidence, idleFrame, serverOpenTurnToken) {
+    const { activity, server } = inputs;
+    const { serverFresh, abortFloor, activityFresh } = evidence;
+    const activityAfterIdle = activityFresh && (!idleFrame || activity.atMs > idleFrame.atMs);
+    if (activityAfterIdle && activity.atMs >= abortFloor) {
+        return {
+            state: 'working',
+            source: 'stream',
+            turnId: serverFresh
+                ? (server.turns.find((turn) => turn.state === 'active' && !endedByRuntime(turn, idleFrame, server))?.message_id ?? null)
+                : null,
+            since: activity.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    return null;
+}
+function openAuthority(inputs, evidence, idleFrame, serverOpenTurnToken) {
+    const { server, stream } = inputs;
+    const { serverFresh, abortFloor } = evidence;
+    const openTurns = serverFresh
+        ? server.turns.filter((t) => !endedByRuntime(t, idleFrame, server))
+        : [];
+    const openTurn = openTurns.find((turn) => turn.state === 'active') ?? openTurns[0];
+    const streamContradicts = !!stream && !(stream.type === 'idle' && stream.origin === 'local');
+    if (openTurn &&
+        server.atMs >= abortFloor &&
+        (!streamContradicts || server.atMs >= stream.atMs)) {
+        return {
+            result: {
+                ...(openTurn.state === 'delivering' ? { pendingDelivery: true } : {}),
+                state: 'working',
+                source: 'server',
+                turnId: openTurn.message_id,
+                since: instant(openTurn.started_at) ?? server.atMs,
+                serverOpenTurnToken,
+            },
+            openTurn,
+        };
+    }
+    return { result: null, openTurn };
+}
+function inboxAuthority(inputs, evidence, serverOpenTurnToken) {
+    const { inbox, server, stream } = inputs;
+    const { inboxFresh, abortFloor, streamFresh, serverFresh, receiptLive, receiptTurnId, abortLive, } = evidence;
+    if (inboxFresh && inbox.pending > 0 && inbox.atMs >= abortFloor) {
+        const runtimeIsResponding = streamFresh &&
+            stream.type !== 'idle' &&
+            (!serverFresh || stream.atMs > server.atMs) &&
+            stream.atMs >= abortFloor;
+        return {
+            ...(!runtimeIsResponding ? { pendingDelivery: true } : {}),
+            state: 'working',
+            source: 'server',
+            turnId: receiptLive ? receiptTurnId : null,
+            since: inbox.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    const drainedAtMs = inbox?.drainedAtMs;
+    const drainFloorHolds = inboxFresh &&
+        inbox.pending === 0 &&
+        drainedAtMs != null &&
+        !abortLive &&
+        !(serverFresh && server.atMs >= drainedAtMs);
+    if (drainFloorHolds) {
+        return {
+            pendingDelivery: true,
+            state: 'working',
+            source: 'server',
+            turnId: null,
+            since: drainedAtMs,
+            serverOpenTurnToken,
+        };
+    }
+    return null;
+}
+function lastAnswer(inputs, evidence, openTurn, serverOpenTurnToken) {
+    const { server, stream, optimistic, nowMs } = inputs;
+    const { serverFresh, serverFloor, streamFresh, streamFloor, abortFloor, receiptLive, receiptTurnId, } = evidence;
+    const serverAnswers = serverFresh && !openTurn && server.atMs >= serverFloor;
+    const streamAnswers = streamFresh &&
+        stream.atMs >= streamFloor &&
+        (stream.type === 'idle' || stream.atMs >= abortFloor);
+    if (serverAnswers && (!stream || server.atMs >= stream.atMs)) {
+        return {
+            state: 'idle',
+            source: 'server',
+            turnId: null,
+            since: instant(server.lastEnded?.ended_at) ?? server.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    if (streamAnswers) {
+        return {
+            state: stream.type === 'idle' ? 'idle' : 'working',
+            source: 'stream',
+            turnId: null,
+            since: stream.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    if (receiptLive) {
+        return {
+            pendingDelivery: true,
+            state: 'working',
+            source: 'optimistic',
+            turnId: receiptTurnId,
+            since: optimistic.atMs,
+            serverOpenTurnToken,
+        };
+    }
+    const newest = server && stream
+        ? server.atMs >= stream.atMs
+            ? { source: 'server', atMs: server.atMs }
+            : { source: 'stream', atMs: stream.atMs }
+        : server
+            ? { source: 'server', atMs: server.atMs }
+            : stream
+                ? { source: 'stream', atMs: stream.atMs }
+                : { source: 'server', atMs: nowMs };
+    return {
+        state: 'idle',
+        source: newest.source,
+        turnId: null,
+        since: newest.atMs,
+        serverOpenTurnToken,
+    };
+}
+export function decideWorking(inputs) {
+    const evidence = workingEvidence(inputs);
+    const { server, stream } = inputs;
+    const idleFrame = stream && stream.type === 'idle' && stream.origin !== 'local' ? stream : null;
+    const serverOpenTurnToken = server?.turns[0]?.turn_token ?? null;
+    const activity = runtimeActivity(inputs, evidence, idleFrame, serverOpenTurnToken);
+    if (activity)
+        return activity;
+    const { result, openTurn } = openAuthority(inputs, evidence, idleFrame, serverOpenTurnToken);
+    return (result ??
+        inboxAuthority(inputs, evidence, serverOpenTurnToken) ??
+        lastAnswer(inputs, evidence, openTurn, serverOpenTurnToken));
+}

package/dist/core/session/working-runtime.d.ts

@@ -0,0 +1,3 @@
+import type { SessionTurn } from '../rest/projects-client/sessions.js';
+import type { WorkingServerInput, WorkingStreamInput } from './working.js';
+export declare function endedByRuntime(candidate: SessionTurn, idleFrame: WorkingStreamInput | null, server: WorkingServerInput | null): boolean;

package/dist/core/session/working-runtime.js

@@ -0,0 +1,16 @@
+import { instant } from './working-time.js';
+export function endedByRuntime(candidate, idleFrame, server) {
+    if (!idleFrame)
+        return false;
+    const startedAt = instant(candidate.started_at);
+    if (startedAt === null || startedAt >= idleFrame.atMs)
+        return false;
+    const lastEnded = server?.lastEnded;
+    const endedAt = instant(lastEnded?.ended_at);
+    if (lastEnded &&
+        endedAt !== null &&
+        Math.abs(endedAt - idleFrame.atMs) <= 1_000 &&
+        lastEnded.turn_token !== candidate.turn_token)
+        return false;
+    return true;
+}

package/dist/core/session/working-server.d.ts

@@ -0,0 +1,20 @@
+import type { WorkingProjection, SendReceipt, AbortReceipt } from './working.js';
+export interface SessionWorkingVerdict {
+    state: 'working' | 'idle';
+    since: string | null;
+    turn_token: string | null;
+    pending_delivery: boolean;
+}
+export declare const SERVER_WORKING_SEND_GRACE_MS = 2000;
+export interface ServerWorkingInput {
+    working: SessionWorkingVerdict;
+    atMs: number;
+    optimistic: SendReceipt | null;
+    abort: AbortReceipt | null;
+    nowMs: number;
+}
+export declare function projectServerWorking(input: ServerWorkingInput): WorkingProjection;
+export declare function serverWorkingExpiryAtMs(input: {
+    optimistic: SendReceipt | null;
+    abort: AbortReceipt | null;
+}): number | null;

package/dist/core/session/working-server.js

@@ -0,0 +1,57 @@
+import { OPTIMISTIC_ABORT_MAX_MS, OPTIMISTIC_RECEIPT_MAX_MS } from './working.js';
+export const SERVER_WORKING_SEND_GRACE_MS = 2_000;
+function predates(atMs, settledAtMs) {
+    return settledAtMs == null || atMs < settledAtMs + SERVER_WORKING_SEND_GRACE_MS;
+}
+export function projectServerWorking(input) {
+    const { working, atMs, optimistic, abort, nowMs } = input;
+    const serverWorking = working.state === 'working';
+    const sinceMs = working.since ? Date.parse(working.since) : Number.NaN;
+    if (abort &&
+        serverWorking &&
+        nowMs - abort.atMs < OPTIMISTIC_ABORT_MAX_MS &&
+        predates(atMs, abort.settledAtMs)) {
+        return {
+            state: 'idle',
+            source: 'optimistic',
+            turnId: null,
+            since: abort.atMs,
+            serverOpenTurnToken: working.pending_delivery ? null : working.turn_token,
+        };
+    }
+    if (optimistic &&
+        !serverWorking &&
+        nowMs - optimistic.atMs < OPTIMISTIC_RECEIPT_MAX_MS &&
+        predates(atMs, optimistic.acceptedAtMs)) {
+        return {
+            state: 'working',
+            source: 'optimistic',
+            turnId: optimistic.turnId === undefined ? optimistic.messageId : optimistic.turnId,
+            since: optimistic.atMs,
+            serverOpenTurnToken: null,
+        };
+    }
+    return {
+        state: working.state,
+        ...(serverWorking && working.pending_delivery ? { pendingDelivery: true } : {}),
+        source: 'server',
+        turnId: working.turn_token,
+        since: Number.isFinite(sinceMs) ? sinceMs : atMs,
+        serverOpenTurnToken: serverWorking && !working.pending_delivery ? working.turn_token : null,
+    };
+}
+export function serverWorkingExpiryAtMs(input) {
+    const deadlines = [];
+    const { optimistic, abort } = input;
+    if (optimistic) {
+        deadlines.push(optimistic.atMs + OPTIMISTIC_RECEIPT_MAX_MS);
+        if (optimistic.acceptedAtMs != null)
+            deadlines.push(optimistic.acceptedAtMs + SERVER_WORKING_SEND_GRACE_MS);
+    }
+    if (abort) {
+        deadlines.push(abort.atMs + OPTIMISTIC_ABORT_MAX_MS);
+        if (abort.settledAtMs != null)
+            deadlines.push(abort.settledAtMs + SERVER_WORKING_SEND_GRACE_MS);
+    }
+    return deadlines.length > 0 ? Math.min(...deadlines) : null;
+}

package/dist/core/session/working-time.d.ts

@@ -0,0 +1 @@
+export declare function instant(value: string | null | undefined): number | null;

package/dist/core/session/working-time.js

@@ -0,0 +1,6 @@
+export function instant(value) {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? null : parsed;
+}

package/dist/core/session/working.d.ts

@@ -0,0 +1,58 @@
+import type { SessionPrompt, SessionTurn, SessionTurnEnded } from '../rest/projects-client/sessions.js';
+export type WorkingSource = 'server' | 'stream' | 'optimistic';
+export interface WorkingProjection {
+    state: 'idle' | 'working';
+    pendingDelivery?: true;
+    source: WorkingSource;
+    turnId: string | null;
+    since: number;
+    serverOpenTurnToken: string | null;
+}
+export declare const OPTIMISTIC_RECEIPT_MAX_MS = 60000;
+export declare const SERVER_OBSERVATION_MAX_MS = 45000;
+export declare const STREAM_OBSERVATION_MAX_MS = 45000;
+export declare const INBOX_OBSERVATION_MAX_MS = 10000;
+export declare const TURN_END_LEDGER_LAG_MS = 3000;
+export declare const OPTIMISTIC_ABORT_MAX_MS = 15000;
+export interface SendReceipt {
+    messageId: string;
+    turnId?: string | null;
+    atMs: number;
+    acceptedAtMs?: number | null;
+}
+export interface AbortReceipt {
+    atMs: number;
+    settledAtMs?: number | null;
+}
+export interface WorkingServerInput {
+    turns: SessionTurn[];
+    lastEnded?: SessionTurnEnded;
+    atMs: number;
+}
+export interface WorkingStreamInput {
+    type: 'busy' | 'retry' | 'idle';
+    origin?: 'wire' | 'local';
+    atMs: number;
+}
+export interface WorkingActivityInput {
+    atMs: number;
+}
+export interface WorkingInboxInput {
+    pending: number;
+    atMs: number;
+    serverAtMs?: number;
+    drainedAtMs?: number;
+}
+export declare function inboxObservationSupersedes(candidate: WorkingInboxInput, current: WorkingInboxInput | null | undefined): boolean;
+export interface WorkingInputs {
+    optimistic: SendReceipt | null;
+    abort?: AbortReceipt | null;
+    inbox?: WorkingInboxInput | null;
+    server: WorkingServerInput | null;
+    stream: WorkingStreamInput | null;
+    activity?: WorkingActivityInput | null;
+    nowMs: number;
+}
+export declare function countLiveInboxPrompts(prompts: readonly SessionPrompt[]): number;
+export declare function projectWorking(inputs: WorkingInputs): WorkingProjection;
+export declare function workingExpiryAtMs(inputs: WorkingInputs): number | null;

package/dist/core/session/working.js

@@ -0,0 +1,48 @@
+export const OPTIMISTIC_RECEIPT_MAX_MS = 60_000;
+export const SERVER_OBSERVATION_MAX_MS = 45_000;
+export const STREAM_OBSERVATION_MAX_MS = 45_000;
+export const INBOX_OBSERVATION_MAX_MS = 10_000;
+export const TURN_END_LEDGER_LAG_MS = 3_000;
+export const OPTIMISTIC_ABORT_MAX_MS = 15_000;
+export function inboxObservationSupersedes(candidate, current) {
+    if (!current)
+        return true;
+    if (current.serverAtMs != null && candidate.serverAtMs != null) {
+        return candidate.serverAtMs >= current.serverAtMs;
+    }
+    return candidate.atMs >= current.atMs;
+}
+export function countLiveInboxPrompts(prompts) {
+    let live = 0;
+    for (const prompt of prompts) {
+        if (prompt.state === 'queued' || prompt.state === 'delivering')
+            live += 1;
+        else if (prompt.state === 'waiting' && prompt.reason !== 'held')
+            live += 1;
+    }
+    return live;
+}
+import { decideWorking } from './working-project.js';
+export function projectWorking(inputs) {
+    return decideWorking(inputs);
+}
+export function workingExpiryAtMs(inputs) {
+    const { optimistic, abort, inbox, server, stream, activity, nowMs } = inputs;
+    const deadlines = [
+        null,
+        optimistic ? optimistic.atMs + OPTIMISTIC_RECEIPT_MAX_MS : null,
+        abort ? abort.atMs + OPTIMISTIC_ABORT_MAX_MS : null,
+        inbox ? inbox.atMs + INBOX_OBSERVATION_MAX_MS : null,
+        server ? server.atMs + SERVER_OBSERVATION_MAX_MS : null,
+        stream ? stream.atMs + STREAM_OBSERVATION_MAX_MS : null,
+        activity ? activity.atMs + STREAM_OBSERVATION_MAX_MS : null,
+    ];
+    let next = null;
+    for (const deadline of deadlines) {
+        if (deadline === null || deadline <= nowMs)
+            continue;
+        if (next === null || deadline < next)
+            next = deadline;
+    }
+    return next;
+}

package/dist/core/session-sync/fragment.d.ts

@@ -0,0 +1,4 @@
+export declare function transcriptIsFragment(input: {
+    hasMessages: boolean;
+    wasEvicted: boolean;
+}): boolean;

package/dist/core/session-sync/fragment.js

@@ -0,0 +1,3 @@
+export function transcriptIsFragment(input) {
+    return input.hasMessages && input.wasEvicted;
+}

package/dist/core/session-sync/saved-copy-store.d.ts

@@ -0,0 +1,23 @@
+import type { KeyValueStorage } from '../cache/persisted-query-cache.js';
+import type { SessionTranscriptSyncEnvelope } from '../rest/projects-client/sessions.js';
+export interface SavedCopyStoreOptions {
+    storage: KeyValueStorage;
+    userId: string;
+    maxSessions?: number;
+    maxBytes?: number;
+    maxEnvelopeBytes?: number;
+    maxAgeMs?: number;
+    namespace?: string;
+    now?: () => number;
+}
+export interface SavedCopyStore {
+    keyFor(projectId: string, sessionId: string): string;
+    read(projectId: string, sessionId: string): SessionTranscriptSyncEnvelope | null | Promise<SessionTranscriptSyncEnvelope | null>;
+    write(projectId: string, sessionId: string, envelope: SessionTranscriptSyncEnvelope): Promise<void>;
+    remove(projectId: string, sessionId: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare function isPaintableSavedCopy(envelope: SessionTranscriptSyncEnvelope | null | undefined): envelope is SessionTranscriptSyncEnvelope;
+export declare function createSavedCopyStore(options: SavedCopyStoreOptions): SavedCopyStore;
+export declare function setSavedCopyStore(store: SavedCopyStore | null): void;
+export declare function currentSavedCopyStore(): SavedCopyStore | null;