@teambit/lanes 1.0.1100 → 1.0.1102

package/dist/lanes.main.runtime.js

@@ -17,16 +17,16 @@ function _cli() {
   };
   return data;
 }
-function _pMapSeries() {
-  const data = _interopRequireDefault(require("p-map-series"));
-  _pMapSeries = function () {
+function _pMap() {
+  const data = _interopRequireDefault(require("p-map"));
+  _pMap = function () {
     return data;
   };
   return data;
 }
-function _pMap() {
-  const data = _interopRequireDefault(require("p-map"));
-  _pMap = function () {
+function _pLimit() {
+  const data = _interopRequireDefault(require("p-limit"));
+  _pLimit = function () {
     return data;
   };
   return data;
@@ -316,7 +316,9 @@ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbol
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 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); }
+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); } /* eslint-disable max-lines */
+/** where the base was resolved from: `workspace` (already local) or `scope` (fetched from remote). */
+
 class LanesMain {
   constructor(workspace, scope, merging, componentAspect, logger, importer, exporter, componentCompare, componentWriter, remove, checkout, install) {
     this.workspace = workspace;
@@ -331,8 +333,97 @@ class LanesMain {
     this.remove = remove;
     this.checkout = checkout;
     this.install = install;
+    /**
+     * disk-persisted memo layer for the lane-diff computation (snaps-distance, change-types and the
+     * top-level result). extracted to its own class — see `LaneDiffCache` in lanes/diff.
+     */
+    _defineProperty(this, "_laneDiffCache", void 0);
+    /**
+     * Bound the parallelism of `deriveChangeTypes` across all in-flight requests. graphql-js resolves
+     * list fields in parallel via `Promise.all`, so an uncapped derivation fires one `compare()` per
+     * component at once. The old cap of 4 existed because derivation also ran `getAPIDiff` (serial
+     * tsserver schema extraction) — that's now deferred to the API view, so derivation only does the
+     * I/O+CPU-bound `compare()`, which parallelizes well. Cap to the component concurrency limit.
+     */
+    _defineProperty(this, "deriveChangesLimit", (0, _pLimit().default)((0, _harmonyModules().concurrentComponentsLimit)()));
+    /** single-flight for concurrent `deriveComponentChanges` calls on the same memo key. */
+    _defineProperty(this, "changeTypesInflight", new Map());
+  }
+  get laneDiffCache() {
+    if (!this._laneDiffCache) this._laneDiffCache = new (_lanesModules().LaneDiffCache)(this.logger);
+    return this._laneDiffCache;
+  }
+  tryDiffStatusResultMemo(resultMemoKey, sourceLaneId, targetLaneId) {
+    const cached = this.laneDiffCache.getDiffStatus(resultMemoKey);
+    if (!cached) return undefined;
+    return {
+      source: sourceLaneId,
+      target: targetLaneId || this.getDefaultLaneId(),
+      componentsStatus: cached
+    };
   }
 
+  /**
+   * Pre-warm the downstream caches the lane-compare UI hits right after `LaneDiffStatus`:
+   * - the scope's `ScopeComponentLoader.componentsCache` via `host.getMany([…])`
+   * - `componentCompare`'s disk-persisted result memo via `compareComponents(pairs)`
+   *
+   * Fire-and-forget. The UI's follow-up `Component` and `CompareComponents` queries arrive ~50–200 ms
+   * after we return; this kickoff happens *before* we return, so the work overlaps the UI's render
+   * tick and the response serialization. By the time the UI's queries land on the server, the caches
+   * are populated (or, worst case, the pre-warm work is in-flight and the resolver-level single-flight
+   * in `componentCompare` dedupes the load).
+   */
+  prewarmCompareCaches(host, visibleDiffProps) {
+    const allVersionedIds = [];
+    const comparePairs = [];
+    for (const {
+      componentId,
+      sourceHead,
+      targetHead
+    } of visibleDiffProps) {
+      const compareId = componentId.changeVersion(sourceHead);
+      allVersionedIds.push(compareId);
+      if (targetHead) {
+        const baseId = componentId.changeVersion(targetHead);
+        allVersionedIds.push(baseId);
+        comparePairs.push({
+          baseId: baseId.toString(),
+          compareId: compareId.toString()
+        });
+      }
+    }
+    if (allVersionedIds.length === 0) return;
+    // NOTE: `host.getMany` uses mapSeries internally (sequential). For cold pre-warm to actually
+    // beat the UI's concurrent N-op `Component` batch we have to drive parallelism ourselves. pMap
+    // here uses the same `concurrentComponentsLimit()` cap as the lane diff body, matching what
+    // downstream loaders are tuned for.
+    Promise.all([
+    // wrap in try/catch since `host.get` could be missing or throw synchronously; the previous
+    // `host.get?.(id).catch(...)` chained .catch on `undefined` when get was absent.
+    (0, _pMap().default)(allVersionedIds, async id => {
+      try {
+        return await host.get?.(id);
+      } catch {
+        return undefined;
+      }
+    }, {
+      concurrency: (0, _harmonyModules().concurrentComponentsLimit)()
+    }).catch(() => undefined), comparePairs.length > 0 ? this.componentCompare.compareComponents(comparePairs).catch(() => undefined) : Promise.resolve()]).catch(() => {});
+  }
+  populateDiffStatusMemoAsync(resultMemoKey, results) {
+    Promise.all(results.map(async status => {
+      if (status.changes) return;
+      status.changes = await this.deriveComponentChanges(status);
+    })).then(() => {
+      // don't persist a result set where a component's change types couldn't be derived: `changes`
+      // came back undefined for a reason OTHER than being explicitly skipped (i.e. a transient
+      // Version-load failure). persisting it under the immutable lane-pair key would serve that gap
+      // forever; it recomputes and persists on a later request once the objects are available.
+      const anyFailed = results.some(s => s.changes === undefined && !s.changesContext?.skipped);
+      if (!anyFailed) this.laneDiffCache.storeDiffStatus(resultMemoKey, results);
+    }).catch(() => {});
+  }
   /**
    * return the lane data without the deleted components.
    * the deleted components are filtered out in legacyScope.lanes.getLanesData()
@@ -698,12 +789,9 @@ please create a new lane instead, which will include all components of this lane
     return deletedComps.map(c => c.id);
   }
 
-  /**
-   * get the head hash (snap) of main. return undefined if the component exists only on a lane and was never merged to main
-   */
+  /** head hash of main, with remote-scope fallback. undefined only for a genuinely-new component. */
   async getHeadOnMain(componentId) {
-    const modelComponent = await this.scope.legacyScope.getModelComponent(componentId);
-    return modelComponent.head?.toString();
+    return (0, _lanesModules().getHeadOnMain)(this.scope, componentId);
   }
 
   /**
@@ -861,8 +949,13 @@ please create a new lane instead, which will include all components of this lane
     if (!lane) return [];
     const laneComponents = lane.components;
     const workspace = this.workspace;
-    const bitIdsFromBitmap = workspace ? workspace.consumer.bitMap.getAllBitIdsFromAllLanes() : [];
-    const filteredComponentIds = workspace ? laneComponents.filter(laneComponent => bitIdsFromBitmap.some(bitmapComponentId => bitmapComponentId.isEqualWithoutVersion(laneComponent.id))) : laneComponents;
+    // the bitmap filter only makes sense for the lane currently checked out — it keeps that view
+    // aligned with what's actually in the workspace. any OTHER lane lives only in the local scope:
+    // its components are never in the bitmap, so filtering by it empties the lane (a fully-fetched
+    // lane renders as "no components" in the overview) even though every object is available.
+    const isCurrentLane = Boolean(workspace && this.getCurrentLaneId()?.isEqual(lane.id));
+    const bitIdsFromBitmap = workspace && isCurrentLane ? workspace.consumer.bitMap.getAllBitIdsFromAllLanes() : [];
+    const filteredComponentIds = isCurrentLane ? laneComponents.filter(laneComponent => bitIdsFromBitmap.some(bitmapComponentId => bitmapComponentId.isEqualWithoutVersion(laneComponent.id))) : laneComponents;
     return filteredComponentIds.map(laneComponent => laneComponent.id.changeVersion(laneComponent.head));
   }
 
@@ -927,6 +1020,7 @@ please create a new lane instead, which will include all components of this lane
     };
   }
   async diffStatus(sourceLaneId, targetLaneId, options) {
+    await this.laneDiffCache.ensureLoaded();
     this.logger.profile(`diff status for source lane: ${sourceLaneId.name} and target lane: ${targetLaneId?.name}`);
     const sourceLane = sourceLaneId.isDefault() ? await this.getLaneDataOfDefaultLane() : await this.loadLane(sourceLaneId);
     const sourceLaneComponents = sourceLaneId.isDefault() ? sourceLane?.components.map(main => ({
@@ -936,13 +1030,39 @@ please create a new lane instead, which will include all components of this lane
     const targetLane = targetLaneId ? await this.loadLane(targetLaneId) : undefined;
     const targetLaneIds = targetLane?.toBitIds();
     const host = this.componentAspect.getHost();
-    const targetMainHeads = !targetLaneId || targetLaneId?.isDefault() ? (0, _lodash().compact)(await Promise.all((sourceLaneComponents || []).map(async ({
+
+    // Resolve the main-side heads up-front: they feed BOTH the memo key (so the cache invalidates
+    // when main advances) and the diff computation below. The target=main case has no single lane
+    // hash, so without this the key was constant ('default') and stale results were served when main
+    // moved ahead (lanes.spec "not up to date when main is ahead").
+    const targetIsMain = !targetLaneId || Boolean(targetLaneId?.isDefault());
+    // whether each base on main was already local (snapshot *before* the remote fetch) - drives the
+    // UI "workspace vs remote scope" source indicator.
+    const baseWasLocalByComp = new Map();
+    if (targetIsMain) {
+      const sourceComponentIds = await Promise.all((sourceLaneComponents || []).map(({
+        id
+      }) => host.resolveComponentId(id)));
+      await Promise.all(sourceComponentIds.map(async cid => {
+        const modelComp = await this.scope.legacyScope.getModelComponentIfExist(cid);
+        baseWasLocalByComp.set(cid.toString(), Boolean(modelComp?.head));
+      }));
+      // the base on main may live only on the remote scope; pull it so the diff is real, not a spurious NEW.
+      await (0, _lanesModules().importMainHeads)(this.scope, sourceComponentIds);
+    }
+    const targetMainHeads = targetIsMain ? (0, _lodash().compact)(await Promise.all((sourceLaneComponents || []).map(async ({
       id
     }) => {
       const componentId = await host.resolveComponentId(id);
       const headOnMain = await this.getHeadOnMain(componentId);
       return headOnMain ? id.changeVersion(headOnMain) : undefined;
     }))) : [];
+    const resultMemoKey = this.laneDiffCache.diffStatusKey(sourceLaneId, sourceLane ?? undefined, targetLaneId, targetLane ?? undefined, options, targetMainHeads);
+    const earlyReturn = this.tryDiffStatusResultMemo(resultMemoKey, sourceLaneId, targetLaneId);
+    if (earlyReturn) {
+      this.logger.profile(`diff status for source lane: ${sourceLaneId.name} and target lane: ${targetLaneId?.name}`);
+      return earlyReturn;
+    }
     await this.importer.importObjectsFromMainIfExist(targetMainHeads, {
       cache: true
     });
@@ -972,12 +1092,28 @@ please create a new lane instead, which will include all components of this lane
     })));
     const snapDistancesByComponentId = new Map();
     this.logger.profile(`get snaps distance for source lane: ${sourceLane?.id.name} and target lane: ${targetLane?.id.name} with ${diffProps.length} components`);
+    let memoHits = 0;
     await (0, _pMap().default)(diffProps, async ({
       componentId,
       sourceHead,
       targetHead
     }) => {
-      const snapsDistance = await this.scope.getSnapsDistanceBetweenTwoSnaps(componentId, sourceHead, targetHead, false);
+      const memoKey = this.laneDiffCache.snapsDistanceKey(componentId, sourceHead, targetHead);
+      const cached = this.laneDiffCache.getSnapsDistance(memoKey, componentId.toString());
+      let snapsDistance;
+      if (cached) {
+        memoHits += 1;
+        snapsDistance = cached;
+      } else {
+        const computed = await this.scope.getSnapsDistanceBetweenTwoSnaps(componentId, sourceHead, targetHead, false);
+        if (computed) {
+          // cache success + the deterministic "unrelated" outcome. transient errors stay uncached.
+          if (!computed.err || computed.err instanceof _legacy().NoCommonSnap) {
+            this.laneDiffCache.storeSnapsDistance(memoKey, computed);
+          }
+          snapsDistance = computed;
+        }
+      }
       if (snapsDistance) {
         snapDistancesByComponentId.set(componentId.toString(), {
           snapsDistance,
@@ -989,21 +1125,64 @@ please create a new lane instead, which will include all components of this lane
     }, {
       concurrency: (0, _harmonyModules().concurrentComponentsLimit)()
     });
-    this.logger.profile(`get snaps distance for source lane: ${sourceLane?.id.name} and target lane: ${targetLane?.id.name} with ${diffProps.length} components`);
-    const commonSnapsToImport = (0, _lodash().compact)([...snapDistancesByComponentId.values()].map(s => s.snapsDistance.commonSnapBeforeDiverge ? s.componentId.changeVersion(s.snapsDistance.commonSnapBeforeDiverge.hash) : null));
+    this.logger.profile(`get snaps distance for source lane: ${sourceLane?.id.name} and target lane: ${targetLane?.id.name} with ${diffProps.length} components (memo hits: ${memoHits}/${diffProps.length})`);
+
+    // when `skipUpToDate` is set, drop only components with NO difference vs the target. keep any
+    // divergence — crucially `isSourceAhead()` (the lane's own changes): a lane forked from main has no
+    // target-only snaps, so `isUpToDate()` (=!isTargetAhead) alone would wrongly hide the whole diff.
+    const visibleDiffProps = options?.skipUpToDate ? diffProps.filter(({
+      componentId
+    }) => {
+      // `d` may be a memo reconstruction exposing only data + `isUpToDate()`; test source-ahead via
+      // `snapsOnSourceOnly.length`, not the `isSourceAhead()` method (absent on the reconstruction).
+      const d = snapDistancesByComponentId.get(componentId.toString())?.snapsDistance;
+      return !d || (d.snapsOnSourceOnly?.length ?? 0) > 0 || !d.isUpToDate();
+    }) : diffProps;
+    const commonSnapsToImport = (0, _lodash().compact)(visibleDiffProps.map(({
+      componentId
+    }) => {
+      const s = snapDistancesByComponentId.get(componentId.toString());
+      return s?.snapsDistance.commonSnapBeforeDiverge ? s.componentId.changeVersion(s.snapsDistance.commonSnapBeforeDiverge.hash) : null;
+    }));
     const sourceOrTargetLane = ((sourceLaneId.isDefault() ? null : sourceLane) || (targetLaneId?.isDefault() ? null : targetLane)) ?? undefined;
-    if (commonSnapsToImport.length > 0 && !options?.skipChanges) {
+    if (commonSnapsToImport.length > 0 && !options?.skipChanges && !options?.deferChanges) {
+      this.logger.profile(`import common snaps for lane diff (${commonSnapsToImport.length} snaps)`);
       await this.scope.legacyScope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray(commonSnapsToImport), {
         cache: true,
         reason: `get the common snap for lane diff`,
         lane: sourceOrTargetLane
       });
+      this.logger.profile(`import common snaps for lane diff (${commonSnapsToImport.length} snaps)`);
     }
-    const results = await (0, _pMapSeries().default)(diffProps, async ({
+    this.logger.profile(`componentDiffStatus pMap (${visibleDiffProps.length} components)`);
+    // run in parallel — bounded by `concurrentComponentsLimit()`. previously this was pMapSeries which
+    // serialized 30 schema extractions and dominated the cold call (minutes).
+    const results = await (0, _pMap().default)(visibleDiffProps, async ({
       componentId,
       sourceHead,
       targetHead
-    }) => this.componentDiffStatus(componentId, sourceHead, targetHead, snapDistancesByComponentId.get(componentId.toString())?.snapsDistance, options));
+    }) => {
+      // report whether an existing main base was already local (`workspace`) or pulled from remote (`scope`).
+      const baseSource = targetIsMain && targetHead ? baseWasLocalByComp.get(componentId.toString()) ? 'workspace' : 'scope' : undefined;
+      return this.componentDiffStatus(componentId, sourceHead, targetHead, snapDistancesByComponentId.get(componentId.toString())?.snapsDistance, options, baseSource);
+    }, {
+      concurrency: (0, _harmonyModules().concurrentComponentsLimit)()
+    });
+    this.logger.profile(`componentDiffStatus pMap (${visibleDiffProps.length} components)`);
+
+    // best-effort populate the top-level result memo. eagerly resolve `changes` for any deferred
+    // components so the next cold call can return immediately — does not block this response.
+    if (resultMemoKey) this.populateDiffStatusMemoAsync(resultMemoKey, results);
+
+    // Pre-warm caches the lane-compare UI will hit right after this query returns:
+    //   - `host.getMany([base+compare versioned ids])` populates `ScopeComponentLoader.componentsCache`
+    //      so the UI's 20 per-component `getHost.get` queries (componentFields + componentFieldWithLogs
+    //      for each side of each visible pair) all hit cache instead of racing through cold loads.
+    //   - `componentCompare.compareComponents(pairs)` populates the new compare-result memo so the UI's
+    //      `CompareComponents` query is answered from cache.
+    // Fired *after* we have the answer ready — never blocks the response, catch() hides any failure.
+    // Gated to `prewarmCaches` (the UI caller) so CLI/programmatic consumers don't pay & multiply it.
+    if (options?.prewarmCaches && visibleDiffProps.length > 0) this.prewarmCompareCaches(host, visibleDiffProps);
     this.logger.profile(`diff status for source lane: ${sourceLaneId.name} and target lane: ${targetLaneId?.name}`);
     return {
       source: sourceLaneId,
@@ -1011,20 +1190,26 @@ please create a new lane instead, which will include all components of this lane
       componentsStatus: results
     };
   }
-  async componentDiffStatus(componentId, sourceHead, targetHead, snapsDistance, options) {
+  async componentDiffStatus(componentId, sourceHead, targetHead, snapsDistance, options, baseSource) {
     if (snapsDistance?.err) {
       const noCommonSnap = snapsDistance.err instanceof _legacy().NoCommonSnap;
       return {
         componentId,
         sourceHead,
         targetHead,
+        baseSource,
         upToDate: snapsDistance?.isUpToDate(),
         unrelated: noCommonSnap || undefined,
         changes: []
       };
     }
     const commonSnap = snapsDistance?.commonSnapBeforeDiverge;
-    const changes = !options?.skipChanges ? await this.deriveChangeTypes(commonSnap, componentId, sourceHead) : undefined;
+
+    // when changes are skipped or deferred, return the snap-distance metadata immediately and leave
+    // `changes` unset. callers derive them lazily through `deriveComponentChanges` (used by the GraphQL
+    // `changes` field resolver, which runs the work per-component in parallel only when the client
+    // selects the field — keeps cold p50 under 200 ms even for many components).
+    const changes = options?.skipChanges || options?.deferChanges ? undefined : await this.deriveChangeTypes(commonSnap, componentId, sourceHead);
     const changeType = changes ? changes[0] : undefined;
     return {
       componentId,
@@ -1032,70 +1217,103 @@ please create a new lane instead, which will include all components of this lane
       changes,
       sourceHead,
       targetHead: commonSnap?.hash,
+      baseSource,
       upToDate: snapsDistance?.isUpToDate(),
       snapsDistance: {
         onSource: snapsDistance?.snapsOnSourceOnly.map(s => s.hash) ?? [],
         onTarget: snapsDistance?.snapsOnTargetOnly.map(s => s.hash) ?? [],
         common: snapsDistance?.commonSnapBeforeDiverge?.hash
+      },
+      changesContext: {
+        commonSnap,
+        skipped: options?.skipChanges
       }
     };
   }
-  async componentDiffStatusOld(componentId, sourceHead, targetHead, options) {
-    const snapsDistance = await this.scope.getSnapsDistanceBetweenTwoSnaps(componentId, sourceHead, targetHead, false);
-    if (snapsDistance?.err) {
-      const noCommonSnap = snapsDistance.err instanceof _legacy().NoCommonSnap;
-      return {
-        componentId,
-        sourceHead,
-        targetHead,
-        upToDate: snapsDistance?.isUpToDate(),
-        unrelated: noCommonSnap || undefined,
-        changes: []
-      };
+
+  /**
+   * Lazily derive the change types for a single component diff status. Used by the GraphQL `changes`
+   * field resolver so the (expensive) derivation only runs when the field is selected. Memoized per
+   * status object via `changesContext.pending`, so selecting both `changes` and `changeType` computes
+   * the value once.
+   */
+  async deriveComponentChanges(status) {
+    if (status.changes) return status.changes;
+    const context = status.changesContext;
+    if (!context || context.skipped) return undefined;
+    await this.laneDiffCache.ensureLoaded();
+
+    // top-level memo on the final ChangeType[] — short-circuits BEFORE compare()/getAPIDiff() run.
+    // Persisted to disk, keyed on immutable hashes, so a cold server start with a populated cache
+    // answers the entire derivation from a Map.get().
+    const memoKey = this.laneDiffCache.changeTypesKey(status.componentId, status.sourceHead, context.commonSnap?.hash ?? null);
+    const cached = this.laneDiffCache.getChangeTypes(memoKey);
+    if (cached) return cached;
+
+    // single-flight concurrent requests for the same (componentId, sourceHead, commonSnap) tuple.
+    let pending = this.changeTypesInflight.get(memoKey);
+    if (!pending) {
+      pending = this.deriveChangesLimit(() => this.deriveChangeTypes(context.commonSnap, status.componentId, status.sourceHead)).then(result => {
+        // `undefined` means the derivation couldn't load a Version object (transient) — don't persist
+        // it under the immutable-hash key; let it recompute on a later request once the object exists.
+        if (result) this.laneDiffCache.storeChangeTypes(memoKey, result);
+        return result;
+      }).finally(() => {
+        this.changeTypesInflight.delete(memoKey);
+      });
+      this.changeTypesInflight.set(memoKey, pending);
     }
-    const commonSnap = snapsDistance?.commonSnapBeforeDiverge;
-    const changes = !options?.skipChanges ? await this.deriveChangeTypes(commonSnap, componentId, sourceHead) : undefined;
-    const changeType = changes ? changes[0] : undefined;
-    return {
-      componentId,
-      changeType,
-      changes,
-      sourceHead,
-      targetHead: commonSnap?.hash,
-      upToDate: snapsDistance?.isUpToDate(),
-      snapsDistance: {
-        onSource: snapsDistance?.snapsOnSourceOnly.map(s => s.hash) ?? [],
-        onTarget: snapsDistance?.snapsOnTargetOnly.map(s => s.hash) ?? [],
-        common: snapsDistance?.commonSnapBeforeDiverge?.hash
-      }
-    };
+    context.pending = pending;
+    return pending;
   }
   async deriveChangeTypes(commonSnap, componentId, sourceHead) {
     if (!commonSnap) return [_lanesEntities().ChangeType.NEW];
-    const baseIdStr = componentId.changeVersion(commonSnap.hash).toString();
-    const compareIdStr = componentId.changeVersion(sourceHead).toString();
-    const [compare, apiDiff] = await Promise.all([this.componentCompare.compare(baseIdStr, compareIdStr), this.componentCompare.getAPIDiff(baseIdStr, compareIdStr)]);
-    const hasCodeChanges = compare.code.some(c => c.status !== 'UNCHANGED');
-    const hasFieldChanges = compare.fields.length > 0;
-    const hasApiChanges = apiDiff?.hasChanges ?? false;
-    if (!hasFieldChanges && !hasCodeChanges && !hasApiChanges) {
-      return [_lanesEntities().ChangeType.NONE];
-    }
-    const changed = [];
-    if (hasCodeChanges) {
-      changed.push(_lanesEntities().ChangeType.SOURCE_CODE);
-    }
-    if (hasFieldChanges) {
-      changed.push(_lanesEntities().ChangeType.ASPECTS);
-    }
-    const depsFields = ['dependencies', 'devDependencies', 'extensionDependencies'];
-    if (compare.fields.some(field => depsFields.includes(field.fieldName))) {
-      changed.push(_lanesEntities().ChangeType.DEPENDENCY);
-    }
-    if (hasApiChanges) {
-      changed.push(_lanesEntities().ChangeType.API);
+
+    // Classify changes by comparing the two raw `Version` objects directly (files-by-hash, deps,
+    // extensions) instead of `componentCompare.compare()`. compare() loads full consumer components
+    // (aspect calculation, capsules) for both sides just to extract two booleans — dominating the cold
+    // derivation for a large lane. Loading the raw Version objects is a cheap object read.
+    // The API change type is intentionally not computed here: it needs serial tsserver schema
+    // extraction and is resolved lazily by the API view, gated on the SOURCE_CODE/DEPENDENCY evidence.
+    const repo = this.scope.legacyScope.objects;
+    const loadPair = () => Promise.all([repo.load(_objects().Ref.from(commonSnap.hash), false), repo.load(_objects().Ref.from(sourceHead), false)]);
+    let [baseVersion, compareVersion] = await loadPair();
+
+    // the deferChanges path (the default for UI lane compares) skips the eager common-snap import, so
+    // the merge-base Version can be absent locally here. rather than give up — which classifies a
+    // genuinely-changed component as "couldn't classify" and drops it from the diff views — import the
+    // missing snap(s) on demand and retry once. this fires only on a miss and is per-component, so the
+    // fast deferred path stays fast while staying correct; the derived result is memoized afterwards.
+    if (!baseVersion || !compareVersion) {
+      const missing = [];
+      if (!baseVersion) missing.push(componentId.changeVersion(commonSnap.hash));
+      if (!compareVersion) missing.push(componentId.changeVersion(sourceHead));
+      try {
+        await this.scope.legacyScope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray(missing), {
+          cache: true,
+          ignoreMissingHead: true,
+          reason: `derive lane diff change types (snap missing locally)`
+        });
+        [baseVersion, compareVersion] = await loadPair();
+      } catch {
+        // best-effort: if the import fails (e.g. the snap only exists on a lane we lack context for here),
+        // fall through to the undefined return below rather than throwing out of the field resolver.
+      }
     }
-    return changed;
+
+    // still couldn't load a Version. this is a transient "couldn't classify", NOT "no changes"
+    // ([ChangeType.NONE]) — return undefined so it's distinguishable and never persisted to the
+    // immutable-hash-keyed memo, or the component would be reported with no change types forever.
+    if (!baseVersion || !compareVersion) return undefined;
+
+    // pure classification of the two raw Version shapes — extracted & unit-tested in lanes/diff.
+    return (0, _lanesModules().classifyVersionChanges)({
+      obj: baseVersion.toObject(),
+      extensionDependencies: baseVersion.extensionDependencies.cloneAsString()
+    }, {
+      obj: compareVersion.toObject(),
+      extensionDependencies: compareVersion.extensionDependencies.cloneAsString()
+    });
   }
   async recreateNewLaneIfDeleted() {
     if (!this.workspace) return;