@ricsam/r5d-worker 0.0.86 → 0.0.87

package/dist/cjs/main.cjs

@@ -839,6 +839,33 @@ function tryGit(args, options = {}) {
     return false;
   }
 }
+async function runGitAsync(args, options = {}) {
+  const command = workerGitCommand.commandArgs(args);
+  const subprocess = Bun.spawn(command, {
+    cwd: options.cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: (0, import_git_process_environment.workerGitProcessEnvironment)()
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(subprocess.stdout).text(),
+    new Response(subprocess.stderr).text(),
+    subprocess.exited
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(`git ${args.join(" ")} failed: ${stderr.trim() || stdout.trim() || `exit ${exitCode}`}`);
+  }
+  return stdout.trim();
+}
+async function tryGitAsync(args, options = {}) {
+  try {
+    await runGitAsync(args, options);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function getGitBlobHashForContent(content) {
   const buffer = typeof content === "string" ? Buffer.from(content, "utf8") : content;
   return (0, import_node_crypto.createHash)("sha1").update(`blob ${buffer.length}\0`).update(buffer).digest("hex");
@@ -3810,10 +3837,14 @@ async function startWorker(options) {
     }
     return mounts;
   };
-  const workspaceLocalHead = () => import_node_fs.default.existsSync(import_node_path.default.join(workspaceShadowRoot, ".git")) && tryGit(["rev-parse", "--verify", "HEAD"], { cwd: workspaceShadowRoot }) ? runGit(["rev-parse", "HEAD"], { cwd: workspaceShadowRoot }) : null;
-  const workspaceGitStatus = () => {
+  const workspaceLocalHead = async () => {
+    if (!import_node_fs.default.existsSync(import_node_path.default.join(workspaceShadowRoot, ".git"))) return null;
+    if (!await tryGitAsync(["rev-parse", "--verify", "HEAD"], { cwd: workspaceShadowRoot })) return null;
+    return runGitAsync(["rev-parse", "HEAD"], { cwd: workspaceShadowRoot });
+  };
+  const workspaceGitStatus = async () => {
     try {
-      return runGit(["status", "--porcelain"], { cwd: workspaceShadowRoot });
+      return await runGitAsync(["status", "--porcelain"], { cwd: workspaceShadowRoot });
     } catch {
       return "";
     }
@@ -3826,7 +3857,7 @@ async function startWorker(options) {
       })
     )
   ].sort();
-  const ensureConfiguredProjects = () => {
+  const ensureConfiguredProjects = async () => {
     for (const project of projectConfigById.values()) {
       validateProjectId(project.projectId);
       (0, import_repository_transition_policy.assertRepositoryTransitionState)(project);
@@ -3863,7 +3894,7 @@ async function startWorker(options) {
       }
       try {
         const connection = projectConnection(project);
-        const states = (0, import_project_worktrees.ensureProjectWorktrees)({
+        const states = await (0, import_project_worktrees.ensureProjectWorktrees)({
           projectRoot,
           snapshotRoot: projectWorktreeSnapshotsRoot,
           primaryBranchName: primaryProjectBranch(project),
@@ -3912,13 +3943,13 @@ async function startWorker(options) {
       }
     }
   };
-  const collectAheadOfOriginBranches = () => {
+  const collectAheadOfOriginBranches = async () => {
     const aheadBranches = [];
     for (const project of projectConfigById.values()) {
       if (project.executionDisabled || !readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
       const connection = projectConnection(project);
       const primaryPath = configuredProjectBranchPath(projectsRoot, project, primaryProjectBranch(project));
-      if (!tryGit(
+      if (!await tryGitAsync(
         [
           ...(0, import_git_process_environment.gitTransportSecurityArgs)(connection.originUrl, connection.credentialHelper, connection.originCredentialUsername),
           "fetch",
@@ -3942,11 +3973,11 @@ async function startWorker(options) {
             primaryBranchName: primaryProjectBranch(project),
             defaultBranch: project.defaultBranch
           })}`;
-          if (tryGit(["show-ref", "--verify", "--quiet", originRef], { cwd: branchPath })) {
-            const counts = runGit(["rev-list", "--left-right", "--count", `${originRef}...HEAD`], { cwd: branchPath }).split(/\s+/).map(Number);
+          if (await tryGitAsync(["show-ref", "--verify", "--quiet", originRef], { cwd: branchPath })) {
+            const counts = (await runGitAsync(["rev-list", "--left-right", "--count", `${originRef}...HEAD`], { cwd: branchPath })).split(/\s+/).map(Number);
             ahead = Number.isSafeInteger(counts[1]) ? counts[1] : 0;
-          } else if (tryGit(["cat-file", "-e", `${branch.baseCommitHash}^{commit}`], { cwd: branchPath })) {
-            const count = Number(runGit(["rev-list", "--count", `${branch.baseCommitHash}..HEAD`], { cwd: branchPath }));
+          } else if (await tryGitAsync(["cat-file", "-e", `${branch.baseCommitHash}^{commit}`], { cwd: branchPath })) {
+            const count = Number(await runGitAsync(["rev-list", "--count", `${branch.baseCommitHash}..HEAD`], { cwd: branchPath }));
             ahead = Number.isSafeInteger(count) ? count : 0;
           }
           if (ahead > 0) aheadBranches.push({ projectId: project.projectId, branchName: branch.branchName, ahead });
@@ -3962,19 +3993,19 @@ async function startWorker(options) {
       (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
     );
   };
-  const captureProjectHeadsForWorkspacePublication = () => {
+  const captureProjectHeadsForWorkspacePublication = async () => {
     const heads = /* @__PURE__ */ new Map();
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId)) continue;
       for (const branch of project.branches) {
         const branchPath = configuredProjectBranchPath(projectsRoot, project, branch.branchName);
         if (!hasProjectWorktree(branchPath)) continue;
-        heads.set(projectMountId(project.projectId, branch.branchName), runGit(["rev-parse", "HEAD"], { cwd: branchPath }));
+        heads.set(projectMountId(project.projectId, branch.branchName), await runGitAsync(["rev-parse", "HEAD"], { cwd: branchPath }));
       }
     }
     return heads;
   };
-  const pushChangedProjectHeads = (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
+  const pushChangedProjectHeads = async (activeMountIds, publishedHead, publicationHeads, suppressedMountIds = /* @__PURE__ */ new Set()) => {
     const active = new Set(activeMountIds);
     for (const project of projectConfigById.values()) {
       if (!readyProjectIds.has(project.projectId) || !(0, import_repository_transition_policy.repositoryMirrorWritesAllowed)(project)) continue;
@@ -3990,7 +4021,7 @@ async function startWorker(options) {
       }
       if (changed.size === 0) continue;
       const connection = projectConnection(project);
-      const results = (0, import_project_worktrees.pushProjectMirrorHeads)({
+      const results = await (0, import_project_worktrees.pushProjectMirrorHeads)({
         projectRoot: configuredProjectRoot(projectsRoot, project),
         branchNames: project.branches.map(({ branchName }) => branchName),
         mirrorUrl: connection.mirrorUrl,
@@ -4021,7 +4052,7 @@ async function startWorker(options) {
       if (!active.has(deletion.id)) continue;
       if (!(0, import_repository_transition_policy.repositoryMirrorWritesAllowed)(projectConfigById.get(deletion.projectId))) continue;
       if (!deletion.projectDeleted) {
-        (0, import_project_worktrees.deleteProjectMirrorBranch)({
+        await (0, import_project_worktrees.deleteProjectMirrorBranch)({
           gitDirectory: deletion.gitDirectory,
           branchName: deletion.branchName,
           mirrorUrl: deletion.mirrorUrl,
@@ -4042,7 +4073,7 @@ async function startWorker(options) {
       lastObservedProjectHeads.delete(key);
     }
   };
-  const observeProjectHeadsBeforeOuterWorkspace = (input) => {
+  const observeProjectHeadsBeforeOuterWorkspace = async (input) => {
     const bundles = [];
     for (const project of projectConfigById.values()) {
       if (project.executionDisabled || !readyProjectIds.has(project.projectId) || project.branches.length === 0) continue;
@@ -4054,7 +4085,7 @@ async function startWorker(options) {
           projectId: project.projectId,
           projectRoot,
           primaryBranchName,
-          observations: (0, import_project_worktrees.observeProjectMirrorHeads)({
+          observations: await (0, import_project_worktrees.observeProjectMirrorHeads)({
             projectRoot,
             primaryBranchName,
             branchNames: project.branches.map(({ branchName }) => branchName),
@@ -4074,7 +4105,7 @@ async function startWorker(options) {
     }
     return bundles;
   };
-  const applyObservedProjectHeadsAfterInboundWorkspace = (bundles, activeMountIds, requireObservedHeads) => {
+  const applyObservedProjectHeadsAfterInboundWorkspace = async (bundles, activeMountIds, requireObservedHeads) => {
     const active = new Set(activeMountIds);
     for (const bundle of bundles) {
       const project = projectConfigById.get(bundle.projectId);
@@ -4082,7 +4113,7 @@ async function startWorker(options) {
       const observations = bundle.observations.filter(({ branchName }) => active.has(projectMountId(project.projectId, branchName)));
       if (observations.length === 0) continue;
       try {
-        const refreshed = (0, import_project_worktrees.applyObservedProjectMirrorHeads)({
+        const refreshed = await (0, import_project_worktrees.applyObservedProjectMirrorHeads)({
           projectRoot: bundle.projectRoot,
           primaryBranchName: bundle.primaryBranchName,
           observations,
@@ -4092,7 +4123,7 @@ async function startWorker(options) {
           for (const observation of observations) {
             if (!observation.shouldMove || !observation.mirrorHead) continue;
             const checkoutPath = configuredProjectBranchPath(projectsRoot, project, observation.branchName);
-            const currentHead = runGit(["rev-parse", "HEAD"], { cwd: checkoutPath });
+            const currentHead = await runGitAsync(["rev-parse", "HEAD"], { cwd: checkoutPath });
             if (currentHead !== observation.mirrorHead) {
               throw new Error(
                 `Project ${project.projectId}/${observation.branchName} did not apply observed hidden mirror head ${observation.mirrorHead}`
@@ -4115,7 +4146,7 @@ async function startWorker(options) {
       }
     }
   };
-  const mapWorkspaceGitResult = (attemptId, trigger, result) => {
+  const mapWorkspaceGitResult = async (attemptId, trigger, result) => {
     const activeProjectBranchPublications = (0, import_workspace_publication_evidence.activeProjectBranchPublicationEvidence)([...projectConfigById.values()], result.activeMountIds);
     return {
       type: "workspace_sync",
@@ -4128,7 +4159,7 @@ async function startWorker(options) {
       ...result.publishedHead ? { publishedHead: result.publishedHead } : {},
       rebaseCount: result.rebaseCount,
       diffSizeBytes: result.diffSizeBytes,
-      gitStatus: workspaceGitStatus(),
+      gitStatus: await workspaceGitStatus(),
       affectedProjects: affectedProjects(result.affectedPaths),
       affectedPaths: result.affectedPaths,
       activeMountIds: result.activeMountIds,
@@ -4143,23 +4174,26 @@ async function startWorker(options) {
       ...result.error ? { error: result.error } : {}
     };
   };
-  const failedWorkspaceSyncResult = (attemptId, trigger, error) => ({
-    type: "workspace_sync",
-    attemptId,
-    workerLabel: label,
-    trigger,
-    outcome: "failed",
-    startingHead: workspaceLocalHead(),
-    ...workspaceLocalHead() ? { localHead: workspaceLocalHead() } : {},
-    rebaseCount: 0,
-    diffSizeBytes: 0,
-    gitStatus: workspaceGitStatus(),
-    affectedProjects: [],
-    affectedPaths: [],
-    discardedPaths: [],
-    localChangesDiscarded: false,
-    error: error instanceof Error ? error.message : String(error)
-  });
+  const failedWorkspaceSyncResult = async (attemptId, trigger, error) => {
+    const localHead = await workspaceLocalHead();
+    return {
+      type: "workspace_sync",
+      attemptId,
+      workerLabel: label,
+      trigger,
+      outcome: "failed",
+      startingHead: localHead,
+      ...localHead ? { localHead } : {},
+      rebaseCount: 0,
+      diffSizeBytes: 0,
+      gitStatus: await workspaceGitStatus(),
+      affectedProjects: [],
+      affectedPaths: [],
+      discardedPaths: [],
+      localChangesDiscarded: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  };
   const performWorkspaceSync = async (input) => {
     if (!workspaceRemoteUrl || !workspaceCredentialHelper || !workspaceCredentialUsername || !workspaceGitIdentity) {
       throw new Error("Worker workspace configuration has not been received");
@@ -4172,11 +4206,11 @@ async function startWorker(options) {
       if (resetHasBusyLiveMount) {
         throw new Error("Workspace reset cannot observe project mirror heads while a live mount is busy; remediation remains active");
       }
-      const observedProjectHeads2 = observeProjectHeadsBeforeOuterWorkspace({
+      const observedProjectHeads2 = await observeProjectHeadsBeforeOuterWorkspace({
         allowNonFastForward: true,
         failClosed: true
       });
-      const reset = (0, import_workspace_git_sync.resetWorkspaceGit)({
+      const reset = await (0, import_workspace_git_sync.resetWorkspaceGit)({
         workspacePath: workspaceShadowRoot,
         remoteUrl: workspaceRemoteUrl,
         credentialHelper: workspaceCredentialHelper,
@@ -4184,7 +4218,7 @@ async function startWorker(options) {
         gitIdentity: workspaceGitIdentity,
         mounts: configuredMounts
       });
-      applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads2, reset.activeMountIds, true);
+      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads2, reset.activeMountIds, true);
       return {
         type: "workspace_sync",
         attemptId: input.attemptId,
@@ -4196,7 +4230,7 @@ async function startWorker(options) {
         ...reset.remoteHead ? { publishedHead: reset.remoteHead } : {},
         rebaseCount: 0,
         diffSizeBytes: 0,
-        gitStatus: workspaceGitStatus(),
+        gitStatus: await workspaceGitStatus(),
         affectedProjects: affectedProjects(reset.discardedPaths),
         affectedPaths: reset.discardedPaths,
         activeMountIds: reset.activeMountIds,
@@ -4207,13 +4241,13 @@ async function startWorker(options) {
     }
     const outerRemediation = input.trigger.type === "remediation" || input.trigger.type === "remediation_confirm";
     const mounts = outerRemediation ? (0, import_workspace_git_sync.workspaceGitMountsForRemediation)(configuredMounts) : configuredMounts;
-    const observedProjectHeads = outerRemediation ? [] : observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
+    const observedProjectHeads = outerRemediation ? [] : await observeProjectHeadsBeforeOuterWorkspace({ allowNonFastForward: false, failClosed: false });
     const inboundMoveMountIds = new Set(
       observedProjectHeads.flatMap(
         ({ projectId, observations }) => observations.filter(({ shouldMove }) => shouldMove).map(({ branchName }) => projectMountId(projectId, branchName))
       )
     );
-    const publicationHeads = outerRemediation ? /* @__PURE__ */ new Map() : captureProjectHeadsForWorkspacePublication();
+    const publicationHeads = outerRemediation ? /* @__PURE__ */ new Map() : await captureProjectHeadsForWorkspacePublication();
     const result = await (0, import_workspace_git_sync.synchronizeWorkspaceGit)({
       attemptId: input.attemptId,
       workerLabel: label,
@@ -4228,13 +4262,13 @@ async function startWorker(options) {
       skipMountMirror: outerRemediation,
       requiredAncestorHeads: input.requiredAncestorHeads,
       assertStillAdmitted: input.assertStillAdmitted,
-      afterWorkspacePublished: outerRemediation ? void 0 : ({ activeMountIds, publishedHead }) => {
-        pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
+      afterWorkspacePublished: outerRemediation ? void 0 : async ({ activeMountIds, publishedHead }) => {
+        await pushChangedProjectHeads(activeMountIds, publishedHead, publicationHeads, inboundMoveMountIds);
       }
     });
     input.assertStillAdmitted?.();
     if (["no_change", "updated", "pushed"].includes(result.outcome) && !outerRemediation) {
-      applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
+      await applyObservedProjectHeadsAfterInboundWorkspace(observedProjectHeads, result.activeMountIds, false);
     }
     return mapWorkspaceGitResult(input.attemptId, input.trigger, result);
   };
@@ -4265,7 +4299,7 @@ async function startWorker(options) {
     };
     if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
       const result2 = {
-        ...failedWorkspaceSyncResult(
+        ...await failedWorkspaceSyncResult(
           attemptId,
           input.trigger,
           new Error(
@@ -4292,7 +4326,7 @@ async function startWorker(options) {
         queueEnteredAt = Date.now();
         syncStartedAt = Date.now();
         if (!deferredWorkspaceSyncTriggerIsAllowed(deferredWorkspaceConfiguration, activeWorkspaceIncidentId, input.trigger)) {
-          return failedWorkspaceSyncResult(
+          return await failedWorkspaceSyncResult(
             attemptId,
             input.trigger,
             new Error(
@@ -4331,7 +4365,7 @@ async function startWorker(options) {
             },
             exitCode: 1
           });
-          return failedWorkspaceSyncResult(attemptId, input.trigger, error);
+          return await failedWorkspaceSyncResult(attemptId, input.trigger, error);
         }
       });
     } finally {
@@ -4430,7 +4464,7 @@ async function startWorker(options) {
     if (incidentDeferral.error) {
       workspaceConfigured = false;
       return {
-        result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, incidentDeferral.error),
+        result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, incidentDeferral.error),
         pending: incidentDeferredProjectCheckouts(message.projects),
         aheadOfOriginBranches: []
       };
@@ -4458,7 +4492,7 @@ async function startWorker(options) {
       canonicalRemediationActive: canonicalWorkspaceMutationIsActive(activeWorkspaceMutationTargets())
     })) {
       return {
-        result: failedWorkspaceSyncResult(
+        result: await failedWorkspaceSyncResult(
           crypto.randomUUID(),
           { type: "connect" },
           new Error("Workspace credential rotation is deferred until the active canonical remediation command finishes")
@@ -4517,7 +4551,7 @@ async function startWorker(options) {
       } catch (error) {
         const wrapped = error instanceof import_registry_auth.RegistryAuthConfigurationError ? error : new import_registry_auth.RegistryAuthConfigurationError(error);
         return {
-          result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, wrapped),
+          result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, wrapped),
           pending: [],
           aheadOfOriginBranches: []
         };
@@ -4694,7 +4728,7 @@ async function startWorker(options) {
         }));
         const nextProjectConfigById = new Map(effectiveProjects.map((project) => [project.projectId, project]));
         if (incidentDeferral.incidentId) {
-          (0, import_workspace_git_sync.configureExistingWorkspaceGitForRemediation)({
+          await (0, import_workspace_git_sync.configureExistingWorkspaceGitForRemediation)({
             workspacePath: workspaceShadowRoot,
             remoteUrl: message.workspaceRemoteUrl,
             credentialHelper: nextWorkspaceCredentialHelper,
@@ -4713,7 +4747,7 @@ async function startWorker(options) {
             result: deferredIncidentWorkspaceConfigurationResult({
               attemptId: crypto.randomUUID(),
               workerLabel: label,
-              head: workspaceLocalHead(),
+              head: await workspaceLocalHead(),
               skippedMountIds: buildWorkspaceMounts().map(({ id }) => id)
             }),
             pending: pending2,
@@ -4721,7 +4755,7 @@ async function startWorker(options) {
             deferredWorkspaceSyncForIncidentId: incidentDeferral.incidentId
           };
         }
-        (0, import_workspace_git_sync.ensureWorkspaceGitClone)({
+        await (0, import_workspace_git_sync.ensureWorkspaceGitClone)({
           workspacePath: workspaceShadowRoot,
           remoteUrl: message.workspaceRemoteUrl,
           credentialHelper: nextWorkspaceCredentialHelper,
@@ -4741,7 +4775,7 @@ async function startWorker(options) {
           sourcePath: recoverySourceOverrides.get(mount.id) ?? mount.sourcePath,
           busy: mount.busyForRecovery ?? mount.busy
         }));
-        (0, import_workspace_git_sync.recoverWorkspaceGitHydration)(workspaceShadowRoot, recoveryMounts, { preserveStaleBases: true });
+        await (0, import_workspace_git_sync.recoverWorkspaceGitHydration)(workspaceShadowRoot, recoveryMounts, { preserveStaleBases: true });
         for (const project of message.projects) {
           for (const { branchName } of project.preserveOnlyBranches) {
             if (stillPendingCreatedBranches.has((0, import_workspace_automatic_sync_policy.pendingCreatedBranchKey)(project.projectId, branchName))) {
@@ -4778,7 +4812,7 @@ async function startWorker(options) {
         }
         stageDurableWorkspaceDeletions();
         const mountsBeforeGit = buildWorkspaceMounts();
-        (0, import_workspace_git_sync.hydrateWorkspaceGitMounts)(
+        await (0, import_workspace_git_sync.hydrateWorkspaceGitMounts)(
           workspaceShadowRoot,
           mountsBeforeGit.filter((mount) => !mount.deleteWhenSourceMissing && !import_node_fs.default.existsSync(mount.sourcePath) && mount.busy?.() !== true),
           // These mounts are intentionally hydrated before their project Git
@@ -4787,7 +4821,7 @@ async function startWorker(options) {
           // checkout initialization from erasing synchronized dirt.
           { ignoreBusy: true }
         );
-        ensureConfiguredProjects();
+        await ensureConfiguredProjects();
         const configurationSyncAdmissionGeneration = workerAdmissionGeneration;
         const assertConfigurationSyncStillAdmitted = () => {
           if (receiptGeneration !== workspaceConfigurationReceiptGeneration || configurationSyncAdmissionGeneration !== workerAdmissionGeneration || !workspaceConfigurationIncidentSnapshotIsCurrent(incidentDeferral.incidentId, activeWorkspaceIncidentId) || currentWorkerSocket !== ws || ws.readyState !== WebSocket.OPEN) {
@@ -4832,12 +4866,12 @@ async function startWorker(options) {
         const pending = [...pendingCheckouts.values()].sort(
           (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
         );
-        return { result, pending, aheadOfOriginBranches: collectAheadOfOriginBranches() };
+        return { result, pending, aheadOfOriginBranches: await collectAheadOfOriginBranches() };
       });
     } catch (error) {
       if (receiptGeneration !== workspaceConfigurationReceiptGeneration) {
         return {
-          result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
+          result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
           pending: incidentDeferredProjectCheckouts(message.projects),
           aheadOfOriginBranches: []
         };
@@ -4869,7 +4903,7 @@ async function startWorker(options) {
         pendingCheckouts.set(projectBranchKey(pending.projectId, pending.branchName), pending);
       }
       return {
-        result: failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
+        result: await failedWorkspaceSyncResult(crypto.randomUUID(), { type: "connect" }, error),
         pending: [...pendingCheckouts.values()].sort(
           (left, right) => left.projectId.localeCompare(right.projectId) || left.branchName.localeCompare(right.branchName)
         ),

package/dist/cjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.86",
+  "version": "0.0.87",
   "type": "commonjs"
 }