@jingyi0605/codingns 0.5.0 → 0.5.5

package/dist/server/ws/workbench-ws-hub.js

@@ -1,4 +1,5 @@
 import { AppError } from "../shared/errors/app-error.js";
+import { logPerformance } from "../shared/utils/perf-log.js";
 import { logTerminalDebug, terminalDebugNowMs } from "../shared/utils/terminal-debug-log.js";
 const WORKBENCH_REFRESH_INTERVAL_MS = 60_000;
 const GIT_SUBSCRIPTION_MIN_REFRESH_INTERVAL_MS = 15_000;
@@ -42,7 +43,7 @@ export class WorkbenchWsHub {
         try {
             switch (message.type) {
                 case "workbench.subscribe":
-                    void this.sendWorkbenchSnapshotToClient(client, userId, channel);
+                    void this.sendWorkbenchSnapshotToClient(client, userId, channel, message.knownRevision);
                     if (this.workbenchService.shouldRefreshSnapshot()) {
                         this.workbenchService.scheduleSnapshotRefresh(userId);
                     }
@@ -51,18 +52,18 @@ export class WorkbenchWsHub {
                     void this.refreshAndBroadcast(userId, true);
                     return true;
                 case "fileTree.subscribe":
-                    this.replaceFileTreeSubscription(client, message.workspaceId, message.paths);
+                    this.replaceFileTreeSubscription(client, message.workspaceId, message.paths, message.knownRevisions);
                     void this.refreshFileTreeSubscriptions(client);
                     return true;
                 case "fileTree.refresh":
                     for (const path of normalizePanelPaths(message.paths)) {
                         this.workspacePanelSnapshotService.invalidateFileTree(message.workspaceId.trim(), path);
                     }
-                    this.ensureFileTreeSubscription(client, message.workspaceId, message.paths);
+                    this.ensureFileTreeSubscription(client, message.workspaceId, message.paths, message.knownRevisions);
                     void this.refreshFileTreeSubscriptions(client, true);
                     return true;
                 case "git.subscribe":
-                    this.ensureGitSubscription(client, message.workspaceId);
+                    this.ensureGitSubscription(client, message.workspaceId, message.knownRevision);
                     void this.refreshGitSubscription(client, false, {
                         deliverIfUnchanged: true,
                         ignoreMinInterval: true
@@ -70,18 +71,18 @@ export class WorkbenchWsHub {
                     return true;
                 case "git.refresh":
                     this.workspacePanelSnapshotService.invalidateGit(message.workspaceId.trim());
-                    this.ensureGitSubscription(client, message.workspaceId);
+                    this.ensureGitSubscription(client, message.workspaceId, message.knownRevision);
                     this.scheduleGitRefresh(client, {
                         force: true
                     });
                     return true;
                 case "terminalManager.subscribe":
-                    this.ensureTerminalManagerSubscription(client, message.workspaceId);
+                    this.ensureTerminalManagerSubscription(client, message.workspaceId, message.knownRevision);
                     this.scheduleTerminalManagerRefresh(client);
                     return true;
                 case "terminalManager.refresh":
                     this.workspacePanelSnapshotService.invalidateTerminalManager(message.workspaceId.trim());
-                    this.ensureTerminalManagerSubscription(client, message.workspaceId);
+                    this.ensureTerminalManagerSubscription(client, message.workspaceId, message.knownRevision);
                     this.scheduleTerminalManagerRefresh(client, {
                         force: true
                     });
@@ -89,7 +90,8 @@ export class WorkbenchWsHub {
                 case "workspaceManagement.subscribe":
                     this.clientWorkspaceManagementSubscriptions.set(client, {
                         workspaceId: message.workspaceId.trim(),
-                        lastPayload: null
+                        lastPayload: null,
+                        knownRevision: normalizeKnownRevision(message.knownRevision) ?? null
                     });
                     void this.refreshWorkspaceManagementSubscription(client);
                     return true;
@@ -97,7 +99,8 @@ export class WorkbenchWsHub {
                     this.workspacePanelSnapshotService.invalidateWorkspaceManagement(message.workspaceId.trim());
                     this.clientWorkspaceManagementSubscriptions.set(client, {
                         workspaceId: message.workspaceId.trim(),
-                        lastPayload: null
+                        lastPayload: null,
+                        knownRevision: normalizeKnownRevision(message.knownRevision) ?? null
                     });
                     void this.refreshWorkspaceManagementSubscription(client, true);
                     return true;
@@ -185,19 +188,42 @@ export class WorkbenchWsHub {
         }
         channel.realtimeBroadcastQueued = false;
         channel.realtimeBroadcastTask = (async () => {
+            const startedAt = Date.now();
             const startedAtMs = terminalDebugNowMs();
             try {
-                const payload = buildWorkbenchPayload(this.workbenchService.getSnapshot(userId));
-                if (payload === channel.lastWorkbenchPayload) {
+                const snapshotStartedAt = Date.now();
+                const snapshot = this.workbenchService.getSnapshot(userId);
+                const snapshotMs = Date.now() - snapshotStartedAt;
+                const serializeStartedAt = Date.now();
+                const payload = buildWorkbenchBroadcastPayload(channel.lastWorkbenchSnapshot, snapshot);
+                const serializeMs = Date.now() - serializeStartedAt;
+                if (snapshot.revision === channel.lastWorkbenchRevision) {
                     return;
                 }
                 channel.lastWorkbenchPayload = payload;
-                for (const client of channel.clients) {
-                    client.send(payload);
-                }
+                channel.lastWorkbenchRevision = snapshot.revision;
+                channel.lastWorkbenchSnapshot = snapshot;
+                const sessionCount = snapshot.items.reduce((total, item) => total + countWorkbenchSessions(item), 0);
+                const broadcastMetric = broadcastSerializedPayload(channel.clients, payload);
+                logPerformance("ws.workbench.realtime_broadcast", Date.now() - startedAt, {
+                    userId,
+                    clientCount: channel.clients.size,
+                    workspaceCount: snapshot.items.length,
+                    sessionCount,
+                    snapshotMs,
+                    serializeMs,
+                    payloadBytes: broadcastMetric.payloadBytes,
+                    sendMs: broadcastMetric.sendMs,
+                    maxBufferedAmount: broadcastMetric.maxBufferedAmount
+                }, {
+                    thresholdMs: 0,
+                    force: true
+                });
                 logTerminalDebug("workbench.realtime_broadcast.completed", {
                     userId,
                     clientCount: channel.clients.size,
+                    payloadBytes: broadcastMetric.payloadBytes,
+                    maxBufferedAmount: broadcastMetric.maxBufferedAmount,
                     durationMs: terminalDebugNowMs() - startedAtMs
                 });
             }
@@ -263,6 +289,8 @@ export class WorkbenchWsHub {
         channel = {
             clients: new Set(),
             lastWorkbenchPayload: null,
+            lastWorkbenchRevision: null,
+            lastWorkbenchSnapshot: null,
             workbenchTimer: null,
             workspaceManagementTimer: null,
             realtimeBroadcastTimer: null,
@@ -288,11 +316,42 @@ export class WorkbenchWsHub {
         this.userChannels.set(userId, channel);
         return channel;
     }
-    async sendWorkbenchSnapshotToClient(client, userId, channel) {
+    async sendWorkbenchSnapshotToClient(client, userId, channel, knownRevision) {
+        const startedAt = Date.now();
         try {
-            const payload = buildWorkbenchPayload(this.workbenchService.getSnapshot(userId));
-            channel.lastWorkbenchPayload = payload;
-            client.send(payload);
+            const snapshotStartedAt = Date.now();
+            const snapshot = this.workbenchService.getSnapshot(userId);
+            const snapshotMs = Date.now() - snapshotStartedAt;
+            const fullPayloadStartedAt = Date.now();
+            const fullPayload = buildWorkbenchPayload(snapshot);
+            const fullPayloadBuildMs = Date.now() - fullPayloadStartedAt;
+            const unchanged = Boolean(knownRevision && knownRevision === snapshot.revision);
+            let clientPayload = fullPayload;
+            let clientPayloadBuildMs = 0;
+            if (unchanged) {
+                const clientPayloadStartedAt = Date.now();
+                clientPayload = buildWorkbenchPayload(snapshot, knownRevision);
+                clientPayloadBuildMs = Date.now() - clientPayloadStartedAt;
+            }
+            channel.lastWorkbenchPayload = fullPayload;
+            channel.lastWorkbenchRevision = snapshot.revision;
+            channel.lastWorkbenchSnapshot = snapshot;
+            const sendMetric = sendSerializedPayload(client, clientPayload);
+            logPerformance("ws.workbench.subscribe", Date.now() - startedAt, {
+                userId,
+                snapshotMs,
+                fullPayloadBuildMs,
+                clientPayloadBuildMs,
+                payloadBytes: sendMetric.payloadBytes,
+                sendMs: sendMetric.sendMs,
+                bufferedAmount: sendMetric.bufferedAmount,
+                workspaceCount: snapshot.items.length,
+                sessionCount: snapshot.items.reduce((total, item) => total + countWorkbenchSessions(item), 0),
+                unchanged
+            }, {
+                thresholdMs: 0,
+                force: true
+            });
         }
         catch (error) {
             this.reportAsyncError("sendWorkbenchSnapshotToClient", error, { userId });
@@ -307,22 +366,45 @@ export class WorkbenchWsHub {
             await channel.refreshTask;
         }
         channel.refreshTask = (async () => {
+            const startedAt = Date.now();
             const startedAtMs = terminalDebugNowMs();
             try {
+                const snapshotStartedAt = Date.now();
                 const snapshot = await this.workbenchService.refreshSnapshot(userId);
-                const payload = buildWorkbenchPayload(snapshot);
-                if (payload === channel.lastWorkbenchPayload) {
+                const snapshotMs = Date.now() - snapshotStartedAt;
+                const serializeStartedAt = Date.now();
+                const payload = buildWorkbenchBroadcastPayload(channel.lastWorkbenchSnapshot, snapshot);
+                const serializeMs = Date.now() - serializeStartedAt;
+                if (snapshot.revision === channel.lastWorkbenchRevision) {
                     return;
                 }
                 channel.lastWorkbenchPayload = payload;
-                for (const client of channel.clients) {
-                    client.send(payload);
-                }
+                channel.lastWorkbenchRevision = snapshot.revision;
+                channel.lastWorkbenchSnapshot = snapshot;
+                const sessionCount = snapshot.items.reduce((total, item) => total + countWorkbenchSessions(item), 0);
+                const broadcastMetric = broadcastSerializedPayload(channel.clients, payload);
+                logPerformance("ws.workbench.refresh", Date.now() - startedAt, {
+                    userId,
+                    force,
+                    clientCount: channel.clients.size,
+                    snapshotMs,
+                    serializeMs,
+                    payloadBytes: broadcastMetric.payloadBytes,
+                    sendMs: broadcastMetric.sendMs,
+                    maxBufferedAmount: broadcastMetric.maxBufferedAmount,
+                    workspaceCount: snapshot.items.length,
+                    sessionCount
+                }, {
+                    thresholdMs: 0,
+                    force: true
+                });
                 logTerminalDebug("workbench.refresh.completed", {
                     userId,
                     force,
                     clientCount: channel.clients.size,
                     workspaceCount: snapshot.items.length,
+                    payloadBytes: broadcastMetric.payloadBytes,
+                    maxBufferedAmount: broadcastMetric.maxBufferedAmount,
                     durationMs: terminalDebugNowMs() - startedAtMs
                 });
             }
@@ -334,20 +416,23 @@ export class WorkbenchWsHub {
         });
         return channel.refreshTask;
     }
-    ensureFileTreeSubscription(client, workspaceId, paths) {
+    ensureFileTreeSubscription(client, workspaceId, paths, knownRevisions) {
         const current = this.clientFileTreeSubscriptions.get(client);
         const normalizedWorkspaceId = workspaceId.trim();
         const normalizedPaths = normalizePanelPaths(paths);
         const nextPaths = normalizedPaths.length > 0 ? normalizedPaths : [""];
+        const nextKnownRevisionByPath = buildKnownRevisionByPathMap(nextPaths, knownRevisions);
         if (current &&
             current.workspaceId === normalizedWorkspaceId &&
             areStringArraysEqual(current.paths, nextPaths)) {
+            current.knownRevisionByPath = nextKnownRevisionByPath;
             return current;
         }
         const next = {
             workspaceId: normalizedWorkspaceId,
             paths: nextPaths,
-            lastPayloadByPath: new Map()
+            lastPayloadByPath: new Map(),
+            knownRevisionByPath: nextKnownRevisionByPath
         };
         this.fileWatcher.subscribeFileTree(normalizedWorkspaceId, nextPaths);
         this.clientFileTreeSubscriptions.set(client, next);
@@ -356,8 +441,8 @@ export class WorkbenchWsHub {
         }
         return next;
     }
-    replaceFileTreeSubscription(client, workspaceId, paths) {
-        return this.ensureFileTreeSubscription(client, workspaceId, paths);
+    replaceFileTreeSubscription(client, workspaceId, paths, knownRevisions) {
+        return this.ensureFileTreeSubscription(client, workspaceId, paths, knownRevisions);
     }
     async refreshFileTreeSubscriptions(client, force = false) {
         const subscription = this.clientFileTreeSubscriptions.get(client);
@@ -368,11 +453,12 @@ export class WorkbenchWsHub {
             const uniquePaths = normalizePanelPaths(subscription.paths);
             for (const path of uniquePaths) {
                 const snapshot = await this.workspacePanelSnapshotService.getFileTreeSnapshot(subscription.workspaceId, path, { force });
-                const payload = buildFileTreePayload(snapshot);
+                const payload = buildFileTreePayload(snapshot, subscription.knownRevisionByPath.get(path) ?? null);
                 const lastPayload = subscription.lastPayloadByPath.get(path) ?? null;
                 if (payload === lastPayload) {
                     continue;
                 }
+                subscription.knownRevisionByPath.set(path, snapshot.revision);
                 subscription.lastPayloadByPath.set(path, payload);
                 client.send(payload);
             }
@@ -422,10 +508,13 @@ export class WorkbenchWsHub {
                 if (controller.signal.aborted) {
                     return;
                 }
-                const payload = buildGitPayload(snapshot);
-                if (payload === subscription.lastPayload && !options?.deliverIfUnchanged) {
+                const payload = buildGitPayload(snapshot, subscription.knownRevision, {
+                    includeSnapshotWhenUnchanged: force || options?.deliverIfUnchanged === true
+                });
+                if (payload === subscription.lastPayload && !options?.deliverIfUnchanged && !force) {
                     return;
                 }
+                subscription.knownRevision = snapshot.revision;
                 subscription.lastPayload = payload;
                 client.send(payload);
                 logTerminalDebug("workbench.git_refresh.completed", {
@@ -455,15 +544,18 @@ export class WorkbenchWsHub {
         });
         return subscription.refreshTask;
     }
-    ensureGitSubscription(client, workspaceId) {
+    ensureGitSubscription(client, workspaceId, knownRevision) {
         const normalizedWorkspaceId = workspaceId.trim();
         const current = this.clientGitSubscriptions.get(client);
+        const normalizedKnownRevision = normalizeKnownRevision(knownRevision) ?? null;
         if (current && current.workspaceId === normalizedWorkspaceId) {
+            current.knownRevision = normalizedKnownRevision;
             return current;
         }
         const next = {
             workspaceId: normalizedWorkspaceId,
             lastPayload: null,
+            knownRevision: normalizedKnownRevision,
             lastRequestedAt: 0,
             refreshTask: null,
             refreshController: null,
@@ -523,10 +615,12 @@ export class WorkbenchWsHub {
             this.flushQueuedGitRefresh(client);
         }, Math.max(0, delayMs));
     }
-    ensureTerminalManagerSubscription(client, workspaceId) {
+    ensureTerminalManagerSubscription(client, workspaceId, knownRevision) {
         const normalizedWorkspaceId = workspaceId.trim();
         const current = this.clientTerminalManagerSubscriptions.get(client);
+        const normalizedKnownRevision = normalizeKnownRevision(knownRevision) ?? null;
         if (current && current.workspaceId === normalizedWorkspaceId) {
+            current.knownRevision = normalizedKnownRevision;
             return current;
         }
         if (current?.refreshTimer) {
@@ -535,6 +629,7 @@ export class WorkbenchWsHub {
         const next = {
             workspaceId: normalizedWorkspaceId,
             lastPayload: null,
+            knownRevision: normalizedKnownRevision,
             refreshTask: null,
             refreshTimer: null,
             queuedRefresh: false,
@@ -602,11 +697,12 @@ export class WorkbenchWsHub {
                 const startedAtMs = terminalDebugNowMs();
                 const snapshot = await this.workspacePanelSnapshotService.getTerminalManagerSnapshot(subscription.workspaceId, { force });
                 const payloadStartedAtMs = terminalDebugNowMs();
-                const payload = buildTerminalManagerPayload(snapshot);
+                const payload = buildTerminalManagerPayload(snapshot, subscription.knownRevision);
                 const payloadBuildMs = terminalDebugNowMs() - payloadStartedAtMs;
                 if (payload === subscription.lastPayload) {
                     return;
                 }
+                subscription.knownRevision = snapshot.revision;
                 subscription.lastPayload = payload;
                 const sendStartedAtMs = terminalDebugNowMs();
                 client.send(payload);
@@ -641,10 +737,11 @@ export class WorkbenchWsHub {
         }
         try {
             const snapshot = await this.workspacePanelSnapshotService.getWorkspaceManagementSnapshot(subscription.workspaceId, { force });
-            const payload = buildWorkspaceManagementPayload(snapshot);
+            const payload = buildWorkspaceManagementPayload(snapshot, subscription.knownRevision);
             if (payload === subscription.lastPayload) {
                 return;
             }
+            subscription.knownRevision = snapshot.revision;
             subscription.lastPayload = payload;
             client.send(payload);
         }
@@ -700,7 +797,8 @@ function parseWorkbenchMessage(payload) {
         case "workbench.subscribe":
         case "workbench.refresh":
             return {
-                type: candidate.type
+                type: candidate.type,
+                knownRevision: normalizeKnownRevision(candidate.knownRevision)
             };
         case "fileTree.subscribe":
         case "fileTree.refresh":
@@ -710,7 +808,8 @@ function parseWorkbenchMessage(payload) {
                     workspaceId: candidate.workspaceId,
                     paths: Array.isArray(candidate.paths)
                         ? candidate.paths.filter((value) => typeof value === "string")
-                        : undefined
+                        : undefined,
+                    knownRevisions: normalizeKnownRevisionRecord(candidate.knownRevisions)
                 }
                 : null;
         case "git.subscribe":
@@ -718,7 +817,8 @@ function parseWorkbenchMessage(payload) {
             return typeof candidate.workspaceId === "string"
                 ? {
                     type: candidate.type,
-                    workspaceId: candidate.workspaceId
+                    workspaceId: candidate.workspaceId,
+                    knownRevision: normalizeKnownRevision(candidate.knownRevision)
                 }
                 : null;
         case "terminalManager.subscribe":
@@ -728,7 +828,8 @@ function parseWorkbenchMessage(payload) {
             return typeof candidate.workspaceId === "string"
                 ? {
                     type: candidate.type,
-                    workspaceId: candidate.workspaceId
+                    workspaceId: candidate.workspaceId,
+                    knownRevision: normalizeKnownRevision(candidate.knownRevision)
                 }
                 : null;
         default:
@@ -764,34 +865,185 @@ function areStringArraysEqual(left, right) {
     }
     return left.every((value, index) => value === right[index]);
 }
-function buildWorkbenchPayload(snapshot) {
+function sendSerializedPayload(client, payload) {
+    const sendStartedAt = Date.now();
+    client.send(payload);
+    return {
+        payloadBytes: Buffer.byteLength(payload),
+        sendMs: Date.now() - sendStartedAt,
+        bufferedAmount: client.bufferedAmount
+    };
+}
+function broadcastSerializedPayload(clients, payload) {
+    const sendStartedAt = Date.now();
+    let maxBufferedAmount = 0;
+    for (const client of clients) {
+        client.send(payload);
+        maxBufferedAmount = Math.max(maxBufferedAmount, client.bufferedAmount);
+    }
+    return {
+        payloadBytes: Buffer.byteLength(payload),
+        sendMs: Date.now() - sendStartedAt,
+        maxBufferedAmount
+    };
+}
+function buildWorkbenchPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "workbench.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "workbench.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildFileTreePayload(snapshot) {
+function buildWorkbenchBroadcastPayload(previousSnapshot, nextSnapshot) {
+    if (!previousSnapshot || previousSnapshot.revision === nextSnapshot.revision) {
+        return buildWorkbenchPayload(nextSnapshot);
+    }
+    const fullPayload = buildWorkbenchPayload(nextSnapshot);
+    const deltaPayload = JSON.stringify(buildWorkbenchDeltaPayload(previousSnapshot, nextSnapshot));
+    return Buffer.byteLength(deltaPayload, "utf8") < Buffer.byteLength(fullPayload, "utf8")
+        ? deltaPayload
+        : fullPayload;
+}
+function buildWorkbenchDeltaPayload(previousSnapshot, nextSnapshot) {
+    const previousByWorkspaceId = new Map(previousSnapshot.items.map((item) => [item.workspace.id, item]));
+    const nextByWorkspaceId = new Map(nextSnapshot.items.map((item) => [item.workspace.id, item]));
+    const changedItems = [];
+    for (const item of nextSnapshot.items) {
+        const previous = previousByWorkspaceId.get(item.workspace.id);
+        if (!previous || JSON.stringify(previous) !== JSON.stringify(item)) {
+            changedItems.push(item);
+        }
+    }
+    return {
+        type: "workbench.delta",
+        baseRevision: previousSnapshot.revision,
+        revision: nextSnapshot.revision,
+        orderedWorkspaceIds: nextSnapshot.items.map((item) => item.workspace.id),
+        removedWorkspaceIds: previousSnapshot.items
+            .map((item) => item.workspace.id)
+            .filter((workspaceId) => !nextByWorkspaceId.has(workspaceId)),
+        changedItems
+    };
+}
+function buildFileTreePayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "fileTree.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "fileTree.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildGitPayload(snapshot) {
+function buildGitPayload(snapshot, knownRevision, options) {
+    if (knownRevision
+        && knownRevision === snapshot.revision
+        && options?.includeSnapshotWhenUnchanged !== true) {
+        return JSON.stringify({
+            type: "git.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "git.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildTerminalManagerPayload(snapshot) {
+function buildTerminalManagerPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "terminalManager.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "terminalManager.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
-function buildWorkspaceManagementPayload(snapshot) {
+function buildWorkspaceManagementPayload(snapshot, knownRevision) {
+    if (knownRevision && knownRevision === snapshot.revision) {
+        return JSON.stringify({
+            type: "workspaceManagement.snapshot",
+            revision: snapshot.revision,
+            unchanged: true,
+            snapshot: null
+        });
+    }
     return JSON.stringify({
         type: "workspaceManagement.snapshot",
+        revision: snapshot.revision,
+        unchanged: false,
         snapshot
     });
 }
+function normalizeKnownRevision(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function normalizeKnownRevisionRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    const normalizedEntries = Object.entries(value)
+        .map(([key, candidate]) => [key.trim(), normalizeKnownRevision(candidate)])
+        .filter((entry) => Boolean(entry[1]));
+    if (normalizedEntries.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(normalizedEntries);
+}
+function buildKnownRevisionByPathMap(paths, knownRevisions) {
+    const map = new Map();
+    if (!knownRevisions) {
+        return map;
+    }
+    for (const path of paths) {
+        const knownRevision = knownRevisions[path];
+        if (knownRevision) {
+            map.set(path, knownRevision);
+        }
+    }
+    return map;
+}
+function countWorkbenchSessions(item) {
+    const childNodes = Array.isArray(item.childWorktrees)
+        ? item.childWorktrees
+        : Array.isArray(item.children)
+            ? item.children
+            : [];
+    return item.sessions.length + childNodes.reduce((total, child) => {
+        if (typeof child !== "object" || child === null) {
+            return total;
+        }
+        const candidate = child;
+        return total + countWorkbenchSessions({
+            sessions: Array.isArray(candidate.sessions) ? candidate.sessions : [],
+            childWorktrees: candidate.childWorktrees,
+            children: candidate.children
+        });
+    }, 0);
+}
 //# sourceMappingURL=workbench-ws-hub.js.map