@teambit/ci 1.0.383 → 1.0.385

package/dist/ci.main.runtime.js

@@ -74,6 +74,27 @@ function _checkout() {
   };
   return data;
 }
+function _component() {
+  const data = require("@teambit/component.snap-distance");
+  _component = function () {
+    return data;
+  };
+  return data;
+}
+function _configMerger() {
+  const data = require("@teambit/config-merger");
+  _configMerger = function () {
+    return data;
+  };
+  return data;
+}
+function _dependencyResolver() {
+  const data = require("@teambit/dependency-resolver");
+  _dependencyResolver = function () {
+    return data;
+  };
+  return data;
+}
 function _execa() {
   const data = _interopRequireDefault(require("execa"));
   _execa = function () {
@@ -144,6 +165,13 @@ function _lodash() {
   };
   return data;
 }
+function _objects() {
+  const data = require("@teambit/objects");
+  _objects = function () {
+    return data;
+  };
+  return data;
+}
 function _sourceBranchDetector() {
   const data = require("./source-branch-detector");
   _sourceBranchDetector = function () {
@@ -164,13 +192,17 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * Sentinel substring emitted by the hub when a lane push is rejected because a lane with the same
- * id already exists with a different hash. Thrown as `BitError` from
- * `components/legacy/scope/repositories/sources.ts` and wrapped in `UnexpectedNetworkError` across
- * the wire, so we match on the message text rather than an error class.
- */
+// Two distinct conflicts can surface from the remote on a concurrent `bit ci pr` race.
+// LANE_HASH_MISMATCH fires when both runners called `Lane.create` (the lane didn't exist on
+// the remote yet), so they each minted a random `sha1(v4())` hash — `sources.mergeLane` then
+// rejects the second push's lane object on hash mismatch.
+// COMPONENT_DIVERGENCE fires when the lane already exists (both runners `switchToLane`'d
+// and got the same lane hash) but they both snapped the SAME component with DIFFERENT
+// content — `mergeLane`'s per-component diverge check collects a `ComponentNeedsUpdate`
+// and throws `MergeConflictOnRemote("merge error occurred when exporting the component(s)…")`.
+// Both recover through the same adopt-and-rebase path in `rebaseOntoRemoteLane`.
 const LANE_HASH_MISMATCH_MARKER = 'a lane with the same id already exists with a different hash';
+const COMPONENT_DIVERGENCE_MARKER = 'merge error occurred when exporting';
 class CiMain {
   constructor(workspace, builder, status, lanes, snapping, exporter, importer, checkout, logger, config) {
     this.workspace = workspace;
@@ -346,6 +378,13 @@ class CiMain {
       status
     };
   }
+
+  /**
+   * Returns the caught Error on failure, or undefined on success (including the "already checked
+   * out" no-op case). Callers that need to react to a specific failure mode (e.g. stale lane) can
+   * inspect the returned error; existing callers ignore it and rely on a follow-up
+   * `getCurrentLane()` check.
+   */
   async switchToLane(laneName, options = {}) {
     this.logger.console(_chalk().default.blue(`Switching to ${laneName}`));
     try {
@@ -355,11 +394,158 @@ class CiMain {
         skipDependencyInstallation: true
       }, options));
     } catch (e) {
-      if (e.toString().includes('already checked out')) {
+      if (e?.toString().includes('already checked out')) {
         this.logger.console(_chalk().default.yellow(`Lane ${laneName} already checked out, skipping checkout`));
-        return true;
+        return undefined;
       }
-      this.logger.console(_chalk().default.red(`Failed switching to ${laneName}: ${e.toString()}`));
+      this.logger.console(_chalk().default.red(`Failed switching to ${laneName}: ${e?.toString() ?? e}`));
+      return e;
+    }
+    return undefined;
+  }
+
+  /**
+   * Sync *config-only* changes from main onto the lane — without a full `bit lane merge`.
+   *
+   * In this workflow git is the source of truth for files: the PR author merges the default branch
+   * into their PR branch, so source changes arrive via git. The one thing git can't carry is
+   * config that's already been *tagged into objects* on main — e.g. another PR ran `bit env set` /
+   * `bit deps set`; those records lived in `.bitmap`, rode git into main, and `bit ci merge` baked
+   * them into the component's Version (clearing them from `.bitmap`). A long-running PR's lane
+   * would otherwise miss them.
+   *
+   * A full lane merge is the wrong tool here: it does a 3-way *file* merge and refuses to run while
+   * the workspace has modified components — but in `bit ci pr` the workspace is always dirty (the
+   * PR's changes, not yet snapped). So instead we do a per-component 3-way merge of the aspect
+   * *config only* (base = common ancestor, ours = lane, theirs = main), keeping the PR's config on
+   * conflict, and stash the result on an `unmergedComponents` entry's `mergedConfig`. The
+   * subsequent `snap` reads it (via the aspects-merger on component load) and bakes main's config
+   * into the new snap, while the snap's files still come from the workspace (git). No file
+   * checkout, so no clean-workspace requirement.
+   */
+  async syncConfigFromMain(laneId) {
+    const legacyScope = this.workspace.scope.legacyScope;
+    const repo = legacyScope.objects;
+    const mainLaneId = this.lanes.getDefaultLaneId();
+    const currentLane = await this.lanes.getCurrentLane();
+    if (!currentLane) return;
+    const workspaceIds = this.workspace.listIds();
+    this.logger.console(_chalk().default.blue(`Syncing config changes from ${mainLaneId.toString()} into ${laneId.toString()}`));
+    const syncedIds = [];
+    for (const laneComp of currentLane.components) {
+      try {
+        const modelComponent = await legacyScope.getModelComponent(laneComp.id);
+        const mainHead = modelComponent.head; // the component's head on main
+        if (!mainHead) continue; // component isn't on main — nothing to sync from there
+        const laneHead = laneComp.head;
+        if (mainHead.isEqual(laneHead)) continue; // lane already points at main's head
+
+        const divergeData = await (0, _component().getDivergeData)({
+          repo,
+          modelComponent,
+          sourceHead: laneHead,
+          targetHead: mainHead,
+          throws: false
+        });
+        // Only sync when main has snaps the lane doesn't (target ahead, or diverged). If the lane
+        // is ahead-only / equal there's nothing on main to bring in.
+        if (!divergeData.isTargetAhead() && !divergeData.isDiverged()) continue;
+        const currentVersion = await modelComponent.loadVersion(laneHead.toString(), repo);
+        const otherVersion = await modelComponent.loadVersion(mainHead.toString(), repo);
+        // base = common ancestor. When the lane is strictly behind main (no divergence) the common
+        // ancestor IS the lane head, so the lane's own aspects serve as the base.
+        const baseSnap = divergeData.commonSnapBeforeDiverge;
+        const baseVersion = baseSnap ? await modelComponent.loadVersion(baseSnap.toString(), repo) : currentVersion;
+        const configMerger = new (_configMerger().ComponentConfigMerger)(laneComp.id.toStringWithoutVersion(), workspaceIds, undefined,
+        // merging from main (the default lane) — there's no Lane object for it
+        currentVersion.extensions, baseVersion.extensions, otherVersion.extensions, laneId.toString(), mainLaneId.toString(), this.logger, 'ours' // keep the PR's config on a genuine conflict
+        );
+        const mergedConfig = configMerger.merge().getSuccessfullyMergedConfig();
+        if (!mergedConfig || !Object.keys(mergedConfig).length) continue;
+
+        // Strip dependency deletion markers (version: '-'); the aspects-merger applies mergedConfig
+        // as-is, so a leftover '-' would land in the policy.
+        this.filterDeletedDependenciesFromConfig(mergedConfig);
+
+        // Upsert: addEntry throws if an entry for this component already exists. A prior
+        // --keep-lane run that crashed mid-snap (or otherwise left unmerged.json entries behind)
+        // would otherwise make every later run throw here, skip the component, and keep serving
+        // stale config. Remove any existing entry first so repeated runs converge on main's latest.
+        legacyScope.objects.unmergedComponents.removeComponent(laneComp.id);
+        legacyScope.objects.unmergedComponents.addEntry({
+          id: {
+            scope: laneComp.id.scope,
+            name: laneComp.id.fullName
+          },
+          head: mainHead,
+          laneId: mainLaneId,
+          mergedConfig
+        });
+        syncedIds.push(laneComp.id);
+        this.logger.console(_chalk().default.blue(`  ${laneComp.id.toStringWithoutVersion()}: applying main's config (${Object.keys(mergedConfig).join(', ')})`));
+      } catch (e) {
+        // Best-effort per component: one component's config-merge quirk shouldn't abort the whole
+        // `bit ci pr`. Log and move on — the build just won't reflect that component's main-side
+        // config this run.
+        this.logger.console(_chalk().default.yellow(`  ${laneComp.id.toStringWithoutVersion()}: skipping config sync from main (${e?.message || e})`));
+      }
+    }
+    if (!syncedIds.length) {
+      this.logger.console(_chalk().default.blue('No config changes from main to sync'));
+      return;
+    }
+    await legacyScope.objects.unmergedComponents.write();
+    // The components were already loaded (and their aspects cached) earlier in this run, before the
+    // unmergedComponents entries existed. Clear the cache so the upcoming `snap` reloads them and
+    // the aspects-merger folds in the synced `mergedConfig`.
+    this.workspace.clearAllComponentsCache();
+    this.logger.console(_chalk().default.green(`Synced config from main for ${syncedIds.length} component(s)`));
+  }
+
+  /**
+   * Copied from `merging.main.runtime` (`filterDeletedDependenciesFromConfig`): the config merge
+   * can emit deletion markers (`version: '-'`) for deps removed on main. The aspects-merger applies
+   * `mergedConfig` verbatim, so strip those here to avoid writing a policy entry with version '-'.
+   */
+  filterDeletedDependenciesFromConfig(mergeConfig) {
+    const policy = mergeConfig?.[_dependencyResolver().DependencyResolverAspect.id]?.policy;
+    if (!policy) return;
+    Object.keys(policy).forEach(depType => {
+      const filtered = policy[depType].filter(dep => dep.version !== '-');
+      if (filtered.length === 0) delete policy[depType];else policy[depType] = filtered;
+    });
+  }
+
+  /**
+   * Best-effort, fetch-free check for whether the current (PR) branch is *behind* the default
+   * branch — i.e. the default branch has commits the PR branch doesn't contain.
+   *
+   * We intentionally do NOT `git fetch` here (a fetch in CI can hang on an interactive SSH
+   * host-key prompt — that's why `isStaleCiRun` was removed in #10300). We compare against
+   * whatever `origin/<default>` ref the checkout already has, which reflects the state the default
+   * branch was in when this CI run started — exactly the reference point we care about.
+   *
+   * Returns true only when we can *confirm* the branch is behind. If the ref can't be resolved or
+   * anything else goes wrong, returns false (treat as "not behind" / proceed) so we never silently
+   * disable the main→lane config propagation.
+   */
+  async isBranchBehindDefaultBranch() {
+    try {
+      const defaultBranch = await this.getDefaultBranchName();
+      const defaultRefSha = (await _git().git.revparse([`refs/remotes/origin/${defaultBranch}`])).trim();
+      const headSha = (await _git().git.revparse(['HEAD'])).trim();
+      if (defaultRefSha === headSha) return false; // identical → up to date
+      // We deliberately do NOT use `merge-base --is-ancestor`: it reports the answer via exit code
+      // (0 = ancestor, 1 = not), but simple-git's `raw` resolves rather than rejects on exit code
+      // 1, so the "not an ancestor" case was silently read as "is an ancestor" — the behind check
+      // never fired. Instead compute the merge-base and compare: `merge-base(A, B) === A` iff A is
+      // an ancestor of B. When origin/<default> is an ancestor of HEAD the PR already contains it
+      // (not behind); otherwise the default branch has commits HEAD doesn't (behind).
+      const mergeBase = (await _git().git.raw(['merge-base', defaultRefSha, headSha])).trim();
+      return mergeBase !== defaultRefSha;
+    } catch (err) {
+      this.logger.console(_chalk().default.yellow(`Could not determine whether the PR branch is up to date with the default branch ` + `(proceeding as if up to date): ${err?.message || err}`));
+      return false;
     }
   }
   async verifyWorkspaceStatus() {
@@ -380,7 +566,8 @@ class CiMain {
     message,
     build,
     strict,
-    dryRun
+    dryRun,
+    keepLane
   }) {
     this.logger.console(_chalk().default.blue(`Lane name: ${laneIdStr}`));
     const originalLane = await this.lanes.getCurrentLane();
@@ -395,6 +582,231 @@ class CiMain {
     });
     this.logger.console('🔄 Lane Management');
 
+    // `--keep-lane` opts into reusing the same remote lane across subsequent commits to a PR, so
+    // the lane's history and any lane-based UI edits on Bit Cloud survive. Without it we use the
+    // default, battle-tested flow: snap onto a throwaway temp lane and delete+recreate the final
+    // lane at export time (the lane is recreated on every PR commit).
+    if (keepLane) {
+      return this.snapAndExportReusingLane({
+        laneId,
+        originalLane,
+        message,
+        build,
+        dryRun
+      });
+    }
+    return this.snapAndExportWithTempLane({
+      laneId,
+      originalLane,
+      message,
+      build,
+      dryRun
+    });
+  }
+
+  /**
+   * `--keep-lane` flow: reuse the existing remote lane (or create it on the first run), merge main
+   * into it to pick up config changes that landed since the fork, snap, and export with
+   * adopt-on-conflict recovery for concurrent CI pushes. The lane object is preserved across PR
+   * commits, so its history and lane-based UI edits on Bit Cloud survive.
+   */
+  async snapAndExportReusingLane({
+    laneId,
+    originalLane,
+    message,
+    build,
+    dryRun
+  }) {
+    // Query the remote (by name, to avoid fetching all lanes) so we know whether to reuse or create
+    const existingLanes = await this.lanes.getLanes({
+      remote: laneId.scope,
+      name: laneId.name
+    }).catch(e => {
+      if (e.toString().includes('was not found')) return [];
+      throw new Error(`Failed to check lane ${laneId.toString()}: ${e.toString()}`);
+    });
+    const laneExists = existingLanes.length > 0;
+    let foundErr;
+    try {
+      if (laneExists) {
+        // Reuse the existing remote lane so that the lane history, lane-based UI edits, and
+        // lane-history feature on Bit Cloud all survive across subsequent commits to the same PR.
+        // switchToLane fetches the latest lane head from remote.
+        this.logger.console(_chalk().default.blue(`Lane ${laneId.toString()} exists on remote, reusing it`));
+        const switchErr = await this.switchToLane(laneId.toString());
+        // switchToLane returns the caught error (undefined on success). Combine with a
+        // current-lane-state probe — comparing BOTH name AND scope, so a same-named lane in a
+        // different scope can't masquerade as a successful switch.
+        const switchedLane = await this.lanes.getCurrentLane();
+        const landedOnLane = switchedLane?.name === laneId.name && switchedLane?.scope === laneId.scope;
+        if (landedOnLane) {
+          // Sync config-only changes from main onto the lane, so config that was tagged into
+          // objects on main since the lane forked (e.g. `bit deps set` / `bit env set` from
+          // another PR, not visible via the workspace's git checkout) is reflected on the lane.
+          // Source files are git's job — see syncConfigFromMain.
+          //
+          // BUT only when the PR branch is actually up to date with the default branch. If the PR
+          // is behind (hasn't pulled main's latest), its git checkout still reflects the older
+          // fork point, so pulling main's newer config onto the lane would desync the lane from
+          // the source. The author merges the default branch into their PR in git; the next
+          // `bit ci pr` then propagates it here.
+          if (await this.isBranchBehindDefaultBranch()) {
+            this.logger.console(_chalk().default.yellow(`PR branch is behind the default branch — skipping config sync from main. ` + `Merge or rebase the default branch into your PR to pick up main's latest config.`));
+          } else {
+            await this.syncConfigFromMain(laneId);
+          }
+        } else {
+          // Switch failed even though the remote lane exists. The destructive recovery below
+          // (delete the remote lane + recreate fresh) is safe only when the failure is the
+          // specific "stale lane" pattern — the lane references a ModelComponent the PR has
+          // since removed/renamed (`unable to merge lane …, the component … was not found`).
+          // For any other failure (transient network blip during fetch, auth error, lane locked
+          // by Cloud UI, etc.) destroying lane history would be the wrong response, so we
+          // rethrow and let the caller report the real cause.
+          const errMsg = switchErr?.toString() ?? '';
+          const isStaleLane = errMsg.includes('unable to merge lane');
+          if (!isStaleLane) {
+            throw new Error(`Failed to switch to remote lane ${laneId.toString()}: ${errMsg || '(no error captured)'}. ` + `Refusing destructive recovery for this failure class — the error doesn't match the ` + `stale-lane marker, so deleting the lane could destroy real history. Investigate or retry.`);
+          }
+          this.logger.console(_chalk().default.yellow(`Stale remote lane ${laneId.toString()} — switching failed. ` + `Deleting it and creating a fresh lane to recover.`));
+          // Re-check the remote lane's hash immediately before deleting. The central-hub delete
+          // API is name-based — there's no compare-and-swap — so two CI jobs racing the same
+          // recovery could otherwise have job B delete job A's freshly-recreated lane. By
+          // re-fetching here we shrink the TOCTOU window to milliseconds: if A's recreate landed
+          // before our re-fetch, the hash changed and we skip the delete entirely. The downstream
+          // export then hits the lane-hash mismatch and lands in `exportWithAdoptOnConflict`,
+          // which rebases our snaps onto the winner's lane — no destroyed history.
+          const staleHash = existingLanes[0]?.hash;
+          const recheck = await this.lanes.getLanes({
+            remote: laneId.scope,
+            name: laneId.name
+          }).catch(() => []);
+          const currentRemoteHash = recheck[0]?.hash;
+          const remoteChanged = staleHash && currentRemoteHash && currentRemoteHash !== staleHash;
+          if (remoteChanged) {
+            this.logger.console(_chalk().default.blue(`Remote lane ${laneId.toString()} changed since we first checked (hash ` + `${staleHash.slice(0, 9)} → ${currentRemoteHash.slice(0, 9)}) — another concurrent ` + `recovery already recreated it. Skipping the delete; export will adopt-on-conflict.`));
+          } else {
+            await this.lanes.removeLanes([laneId.toString()], {
+              remote: true,
+              force: true
+            }).catch(e => {
+              const msg = e?.toString() ?? '';
+              // Tolerate the race where another concurrent recovery deleted the lane first — the
+              // desired post-condition (lane gone from remote) is already met.
+              if (msg.includes('was not found') || msg.includes('not found')) {
+                this.logger.console(_chalk().default.blue(`Remote lane ${laneId.toString()} was already gone — proceeding`));
+                return;
+              }
+              throw new Error(`Failed to delete stale remote lane ${laneId.toString()}: ${msg || e}`);
+            });
+          }
+          // switchToLane fetched the remote lane and persisted it into the local scope's lane
+          // index (via `importLaneObject` → `legacyScope.lanes.saveLane`) BEFORE the underlying
+          // merge failed. Without dropping that local copy here, the upcoming `createLane` would
+          // hit the "lane … already exists" guard in create-lane.ts. Same trash-the-local-object
+          // pattern as `rebaseOntoRemoteLane`.
+          const legacyScope = this.workspace.scope.legacyScope;
+          const localLane = await legacyScope.loadLane(laneId);
+          if (localLane) {
+            await legacyScope.objects.moveObjectsToTrash([localLane.hash()]);
+          }
+          // Reset the workspace's current-lane pointer to main before createLane, so the new lane
+          // is forked from main with an empty component list. `createLane` populates new lanes
+          // from `consumer.getCurrentLaneObject()` regardless of `forkLaneNewScope` (which only
+          // suppresses the cross-scope guard) — if `originalLane` is non-default (a developer
+          // running `bit ci pr` from a lane), without this reset the "fresh" lane would silently
+          // inherit `originalLane`'s components. Check the return value: a silent failure here
+          // would defeat the whole point of the reset.
+          const resetErr = await this.switchToLane('main');
+          const afterReset = await this.lanes.getCurrentLane();
+          if (resetErr || afterReset) {
+            throw new Error(`Failed to reset to main before recreating ${laneId.toString()}: ` + `${resetErr?.toString() ?? `(still on lane "${afterReset?.name}")`}. ` + `Aborting to avoid silently forking the recreated lane from the wrong source.`);
+          }
+          const createLaneResult = await this.lanes.createLane(laneId.name, {
+            scope: laneId.scope,
+            forkLaneNewScope: true
+          });
+          this.logger.console(_chalk().default.blue(`Recreated lane ${laneId.toString()} (hash: ${createLaneResult.hash})`));
+        }
+      } else {
+        this.logger.console(_chalk().default.blue(`Creating lane ${laneId.toString()}`));
+        const createLaneResult = await this.lanes.createLane(laneId.name, {
+          scope: laneId.scope,
+          forkLaneNewScope: true
+        });
+        this.logger.console(_chalk().default.blue(`Created lane ${laneId.toString()} (hash: ${createLaneResult.hash})`));
+      }
+      const currentLane = await this.lanes.getCurrentLane();
+      this.logger.console(_chalk().default.blue(`Current lane: ${currentLane?.name ?? 'main'}`));
+      if (currentLane?.name !== laneId.name) {
+        throw new Error(`Expected to be on lane ${laneId.name}, but current lane is ${currentLane?.name ?? 'main'}`);
+      }
+      this.logger.console('📦 Snapping Components');
+      const results = await this.snapping.snap({
+        message,
+        build,
+        exitOnFirstFailedTask: true
+      });
+      if (!results) {
+        this.logger.console(_chalk().default.yellow('No changes detected, nothing to snap'));
+        return 'No changes detected, nothing to snap';
+      }
+      const {
+        snappedComponents
+      } = results;
+      const snapOutput = (0, _snapping().snapResultOutput)(results);
+      this.logger.console(snapOutput);
+      if (dryRun) {
+        this.logger.console(_chalk().default.yellow('🏃 Dry-run mode: skipping export'));
+        this.logger.console(_chalk().default.green(`Snapped ${snappedComponents.length} component(s) successfully`));
+        return snapOutput;
+      }
+      this.logger.console(_chalk().default.blue(`Exporting ${snappedComponents.length} components`));
+      await this.exportWithAdoptOnConflict(laneId, snappedComponents);
+    } catch (e) {
+      foundErr = e;
+      throw e;
+    } finally {
+      if (foundErr) {
+        this.logger.console(_chalk().default.red(`Found error: ${foundErr.message}`));
+      }
+      // Best-effort cleanup: switch back to the original lane/main. Wrap it so a cleanup
+      // failure (failed switch/checkout) only warns instead of throwing out of `finally` and
+      // masking the real error from snap/export above (also avoids no-unsafe-finally).
+      try {
+        this.logger.console('🔄 Cleanup');
+        const targetLane = originalLane?.name ?? 'main';
+        this.logger.console(_chalk().default.blue(`Switching back to ${targetLane}`));
+        const currentLane = await this.lanes.getCurrentLane();
+        if (currentLane) {
+          await this.switchToLane(targetLane);
+        } else {
+          this.logger.console(_chalk().default.yellow('Already on main, checking out to head'));
+          await this.lanes.checkout.checkout({
+            head: true,
+            skipNpmInstall: true
+          });
+        }
+      } catch (cleanupErr) {
+        this.logger.consoleWarning(`Cleanup after PR snap failed: ${cleanupErr.message}`);
+      }
+    }
+  }
+
+  /**
+   * Default flow: snap onto a uniquely-named temporary lane, then at export time delete any
+   * existing remote lane and rename the temp lane to the final name. The temp name minimizes the
+   * race window when multiple CI jobs run concurrently on the same branch. Trade-off: the final
+   * lane is recreated on every PR commit, so its history and any lane-based UI edits on Bit Cloud
+   * don't survive across commits — use `--keep-lane` for that.
+   */
+  async snapAndExportWithTempLane({
+    laneId,
+    originalLane,
+    message,
+    build,
+    dryRun
+  }) {
     // Use unique temp lane name to avoid race conditions when multiple CI jobs run concurrently
     const tempLaneName = `${laneId.name}-${(0, _toolboxString().generateRandomStr)(5)}`;
     let foundErr;
@@ -525,6 +937,178 @@ class CiMain {
       }
     }
   }
+
+  /**
+   * Export with a recovery path for the two concurrent-CI conflicts that can surface from the
+   * remote (see the marker constants at the top of the file): lane-hash mismatch (both runners
+   * created fresh lane objects when the lane didn't yet exist on the remote) and per-component
+   * divergence (both reused the existing lane but snapped the same component with different
+   * content).
+   *
+   * Recovery: adopt-the-winner. The remote lane (whoever pushed first) becomes canonical. We
+   * drop our local lane object, fetch the remote, rebase our snapped Version objects so each
+   * one's parent points to the remote head for that component, then swap those rebased Versions
+   * in as the new lane heads and re-export. Build artifacts are preserved — only the parent
+   * pointers on the Version objects change. Result: both runners' snaps end up chained on a
+   * single lane object (last-writer-wins on content for any contested component, with the
+   * winner's snap preserved in history as the parent).
+   */
+  async exportWithAdoptOnConflict(laneId, snappedComponents) {
+    try {
+      const exportResults = await this.exporter.export();
+      this.logger.console(_chalk().default.green(`Exported ${exportResults.componentsIds.length} components`));
+      return;
+    } catch (e) {
+      const msg = e?.message || e?.toString() || '';
+      const isLaneHashMismatch = msg.includes(LANE_HASH_MISMATCH_MARKER);
+      const isComponentDivergence = msg.includes(COMPONENT_DIVERGENCE_MARKER);
+      if (!isLaneHashMismatch && !isComponentDivergence) throw e;
+      const cause = isLaneHashMismatch ? 'Lane hash mismatch' : 'Per-component divergence';
+      this.logger.console(_chalk().default.yellow(`${cause} on "${laneId.toString()}" — likely a concurrent CI push. Adopting the remote lane and rebasing local snaps onto its heads.`));
+    }
+    const snappedHeads = snappedComponents.map(c => {
+      // A just-snapped component always has a version; guard defensively so a missing one fails
+      // with a clear message instead of `Ref.from(undefined)`'s opaque "hash argument is empty".
+      if (!c.version) {
+        throw new Error(`unable to recover from the lane-hash mismatch: snapped component "${c.id.toString()}" has no version to rebase onto the remote lane`);
+      }
+      return {
+        id: c.id,
+        head: _objects().Ref.from(c.version)
+      };
+    });
+    await this.rebaseOntoRemoteLane(laneId, snappedHeads);
+    this.logger.console(_chalk().default.blue('Retrying export with rebased snaps'));
+    const exportResults = await this.exportWithBusyRetry();
+    this.logger.console(_chalk().default.green(`Exported ${exportResults.componentsIds.length} components after rebase`));
+  }
+
+  /**
+   * Wrap `exporter.export()` with retry on the "server is busy" error. The retried export's
+   * pending-dir lands behind whichever concurrent client is still in the remote's queue (we
+   * arrived second by definition — we're the loser of the original race). The 60s wait inside
+   * `export-validate.waitIfNeeded` covers the common case, but on slow CI hosts or large pushes
+   * we sometimes time out before the other client finishes its persist. A short sleep + retry
+   * here just gives the queue room to drain.
+   */
+  async exportWithBusyRetry(maxAttempts = 3) {
+    const isBusyErr = err => (err?.message || err?.toString() || '').includes('server is busy by other exports');
+    let lastErr;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      try {
+        return await this.exporter.export();
+      } catch (e) {
+        lastErr = e;
+        if (!isBusyErr(e)) throw e;
+        this.logger.console(_chalk().default.yellow(`Export attempt ${attempt}/${maxAttempts} blocked by a busy remote queue. Waiting before retrying.`));
+        await new Promise(resolve => setTimeout(resolve, 2000 * attempt));
+      }
+    }
+    throw lastErr;
+  }
+  async rebaseOntoRemoteLane(laneId, snappedHeads) {
+    const legacyScope = this.workspace.scope.legacyScope;
+    const repo = legacyScope.objects;
+
+    // Our local lane object (the one we just snapped onto) shares the LaneId with the remote
+    // (winning) lane but has a different, randomly-minted hash. Fetching the remote lane writes it
+    // into our scope via `sources.mergeLane`, which rejects a same-id/different-hash lane ("a lane
+    // with the same id already exists with a different hash") — so we must drop our local lane
+    // object BEFORE the fetch, not after. We can't use `lanes.removeLanes` (it refuses to remove
+    // the currently-checked-out lane), so we trash the lane object directly; that also removes it
+    // from the scope index, so `loadLane` (the guard's lookup) no longer finds it. Only the lane
+    // pointer is trashed — the Version objects we snapped stay in the scope for the rebase below,
+    // and the fetch immediately re-persists a same-id lane object, satisfying the current-lane
+    // workspace pointer again.
+    const localLane = await legacyScope.loadLane(laneId);
+    if (localLane) {
+      this.logger.console(_chalk().default.blue(`Dropping local lane object ${laneId.toString()} to adopt the remote one`));
+      await repo.moveObjectsToTrash([localLane.hash()]);
+    }
+
+    // Fetch the remote (winning) lane and the Version objects it points at. With our local lane
+    // object gone, `mergeLane` sees no conflicting same-id lane and persists the remote one.
+    this.logger.console(_chalk().default.blue(`Fetching remote lane ${laneId.toString()}`));
+    const remoteLane = await this.lanes.fetchLaneWithItsComponents(laneId);
+
+    // Rewrite each snapped Version's parent to point at the remote head for that component.
+    // Bit's Version objects aren't content-addressed — `_hash` is set once and not derived
+    // from content — so we can mutate `parents` in place. The hash stays the same, so the
+    // build artifacts referenced from the Version remain valid and the lane's component head
+    // doesn't need to be re-pointed. The remote receives the updated Version because our
+    // first failed export attempt was rejected during the export-validate step (via
+    // `sources.mergeLane`'s same-id/different-hash guard) — *before* `ExportPersist` writes any
+    // files to disk — so the remote doesn't yet have this hash and won't dedupe-skip it during
+    // transfer.
+    for (const snap of snappedHeads) {
+      const remoteComp = remoteLane.components.find(c => c.id.isEqualWithoutVersion(snap.id));
+      if (!remoteComp) continue; // component is only on our lane, not on the remote — no rebase target
+      const remoteHead = remoteComp.head;
+      if (snap.head.isEqual(remoteHead)) continue;
+      const version = await repo.load(snap.head);
+      if (!version) {
+        throw new Error(`rebaseOntoRemoteLane: unable to load Version object for ${snap.id.toString()} hash ${snap.head.toString()}`);
+      }
+      if (version.parents.some(p => p.isEqual(remoteHead))) continue; // already chains correctly
+
+      const beforeParents = version.parents.map(p => p.toString().slice(0, 9)).join(',');
+      // Re-point only the lane-lineage parent (the first parent — the predecessor snap on the
+      // lane) to the remote head, preserving any additional parents. A snap produced after
+      // `syncConfigFromMain` is a merge snap whose second parent links to main's head; overwriting
+      // the whole array with `[remoteHead]` would silently drop that merge edge and corrupt the
+      // lane's ancestry.
+      version.parents = [remoteHead, ...version.parents.slice(1)];
+      const afterParents = version.parents.map(p => p.toString().slice(0, 9)).join(',');
+      this.logger.console(_chalk().default.blue(`Rebasing ${snap.id.toString()}@${snap.head.toString().slice(0, 9)}: parents [${beforeParents}] → [${afterParents}]`));
+      repo.add(version);
+
+      // Keep the local VersionHistory in sync with the rewritten parents. The first (failed)
+      // export already traversed and wrote VersionHistory with this version's *original* parent;
+      // without this update the re-export's diverge computation reads that stale history, never
+      // sees the remote head as an ancestor, and can send the wrong version set or throw a
+      // spurious "no common snap" error. `updateRebasedVersionHistory` only touches the entry if
+      // this version already exists in the history (it does, from that first traversal).
+      const modelComponent = await legacyScope.getModelComponent(snap.id);
+      const versionHistory = await modelComponent.updateRebasedVersionHistory(repo, [version]);
+      if (versionHistory) repo.add(versionHistory);
+    }
+
+    // Replace the remote lane's component heads with our snapped Versions. Anything we
+    // didn't snap stays as the remote had it.
+    //
+    // TODO(stale-runner): if two consecutive PR commits trigger two CI runs and the older one
+    // finishes last, it will rebase its (older-content) snap on top of the newer one — the
+    // newer commit's snap stays in history but the lane head regresses to the older content.
+    // The fix needs git-SHA-aware staleness detection (embed `git rev-parse HEAD` in the snap
+    // log on creation, compare against the remote head's stored SHA on rebase, abort if our
+    // commit is an ancestor of theirs). The prior `isStaleCiRun` (removed in #10300 for
+    // SSH-prompt reasons) attempted this via `git fetch`; we'd want a fetch-free variant here.
+    const updatedComponents = remoteLane.components.map(c => {
+      const snap = snappedHeads.find(s => s.id.isEqualWithoutVersion(c.id));
+      return snap ? _objectSpread(_objectSpread({}, c), {}, {
+        head: snap.head
+      }) : c;
+    });
+    // Pick up any components we snapped that aren't on the remote lane yet (newly added on this PR).
+    for (const snap of snappedHeads) {
+      if (!updatedComponents.some(c => c.id.isEqualWithoutVersion(snap.id))) {
+        updatedComponents.push({
+          id: snap.id,
+          head: snap.head
+        });
+      }
+    }
+    remoteLane.setLaneComponents(updatedComponents);
+    remoteLane.hasChanged = true;
+    await legacyScope.lanes.saveLane(remoteLane, {
+      saveLaneHistory: false
+    });
+    await repo.persist();
+
+    // Make sure the workspace's current-lane pointer points at the lane we just adopted.
+    this.workspace.consumer.setCurrentLane(laneId, true);
+    await this.workspace.bitMap.write();
+  }
   async mergePr({
     message: argMessage,
     build,
@@ -823,9 +1407,10 @@ class CiMain {
   /**
    * Export with retry on lane hash-mismatch, caused by a concurrent `bit ci pr` run pushing the
    * same lane id between our pre-export delete and the hub's merge (the export takes 1-2 minutes,
-   * plenty of time to race). Before each retry we skip if the PR branch has advanced past our
-   * commit - in that case a newer run will publish the correct lane, and retrying with our older
-   * snaps would regress the PR preview.
+   * plenty of time to race). Used by the default (temp-lane) flow. On mismatch we delete the
+   * remote lane and retry — the temp-lane flow recreates the lane on every run anyway, so there's
+   * no lane history to preserve. (The `--keep-lane` flow instead adopts the remote lane and
+   * rebases onto it; see `exportWithAdoptOnConflict`.)
    */
   async exportWithRetryOnLaneHashMismatch(laneIdStr, maxAttempts = 3) {
     const isHashMismatchErr = err => (err?.message || err?.toString() || '').includes(LANE_HASH_MISMATCH_MARKER);