@kortix/sdk 0.13.4 → 0.13.7

package/dist/core/session/working.js

@@ -45,6 +45,35 @@ export const STREAM_OBSERVATION_MAX_MS = 45_000;
  * Stop with its reply on screen for up to 45s.
  */
 export const INBOX_OBSERVATION_MAX_MS = 10_000;
+/**
+ * How long a runtime `idle` frame may outrank the control plane's turn row.
+ *
+ * The ledger is closed by a SEPARATE daemon relay (`POST .../turn-stream`
+ * `kind:"end"`), so for a moment after the runtime goes idle the row is still
+ * open and a `/turn` read taken in that window honestly reports a turn that has
+ * finished. MEASURED 2026-08-21 on a healthy stack: the relay POST itself took
+ * 1765ms, while the idle frame reaches the tab immediately and triggers its own
+ * refetch that lands ~186ms later — squarely inside the gap. Without this the
+ * composer's Stop button and the turn shimmer came back ~200ms after the reply
+ * and stayed for the whole poll interval.
+ *
+ * BOUNDED, and this is the important half. An idle frame is NOT proof the turn
+ * ended: `session.error` is relayed as `idle` too ("errors terminate the
+ * response"), and OpenCode emits it while it is RETRYING a provider — a 429
+ * backoff, a transient upstream 5xx — with the turn still very much live. An
+ * unbounded rule therefore un-busied the composer mid-turn on every retry and
+ * held it that way until the next `busy` frame, which is a worse flicker than
+ * the one it fixes. Past this window the ledger is believed again, so a retry
+ * blip self-heals in seconds instead of lasting the stream's whole 45s life.
+ *
+ * Comfortably above the measured relay, far below a provider backoff.
+ */
+export const TURN_END_LEDGER_LAG_MS = 3_000;
+// RETAINED AS A MEASUREMENT, NOT A RULE. It no longer gates anything: the veto
+// above is causal now, because a row still open past this lag is far more often
+// a dropped `kind:"end"` relay (turn over) than a live retry (turn running), and
+// guessing wrong in the first case is a visible oscillation. Exported because
+// this package's names are a public contract.
 /**
  * How long a stop this tab issued may bar a server read from reporting the
  * turn it is ending.
@@ -56,6 +85,25 @@ export const INBOX_OBSERVATION_MAX_MS = 10_000;
  * because the evidence arrives sooner.
  */
 export const OPTIMISTIC_ABORT_MAX_MS = 15_000;
