Unify lane.updateDependents into lane.components via skipWorkspace flag

components/legacy/component-list/components-list.ts

@@ -156,18 +156,39 @@ export class ComponentsList {
    * will be easier to add it here once all legacy are not using this class and then ScopeMain will be in the
    * constructor.
    */
-  async listExportPendingComponentsIds(lane?: Lane | null): Promise<ComponentIdList> {
+  /**
+   * @param includeHiddenLaneEntries when true, lane components with `skipWorkspace: true` (cascade
+   * updateDependents) are included if they have local snaps. Default `false` keeps the
+   * workspace-staged view used by `bit status` free of internal lane plumbing — those entries
+   * don't live in `.bitmap` and surfacing them as if they were workspace components confuses the
+   * "staged components" output. Export and reset opt in (`true`) for different reasons:
+   *   - export: the cascade snap's Version object must land in the export bundle, otherwise the
+   *     lane object would reference a Version the remote doesn't have.
+   *   - reset: the cascade snap itself must be reverted end-to-end (cascade spec scenario 8); the
+   *     bitmap-update step in `snapping.reset` skips hidden entries explicitly so we don't try to
+   *     write workspace state for components that don't live in the workspace.
+   */
+  async listExportPendingComponentsIds(
+    lane?: Lane | null,
+    { includeHiddenLaneEntries = false }: { includeHiddenLaneEntries?: boolean } = {}
+  ): Promise<ComponentIdList> {
     const fromBitMap = this.bitMap.getAllIdsAvailableOnLaneIncludeRemoved();
     const modelComponents = await this.getModelComponents();
     const pendingExportComponents = await pFilter(modelComponents, async (component: ModelComponent) => {
       const foundInBitMap = fromBitMap.searchWithoutVersion(component.toComponentId());
       if (!foundInBitMap) {
-        // it's not on the .bitmap only in the scope, as part of the out-of-sync feature, it should
-        // be considered as staged and should be exported. same for soft-removed components, which are on scope only.
-        // notice that we use `hasLocalChanges`
-        // and not `isLocallyChanged` by purpose. otherwise, cached components that were not
-        // updated from a remote will be calculated as remote-ahead in the setDivergeData and will
-        // be exported unexpectedly.
+        // it's not on the .bitmap only in the scope. Two cases land here:
+        //  - out-of-sync: a workspace component that lost its bitmap entry but still has scope data
+        //  - hidden lane entry: a `skipWorkspace: true` lane component (cascade-on-snap, bare-scope
+        //    `_snap --update-dependents`) that exists only in scope+lane, never the workspace
+        const laneEntry = lane?.getComponent(component.toComponentId());
+        if (laneEntry?.skipWorkspace) {
+          if (!includeHiddenLaneEntries) return false;
+          return component.isLocallyChanged(this.scope.objects, lane);
+        }
+        if (lane && laneEntry) {
+          return component.isLocallyChanged(this.scope.objects, lane);
+        }
         return component.isLocallyChangedRegardlessOfLanes();
       }
       return component.isLocallyChanged(this.scope.objects, lane, foundInBitMap);
@@ -201,8 +222,11 @@ export class ComponentsList {
     return ComponentIdList.fromArray(updatedIds);
   }
 
-  async listExportPendingComponents(laneObj?: Lane): Promise<ModelComponent[]> {
-    const exportPendingComponentsIds: ComponentIdList = await this.listExportPendingComponentsIds(laneObj);
+  async listExportPendingComponents(
+    laneObj?: Lane,
+    options?: { includeHiddenLaneEntries?: boolean }
+  ): Promise<ModelComponent[]> {
+    const exportPendingComponentsIds: ComponentIdList = await this.listExportPendingComponentsIds(laneObj, options);
     return Promise.all(exportPendingComponentsIds.map((id) => this.scope.getModelComponent(id)));
   }
 

components/legacy/e2e-helper/e2e-helper.ts

@@ -21,6 +21,7 @@ import ScopeJsonHelper from './e2e-scope-json-helper';
 import type { ScopesOptions } from './e2e-scopes';
 import ScopesData from './e2e-scopes';
 import CapsulesHelper from './e2e-capsules-helper';
+import SnappingHelper from './e2e-snapping-helper';
 
 export type HelperOptions = {
   scopesOptions?: ScopesOptions;
@@ -44,6 +45,7 @@ export class Helper {
   scopeHelper: ScopeHelper;
   git: GitHelper;
   capsules: CapsulesHelper;
+  snapping: SnappingHelper;
   constructor(helperOptions?: HelperOptions) {
     this.debugMode = Boolean(process.env.npm_config_debug) || process.argv.includes('--debug'); // debug mode shows the workspace/scopes dirs and doesn't delete them
     this.scopes = new ScopesData(helperOptions?.scopesOptions); // generates dirs and scope names
@@ -85,6 +87,7 @@ export class Helper {
     this.env = new EnvHelper(this.command, this.fs, this.scopes, this.scopeHelper, this.fixtures, this.extensions);
     this.general = new GeneralHelper(this.scopes, this.npm, this.command);
     this.capsules = new CapsulesHelper(this.command);
+    this.snapping = new SnappingHelper();
   }
 }
 

components/legacy/e2e-helper/e2e-snapping-helper.ts

@@ -0,0 +1,29 @@
+import { execFileSync } from 'child_process';
+import path from 'path';
+import type { SnapDataPerCompRaw } from '@teambit/snapping';
+
+/**
+ * In-process invocation of `SnappingMain.snapFromScope` against a bare scope path. Spawns
+ * `snap-from-scope-runner.js` so each call gets a fresh Node process — `loadBit` accumulates
+ * module-level state across in-process invocations and that state leaks into downstream
+ * shell-spawned `bit` commands when many scenarios share a single test process. Used by e2e tests
+ * that need to seed `lane.updateDependents` (hidden cascade entries with `skipWorkspace: true`)
+ * on a remote lane.
+ */
+export default class SnappingHelper {
+  async snapFromScope(
+    scopePath: string,
+    snapData: SnapDataPerCompRaw[],
+    options: {
+      lane?: string;
+      updateDependents?: boolean;
+      push?: boolean;
+      message?: string;
+    } = {}
+  ): Promise<void> {
+    const runnerPath = path.resolve(__dirname, 'snap-from-scope-runner.js');
+    execFileSync('node', [runnerPath, scopePath, JSON.stringify(snapData), JSON.stringify(options)], {
+      stdio: 'inherit',
+    });
+  }
+}

components/legacy/e2e-helper/index.ts

@@ -15,6 +15,7 @@ import ScopeHelper from './e2e-scope-helper';
 import ScopeJsonHelper from './e2e-scope-json-helper';
 import ScopesData, { ScopesOptions, DEFAULT_OWNER } from './e2e-scopes';
 import CapsulesHelper from './e2e-capsules-helper';
+import SnappingHelper from './e2e-snapping-helper';
 import * as fixtures from './fixtures';
 
 export {
@@ -36,6 +37,7 @@ export {
   ScopeHelper,
   ScopeJsonHelper,
   CapsulesHelper,
+  SnappingHelper,
   fixtures,
   DEFAULT_OWNER,
 };

components/legacy/e2e-helper/snap-from-scope-runner.ts

@@ -0,0 +1,37 @@
+/* eslint-disable no-console */
+/**
+ * Standalone subprocess runner for `helper.snapping.snapFromScope`. The helper spawns this script
+ * via `child_process` so each invocation gets a clean Node process — `loadBit` mutates module-level
+ * state that doesn't fully reset between in-process calls, and accumulating that state across many
+ * scenarios in one process surfaces as "Version X not found in scope" failures during downstream
+ * shell-spawned `bit` commands.
+ *
+ * argv: <scopePath> <snapDataJson> <optionsJson>
+ */
+import { loadBit } from '@teambit/bit';
+import type { SnappingMain } from '@teambit/snapping';
+import { SnappingAspect } from '@teambit/snapping';
+
+async function main(): Promise<void> {
+  const [, , scopePath, snapDataJson, optionsJson] = process.argv;
+  const snapData = JSON.parse(snapDataJson);
+  const options = JSON.parse(optionsJson);
+
+  const harmony = await loadBit(scopePath);
+  const snapping = harmony.get<SnappingMain>(SnappingAspect.id);
+  await snapping.snapFromScope(snapData, {
+    lane: options.lane,
+    updateDependents: options.updateDependents,
+    push: options.push,
+    message: options.message,
+    build: false,
+    disableTagAndSnapPipelines: true,
+  });
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });

components/legacy/scope/repositories/sources.ts

@@ -352,7 +352,14 @@ to quickly fix the issue, please delete the object at "${this.objects().objectPa
         }
       }
 
-      const head = component.head || laneItem?.head;
+      // when on a lane, walk the LANE's parent chain — `laneItem.head` is the lane head we're
+      // about to rewind, and the prior snap lives in *its* parent graph, not in main's. Falling
+      // back to `component.head` (main head) here was a long-standing bug that surfaced once the
+      // component-tagged-on-main-then-imported-to-lane case became common (cascade-on-snap):
+      // `bit reset --head` walked main's parents, found none for the tag, returned undefined,
+      // and `lane.removeComponent` was called — leaving the bitmap to rewind all the way back to
+      // the imported tag instead of the previous lane snap.
+      const head = laneItem?.head || component.head;
       if (!head) {
         return undefined;
       }
@@ -720,8 +727,15 @@ possible causes:
       mergeResults.push({ mergedComponent: modelComponent, mergedVersions: [] });
     };
 
+    // hidden (`skipWorkspace: true`) lane components go through the dedicated updateDependents
+    // merge branch below, not the per-component loop. On import, the legacy semantic is "remote is
+    // authoritative for hidden entries"; on export, the `overrideUpdateDependents` wire signal
+    // governs when the client's hidden entries replace the server's. Rewiring hidden entries into
+    // the full per-component diverge-check would need matching cascade mechanics in this layer too,
+    // which is outside the foundation-only scope.
+    const visibleIncomingComponents = lane.components.filter((c) => !c.skipWorkspace);
     await pMap(
-      lane.components,
+      visibleIncomingComponents,
       async (component) => {
         await mergeLaneComponent(component);
       },
@@ -733,27 +747,47 @@ possible causes:
     if (existingLane?.hasChanged && existingLane.includeDeletedData() && !lane.includeDeletedData()) {
       existingLane.setSchemaToNotSupportDeletedData();
     }
-    // merging updateDependents is tricky. the end user should never change it, only get it as is from the remote.
-    // this prop gets updated with snap-from-scope with --update-dependents flag. and a graphql query should remove entries
-    // from there. other than these 2 places, it should never change. so when a user imports it, always override.
-    // if it is being exported, the remote should override it only when it comes from the snap-from-scope command, to
-    // indicate this, the lane should have the overrideUpdateDependents prop set to true.
-    if (isImport && existingLane) {
+    // hidden (skipWorkspace) entries are merged here via the legacy `updateDependents`-shaped
+    // override/wire path. New flows that produce hidden entries (workspace cascade-on-snap, the
+    // bare-scope `_snap --update-dependents`) set `overrideUpdateDependents=true` to claim the
+    // local list as authoritative; we honor it on export and protect it from being clobbered on
+    // import.
+    if (isImport && existingLane && !existingLane.shouldOverrideUpdateDependents()) {
       existingLane.updateDependents = lane.updateDependents;
     }
     if (isExport && existingLane && lane.shouldOverrideUpdateDependents()) {
-      await Promise.all(
-        (lane.updateDependents || []).map(async (id) => {
-          const existing = existingLane.updateDependents?.find((existingId) => existingId.isEqualWithoutVersion(id));
+      // Cache both sides outside the loop. With the unified-components getter, each
+      // `lane.updateDependents` access recomputes (filter + map) the hidden slice; without
+      // caching, an export with N incoming hidden entries against an existing lane with M
+      // recomputes the existing array N times for an O(N·M²) lookup. Snapshot once → O(N·M).
+      const incomingHidden = lane.updateDependents || [];
+      const existingHidden = existingLane.updateDependents || [];
+      const existingByName = new Map(existingHidden.map((id) => [id.toStringWithoutVersion(), id]));
+      // Bound concurrency — each task may load a ModelComponent from storage. With many incoming
+      // hidden entries, an unbounded `Promise.all` could spike I/O during a large export. Match
+      // the per-component merge loop above which uses `concurrentComponentsLimit()`.
+      await pMap(
+        incomingHidden,
+        async (id) => {
+          const existing = existingByName.get(id.toStringWithoutVersion());
           if (!existing || existing.version !== id.version) {
             const mergedComponent = await getModelComponent(id);
             mergeResults.push({ mergedComponent, mergedVersions: [id.version] });
           }
-        })
+        },
+        { concurrency: concurrentComponentsLimit() }
       );
-      existingLane.updateDependents = lane.updateDependents;
+      existingLane.updateDependents = incomingHidden;
+    }
+
+    const mergeLane = existingLane || lane;
+    // `overrideUpdateDependents` is a one-shot wire signal from client to remote — once we've
+    // honored it above, it must not persist on the remote scope. Clear it so that subsequent
+    // imports of the same lane object don't see a stale "local is authoritative" claim.
+    if (isExport && mergeLane.shouldOverrideUpdateDependents()) {
+      mergeLane.setOverrideUpdateDependents(false);
     }
 
-    return { mergeResults, mergeErrors, mergeLane: existingLane || lane };
+    return { mergeResults, mergeErrors, mergeLane };
   }
 }