@ricsam/r5d-worker 0.0.53 → 0.0.55

package/dist/mjs/main.mjs

@@ -6,9 +6,14 @@ import os, { hostname } from "node:os";
 import { spawn as spawnChildProcess } from "node:child_process";
 import { installCliUpdate, readInstalledCliVersion } from "./cli-update.mjs";
 import { configureVisibleGitIdentity } from "./git-identity.mjs";
-import { hasWorkerHeartbeatTimedOut, WORKER_HEARTBEAT_INTERVAL_MS } from "./heartbeat.mjs";
+import {
+  grantWorkerHeartbeatBusyGrace,
+  hasWorkerHeartbeatTimedOutWithBusyGrace,
+  WORKER_HEARTBEAT_INTERVAL_MS
+} from "./heartbeat.mjs";
 import { terminateProcessTree } from "./process-tree.mjs";
 import { openWorkerPortForwardRelay } from "./port-forward-client.mjs";
+import { applyWorkspaceIncidentUpdate, releasePendingWorkspaceHead } from "./workspace-incident-state.mjs";
 import {
   isRetryableWorkerServerStatus,
   superviseWorkerRuntime,
@@ -39,6 +44,7 @@ const pendingProcessTerminals = /* @__PURE__ */ new Map();
 const cancelledProcessRuns = /* @__PURE__ */ new Set();
 const activePtys = /* @__PURE__ */ new Map();
 let currentWorkerSocket = null;
+const workspaceSyncSingleFlight = new WorkspaceSyncSingleFlight();
 let githubCredential = null;
 let visibleGitIdentity = null;
 function defaultConfigPath() {
@@ -2210,75 +2216,72 @@ function resolveHostShell(command, platform = process.platform) {
   return { file, args: command === void 0 ? ["-l"] : ["-lc", command] };
 }
 async function openPty(input) {
-  try {
-    const planProcessEnv = !(input.resolvedTarget.target.type === "workspace" && input.resolvedTarget.target.rootProfile === "canonical_sync") ? preparePlanEnvForShell({
-      target: input.resolvedTarget.target,
-      planRoot: input.planRoot,
-      activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
-    }) : {};
-    const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
-    const shell = resolveHostShell(input.message.command);
-    const ptyProcess = createNodePtyBridge({
-      file: shell.file,
-      args: shell.args,
-      ptyOptions: {
-        name: "xterm-256color",
-        cols: Math.max(1, Math.min(Math.floor(input.message.cols || 80), 500)),
-        rows: Math.max(1, Math.min(Math.floor(input.message.rows || 24), 500)),
-        cwd: input.resolvedTarget.rootPath,
-        env: {
-          ...process.env,
-          ...githubProcessEnv(),
-          ...input.message.env ?? {},
-          ...planProcessEnv,
-          ...targetProcessEnv
-        }
-      },
-      onOpened: () => {
-        sendWorkerMessage(input.ws, {
-          type: "pty_opened",
-          requestId: input.message.requestId,
-          ptyId: input.message.ptyId
-        });
-      },
-      onOutput: (data) => {
-        sendWorkerMessage(input.ws, {
-          type: "pty_output",
-          ptyId: input.message.ptyId,
-          data
-        });
-      },
-      onExit: (event) => {
-        activePtys.delete(input.message.ptyId);
-        sendWorkerMessage(input.ws, {
-          type: "pty_exit",
-          ptyId: input.message.ptyId,
-          exitCode: event.exitCode,
-          signal: event.signal
-        });
-      },
-      onError: (error) => {
-        activePtys.delete(input.message.ptyId);
-        sendWorkerMessage(input.ws, {
-          type: "pty_error",
-          requestId: input.message.requestId,
-          ptyId: input.message.ptyId,
-          error: error.message
-        });
-      }
-    });
-    activePtys.set(input.message.ptyId, {
-      ...ptyProcess,
-      target: input.resolvedTarget.target
-    });
-  } catch (error) {
-    sendWorkerMessage(input.ws, {
-      type: "pty_error",
-      requestId: input.message.requestId,
-      ptyId: input.message.ptyId,
-      error: error instanceof Error ? error.message : String(error)
-    });
+  if (activePtys.has(input.message.ptyId)) {
+    throw new Error(`Shell ${input.message.ptyId} is already open`);
   }
+  const planProcessEnv = !(input.resolvedTarget.target.type === "workspace" && input.resolvedTarget.target.rootProfile === "canonical_sync") ? preparePlanEnvForShell({
+    target: input.resolvedTarget.target,
+    planRoot: input.planRoot,
+    activePlanId: input.message.env?.R5D_ACTIVE_PLAN_ID
+  }) : {};
+  const targetProcessEnv = targetIdentityEnv(input.resolvedTarget.target);
+  const shell = resolveHostShell(input.message.command);
+  const ptyProcess = createNodePtyBridge({
+    file: shell.file,
+    args: shell.args,
+    ptyOptions: {
+      name: "xterm-256color",
+      cols: Math.max(1, Math.min(Math.floor(input.message.cols || 80), 500)),
+      rows: Math.max(1, Math.min(Math.floor(input.message.rows || 24), 500)),
+      cwd: input.resolvedTarget.rootPath,
+      env: {
+        ...process.env,
+        ...githubProcessEnv(),
+        ...input.message.env ?? {},
+        ...planProcessEnv,
+        ...targetProcessEnv
+      }
+    },
+    onOpened: () => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_opened",
+        requestId: input.message.requestId,
+        ptyId: input.message.ptyId
+      });
+    },
+    onOutput: (data) => {
+      sendWorkerMessage(input.ws, {
+        type: "pty_output",
+        ptyId: input.message.ptyId,
+        data
+      });
+    },
+    onExit: (event) => {
+      input.releaseWorkspaceMutation();
+      activePtys.delete(input.message.ptyId);
+      sendWorkerMessage(input.ws, {
+        type: "pty_exit",
+        ptyId: input.message.ptyId,
+        exitCode: event.exitCode,
+        signal: event.signal
+      });
+    },
+    onError: (error) => {
+      input.releaseWorkspaceMutation();
+      activePtys.delete(input.message.ptyId);
+      sendWorkerMessage(input.ws, {
+        type: "pty_error",
+        requestId: input.message.requestId,
+        ptyId: input.message.ptyId,
+        error: error.message
+      });
+    }
+  });
+  activePtys.set(input.message.ptyId, {
+    ...ptyProcess,
+    target: input.resolvedTarget.target,
+    releaseWorkspaceMutation: input.releaseWorkspaceMutation
+  });
 }
 function writePty(ws, message) {
   const ptyProcess = activePtys.get(message.ptyId);
@@ -2355,7 +2358,6 @@ async function startWorker(options) {
   fs.mkdirSync(planRoot, { recursive: true });
   const manifestByProjectId = /* @__PURE__ */ new Map();
   const pendingManifestCheckouts = /* @__PURE__ */ new Map();
-  const workspaceSyncSingleFlight = new WorkspaceSyncSingleFlight();
   let workspaceRemoteUrl = null;
   let activeWorkspaceIncidentId = null;
   let previousPeriodicFingerprint = null;
@@ -2381,8 +2383,32 @@ async function startWorker(options) {
       ...overrides
     };
   };
-  const sendWorkspaceSyncResult = (requestId, result) => {
-    sendWorkerMessage(ws, { type: "workspace_sync_result", requestId, result });
+  const sendWorkspaceSyncResult = (authority, result) => {
+    try {
+      ws.send(JSON.stringify({ type: "workspace_sync_result", ...authority, result }));
+    } catch (error) {
+      process.stderr.write(
+        `[r5d-worker] failed to send workspace_sync_result on its issuing connection: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+  };
+  const requestWorkspaceSync = (trigger, fingerprint) => {
+    try {
+      ws.send(
+        JSON.stringify({
+          type: "workspace_sync_requested",
+          observationId: crypto.randomUUID(),
+          trigger,
+          ...fingerprint ? { fingerprint } : {}
+        })
+      );
+    } catch (error) {
+      process.stderr.write(
+        `[r5d-worker] failed to send workspace sync observation on its current connection: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
   };
   const manifestCheckoutKey = (projectId, branchName) => `${projectId}\0${branchName}`;
   const allManifestCheckouts = () => [...manifestByProjectId.values()].flatMap(
@@ -2433,7 +2459,7 @@ async function startWorker(options) {
     }
     return created;
   };
-  const runRequestedWorkspaceSync = async (requestId, trigger, overrides = {}) => {
+  const runRequestedWorkspaceSync = async (authority, trigger, overrides = {}) => {
     workspaceSyncRequestsInFlight += 1;
     try {
       let pendingTargets = [];
@@ -2477,7 +2503,7 @@ async function startWorker(options) {
         }
       }
       previousPeriodicFingerprint = null;
-      sendWorkspaceSyncResult(requestId, result);
+      sendWorkspaceSyncResult(authority, result);
       return result;
     } catch (error) {
       const result = {
@@ -2497,7 +2523,7 @@ async function startWorker(options) {
         error: error instanceof Error ? error.message : String(error)
       };
       previousPeriodicFingerprint = null;
-      sendWorkspaceSyncResult(requestId, result);
+      sendWorkspaceSyncResult(authority, result);
       return result;
     } finally {
       workspaceSyncRequestsInFlight -= 1;
@@ -2509,6 +2535,7 @@ async function startWorker(options) {
     }
   });
   let lastServerHeartbeatAt = null;
+  let heartbeatBusyGrace = null;
   let heartbeatTimedOut = false;
   let heartbeatWatchdog;
   const stopHeartbeatWatchdog = () => {
@@ -2520,7 +2547,7 @@ async function startWorker(options) {
   ws.addEventListener("open", () => {
     currentWorkerSocket = ws;
     heartbeatWatchdog = setInterval(() => {
-      if (heartbeatTimedOut || !hasWorkerHeartbeatTimedOut(lastServerHeartbeatAt)) {
+      if (heartbeatTimedOut || !hasWorkerHeartbeatTimedOutWithBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace)) {
         return;
       }
       heartbeatTimedOut = true;
@@ -2540,7 +2567,8 @@ async function startWorker(options) {
         capabilities: {
           updateClis: true,
           canonicalResolverCheckout: true,
-          browserPortForwarding: true
+          browserPortForwarding: true,
+          globalWorkspaceSyncLeaseV1: true
         },
         projectRoot: projectsRoot,
         artifactRoot,
@@ -2567,33 +2595,35 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_manifest") {
-        configureGitHubAuth(message.githubCredential);
-        visibleGitIdentity = message.gitIdentity;
-        workspaceRemoteUrl = message.workspaceRemoteUrl;
-        const previousCheckoutKeys = new Set(
-          allManifestCheckouts().map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
-        );
-        const migratedProjectIds = migrateLegacyProjectRoots(projectsRoot, message.projects);
-        manifestByProjectId.clear();
-        for (const project of message.projects) manifestByProjectId.set(project.projectId, project);
-        const currentCheckouts = allManifestCheckouts();
-        const currentCheckoutKeys = new Set(
-          currentCheckouts.map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
-        );
-        for (const key of pendingManifestCheckouts.keys()) {
-          if (!currentCheckoutKeys.has(key)) pendingManifestCheckouts.delete(key);
-        }
-        for (const checkout of currentCheckouts) {
-          const key = manifestCheckoutKey(checkout.projectId, checkout.branchName);
-          if (previousCheckoutKeys.has(key)) continue;
-          const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
-          if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
-        }
-        previousPeriodicFingerprint = null;
-        process.stdout.write(
-          `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
+        await workspaceSyncSingleFlight.runMutation(() => {
+          configureGitHubAuth(message.githubCredential);
+          visibleGitIdentity = message.gitIdentity;
+          workspaceRemoteUrl = message.workspaceRemoteUrl;
+          const previousCheckoutKeys = new Set(
+            allManifestCheckouts().map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
+          );
+          const migratedProjectIds = migrateLegacyProjectRoots(projectsRoot, message.projects);
+          manifestByProjectId.clear();
+          for (const project of message.projects) manifestByProjectId.set(project.projectId, project);
+          const currentCheckouts = allManifestCheckouts();
+          const currentCheckoutKeys = new Set(
+            currentCheckouts.map(({ projectId, branchName }) => manifestCheckoutKey(projectId, branchName))
+          );
+          for (const key of pendingManifestCheckouts.keys()) {
+            if (!currentCheckoutKeys.has(key)) pendingManifestCheckouts.delete(key);
+          }
+          for (const checkout of currentCheckouts) {
+            const key = manifestCheckoutKey(checkout.projectId, checkout.branchName);
+            if (previousCheckoutKeys.has(key)) continue;
+            const branchPath = path.join(projectRootFor(projectsRoot, checkout.projectId, manifestByProjectId), checkout.branchName);
+            if (!hasNormalVisibleGitDir(branchPath)) pendingManifestCheckouts.set(key, checkout);
+          }
+          previousPeriodicFingerprint = null;
+          process.stdout.write(
+            `[r5d-worker] workspace manifest: ${message.projects.length} projects${migratedProjectIds.length > 0 ? `; migrated ${migratedProjectIds.length} project checkout root(s)` : ""}
 `
-        );
+          );
+        });
         if (!periodicWorkspaceScan) {
           const emptyFingerprint = createHash("sha256").update("").digest("hex");
           periodicWorkspaceScan = setInterval(() => {
@@ -2610,7 +2640,7 @@ async function startWorker(options) {
               );
               if (hasPendingGenericCheckout) {
                 previousPeriodicFingerprint = null;
-                await runRequestedWorkspaceSync(crypto.randomUUID(), {
+                requestWorkspaceSync({
                   type: "periodic",
                   detail: "workspace manifest additions"
                 });
@@ -2626,7 +2656,7 @@ async function startWorker(options) {
                 return;
               }
               previousPeriodicFingerprint = null;
-              await runRequestedWorkspaceSync(crypto.randomUUID(), { type: "periodic" });
+              requestWorkspaceSync({ type: "periodic" }, fingerprint);
             })().catch((error) => {
               process.stderr.write(
                 `[r5d-worker] periodic workspace synchronization failed: ${error instanceof Error ? error.message : String(error)}
@@ -2634,6 +2664,7 @@ async function startWorker(options) {
               );
             }).finally(() => {
               periodicWorkspaceScanInFlight = false;
+              heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
             });
           }, WORKSPACE_PERIODIC_SCAN_INTERVAL_MS);
           periodicWorkspaceScan.unref();
@@ -2641,23 +2672,23 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "sync_workspace") {
-        await runRequestedWorkspaceSync(message.requestId, message.trigger, {
-          attemptId: message.attemptId,
-          confirmedLargeDiff: message.confirmedLargeDiff,
-          confirmationReason: message.confirmationReason,
-          resetToCanonical: message.resetToCanonical,
-          skipVisibleMirror: message.skipVisibleMirror
-        });
-        return;
-      }
-      if (message.type === "workspace_head_updated") {
-        if (!activeWorkspaceIncidentId) {
-          await runRequestedWorkspaceSync(
-            crypto.randomUUID(),
-            { type: "inbound_head", detail: message.commitHash },
-            { skipVisibleMirror: true }
-          );
-        }
+        await runRequestedWorkspaceSync(
+          {
+            requestId: message.requestId,
+            intentId: message.intentId,
+            leaseEpoch: message.leaseEpoch,
+            leaseToken: message.leaseToken
+          },
+          message.trigger,
+          {
+            attemptId: message.attemptId,
+            quarantineRef: message.quarantineRef,
+            confirmedLargeDiff: message.confirmedLargeDiff,
+            confirmationReason: message.confirmationReason,
+            resetToCanonical: message.resetToCanonical,
+            skipVisibleMirror: message.skipVisibleMirror
+          }
+        );
         return;
       }
       if (message.type === "sync_session_artifacts") {
@@ -2687,8 +2718,17 @@ async function startWorker(options) {
         return;
       }
       if (message.type === "workspace_incident_updated") {
-        activeWorkspaceIncidentId = message.status === "remediating" || message.status === "waiting_for_worker" ? message.incidentId : null;
+        const previousIncidentId = activeWorkspaceIncidentId;
+        activeWorkspaceIncidentId = applyWorkspaceIncidentUpdate(activeWorkspaceIncidentId, message);
         previousPeriodicFingerprint = null;
+        const releasedHead = releasePendingWorkspaceHead(
+          previousIncidentId,
+          activeWorkspaceIncidentId,
+          message.status === "resolved" || message.status === "confirmed" || message.status === "reset" ? message.incidentId : null
+        );
+        if (releasedHead.syncHead) {
+          requestWorkspaceSync({ type: "inbound_head", detail: releasedHead.syncHead });
+        }
         return;
       }
       if (message.type === "exec_terminal_ack") {
@@ -2745,6 +2785,7 @@ async function startWorker(options) {
       }
       if (message.type === "ping") {
         lastServerHeartbeatAt = Date.now();
+        heartbeatBusyGrace = null;
         ws.send(JSON.stringify({ type: "pong" }));
         return;
       }
@@ -2785,11 +2826,14 @@ async function startWorker(options) {
           });
           return;
         }
+        const releaseWorkspaceMutation = await workspaceSyncSingleFlight.acquireMutation();
+        let leaseTransferred = false;
         try {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] pty ${message.ptyId}: ${describeWorkerSessionTarget(message.target)}
 `);
-          await openPty({ ws, message, resolvedTarget, planRoot });
+          await openPty({ ws, message, resolvedTarget, planRoot, releaseWorkspaceMutation });
+          leaseTransferred = true;
         } catch (error) {
           sendWorkerMessage(ws, {
             type: "pty_error",
@@ -2797,6 +2841,8 @@ async function startWorker(options) {
             ptyId: message.ptyId,
             error: error instanceof Error ? error.message : String(error)
           });
+        } finally {
+          if (!leaseTransferred) releaseWorkspaceMutation();
         }
         return;
       }
@@ -2825,10 +2871,12 @@ async function startWorker(options) {
         }
         let result;
         try {
-          const resolvedTarget = resolveMessageTarget(message.target);
-          process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
+          result = await workspaceSyncSingleFlight.runMutation(async () => {
+            const resolvedTarget = resolveMessageTarget(message.target);
+            process.stdout.write(`[r5d-worker] exec ${message.runId}: ${message.argv.join(" ")}
 `);
-          result = await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
+            return await executeCommand({ message, resolvedTarget, baseUrl, token, artifactRoot, planRoot });
+          });
         } catch (error) {
           result = {
             type: "exec_result",
@@ -2857,11 +2905,11 @@ async function startWorker(options) {
           requestId: message.requestId,
           runId: message.runId
         });
-        try {
+        void workspaceSyncSingleFlight.runMutation(async () => {
           const resolvedTarget = resolveMessageTarget(message.target);
           process.stdout.write(`[r5d-worker] exec_start ${message.runId}: ${message.argv.join(" ")}
 `);
-          void executeStreamingCommand({
+          await executeStreamingCommand({
             ws,
             message,
             resolvedTarget,
@@ -2869,34 +2917,29 @@ async function startWorker(options) {
             token,
             artifactRoot,
             planRoot
-          }).catch((error) => {
-            sendWorkerMessage(ws, {
-              type: "exec_start_error",
-              requestId: message.requestId,
-              runId: message.runId,
-              error: error instanceof Error ? error.message : String(error)
-            });
           });
-        } catch (error) {
+        }).catch((error) => {
           sendWorkerMessage(ws, {
             type: "exec_start_error",
             requestId: message.requestId,
             runId: message.runId,
             error: error instanceof Error ? error.message : String(error)
           });
-        }
+        });
         return;
       }
       if (message.type === "read" || message.type === "write" || message.type === "edit" || message.type === "grep" || message.type === "find" || message.type === "ls" || message.type === "view_file_bytes") {
         try {
-          const resolvedTarget = resolveMessageTarget(message.target);
-          const result = await executeOperation({
-            message,
-            resolvedTarget,
-            baseUrl,
-            token,
-            artifactRoot,
-            planRoot
+          const result = await workspaceSyncSingleFlight.runMutation(async () => {
+            const resolvedTarget = resolveMessageTarget(message.target);
+            return await executeOperation({
+              message,
+              resolvedTarget,
+              baseUrl,
+              token,
+              artifactRoot,
+              planRoot
+            });
           });
           ws.send(
             JSON.stringify({
@@ -2929,6 +2972,8 @@ async function startWorker(options) {
     })().catch((error) => {
       process.stderr.write(`[r5d-worker] message handling failed: ${error instanceof Error ? error.message : String(error)}
 `);
+    }).finally(() => {
+      heartbeatBusyGrace = grantWorkerHeartbeatBusyGrace(lastServerHeartbeatAt, heartbeatBusyGrace);
     });
   });
   ws.addEventListener("close", (event) => {

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "type": "module"
 }

package/dist/mjs/workspace-incident-state.mjs

@@ -0,0 +1,14 @@
+function applyWorkspaceIncidentUpdate(currentIncidentId, update) {
+  if (update.status === "remediating" || update.status === "waiting_for_worker") return update.incidentId;
+  if (currentIncidentId && update.incidentId && update.incidentId !== currentIncidentId) return currentIncidentId;
+  return null;
+}
+function releasePendingWorkspaceHead(previousIncidentId, currentIncidentId, terminalIncidentId) {
+  if (!previousIncidentId || currentIncidentId) return { syncHead: null };
+  if (terminalIncidentId === previousIncidentId) return { syncHead: "authoritative" };
+  return { syncHead: null };
+}
+export {
+  applyWorkspaceIncidentUpdate,
+  releasePendingWorkspaceHead
+};

package/dist/mjs/workspace-mutation-gate.mjs

@@ -0,0 +1,68 @@
+class WorkspaceMutationGate {
+  activeMutations = 0;
+  syncActive = false;
+  waiters = [];
+  acquireMutation() {
+    return new Promise((resolve) => {
+      this.waiters.push({ kind: "mutation", resolve });
+      this.drain();
+    });
+  }
+  async runMutation(operation) {
+    const release = await this.acquireMutation();
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  async runSync(operation) {
+    const release = await new Promise((resolve) => {
+      this.waiters.push({ kind: "sync", resolve });
+      this.drain();
+    });
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  drain() {
+    if (this.syncActive || this.waiters.length === 0) return;
+    const first = this.waiters[0];
+    if (first?.kind === "sync") {
+      if (this.activeMutations > 0) return;
+      this.waiters.shift();
+      this.syncActive = true;
+      first.resolve(this.releaseSync());
+      return;
+    }
+    while (this.waiters[0]?.kind === "mutation") {
+      const waiter = this.waiters.shift();
+      if (!waiter || waiter.kind !== "mutation") break;
+      this.activeMutations += 1;
+      waiter.resolve(this.releaseMutation());
+    }
+  }
+  releaseMutation() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.activeMutations -= 1;
+      this.drain();
+    };
+  }
+  releaseSync() {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.syncActive = false;
+      this.drain();
+    };
+  }
+}
+export {
+  WorkspaceMutationGate
+};