@teambit/ci 1.0.532 → 1.0.534

package/ci.docs.mdx

@@ -168,7 +168,18 @@ flag changes only the dependents, so you can combine it with the detection.
    bit export
    ```
 
-3. **Archive the remote lane.** This step is house-keeping.
+3. **Archive the remote lane.** This step is house-keeping, with one condition. A lane can carry
+   components of several scopes. Every component this run tagged and exported is released (while
+   the lane still sits at the head it was tagged from), so a
+   repository that holds components of several scopes archives as before. Any other component
+   of another scope is released only if its lane head is already
+   on its own main — in main's history, or released onto main's head: the same sources, package
+   and component dependencies and extension config (that is what a `bit ci merge` in that
+   scope's repository leaves behind); a component the lane deletes is released once its main is
+   removed. While such a component is pending, the lane is left open
+   and the command names it; the last scope to release archives the lane. An open lane whose
+   branch was merged stays converged; delete the branch only after the archive.
+   To archive by hand: `bit lane remove --remote <scope>/<lane>`.
 4. **Commit the lock-file updates**
 
    ```bash

package/dist/ci.docs.mdx

@@ -168,7 +168,18 @@ flag changes only the dependents, so you can combine it with the detection.
    bit export
    ```
 
-3. **Archive the remote lane.** This step is house-keeping.
+3. **Archive the remote lane.** This step is house-keeping, with one condition. A lane can carry
+   components of several scopes. Every component this run tagged and exported is released (while
+   the lane still sits at the head it was tagged from), so a
+   repository that holds components of several scopes archives as before. Any other component
+   of another scope is released only if its lane head is already
+   on its own main — in main's history, or released onto main's head: the same sources, package
+   and component dependencies and extension config (that is what a `bit ci merge` in that
+   scope's repository leaves behind); a component the lane deletes is released once its main is
+   removed. While such a component is pending, the lane is left open
+   and the command names it; the last scope to release archives the lane. An open lane whose
+   branch was merged stays converged; delete the branch only after the archive.
+   To archive by hand: `bit lane remove --remote <scope>/<lane>`.
 4. **Commit the lock-file updates**
 
    ```bash

package/dist/ci.main.runtime.d.ts