+/**
+ * May `candidate` replace `current` as the session's inbox observation?
+ *
+ * ONE clock per comparison. When both observations carry the server's stamp,
+ * the server clock decides — it is the only pair drawn from one clock, and it
+ * orders a read against a write exactly (a read issued before a POST carries an
+ * older `observed_at` than the POST's response, so it can never erase it).
+ * Otherwise the browser stamps decide, as before. Ties stand aside for the
+ * candidate: two reads of the same instant agree, and the newer arrival may
+ * carry a corrected list.
+ */
+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;
+}
 /**
  * How many inbox rows are work the server still intends to run.
  *
@@ -119,8 +167,13 @@ function instant(value) {
  *    must re-evaluate at those instants — see `workingExpiryAtMs`.
  */
 export function projectWorking(inputs) {
-    const { optimistic, abort, inbox, server, stream, nowMs } = inputs;
+    const { optimistic, abort, inbox, server, stream, activity, nowMs } = inputs;
     const receiptLive = !!optimistic && nowMs - optimistic.atMs < OPTIMISTIC_RECEIPT_MAX_MS;
+    const receiptTurnId = optimistic
+        ? optimistic.turnId === undefined
+            ? optimistic.messageId
+            : optimistic.turnId
+        : null;
     // TWO floors, because the two server-side observers have different knowledge.
     //
     // `GET .../turn` reads the control plane's ledger, and there is NO row in it
@@ -151,13 +204,143 @@ export function projectWorking(inputs) {
     const serverFresh = !!server && nowMs - server.atMs <= SERVER_OBSERVATION_MAX_MS;
     const streamFresh = !!stream && nowMs - stream.atMs <= STREAM_OBSERVATION_MAX_MS;
     const inboxFresh = !!inbox && nowMs - inbox.atMs <= INBOX_OBSERVATION_MAX_MS;
-    const openTurn = serverFresh ? server.turns[0] : undefined;
-    const serverOpenTurnToken = openTurn?.turn_token ?? null;
+    // The runtime's own end-of-turn frame.
+    //
+    // NOT gated on `streamFresh`, unlike every branch that decides `working` from
+    // the stream. The bound exists because an old frame cannot testify to what is
+    // happening NOW — but this frame is not asked that. It is asked whether a turn
+    // that started BEFORE it has ended, and that answer does not rot: a turn which
+    // resumed would have produced a newer, non-idle frame, and then this is not an
+    // idle frame at all. Gating it cost exactly what the 3s window cost, 42s later
+    // and permanently — at `stream.atMs + STREAM_OBSERVATION_MAX_MS` the veto
+    // vanished with no new input, and a row the relay never closed put the
+    // composer back on Stop until its deadline (240 MINUTES for an accepted turn).
+    // WIRE frames only. A fabricated local idle (`origin: 'local'`) is the tab
+    // inferring, not the runtime speaking, and this veto is unbounded — one wrong
+    // local frame silenced every fresh `/turn` read for the rest of a quiet turn
+    // (dev, 2026-08-24: busy indicator gone, composer on Send, transcript poll
+    // switched off, all mid-run). See `WorkingStreamInput.origin`.
+    const idleFrame = stream && stream.type === 'idle' && stream.origin !== 'local' ? stream : null;
+    // CONTENT FIRST. Bounded by the stream's own freshness rule, because it
+    // arrives on the same transport and goes stale for the same reasons — but
+    // within that window it outranks every observer, including an idle frame it
+    // postdates. A runtime that is emitting parts is working, whatever the last
+    // status frame said and whatever a poll that has not answered yet will say.
+    const activityFresh = !!activity && nowMs - activity.atMs <= STREAM_OBSERVATION_MAX_MS;
+    const activityAfterIdle = activityFresh && (!idleFrame || activity.atMs > idleFrame.atMs);
+    /**
+     * Whether the runtime has already finished this turn.
+     *
+     * "Newer read wins" is the rule this replaces, and it is wrong here, because
+     * the two observers do not learn the same fact at the same time. The idle
+     * frame comes straight off the runtime over SSE. The ledger row is closed by
+     * a SEPARATE daemon relay (`POST .../turn-stream` `kind:"end"`) — so a `/turn`
+     * read ISSUED after the frame is still ABOUT a turn the frame already ended.
+     *
+     * MEASURED, local stack 2026-08-21, one ordinary composer turn: the idle
+     * frame reached the tab at 00:03:59.964, the refetch that frame itself
+     * triggers landed at 00:04:00.150 stamped 44ms later and still reported the
+     * turn `active`, and the ledger did not record `ended_at` until 00:04:15.132
+     * — the relay for that turn never arrived and a reconciliation sweep closed
+     * it 15.1s late. The composer's Stop button and the turn's shimmer came back
+     * 186ms after they left and stayed for fifteen seconds, with the finished
+     * reply already on screen. Even in the healthy case the relay lands ~200ms
+     * after the frame, which is still inside the window its own refetch lands in.
+     *
+     * `started_at` is what separates the two turns the rule has to tell apart: a
+     * turn that began BEFORE the frame is the turn that frame ended, and a turn
+     * that began after it is a NEW one the frame knows nothing about — a queued
+     * prompt draining, a trigger firing, a second device sending. That one keeps
+     * the ledger's full authority, with no delay and no window.
+     *
+     * A row with no start instant (a legacy `activeTurn`) cannot be ranked
+     * against the frame at all, and inventing an order there would hide a live
+     * turn. The ledger keeps it.
+     */
+    const endedByRuntime = (candidate) => {
+        if (!idleFrame)
+            return false;
+        // Only a turn that began BEFORE the frame — a turn started after it is a
+        // new one the frame knows nothing about.
+        const startedAt = instant(candidate.started_at);
+        if (startedAt === null || startedAt >= idleFrame.atMs)
+            return false;
+        // And that is the whole rule. It used to expire after
+        // `TURN_END_LEDGER_LAG_MS`, on the theory that a row still open past the
+        // relay's lag must mean the frame was a retry's `session.error` rather than
+        // the end of anything. But time is not evidence: when the `kind:"end"`
+        // relay is simply DROPPED — the documented failure mode, closed by a
+        // reconciliation sweep 15.1s late in this file's own measurement — the row
+        // stays open for exactly the same reason and the turn is exactly as
+        // finished. Expiring the veto therefore announced a finished turn again,
+        // and the user watched "Gathering thoughts…" and the Stop button come back
+        // for seconds with the answer already on screen (dev, 2026-08-23).
+        //
+        // A turn that is genuinely still running says so, and that is what returns
+        // authority to the ledger: any newer frame is not idle, so `idleFrame` is
+        // null on the next evaluation and the row decides again — immediately, with
+        // no window to tune.
+        //
+        // "Says so" assumes the stream is delivering. When it is NOT — a
+        // black-holed SSE proxy answers 200 and never writes a byte, and the
+        // client heartbeat is the only detector (apps/api injects no keepalives)
+        // — this veto is deliberately NOT expired by `STREAM_OBSERVATION_MAX_MS`
+        // (a row still open past any time bound is more often a dropped
+        // `kind:"end"` relay than a live turn). The repair for the wrong case —
+        // a running turn behind a dead stream, prod 2026-08-26 — is EVIDENCE,
+        // not time: the transcript liveness poll stays on while the server holds
+        // a turn open (`livenessBusy`'s `serverHoldsTurn`), its runtime read
+        // stamps `sessionActivityAt` when the transcript moved with an open tail
+        // (`sync-store.hydrate`), and `activityAfterIdle` above then outranks
+        // this frame. Also note `started_at` is server clock while `atMs` is this
+        // tab's clock — skew can misclassify a NEW turn as ended, and the same
+        // evidence path is what recovers it.
+        return true;
+    };
+    if (activityAfterIdle) {
+        return {
+            state: 'working',
+            source: 'stream',
+            turnId: null,
+            since: activity.atMs,
+            serverOpenTurnToken: server?.turns[0]?.turn_token ?? null,
+        };
+    }
+    // NOT gated on `serverFresh`. A read going stale is a fact about the READ, not
+    // about the row: the control plane does not release a turn because this tab's
+    // last look got old. Gating it here made being wrong self-sealing — the token
+    // nulls, `serverHoldsTurn` (use-session.ts) goes false, `livenessBusy` goes
+    // false, and the transcript fallback poll clears its own interval. The one
+    // mechanism that could have produced fresh evidence was switched off BY the
+    // staleness it existed to repair, so a false idle could never be discovered.
+    // The token is retired by end-of-turn evidence, never by age.
+    const ledgerTurn = server?.turns[0];
+    // `serverOpenTurnToken` deliberately keeps reporting the LEDGER's turn even
+    // when the runtime's frame has decided the state above — see its docstring.
+    // It answers "is the control plane still holding authority", which is what a
+    // `/` command must check before going straight at OpenCode with no admission
+    // gate in front of it, and that stays true for as long as the row does.
+    // Only the WORKING decision moves.
+    const serverOpenTurnToken = ledgerTurn?.turn_token ?? null;
+    // EVERY row, not just the first. The ledger holds more than one open turn
+    // whenever a prompt is forwarded while another is running — measured on the
+    // local stack as `turns: [B@00:28:56, A@00:28:22]` — and the list is not
+    // ordered newest-first. Testing only `turns[0]` would let one spent row hide
+    // a live one behind it, so the projection keeps the first turn the runtime
+    // has NOT finished.
+    const openTurn = serverFresh ? server.turns.find((t) => !endedByRuntime(t)) : undefined;
     // A turn the authority is holding open, unless the stream has since said the
     // session went idle. The stream frame is newer BY OBSERVATION, and the daemon
     // relays `turn_end` to the control plane at the same moment the frame is
     // emitted — so a fresher idle frame means this read is simply out of date.
-    if (openTurn && server.atMs >= abortFloor && (!stream || server.atMs >= stream.atMs)) {
+    //
+    // A LOCAL idle frame is exempt from that ordering: it is not the runtime
+    // speaking, so "newer" buys it nothing against the lifecycle authority. It
+    // lands between polls by construction (the sweep runs on connect), and
+    // waiting one poll interval for the row to outrank it again is exactly the
+    // flicker being fixed.
+    const streamContradicts = !!stream && !(stream.type === 'idle' && stream.origin === 'local');
+    if (openTurn && server.atMs >= abortFloor && (!streamContradicts || server.atMs >= stream.atMs)) {
         return {
             state: 'working',
             source: 'server',
@@ -168,11 +351,18 @@ export function projectWorking(inputs) {
     }
     // Durable rows outrank an idle read: the read is right that no TURN is
     // running and wrong that nothing is happening.
+    //
+    // Every live row counts, INCLUDING the ones already forwarded to the runtime.
+    // A prompt queued behind a running turn is handed to OpenCode early and sits
+    // in `delivering` ACROSS the turn boundary, so the idle frame that ends the
+    // turn in front of it says nothing about it. Measured on the local stack
+    // 2026-08-21: suppressing forwarded rows on that frame left the composer idle
+    // for 13.8s with the user's queued prompt still waiting to run.
     if (inboxFresh && inbox.pending > 0) {
         return {
             state: 'working',
             source: 'server',
-            turnId: null,
+            turnId: receiptLive ? receiptTurnId : null,
             since: inbox.atMs,
             serverOpenTurnToken,
         };
@@ -201,7 +391,7 @@ export function projectWorking(inputs) {
         return {
             state: 'working',
             source: 'optimistic',
-            turnId: optimistic.messageId,
+            turnId: receiptTurnId,
             since: optimistic.atMs,
             serverOpenTurnToken,
         };
@@ -241,13 +431,22 @@ export function projectWorking(inputs) {
  * skipped, so re-arming from the timer this returns terminates.
  */
 export function workingExpiryAtMs(inputs) {
-    const { optimistic, abort, inbox, server, stream, nowMs } = inputs;
+    const { optimistic, abort, inbox, server, stream, activity, nowMs } = inputs;
     const deadlines = [
+        // The instant a runtime idle frame stops outranking the ledger's turn row.
+        // Nothing else re-renders then, and a session held `idle` by that rule has
+        // to go back to `working` on its own when the frame's window closes.
+        // (An idle frame no longer stops outranking the ledger on a timer — see
+        // `endedByRuntime` — so there is nothing to schedule for it here.)
+        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,
+        // Content stops answering when it goes stale, and nothing else re-renders
+        // at that instant.
+        activity ? activity.atMs + STREAM_OBSERVATION_MAX_MS : null,
     ];
     let next = null;
     for (const deadline of deadlines) {

package/dist/core/session/working.js.map

@@ -1 +1 @@
-{"version":3,"file":"working.js","sourceRoot":"","sources":["../../../src/core/session/working.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"working.js","sourceRoot":"","sources":["../../../src/core/session/working.ts"],"names":[],"mappings":"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"}

package/dist/core/session-sync/durable-log.d.ts

@@ -0,0 +1,96 @@
+/**
+ * The durable per-session event log.
+ *
+ * OpenCode's runtime keeps an ordered, replayable log per session, and exposes
+ * it on two routes that our sandboxes already serve (verified live through the
+ * Kortix proxy, dev, 2026-08-24):
+ *
+ *   GET /api/session/{id}/history?limit&after -> { data: SessionDurableEvent[], hasMore }
+ *   GET /api/session/{id}/event?after=<seq>   -> SSE: replay, then tail
+ *
+ * The SDK's own words for the second one: "Replay durable events after an
+ * aggregate sequence, then continue with new durable events."
+ *
+ * Why this matters more than any repair we have written:
+ *
+ * Every transcript bug this file's neighbours exist to fix comes from the same
+ * shape — the browser holds a COPY assembled from a lossy stream, and has no
+ * way to ask "what did I miss?". So we invented answers: re-read the tail on a
+ * gap, on turn end, on tab return, on eviction; poll every 10s while working;
+ * infer "is it working" from six stamped observations. Each is a guess about
+ * loss we could not measure.
+ *
+ * A sequence cursor replaces all of it with a question the server can answer
+ * exactly: everything after `seq`. Missed nothing -> zero events. Missed a
+ * turn -> exactly that turn. Cost is proportional to what was MISSED rather
+ * than to the size of the transcript, which is the whole reason a 78 MB tail
+ * read could never be the right repair.
+ *
+ * Framework-free on purpose: no DOM, no React, no store. Callers own the cursor.
+ */
+/** One page of durable events. `limit` is per request, not a total. */
+export declare const DURABLE_HISTORY_PAGE_SIZE = 200;
+/** A durable event carries an aggregate sequence; a delta frame does not. */
+export interface DurableEventLike {
+    durable?: {
+        aggregateID?: string;
+        seq?: number;
+        version?: number;
+    };
+}
+export interface DurableHistoryPage {
+    events: unknown[];
+    hasMore: boolean;
+    /**
+     * The cursor to pass as `after` next time. Never lower than the cursor this
+     * read was given — a rewind would replay events already applied.
+     */
+    lastSeq: number | null;
+}
+export interface DurableLogClient {
+    v2?: {
+        session: {
+            history: (request: {
+                sessionID: string;
+                limit?: number;
+                after?: number;
+            }) => Promise<{
+                data?: {
+                    data?: unknown[];
+                    hasMore?: boolean;
+                };
+            }>;
+        };
+    };
+}
+/**
+ * The aggregate sequence of an event, or null if it carries none.
+ *
+ * Only durable events advance the cursor. The runtime also emits pure deltas
+ * (text, reasoning, tool input, compaction) that exist to make typing look
+ * live; they are disposable by design and must never move a cursor, or a
+ * reconnect would skip the durable event they were painting over.
+ */
+export declare function durableSeqOf(event: unknown): number | null;
+/**
+ * Read one page of the log after `after` (exclusive).
+ *
+ * The runtime's own note on this route: "Newly committed events may appear on
+ * later pages" — so `hasMore: false` means "caught up as of now", not "the log
+ * is finished". The caller keeps the cursor and asks again.
+ */
+export declare function readSessionDurableHistory(client: DurableLogClient, sessionId: string, cursor: {
+    after?: number;
+    limit?: number;
+}): Promise<DurableHistoryPage>;
+/**
+ * Does this failure mean "this runtime has no durable log" rather than "the
+ * read failed"?
+ *
+ * Self-hosted installs run older sandbox images. A 404 is a capability answer
+ * and must fall back to the message read. Everything else is a real failure and
+ * must reach the caller's retry — swallowing a 503 as "unsupported" would
+ * permanently downgrade a runtime that was merely asleep.
+ */
+export declare function isDurableLogUnsupported(error: unknown): boolean;
+//# sourceMappingURL=durable-log.d.ts.map

package/dist/core/session-sync/durable-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-log.d.ts","sourceRoot":"","sources":["../../../src/core/session-sync/durable-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,uEAAuE;AACvE,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAE7C,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACpE;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,OAAO,EAAE,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE;QACH,OAAO,EAAE;YACP,OAAO,EAAE,CAAC,OAAO,EAAE;gBACjB,SAAS,EAAE,MAAM,CAAC;gBAClB,KAAK,CAAC,EAAE,MAAM,CAAC;gBACf,KAAK,CAAC,EAAE,MAAM,CAAC;aAChB,KAAK,OAAO,CAAC;gBAAE,IAAI,CAAC,EAAE;oBAAE,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;oBAAC,OAAO,CAAC,EAAE,OAAO,CAAA;iBAAE,CAAA;aAAE,CAAC,CAAC;SACnE,CAAC;KACH,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAK1D;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,gBAAgB,EACxB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACzC,OAAO,CAAC,kBAAkB,CAAC,CAsB7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK/D"}

package/dist/core/session-sync/durable-log.js

@@ -0,0 +1,94 @@
+/**
+ * The durable per-session event log.
+ *
+ * OpenCode's runtime keeps an ordered, replayable log per session, and exposes
+ * it on two routes that our sandboxes already serve (verified live through the
+ * Kortix proxy, dev, 2026-08-24):
+ *
+ *   GET /api/session/{id}/history?limit&after -> { data: SessionDurableEvent[], hasMore }
+ *   GET /api/session/{id}/event?after=<seq>   -> SSE: replay, then tail
+ *
+ * The SDK's own words for the second one: "Replay durable events after an
+ * aggregate sequence, then continue with new durable events."
+ *
+ * Why this matters more than any repair we have written:
+ *
+ * Every transcript bug this file's neighbours exist to fix comes from the same
+ * shape — the browser holds a COPY assembled from a lossy stream, and has no
+ * way to ask "what did I miss?". So we invented answers: re-read the tail on a
+ * gap, on turn end, on tab return, on eviction; poll every 10s while working;
+ * infer "is it working" from six stamped observations. Each is a guess about
+ * loss we could not measure.
+ *
+ * A sequence cursor replaces all of it with a question the server can answer
+ * exactly: everything after `seq`. Missed nothing -> zero events. Missed a
+ * turn -> exactly that turn. Cost is proportional to what was MISSED rather
+ * than to the size of the transcript, which is the whole reason a 78 MB tail
+ * read could never be the right repair.
+ *
+ * Framework-free on purpose: no DOM, no React, no store. Callers own the cursor.
+ */
+/** One page of durable events. `limit` is per request, not a total. */
+export const DURABLE_HISTORY_PAGE_SIZE = 200;
+/**
+ * The aggregate sequence of an event, or null if it carries none.
+ *
+ * Only durable events advance the cursor. The runtime also emits pure deltas
+ * (text, reasoning, tool input, compaction) that exist to make typing look
+ * live; they are disposable by design and must never move a cursor, or a
+ * reconnect would skip the durable event they were painting over.
+ */
+export function durableSeqOf(event) {
+    if (!event || typeof event !== 'object')
+        return null;
+    const durable = event.durable;
+    if (!durable || typeof durable.seq !== 'number' || !Number.isFinite(durable.seq))
+        return null;
+    return durable.seq;
+}
+/**
+ * Read one page of the log after `after` (exclusive).
+ *
+ * The runtime's own note on this route: "Newly committed events may appear on
+ * later pages" — so `hasMore: false` means "caught up as of now", not "the log
+ * is finished". The caller keeps the cursor and asks again.
+ */
+export async function readSessionDurableHistory(client, sessionId, cursor) {
+    const history = client.v2?.session.history;
+    if (!history)
+        throw new Error('durable log unavailable: client exposes no v2 session namespace');
+    const result = await history({
+        sessionID: sessionId,
+        limit: cursor.limit ?? DURABLE_HISTORY_PAGE_SIZE,
+        ...(cursor.after === undefined ? {} : { after: cursor.after }),
+    });
+    const events = result.data?.data ?? [];
+    // The HIGHEST sequence in the page, not the last element's. A page is not
+    // promised in sequence order, and it may carry frames with no sequence at
+    // all; taking the tail element would rewind the cursor on either.
+    let lastSeq = cursor.after ?? null;
+    for (const event of events) {
+        const seq = durableSeqOf(event);
+        if (seq === null)
+            continue;
+        if (lastSeq === null || seq > lastSeq)
+            lastSeq = seq;
+    }
+    return { events, hasMore: result.data?.hasMore === true, lastSeq };
+}
+/**
+ * Does this failure mean "this runtime has no durable log" rather than "the
+ * read failed"?
+ *
+ * Self-hosted installs run older sandbox images. A 404 is a capability answer
+ * and must fall back to the message read. Everything else is a real failure and
+ * must reach the caller's retry — swallowing a 503 as "unsupported" would
+ * permanently downgrade a runtime that was merely asleep.
+ */
+export function isDurableLogUnsupported(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const status = error.status ?? error.statusCode;
+    return status === 404;
+}
+//# sourceMappingURL=durable-log.js.map

package/dist/core/session-sync/durable-log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"durable-log.js","sourceRoot":"","sources":["../../../src/core/session-sync/durable-log.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,uEAAuE;AACvE,MAAM,CAAC,MAAM,yBAAyB,GAAG,GAAG,CAAC;AA6B7C;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,KAAc;IACzC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACrD,MAAM,OAAO,GAAI,KAA0B,CAAC,OAAO,CAAC;IACpD,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,GAAG,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC9F,OAAO,OAAO,CAAC,GAAG,CAAC;AACrB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,yBAAyB,CAC7C,MAAwB,EACxB,SAAiB,EACjB,MAA0C;IAE1C,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,OAAO,CAAC;IAC3C,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,iEAAiE,CAAC,CAAC;IAEjG,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC;QAC3B,SAAS,EAAE,SAAS;QACpB,KAAK,EAAE,MAAM,CAAC,KAAK,IAAI,yBAAyB;QAChD,GAAG,CAAC,MAAM,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;KAC/D,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAAC;IACvC,0EAA0E;IAC1E,0EAA0E;IAC1E,kEAAkE;IAClE,IAAI,OAAO,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC;IACnC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,GAAG,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;QAChC,IAAI,GAAG,KAAK,IAAI;YAAE,SAAS;QAC3B,IAAI,OAAO,KAAK,IAAI,IAAI,GAAG,GAAG,OAAO;YAAE,OAAO,GAAG,GAAG,CAAC;IACvD,CAAC;IAED,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,EAAE,OAAO,EAAE,CAAC;AACrE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAc;IACpD,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACtD,MAAM,MAAM,GACT,KAA8B,CAAC,MAAM,IAAK,KAAkC,CAAC,UAAU,CAAC;IAC3F,OAAO,MAAM,KAAK,GAAG,CAAC;AACxB,CAAC"}

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

@@ -0,0 +1,27 @@
+/**
+ * Is this session's transcript a FRAGMENT — messages the live stream rebuilt
+ * after an eviction, with everything before them missing?
+ *
+ * The sync store already carries the exact signature, in two pieces:
+ *
+ *   - eviction drops a detached session's messages and MARKS the id
+ *   - every path that re-establishes the session authoritatively — `hydrate`,
+ *     `clearSession`, `optimisticAdd` — CLEARS that mark
+ *   - `applyEvent`, the live stream's own path, does not
+ *
+ * So messages present while the mark is still set can only have come from
+ * frames that arrived after the eviction. The transcript starts mid-conversation
+ * and nothing else will correct it: the mount already ran, so no `initial` read
+ * is coming, and the liveness poll only runs while the session is working.
+ *
+ * Named and left open by 5a7a43517f, which removed the IndexedDB mirror that
+ * used to repaint underneath such a fragment: "no reconcile is keyed on
+ * eviction … can sit on a partial transcript until a reload."
+ */
+export declare function transcriptIsFragment(input: {
+    /** The store holds at least one message for this session. */
+    hasMessages: boolean;
+    /** The store still marks this session's transcript as evicted. */
+    wasEvicted: boolean;
+}): boolean;
+//# sourceMappingURL=fragment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fragment.d.ts","sourceRoot":"","sources":["../../../src/core/session-sync/fragment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,6DAA6D;IAC7D,WAAW,EAAE,OAAO,CAAC;IACrB,kEAAkE;IAClE,UAAU,EAAE,OAAO,CAAC;CACrB,GAAG,OAAO,CAEV"}

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

@@ -0,0 +1,24 @@
+/**
+ * Is this session's transcript a FRAGMENT — messages the live stream rebuilt
+ * after an eviction, with everything before them missing?
+ *
+ * The sync store already carries the exact signature, in two pieces:
+ *
+ *   - eviction drops a detached session's messages and MARKS the id
+ *   - every path that re-establishes the session authoritatively — `hydrate`,
+ *     `clearSession`, `optimisticAdd` — CLEARS that mark
+ *   - `applyEvent`, the live stream's own path, does not
+ *
+ * So messages present while the mark is still set can only have come from
+ * frames that arrived after the eviction. The transcript starts mid-conversation
+ * and nothing else will correct it: the mount already ran, so no `initial` read
+ * is coming, and the liveness poll only runs while the session is working.
+ *
+ * Named and left open by 5a7a43517f, which removed the IndexedDB mirror that
+ * used to repaint underneath such a fragment: "no reconcile is keyed on
+ * eviction … can sit on a partial transcript until a reload."
+ */
+export function transcriptIsFragment(input) {
+    return input.hasMessages && input.wasEvicted;
+}
+//# sourceMappingURL=fragment.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fragment.js","sourceRoot":"","sources":["../../../src/core/session-sync/fragment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAKpC;IACC,OAAO,KAAK,CAAC,WAAW,IAAI,KAAK,CAAC,UAAU,CAAC;AAC/C,CAAC"}