chainlesschain 0.166.76 → 0.166.78

package/src/harness/jsonl-session-store.js

@@ -91,6 +91,13 @@ import {
 } from "../lib/execution-location-result.js";
 import { normalizeExecutionLocationResultStoreReceipt } from "../lib/execution-location-result-store.js";
 import skillInvocationReceipt from "@chainlesschain/session-core/skill-invocation-receipt";
+import {
+  BRANCH_HISTORY_MESSAGE,
+  BRANCH_HISTORY_ORIGIN,
+  resolveSessionBranchHistory,
+  branchMessageDigest,
+  createBranchHistoryImport,
+} from "../lib/session-branch-history.js";
 
 const { verifySkillInvocationReceipt } = skillInvocationReceipt;
 
@@ -723,7 +730,13 @@ function getSessionsDir() {
     if (claudeProjectDir) {
       ensureClaudeProjectStorageTree(homeDir, claudeProjectDir);
     } else {
-      ensurePrivateDirectory(dir);
+      // Another process may have created the directory but still be securing
+      // its Windows ACL. Join that check/repair before writing an anchored
+      // child; a later directory DACL change also changes child ctime.
+      ensurePrivateDirectory(dir, {
+        applyWindowsAcl: true,
+        failIfUnavailable: true,
+      });
     }
     securedSessionsDir = dir;
     const secured = lstatSync(dir);
@@ -2187,10 +2200,36 @@ export function withSessionAuthorityTransaction(
       let appendAttempts = 0;
       let writerActive = true;
       let writerPoisoned = false;
+      let readingProjection = false;
       let transactionRecoveryEvidence = null;
       const writer = Object.freeze({
         initialHeadHash: currentHeadHash,
         currentHeadHash: () => currentHeadHash,
+        readProjection(createProjection) {
+          if (!writerActive || writerPoisoned || readingProjection) {
+            throw new Error(
+              "Session authority reader lease is closed or poisoned",
+            );
+          }
+          readingProjection = true;
+          try {
+            const result = readVerifiedProjectionLocked(
+              sessionId,
+              filePath,
+              createProjection,
+              {
+                expectedHeadHash: currentHeadHash,
+              },
+            );
+            if (result && typeof result.then === "function")
+              throw new TypeError(
+                "Session authority projection must be synchronous",
+              );
+            return result;
+          } finally {
+            readingProjection = false;
+          }
+        },
         retainRecoveryEvidence(evidence) {
           if (!writerActive) {
             const error = new Error(
@@ -2209,6 +2248,10 @@ export function withSessionAuthorityTransaction(
           return transactionRecoveryEvidence;
         },
         appendAuthorityEvent(type, data) {
+          if (readingProjection)
+            throw new Error(
+              "Cannot append during a session authority projection",
+            );
           if (!writerActive) {
             const error = new Error(
               `Session authority transaction is already closed: ${sessionId}`,
@@ -3491,7 +3534,9 @@ function assertVerifiedTranscriptAnchor(
  * event reduction, and the independently persisted head/count check share one
  * forward transcript pass. `finish()` may call `authority.readMessages()` to
  * recover only the active context with bounded reverse IO (latest compact
- * checkpoint plus its suffix).
+ * checkpoint plus its suffix). Its optional synchronous `replayEvents(visitor)`
+ * revalidates the same head in another forward pass under this lock. That
+ * visitor lease expires when finish returns; it cannot escape to later tasks.
  *
  * This removes the mandatory all-event array from resume projections. It does
  * not make verification IO sublinear: authenticating a plain chained JSONL
@@ -3519,54 +3564,11 @@ export function readVerifiedProjection(
   return withFileLock(
     filePath,
     () => {
-      const projection = createProjection();
-      if (
-        !projection ||
-        typeof projection.accept !== "function" ||
-        typeof projection.finish !== "function"
-      ) {
-        throw new TypeError(
-          "Verified transcript projection must provide accept() and finish()",
-        );
-      }
-      if (!existsSync(filePath)) {
-        const presence = getSessionPresence(sessionId);
-        if (presence === SESSION_PRESENCE.TOMBSTONED) {
-          throw sessionDeletedError(sessionId);
-        }
-        if (presence === SESSION_PRESENCE.MISSING_TRANSCRIPT) {
-          throw unverifiedTranscriptError(
-            sessionId,
-            missingTranscriptVerification(),
-          );
-        }
-        return projection.finish(
-          Object.freeze({
-            headHash: null,
-            eventCount: 0,
-            readMessages: () => [],
-          }),
-        );
-      }
-      const structure = createSessionTranscriptStructureProjection(sessionId);
-      const verification = verifyTranscriptFile(filePath, {
-        ioMetrics: options.ioMetrics,
-        onVerifiedEvent: (event) => {
-          structure.accept(event);
-          projection.accept(event);
-        },
-      });
-      assertVerifiedTranscriptAnchor(sessionId, verification);
-      structure.finish({ assertValid: true });
-      return projection.finish(
-        Object.freeze({
-          headHash: verification.lastHash,
-          eventCount: verification.chainedEvents,
-          readMessages: () =>
-            rebuildVerifiedMessagesFromFile(filePath, {
-              ioMetrics: options.messageIoMetrics,
-            }),
-        }),
+      return readVerifiedProjectionLocked(
+        sessionId,
+        filePath,
+        createProjection,
+        options,
       );
     },
     {
@@ -3580,6 +3582,119 @@ export function readVerifiedProjection(
   );
 }
 
+function readVerifiedProjectionLocked(
+  sessionId,
+  filePath,
+  createProjection,
+  options = {},
+) {
+  const projection = createProjection();
+  if (
+    !projection ||
+    typeof projection.accept !== "function" ||
+    typeof projection.finish !== "function"
+  ) {
+    throw new TypeError(
+      "Verified transcript projection must provide accept() and finish()",
+    );
+  }
+  if (!existsSync(filePath)) {
+    const presence = getSessionPresence(sessionId);
+    if (presence === SESSION_PRESENCE.TOMBSTONED) {
+      throw sessionDeletedError(sessionId);
+    }
+    if (presence === SESSION_PRESENCE.MISSING_TRANSCRIPT) {
+      throw unverifiedTranscriptError(
+        sessionId,
+        missingTranscriptVerification(),
+      );
+    }
+    return projection.finish(
+      Object.freeze({
+        headHash: null,
+        eventCount: 0,
+        readMessages: () => [],
+      }),
+    );
+  }
+  const structure = createSessionTranscriptStructureProjection(sessionId);
+  const verification = verifyTranscriptFile(filePath, {
+    ioMetrics: options.ioMetrics,
+    onVerifiedEvent: (event) => {
+      structure.accept(event);
+      projection.accept(event);
+    },
+  });
+  assertVerifiedTranscriptAnchor(sessionId, verification);
+  structure.finish({ assertValid: true });
+  if (
+    options.expectedHeadHash !== undefined &&
+    verification.lastHash !== options.expectedHeadHash
+  ) {
+    throw unverifiedTranscriptError(sessionId, verification);
+  }
+  let replayLeaseActive = true;
+  let replaying = false;
+  try {
+    return projection.finish(
+      Object.freeze({
+        headHash: verification.lastHash,
+        eventCount: verification.chainedEvents,
+        readMessages: () =>
+          rebuildVerifiedMessagesFromFile(filePath, {
+            ioMetrics: options.messageIoMetrics,
+          }),
+        // Rewinds can discard the entire bounded page buffer. A second scan
+        // collects the selected prefix without retaining the archive in RAM.
+        // This lease is synchronous and expires before releasing the lock.
+        replayEvents(accept) {
+          if (!replayLeaseActive || replaying) {
+            throw new Error(
+              "Verified replay lease is closed or already in use",
+            );
+          }
+          if (
+            typeof accept !== "function" ||
+            accept.constructor?.name === "AsyncFunction"
+          ) {
+            throw new TypeError(
+              "Verified replay requires a synchronous visitor",
+            );
+          }
+          replaying = true;
+          try {
+            const replayStructure =
+              createSessionTranscriptStructureProjection(sessionId);
+            const replayVerification = verifyTranscriptFile(filePath, {
+              ioMetrics: options.replayIoMetrics,
+              onVerifiedEvent(event) {
+                replayStructure.accept(event);
+                const result = accept(event);
+                if (result && typeof result.then === "function")
+                  throw new TypeError(
+                    "Verified replay visitor must be synchronous",
+                  );
+              },
+            });
+            assertVerifiedTranscriptAnchor(sessionId, replayVerification);
+            replayStructure.finish({ assertValid: true });
+            if (
+              replayVerification.lastHash !== verification.lastHash ||
+              replayVerification.chainedEvents !== verification.chainedEvents
+            ) {
+              throw unverifiedTranscriptError(sessionId, replayVerification);
+            }
+          } finally {
+            replaying = false;
+          }
+        },
+      }),
+    );
+  } finally {
+    replayLeaseActive = false;
+  }
+}
+
 /**
  * Compatibility reader for consumers that still require the complete event
  * array. New resume projections should use `readVerifiedProjection()` so their
@@ -6672,6 +6787,8 @@ export function forkSession(sourceId, options = {}) {
  * @param {string|null} [params.parentTurnId]
  * @param {Array<{role:string,content:any}>} [params.messages]  pre-branch turns
  * @param {{title?:string,provider?:string,model?:string}} [params.meta]
+ * @param {object|null} [params.history] Scoped display-history capability from
+ *   createSessionTranscriptBranchProjection(), consumed under the source lock.
  * @returns {{branchSessionId:string, created:boolean, messages:number}}
  */
 export function createBranchSession({
@@ -6680,6 +6797,7 @@ export function createBranchSession({
   parentTurnId = null,
   messages = [],
   meta = {},
+  history = null,
 } = {}) {
   if (isUnsafeSessionId(branchSessionId)) {
     throw new Error(
@@ -6692,6 +6810,18 @@ export function createBranchSession({
   const canonicalMessages = projectCanonicalResumeMessages(messages, {
     strict: true,
   });
+  const historyPlan = resolveSessionBranchHistory(
+    history,
+    parentSessionId,
+    messages,
+  );
+  if (
+    historyPlan &&
+    (process.platform === "win32"
+      ? branchSessionId.toLowerCase() === parentSessionId.toLowerCase()
+      : branchSessionId === parentSessionId)
+  )
+    throw new Error("A history branch must be independent of its parent");
   if (
     (parentSessionId !== null && typeof parentSessionId !== "string") ||
     (parentTurnId !== null && typeof parentTurnId !== "string")
@@ -6746,36 +6876,10 @@ export function createBranchSession({
     // Host prompts and tool scaffolding are re-established on resume. The
     // canonical projection above retains only explicitly durable systems.
   }
-  const inputDigest = `sha256:${createHash("sha256")
-    .update(JSON.stringify(digestEvents), "utf8")
-    .digest("hex")}`;
   const branchGenerationId = `generation-${createHash("sha256")
     .update(`branch-generation\0${branchSessionId}`, "utf8")
     .digest("hex")
     .slice(0, 32)}`;
-  const plannedEvents = digestEvents.map((event, index) =>
-    index === 0
-      ? {
-          ...event,
-          data: encodeSessionGenerationData(
-            event.data,
-            createSessionGenerationAuthority(
-              branchSessionId,
-              null,
-              branchGenerationId,
-            ),
-          ),
-        }
-      : event,
-  );
-  plannedEvents.push({
-    type: "session_branch_complete",
-    data: {
-      schemaVersion: 1,
-      inputDigest,
-      messageCount: count,
-    },
-  });
 
   const filePath = sessionPath(branchSessionId);
   const sessionsDir = getSessionsDir();
@@ -6800,8 +6904,22 @@ export function createBranchSession({
         );
       }
       if (existsSync(filePath)) inspectPhysicalTail(filePath);
+      const anchoredMeta = readSessionMeta(sessionsDir, branchSessionId);
+      const anchoredCount = Number(anchoredMeta?.event_count);
+      let anchoredEventHash = null;
+      let existingBranchData = null;
+      let seenEvents = 0;
+      const existingHistoryImport = createBranchHistoryImport();
       let verification = existsSync(filePath)
-        ? verifyTranscriptFile(filePath)
+        ? verifyTranscriptFile(filePath, {
+            onVerifiedEvent(event) {
+              existingHistoryImport.accept(event);
+              seenEvents += 1;
+              if (seenEvents === anchoredCount) anchoredEventHash = event.hash;
+              if (seenEvents === 2 && event.type === "session_branch")
+                existingBranchData = event.data;
+            },
+          })
         : {
             status: TRANSCRIPT_CHAIN_STATUS.EMPTY,
             chainedEvents: 0,
@@ -6815,27 +6933,146 @@ export function createBranchSession({
       ) {
         throw unverifiedTranscriptError(branchSessionId, verification);
       }
-      const existingEvents = existsSync(filePath)
-        ? readEvents(branchSessionId)
-        : [];
-      const prefixMatches = existingEvents
-        .slice(0, Math.min(existingEvents.length, plannedEvents.length))
-        .every((event, index) => {
-          let plannedData = plannedEvents[index].data;
-          // Existing v1 branches predate generation authority. They remain
-          // idempotently readable; only newly created branches publish it.
-          if (
-            index === 0 &&
-            event?.data?.[SESSION_GENERATION_AUTHORITY_FIELD] === undefined
-          ) {
-            plannedData = { ...plannedData };
-            delete plannedData[SESSION_GENERATION_AUTHORITY_FIELD];
-          }
-          return (
-            event.type === plannedEvents[index].type &&
-            JSON.stringify(event.data) === JSON.stringify(plannedData)
+      const existingCount = verification.chainedEvents;
+      // Keep old deterministic snapshot branches idempotent. Never retrofit
+      // archive data into an already published branch's execution history.
+      const inherited =
+        existingBranchData && existingBranchData.history == null
+          ? null
+          : historyPlan;
+      if (inherited && inherited.contextOrigins.length !== count)
+        throw new Error("Branch history context does not match its snapshot");
+      const visitDigestEvents = (visit) => {
+        visit(digestEvents[0]);
+        visit(
+          inherited
+            ? {
+                ...digestEvents[1],
+                data: {
+                  ...digestEvents[1].data,
+                  history: inherited.descriptor,
+                },
+              }
+            : digestEvents[1],
+        );
+        if (inherited) {
+          let inheritedRows = 0;
+          inherited.visit((row) => {
+            // Preserve all display text, independently of the page's 200K
+            // rendering cap. Chunks also keep escaped text below record limits.
+            const chunkChars = 128 * 1024;
+            let offset = 0;
+            let part = 0;
+            do {
+              let end = Math.min(row.text.length, offset + chunkChars);
+              const before = row.text.charCodeAt(end - 1);
+              const after = row.text.charCodeAt(end);
+              if (
+                before >= 0xd800 &&
+                before <= 0xdbff &&
+                after >= 0xdc00 &&
+                after <= 0xdfff
+              )
+                end -= 1;
+              visit({
+                type: BRANCH_HISTORY_MESSAGE,
+                data: {
+                  ...row,
+                  text: row.text.slice(offset, end),
+                  part: part++,
+                  last: end === row.text.length,
+                },
+              });
+              offset = end;
+            } while (offset < row.text.length);
+            inheritedRows += 1;
+          });
+          if (inheritedRows !== inherited.descriptor.totalMessages)
+            throw new Error("Branch history source changed while streaming");
+        }
+        digestEvents.slice(2).forEach((event, index) => {
+          visit(event);
+          if (inherited)
+            visit({
+              type: BRANCH_HISTORY_ORIGIN,
+              data: {
+                messageDigest: branchMessageDigest(event.data),
+                origin: inherited.contextOrigins[index],
+              },
+            });
+        });
+      };
+      const inputHash = createHash("sha256").update("[");
+      let plannedCount = 0;
+      visitDigestEvents((event) => {
+        if (plannedCount > 0) inputHash.update(",");
+        inputHash.update(JSON.stringify(event));
+        plannedCount += 1;
+      });
+      const inputDigest = `sha256:${inputHash.update("]").digest("hex")}`;
+      plannedCount += 1;
+      const visitPlannedEvents = (visit) => {
+        let index = 0;
+        visitDigestEvents((event) => {
+          visit(
+            index === 0
+              ? {
+                  ...event,
+                  data: encodeSessionGenerationData(
+                    event.data,
+                    createSessionGenerationAuthority(
+                      branchSessionId,
+                      null,
+                      branchGenerationId,
+                    ),
+                  ),
+                }
+              : event,
+            index++,
           );
         });
+        visit(
+          {
+            type: "session_branch_complete",
+            data: {
+              schemaVersion: inherited ? 2 : 1,
+              inputDigest,
+              messageCount: count,
+            },
+          },
+          index,
+        );
+      };
+      const existingIterator =
+        existingCount > 0 ? iterateCanonicalJsonlLinesSync(filePath) : null;
+      let prefixMatches = true;
+      try {
+        if (existingCount > 0)
+          visitPlannedEvents((planned, index) => {
+            if (index >= existingCount) return;
+            const record = existingIterator.next();
+            if (record.done) {
+              prefixMatches = false;
+              return;
+            }
+            const event = parseCanonicalJsonlRecord(record.value.line);
+            let plannedData = planned.data;
+            // Existing v1 branches predate generation authority. They remain
+            // idempotently readable; only newly created branches publish it.
+            if (
+              index === 0 &&
+              event?.data?.[SESSION_GENERATION_AUTHORITY_FIELD] === undefined
+            ) {
+              plannedData = { ...plannedData };
+              delete plannedData[SESSION_GENERATION_AUTHORITY_FIELD];
+            }
+            prefixMatches &&=
+              event.type === planned.type &&
+              JSON.stringify(event.data) === JSON.stringify(plannedData);
+          });
+      } finally {
+        existingIterator?.return?.();
+      }
       if (!prefixMatches) {
         const error = new Error(
           `Branch session conflicts with its deterministic input: ${branchSessionId}`,
@@ -6843,11 +7080,12 @@ export function createBranchSession({
         error.code = "SESSION_BRANCH_CONFLICT";
         throw error;
       }
+      if (existingCount >= plannedCount) existingHistoryImport.finish();
 
       // Once the exact completion marker is anchored, later branch turns are
       // outside the idempotent creation transaction. A replay resolves to that
       // progressed branch, but an unanchored suffix is never re-blessed.
-      if (existingEvents.length > plannedEvents.length) {
+      if (existingCount > plannedCount) {
         assertVerifiedTranscriptAnchor(branchSessionId, verification);
         return { branchSessionId, created: false, messages: 0 };
       }
@@ -6856,8 +7094,6 @@ export function createBranchSession({
       // sidecar. Only advance an existing anchor along that exact prefix. Never
       // lower or replace a higher/different anchor: doing so would legitimize a
       // truncated deterministic branch and permanently discard later turns.
-      const anchoredMeta = readSessionMeta(sessionsDir, branchSessionId);
-      const anchoredCount = Number(anchoredMeta?.event_count);
       const anchorMatchesCurrent =
         anchoredMeta?.deleted !== true &&
         anchoredMeta?.last_hash === verification.lastHash &&
@@ -6867,11 +7103,9 @@ export function createBranchSession({
         Number.isSafeInteger(anchoredCount) &&
         anchoredCount >= 0 &&
         anchoredCount < verification.chainedEvents &&
-        verification.chainedEvents === existingEvents.length &&
         (anchoredCount === 0
           ? anchoredMeta?.last_hash === null
-          : existingEvents[anchoredCount - 1]?.hash ===
-            anchoredMeta?.last_hash);
+          : anchoredEventHash === anchoredMeta?.last_hash);
       if (
         anchoredMeta !== null &&
         !anchorMatchesCurrent &&
@@ -6879,13 +7113,22 @@ export function createBranchSession({
       ) {
         throw unverifiedTranscriptError(branchSessionId, verification);
       }
-      if (existsSync(filePath) && !anchorMatchesCurrent) {
+      const unpublishedHistoryPrefix =
+        inherited && existingCount < plannedCount;
+      // A second failed attempt must not make an incomplete history branch
+      // resumable. Its first usable sidecar/witness is published only after the
+      // complete archive, execution snapshot and completion digest validate.
+      if (
+        existsSync(filePath) &&
+        !anchorMatchesCurrent &&
+        !unpublishedHistoryPrefix
+      ) {
         rebuildSessionMetaUnlocked(sessionsDir, branchSessionId, filePath);
       }
-      if (existingEvents.length > 0) {
+      if (existingCount > 0 && !unpublishedHistoryPrefix) {
         assertVerifiedTranscriptAnchor(branchSessionId, verification);
       }
-      if (existingEvents.length === plannedEvents.length) {
+      if (existingCount === plannedCount) {
         return { branchSessionId, created: false, messages: 0 };
       }
 
@@ -6893,12 +7136,8 @@ export function createBranchSession({
       let expectedTranscriptState = existsSync(filePath)
         ? readPhysicalTranscriptState(filePath)
         : null;
-      for (
-        let index = existingEvents.length;
-        index < plannedEvents.length;
-        index += 1
-      ) {
-        const planned = plannedEvents[index];
+      visitPlannedEvents((planned, index) => {
+        if (index < existingCount) return;
         const core = {
           type: planned.type,
           timestamp: Date.now(),
@@ -6914,12 +7153,16 @@ export function createBranchSession({
           expectedTranscriptState,
         );
         prevHash = hash;
-      }
+      });
 
-      verification = verifyTranscriptFile(filePath);
+      const completedHistoryImport = createBranchHistoryImport();
+      verification = verifyTranscriptFile(filePath, {
+        onVerifiedEvent: (event) => completedHistoryImport.accept(event),
+      });
+      completedHistoryImport.finish();
       if (
         verification.status !== TRANSCRIPT_CHAIN_STATUS.VERIFIED ||
-        verification.chainedEvents !== plannedEvents.length ||
+        verification.chainedEvents !== plannedCount ||
         verification.lastHash !== prevHash ||
         verification.malformedLines > 0 ||
         verification.truncatedTail

package/src/harness/mcp-client.js

@@ -3525,13 +3525,16 @@ export class MCPClient extends EventEmitter {
    * Call a tool on a specific server. If the server has a registered
    * reconnector and the call fails with a connection-shaped error (server
    * restarted / token rotated / entry dropped), re-resolve the config,
-   * reconnect, and retry the call exactly once.
+   * reconnect, and retry the call exactly once. HTTP 404 only reinitializes
+   * the connection: an already-dispatched tool has an unknown outcome and
+   * must never be retried automatically just because its session expired.
    * @param {string} serverName - Server name
    * @param {string} toolName - Tool name
    * @param {object} args - Tool arguments
    * @param {{signal?: AbortSignal, dispatchAdmission?: Function}} options - Host-owned cancellation and dispatch authority
    */
   async callTool(serverName, toolName, args = {}, options = {}) {
+    const attemptedEntry = this.servers.get(serverName);
     if (options?.signal?.aborted) {
       throw mcpRequestAbortedError(
         serverName,
@@ -3542,6 +3545,43 @@ export class MCPClient extends EventEmitter {
     try {
       return await this._callToolOnce(serverName, toolName, args, options);
     } catch (err) {
+      if (
+        !isMcpRpcError(err) &&
+        safeRpcProperty(err, "code") === "CC_MCP_HTTP_STATUS" &&
+        safeRpcProperty(err, "status") === 404 &&
+        attemptedEntry?.httpUrl &&
+        !options?.signal?.aborted
+      ) {
+        // Both a stateless endpoint's transient 404 and an expired MCP
+        // session may recover through initialize. The HTTP status alone is
+        // insufficient evidence to replay a possibly effectful tool call.
+        const current = this.servers.get(serverName);
+        const recovered =
+          current && current !== attemptedEntry
+            ? current.state === ServerState.CONNECTED
+            : this._reconnecting.has(serverName) ||
+                (current && !current._httpDiscardStopping)
+              ? await this._tryReconnect(serverName, {
+                  connectAuthRetryUsed: true,
+                  expectedEntry: attemptedEntry,
+                })
+              : false;
+        const failure = mcpTransportError(
+          "CC_MCP_HTTP_TOOL_OUTCOME_UNKNOWN",
+          recovered
+            ? "MCP HTTP connection was reinitialized after HTTP 404; the tool outcome is unknown and was not replayed"
+            : "MCP HTTP 404 recovery failed; the tool outcome is unknown and was not replayed",
+          {
+            transport: attemptedEntry.transportKind,
+            url: attemptedEntry.config?.url,
+            status: 404,
+            dispatched: true,
+            outcomeUnknown: true,
+          },
+        );
+        failure.connectionRecovered = Boolean(recovered);
+        throw failure;
+      }
       if (
         mcpRpcControlData.has(err) &&
         (await this._resolveRequiredUrlElicitations(serverName, err))
@@ -3734,6 +3774,9 @@ export class MCPClient extends EventEmitter {
     const p = (async () => {
       try {
         const currentEntry = this.servers.get(name) || null;
+        if (options.expectedEntry && currentEntry !== options.expectedEntry) {
+          return currentEntry?.state === ServerState.CONNECTED;
+        }
         const currentConfig = currentEntry?.config || null;
         // Resource subscriptions belong to the logical client/server
         // relationship, not to one transport connection. Snapshot them before