@@ -339,11 +339,6 @@ export declare class CiMain {
      * the switch from lane to main and get included in the subsequent tag.
      */
     private restoreLaneConfigChanges;
-    /**
-     * Performs lane cleanup by attempting to detect and delete the source lane
-     * after a successful merge, even when running on the main branch
-     */
-    private performLaneCleanup;
     /**
      * 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,

package/dist/ci.main.runtime.js

@@ -186,9 +186,16 @@ function _objects() {
   };
   return data;
 }
-function _sourceBranchDetector() {
-  const data = require("./source-branch-detector");
-  _sourceBranchDetector = function () {
+function _laneCleanup() {
+  const data = require("./lane-cleanup");
+  _laneCleanup = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.scope-api");
+  _legacy = function () {
     return data;
   };
   return data;
@@ -1621,9 +1628,19 @@ class CiMain {
       this.logger.console(_chalk().default.yellow('No components to tag'));
     }
     const hasTaggedComponents = tagResults?.taggedComponents && tagResults.taggedComponents.length > 0;
+    const releasedHeads = new Map();
     if (hasTaggedComponents) {
       this.logger.console(_chalk().default.blue('Exporting components'));
       const exportResult = await this.exporter.export();
+      // released here = tagged by this run AND exported now, remembered with the lane head each was
+      // tagged from (its pre-tag version); an export with no ids also carries components left
+      // export-pending by an earlier run, which this run did not release.
+      const exported = _componentId().ComponentIdList.fromArray(exportResult.componentsIds);
+      [...tagResults.taggedComponents, ...tagResults.autoTaggedResults.map(res => res.component)].forEach(comp => {
+        if (exported.hasWithoutVersion(comp.id)) {
+          releasedHeads.set(comp.id.toStringWithoutVersion(), comp.previouslyUsedVersion);
+        }
+      });
       if (exportResult.componentsIds.length > 0) {
         this.logger.console(_chalk().default.green(`Exported ${exportResult.componentsIds.length} component(s)`));
       } else {
@@ -1644,8 +1661,42 @@ class CiMain {
     }
     this.logger.console(_chalk().default.green('Merged PR'));
 
-    // Enhanced lane cleanup logic
-    await this.performLaneCleanup(currentLane, laneName, initialCommitSha);
+    // Archive the source lane, unless other scopes still have to release their slice of it.
+    await new (_laneCleanup().LaneCleanup)({
+      logger: this.logger,
+      defaultScope: this.workspace.defaultScope,
+      parseLaneId: idStr => this.lanes.parseLaneId(idStr),
+      convertBranchToLaneId: branch => this.convertBranchToLaneId(branch),
+      archiveLane: laneId => this.archiveLane(laneId),
+      readLane: async laneId => {
+        // the lane object itself: `getLanes` drops deleted entries, which are lane work too.
+        // Only bit's own "no such lane" means the lane is gone; any other failure propagates.
+        const lane = await this.lanes.importLaneObject(laneId, false).catch(err => {
+          if (err instanceof _legacy().LaneNotFound) return undefined;
+          throw err;
+        });
+        if (!lane) return undefined;
+        return {
+          components: lane.components.map(c => ({
+            id: c.id,
+            head: c.head.toString(),
+            isDeleted: c.isDeleted
+          })),
+          updateDependents: (lane.updateDependents ?? []).map(id => ({
+            id: id.changeVersion(undefined),
+            head: id.version
+          })),
+          readme: lane.readmeComponent ? `${lane.readmeComponent.id.toStringWithoutVersion()}@${lane.readmeComponent.head?.toString() ?? ''}` : undefined
+        };
+      },
+      // no cache: a model already present locally may predate another scope's release
+      importMainObjects: ids => this.importer.importObjectsFromMainIfExist(ids),
+      getModelComponent: id => this.workspace.scope.legacyScope.getModelComponentIfExist(id),
+      importObjectsByHashes: (scope, hashes) => this.importer.importObjectsByHashes(hashes, scope),
+      releasedHeadByThisRun: id => releasedHeads.get(id.toStringWithoutVersion()),
+      objects: this.workspace.scope.legacyScope.objects,
+      warn: text => this.logger.console((0, _cli().formatWarningSummary)(text))
+    }).run(currentLane, laneName, initialCommitSha);
     return {
       code: 0,
       data: ''
@@ -1747,50 +1798,6 @@ class CiMain {
     }
   }
 
-  /**
-   * Performs lane cleanup by attempting to detect and delete the source lane
-   * after a successful merge, even when running on the main branch
-   */
-  async performLaneCleanup(currentLane, explicitLaneName, initialCommitSha) {
-    this.logger.console('🗑️ Lane Cleanup');
-
-    // If we already have a current lane, use it
-    if (currentLane) {
-      this.logger.console(_chalk().default.blue(`Found current lane: ${currentLane.name}`));
-      const laneId = currentLane.id();
-      await this.archiveLane(laneId.toString());
-      return;
-    }
-
-    // If no current lane but explicit lane name provided, try to delete it
-    if (explicitLaneName) {
-      this.logger.console(_chalk().default.blue(`Using explicitly provided lane name: ${explicitLaneName}`));
-      try {
-        const laneId = await this.lanes.parseLaneId(explicitLaneName);
-        await this.archiveLane(laneId.toString());
-        return;
-      } catch (e) {
-        this.logger.console(_chalk().default.yellow(`Failed to parse lane name '${explicitLaneName}': ${e.message}`));
-      }
-    }
-
-    // Try to auto-detect source branch/lane name using the dedicated detector
-    const sourceBranchDetector = new (_sourceBranchDetector().SourceBranchDetector)(this.logger);
-    const sourceBranchName = await sourceBranchDetector.getSourceBranchName(initialCommitSha);
-    if (!sourceBranchName) {
-      this.logger.console(_chalk().default.yellow('No current lane and unable to detect source branch - skipping lane cleanup'));
-      return;
-    }
-    try {
-      const laneIdStr = this.convertBranchToLaneId(sourceBranchName);
-      this.logger.console(_chalk().default.blue(`Attempting to delete lane based on source branch: ${sourceBranchName} -> ${laneIdStr}`));
-      const laneId = await this.lanes.parseLaneId(laneIdStr);
-      await this.archiveLane(laneId.toString());
-    } catch (e) {
-      this.logger.console(_chalk().default.yellow(`Error during lane cleanup for source branch '${sourceBranchName}': ${e.message}`));
-    }
-  }
-
   /**
    * 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,