@teambit/component-compare 1.0.1080 → 1.0.1082

package/dist/component-compare-page.module.scss

@@ -0,0 +1,124 @@
+.page {
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100%;
+  min-height: 0;
+  background: var(--surface-base-color, #fff);
+}
+
+.versionPickerRow {
+  flex: 0 0 auto;
+  padding: 8px 16px;
+  border-bottom: 1px solid var(--border-color, #e6e8eb);
+}
+
+.blankState {
+  flex: 1 1 auto;
+  min-height: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+@keyframes compareSkeletonShimmer {
+  0% {
+    background-position: 200% 0;
+  }
+  100% {
+    background-position: -200% 0;
+  }
+}
+
+%compareSkeletonShape {
+  border-radius: 6px;
+  background: linear-gradient(
+    90deg,
+    var(--surface-neutral-color, #f0f2f5) 25%,
+    var(--surface-hover-color, #e8ecf0) 37%,
+    var(--surface-neutral-color, #f0f2f5) 63%
+  );
+  background-size: 400% 100%;
+  animation: compareSkeletonShimmer 1.4s ease infinite;
+}
+
+.toolbarSkeleton {
+  flex: 0 0 auto;
+  display: flex;
+  gap: 8px;
+  padding: 10px 16px;
+  border-bottom: 1px solid var(--border-color, #e6e8eb);
+}
+
+.skelPill {
+  @extend %compareSkeletonShape;
+  width: 92px;
+  height: 28px;
+}
+
+.bodySkeleton {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 16px 20px;
+}
+
+.skelHeader {
+  @extend %compareSkeletonShape;
+  width: 40%;
+  height: 16px;
+  margin-bottom: 8px;
+}
+
+.skelLine {
+  @extend %compareSkeletonShape;
+  height: 12px;
+}
+
+.diffPane {
+  flex: 1 1 auto;
+  min-height: 0;
+  // shrink below content width so a wide diff scrolls inside its own file body instead of forcing
+  // the whole page horizontally wider.
+  min-width: 0;
+  overflow: auto;
+  // No padding/gap on the scroll container itself: the sticky component header (top:
+  // `--group-header-height`) and diff-file headers (top: `--group-header-height` +
+  // `--component-header-height`) are measured from the scrollport edge, so any padding here
+  // offsets them and they stop stacking flush. Inner cards/headers carry their own padding
+  // (mirrors lane-compare's padding-less `.diffPane`).
+  display: flex;
+  flex-direction: column;
+
+  // Tab visibility driven by `data-view-mode` on the pane. All `DeferredTab` siblings are mounted
+  // simultaneously so their internal query state survives mode switches; CSS hides the non-active
+  // tabs. Mirror of lane-compare's panel selectors so the same inline-* tabs work in both pages.
+  &[data-view-mode='code'] [data-tab-id]:not([data-tab-id='inline-code']) {
+    display: none;
+  }
+  &[data-view-mode='preview'] [data-tab-id]:not([data-tab-id='inline-preview']) {
+    display: none;
+  }
+  &[data-view-mode='dependencies'] [data-tab-id]:not([data-tab-id='inline-deps']) {
+    display: none;
+  }
+  &[data-view-mode='tests'] [data-tab-id]:not([data-tab-id='inline-tests']) {
+    display: none;
+  }
+  &[data-view-mode='config'] [data-tab-id]:not([data-tab-id='inline-config']) {
+    display: none;
+  }
+  &[data-view-mode='docs'] [data-tab-id]:not([data-tab-id='inline-docs']) {
+    display: none;
+  }
+  // The API view is not an inline `[data-tab-id]` tab — it's rendered as a direct child of the
+  // inline compare (only while active). Hide every inline tab so only the API element shows.
+  &[data-view-mode='api'] [data-tab-id] {
+    display: none;
+  }
+
+  // reveal the header note a view registered for the active view (e.g. the deps change tally).
+  &[data-view-mode='dependencies'] [data-header-extra-view='dependencies'] {
+    display: inline-flex;
+  }
+}

package/dist/component-compare.graphql.js

@@ -35,14 +35,25 @@ function componentCompareSchema(componentCompareMain) {
       type ComponentCompareResult {
         # unique id for graphql - baseId + compareId
         id: String!
+        baseId: String!
+        compareId: String!
         code(fileName: String): [FileCompareResult!]!
         aspects(aspectName: String): [FieldCompareResult!]!
         tests(fileName: String): [FileCompareResult!]
         api: APIDiffResult
       }
 
+      input ComponentComparePair {
+        baseId: String!
+        compareId: String!
+      }
+
       extend type ComponentHost {
         compareComponent(baseId: String!, compareId: String!): ComponentCompareResult
+        # bulk compare a paginated slice of pairs; an element is null if that pair failed to compare
+        compareComponents(pairs: [ComponentComparePair!]!, offset: Int, limit: Int): [ComponentCompareResult]!
+        # bulk api-diff a paginated slice of pairs; an element is null if that pair's diff couldn't be computed
+        apiDiffs(pairs: [ComponentComparePair!]!, offset: Int, limit: Int): [APIDiffResult]!
       }
     `,
     resolvers: {
@@ -52,6 +63,29 @@ function componentCompareSchema(componentCompareMain) {
           compareId
         }) => {
           return componentCompareMain.compare(baseId, compareId);
+        },
+        compareComponents: async (_, {
+          pairs,
+          offset,
+          limit
+        }) => {
+          return componentCompareMain.compareComponents(pairs, {
+            offset,
+            limit
+          });
+        },
+        apiDiffs: async (_, {
+          pairs,
+          offset,
+          limit
+        }) => {
+          // each element is the plain record `getAPIDiff` returns (or null); the APIDiffResult
+          // fields resolve from it via graphql's default field resolvers, same as the single
+          // `apiDiff` resolver in @teambit/semantics.schema.
+          return componentCompareMain.apiDiffs(pairs, {
+            offset,
+            limit
+          });
         }
       },
       ComponentCompareResult: {

package/dist/component-compare.graphql.js.map

@@ -1 +1 @@
-{"version":3,"names":["_graphqlTag","data","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","componentCompareSchema","componentCompareMain","typeDefs","gql","resolvers","ComponentHost","compareComponent","_","baseId","compareId","compare","ComponentCompareResult","id","result","code","fileName","codeFile","filePath","map","c","baseContent","fromContent","compareContent","toContent","tests","testFile","aspects","fieldName","fields","field","api","getAPIDiff"],"sources":["component-compare.graphql.ts"],"sourcesContent":["import { gql } from 'graphql-tag';\nimport type { Schema } from '@teambit/graphql';\nimport type { ComponentCompareMain, ComponentCompareResult } from './component-compare.main.runtime';\n\nexport function componentCompareSchema(componentCompareMain: ComponentCompareMain): Schema {\n  return {\n    typeDefs: gql`\n      type FileCompareResult {\n        fileName: String!\n        baseContent: String!\n        compareContent: String!\n        status: String\n        diffOutput: String\n      }\n\n      type FieldCompareResult {\n        fieldName: String!\n        diffOutput: String\n      }\n\n      type ComponentCompareResult {\n        # unique id for graphql - baseId + compareId\n        id: String!\n        code(fileName: String): [FileCompareResult!]!\n        aspects(aspectName: String): [FieldCompareResult!]!\n        tests(fileName: String): [FileCompareResult!]\n        api: APIDiffResult\n      }\n\n      extend type ComponentHost {\n        compareComponent(baseId: String!, compareId: String!): ComponentCompareResult\n      }\n    `,\n    resolvers: {\n      ComponentHost: {\n        compareComponent: async (_, { baseId, compareId }: { baseId: string; compareId: string }) => {\n          return componentCompareMain.compare(baseId, compareId);\n        },\n      },\n      ComponentCompareResult: {\n        id: (result: ComponentCompareResult) => result.id,\n        code: (result: ComponentCompareResult, { fileName }: { fileName?: string }) => {\n          if (fileName) {\n            return result.code\n              .filter((codeFile) => codeFile.filePath === fileName)\n              .map((c) => ({ ...c, fileName: c.filePath, baseContent: c.fromContent, compareContent: c.toContent }));\n          }\n\n          return result.code.map((c) => ({\n            ...c,\n            fileName: c.filePath,\n            baseContent: c.fromContent,\n            compareContent: c.toContent,\n          }));\n        },\n        tests: (result: ComponentCompareResult, { fileName }: { fileName?: string }) => {\n          if (fileName) {\n            return result.tests\n              .filter((testFile) => testFile.filePath === fileName)\n              .map((c) => ({ ...c, fileName: c.filePath, baseContent: c.fromContent, compareContent: c.toContent }));\n          }\n\n          return result.tests.map((c) => ({\n            ...c,\n            fileName: c.filePath,\n            baseContent: c.fromContent,\n            compareContent: c.toContent,\n          }));\n        },\n        aspects: (result: ComponentCompareResult, { fieldName }: { fieldName?: string }) => {\n          if (fieldName) {\n            return result.fields.filter((field) => field.fieldName === fieldName);\n          }\n          return result.fields;\n        },\n        api: async (result: ComponentCompareResult) => {\n          return (await componentCompareMain.getAPIDiff(result.baseId, result.compareId)) ?? null;\n        },\n      },\n    },\n  };\n}\n"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_graphqlTag","data","require","ownKeys","e","r","t","Object","keys","getOwnPropertySymbols","o","filter","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","_toPropertyKey","value","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","componentCompareSchema","componentCompareMain","typeDefs","gql","resolvers","ComponentHost","compareComponent","_","baseId","compareId","compare","compareComponents","pairs","offset","limit","apiDiffs","ComponentCompareResult","id","result","code","fileName","codeFile","filePath","map","c","baseContent","fromContent","compareContent","toContent","tests","testFile","aspects","fieldName","fields","field","api","getAPIDiff"],"sources":["component-compare.graphql.ts"],"sourcesContent":["import { gql } from 'graphql-tag';\nimport type { Schema } from '@teambit/graphql';\nimport type { ComponentCompareMain, ComponentCompareResult } from './component-compare.main.runtime';\n\nexport function componentCompareSchema(componentCompareMain: ComponentCompareMain): Schema {\n  return {\n    typeDefs: gql`\n      type FileCompareResult {\n        fileName: String!\n        baseContent: String!\n        compareContent: String!\n        status: String\n        diffOutput: String\n      }\n\n      type FieldCompareResult {\n        fieldName: String!\n        diffOutput: String\n      }\n\n      type ComponentCompareResult {\n        # unique id for graphql - baseId + compareId\n        id: String!\n        baseId: String!\n        compareId: String!\n        code(fileName: String): [FileCompareResult!]!\n        aspects(aspectName: String): [FieldCompareResult!]!\n        tests(fileName: String): [FileCompareResult!]\n        api: APIDiffResult\n      }\n\n      input ComponentComparePair {\n        baseId: String!\n        compareId: String!\n      }\n\n      extend type ComponentHost {\n        compareComponent(baseId: String!, compareId: String!): ComponentCompareResult\n        # bulk compare a paginated slice of pairs; an element is null if that pair failed to compare\n        compareComponents(pairs: [ComponentComparePair!]!, offset: Int, limit: Int): [ComponentCompareResult]!\n        # bulk api-diff a paginated slice of pairs; an element is null if that pair's diff couldn't be computed\n        apiDiffs(pairs: [ComponentComparePair!]!, offset: Int, limit: Int): [APIDiffResult]!\n      }\n    `,\n    resolvers: {\n      ComponentHost: {\n        compareComponent: async (_, { baseId, compareId }: { baseId: string; compareId: string }) => {\n          return componentCompareMain.compare(baseId, compareId);\n        },\n        compareComponents: async (\n          _,\n          {\n            pairs,\n            offset,\n            limit,\n          }: { pairs: Array<{ baseId: string; compareId: string }>; offset?: number; limit?: number }\n        ) => {\n          return componentCompareMain.compareComponents(pairs, { offset, limit });\n        },\n        apiDiffs: async (\n          _,\n          {\n            pairs,\n            offset,\n            limit,\n          }: { pairs: Array<{ baseId: string; compareId: string }>; offset?: number; limit?: number }\n        ) => {\n          // each element is the plain record `getAPIDiff` returns (or null); the APIDiffResult\n          // fields resolve from it via graphql's default field resolvers, same as the single\n          // `apiDiff` resolver in @teambit/semantics.schema.\n          return componentCompareMain.apiDiffs(pairs, { offset, limit });\n        },\n      },\n      ComponentCompareResult: {\n        id: (result: ComponentCompareResult) => result.id,\n        code: (result: ComponentCompareResult, { fileName }: { fileName?: string }) => {\n          if (fileName) {\n            return result.code\n              .filter((codeFile) => codeFile.filePath === fileName)\n              .map((c) => ({ ...c, fileName: c.filePath, baseContent: c.fromContent, compareContent: c.toContent }));\n          }\n\n          return result.code.map((c) => ({\n            ...c,\n            fileName: c.filePath,\n            baseContent: c.fromContent,\n            compareContent: c.toContent,\n          }));\n        },\n        tests: (result: ComponentCompareResult, { fileName }: { fileName?: string }) => {\n          if (fileName) {\n            return result.tests\n              .filter((testFile) => testFile.filePath === fileName)\n              .map((c) => ({ ...c, fileName: c.filePath, baseContent: c.fromContent, compareContent: c.toContent }));\n          }\n\n          return result.tests.map((c) => ({\n            ...c,\n            fileName: c.filePath,\n            baseContent: c.fromContent,\n            compareContent: c.toContent,\n          }));\n        },\n        aspects: (result: ComponentCompareResult, { fieldName }: { fieldName?: string }) => {\n          if (fieldName) {\n            return result.fields.filter((field) => field.fieldName === fieldName);\n          }\n          return result.fields;\n        },\n        api: async (result: ComponentCompareResult) => {\n          return (await componentCompareMain.getAPIDiff(result.baseId, result.compareId)) ?? null;\n        },\n      },\n    },\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/component-compare.main.runtime.d.ts

@@ -1,6 +1,6 @@
 import type { CLIMain } from '@teambit/cli';
 import type { Workspace } from '@teambit/workspace';
-import type { ComponentID } from '@teambit/component-id';
+import { ComponentID } from '@teambit/component-id';
 import type { ScopeMain } from '@teambit/scope';
 import type { GraphqlMain } from '@teambit/graphql';
 import type { ModelComponent, Version } from '@teambit/objects';
@@ -10,7 +10,9 @@ import type { DiffOptions, DiffResults, FieldsDiff, FileDiff } from '@teambit/le
 import type { TesterMain } from '@teambit/tester';
 import type { Component, ComponentMain } from '@teambit/component';
 import type { SchemaMain } from '@teambit/schema';
+import type { CacheMain } from '@teambit/cache';
 import type { ImporterMain } from '@teambit/importer';
+import type { ComponentComparePair } from './compare-component-pairs';
 export type ComponentCompareResult = {
     id: string;
     baseId: string;
@@ -18,6 +20,12 @@ export type ComponentCompareResult = {
     code: FileDiff[];
     fields: FieldsDiff[];
     tests: FileDiff[];
+    /**
+     * true when the compare side is the live workspace (on-disk files, incl. uncommitted changes).
+     * such a result is inherently mutable, so it must never be persisted to the cross-run cache —
+     * only the in-flight single-flight dedupe applies. not exposed via graphql.
+     */
+    isLiveWorkspace?: boolean;
 };
 type ConfigDiff = {
     version?: string;
@@ -32,10 +40,61 @@ export declare class ComponentCompareMain {
     private depResolver;
     private importer;
     private schema;
+    private cache;
     private workspace?;
-    constructor(componentAspect: ComponentMain, scope: ScopeMain, logger: Logger, tester: TesterMain, depResolver: DependencyResolverMain, importer: ImporterMain, schema: SchemaMain, workspace?: Workspace | undefined);
+    constructor(componentAspect: ComponentMain, scope: ScopeMain, logger: Logger, tester: TesterMain, depResolver: DependencyResolverMain, importer: ImporterMain, schema: SchemaMain, cache: CacheMain, workspace?: Workspace | undefined);
+    private compareInflight;
+    private apiDiffInflight;
+    /**
+     * Read-through cache with single-flight dedupe: serve a persisted result, else share an in-flight
+     * computation, else compute once and persist. Most `(baseId, compareId)` pairs are immutable (keyed
+     * on snap hashes), so a cached result never goes stale. `cacheable` gates which results are persisted.
+     *
+     * `skipPersistentCache` bypasses the persistent cache entirely (neither read nor write) while still
+     * sharing the in-flight computation. Callers must set it whenever the result depends on mutable state
+     * the key does not capture — e.g. a live-workspace diff against on-disk files — so a previously
+     * persisted snap-to-snap result for the same key is never served in its place.
+     */
+    private getOrCompute;
     compare(baseIdStr: string, compareIdStr: string): Promise<ComponentCompareResult>;
+    /**
+     * cheap, synchronous pre-check mirroring the `comparingWithLocalChanges` / `compareIsLiveWorkspace`
+     * logic in `computeCompare`: will this compare diff against live on-disk workspace files rather than
+     * two immutable snaps? errs toward `true` (skip the persistent cache) whenever the id cannot be
+     * classified, so a stale snap-to-snap result is never served in place of a live one.
+     */
+    private comparesLiveWorkspace;
+    /**
+     * whether this id refers to the component version currently checked out on disk — the one case
+     * where "the same versioned id" can produce different data over time (the user edits files). errs
+     * toward `true` when the id cannot be classified, so a stale cached result is never served.
+     */
+    private isLiveCheckout;
+    /** The original `compare()` body — moved here so the public method can wrap with memo + single-flight. */
+    private computeCompare;
+    /**
+     * compare a paginated slice of component pairs in one call.
+     * a pair that fails to compare (e.g. a component without versions) becomes `null` in the
+     * returned array rather than failing the whole batch. the array is aligned to the requested
+     * slice (`pairs[offset .. offset + limit]`).
+     */
+    compareComponents(pairs: ComponentComparePair[], options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<Array<ComponentCompareResult | null>>;
+    /**
+     * api-diff a paginated slice of component pairs in one call — the bulk counterpart of the single
+     * `getAPIDiff`, mirroring `compareComponents`. reuses `getAPIDiff` per pair (so its disk memo +
+     * single-flight dedupe still apply), turning a pair whose diff throws into `null` rather than
+     * failing the whole batch. the returned array is aligned to the requested slice.
+     */
+    apiDiffs(pairs: ComponentComparePair[], options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<Array<Record<string, any> | null>>;
+    private static isApiDiffCacheable;
     getAPIDiff(baseIdStr: string, compareIdStr: string): Promise<Record<string, any> | null>;
+    private computeAPIDiff;
     diffByCLIValues(pattern?: string, version?: string, toVersion?: string, { verbose, table, parent }?: {
         verbose?: boolean;
         table?: boolean;
@@ -58,7 +117,7 @@ export declare class ComponentCompareMain {
     static slots: never[];
     static dependencies: import("@teambit/harmony").Aspect[];
     static runtime: import("@teambit/harmony").RuntimeDefinition;
-    static provider([graphql, component, scope, loggerMain, cli, workspace, tester, depResolver, importer, schema,]: [
+    static provider([graphql, component, scope, loggerMain, cli, workspace, tester, depResolver, importer, schema, cache,]: [
         GraphqlMain,
         ComponentMain,
         ScopeMain,
@@ -68,7 +127,8 @@ export declare class ComponentCompareMain {
         TesterMain,
         DependencyResolverMain,
         ImporterMain,
-        SchemaMain
+        SchemaMain,
+        CacheMain
     ]): Promise<ComponentCompareMain>;
 }
 export default ComponentCompareMain;

package/dist/component-compare.main.runtime.js

@@ -102,6 +102,13 @@ function _schema() {
   };
   return data;
 }
+function _cache() {
+  const data = require("@teambit/cache");
+  _cache = function () {
+    return data;
+  };
+  return data;
+}
 function _componentCompare() {
   const data = require("./component-compare.graphql");
   _componentCompare = function () {
@@ -130,11 +137,31 @@ function _importer() {
   };
   return data;
 }
+function _harmonyModules() {
+  const data = require("@teambit/harmony.modules.concurrency");
+  _harmonyModules = function () {
+    return data;
+  };
+  return data;
+}
+function _compareComponentPairs() {
+  const data = require("./compare-component-pairs");
+  _compareComponentPairs = function () {
+    return data;
+  };
+  return data;
+}
 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); }
+/**
+ * expiry for persisted compare/api-diff results. the results themselves are immutable (keyed on snap
+ * hashes), but the payloads are heavy — full per-file contents per pair — so without a TTL the cache
+ * directory grows with every pair ever viewed. two weeks comfortably covers a review cycle.
+ */
+const PERSISTENT_CACHE_TTL_MS = 14 * 24 * 60 * 60 * 1000;
 class ComponentCompareMain {
-  constructor(componentAspect, scope, logger, tester, depResolver, importer, schema, workspace) {
+  constructor(componentAspect, scope, logger, tester, depResolver, importer, schema, cache, workspace) {
     this.componentAspect = componentAspect;
     this.scope = scope;
     this.logger = logger;
@@ -142,9 +169,89 @@ class ComponentCompareMain {
     this.depResolver = depResolver;
     this.importer = importer;
     this.schema = schema;
+    this.cache = cache;
     this.workspace = workspace;
+    // in-flight `compute` promises, so concurrent callers for the same pair share one computation
+    // instead of recomputing (the lane compare UI and lane-diff status hit the same pairs in parallel
+    // on a cold load). Persisted results survive restarts via the global `@teambit/cache` aspect.
+    _defineProperty(this, "compareInflight", new Map());
+    _defineProperty(this, "apiDiffInflight", new Map());
+  }
+  /**
+   * Read-through cache with single-flight dedupe: serve a persisted result, else share an in-flight
+   * computation, else compute once and persist. Most `(baseId, compareId)` pairs are immutable (keyed
+   * on snap hashes), so a cached result never goes stale. `cacheable` gates which results are persisted.
+   *
+   * `skipPersistentCache` bypasses the persistent cache entirely (neither read nor write) while still
+   * sharing the in-flight computation. Callers must set it whenever the result depends on mutable state
+   * the key does not capture — e.g. a live-workspace diff against on-disk files — so a previously
+   * persisted snap-to-snap result for the same key is never served in its place.
+   */
+  async getOrCompute(inflight, cacheKey, compute, cacheable = () => true, skipPersistentCache = false) {
+    const pending = inflight.get(cacheKey);
+    if (pending) return pending;
+    if (!skipPersistentCache) {
+      const cached = await this.cache.get(cacheKey);
+      if (cached !== undefined) return cached;
+      // a concurrent caller may have started computing while we awaited the cache read.
+      const started = inflight.get(cacheKey);
+      if (started) return started;
+    }
+    const promise = compute().then(result => {
+      // TTL keeps the cache bounded: compare payloads embed full per-file contents for every pair,
+      // so without an expiry every pair ever viewed stays on disk forever. entries are cheap to
+      // recompute after expiry (sources still cached in the scope), so a stale-eviction is harmless.
+      if (!skipPersistentCache && cacheable(result)) void this.cache.set(cacheKey, result, PERSISTENT_CACHE_TTL_MS);
+      return result;
+    }).finally(() => inflight.delete(cacheKey));
+    inflight.set(cacheKey, promise);
+    return promise;
   }
   async compare(baseIdStr, compareIdStr) {
+    return this.getOrCompute(this.compareInflight, `component-compare:result:${baseIdStr}|${compareIdStr}`, () => this.computeCompare(baseIdStr, compareIdStr),
+    // never persist a live-workspace diff: it reflects on-disk files (incl. uncommitted changes),
+    // so a cached copy would go stale the moment the user edits a file. the (baseId, compareId)
+    // pair is otherwise immutable (keyed on snap hashes), so those stay cacheable.
+    result => !result.isLiveWorkspace,
+    // whether this call *reads* the persistent cache is decided up front from the same signal:
+    // a live-workspace compare must skip the cache entirely, otherwise a snap-to-snap result
+    // persisted for this key in a prior run (or a non-live context) would mask on-disk changes.
+    this.comparesLiveWorkspace(baseIdStr, compareIdStr));
+  }
+
+  /**
+   * cheap, synchronous pre-check mirroring the `comparingWithLocalChanges` / `compareIsLiveWorkspace`
+   * logic in `computeCompare`: will this compare diff against live on-disk workspace files rather than
+   * two immutable snaps? errs toward `true` (skip the persistent cache) whenever the id cannot be
+   * classified, so a stale snap-to-snap result is never served in place of a live one.
+   */
+  comparesLiveWorkspace(baseIdStr, compareIdStr) {
+    if (!this.workspace) return false; // scope/remote host: every compare is an immutable snap-to-snap pair
+    if (baseIdStr === compareIdStr) return true; // the "local changes" view: checked-out snap vs on-disk files
+    return this.isLiveCheckout(compareIdStr);
+  }
+
+  /**
+   * whether this id refers to the component version currently checked out on disk — the one case
+   * where "the same versioned id" can produce different data over time (the user edits files). errs
+   * toward `true` when the id cannot be classified, so a stale cached result is never served.
+   */
+  isLiveCheckout(idStr) {
+    if (!this.workspace) return false;
+    let id;
+    try {
+      id = _componentId().ComponentID.fromString(idStr);
+    } catch {
+      return true; // unclassifiable id → assume live so a stale cached diff is never returned
+    }
+    const checkedOut = this.workspace.getIdIfExist(id);
+    if (!checkedOut) return false; // not checked out → a stored snap, safe to cache
+    // live only when this side is the exact version currently checked out on disk.
+    return !id.hasVersion() || checkedOut.version === id.version;
+  }
+
+  /** The original `compare()` body — moved here so the public method can wrap with memo + single-flight. */
+  async computeCompare(baseIdStr, compareIdStr) {
     const host = this.componentAspect.getHost();
     const [baseCompId, compareCompId] = await host.resolveMultipleComponentIds([baseIdStr, compareIdStr]);
     const modelComponent = await this.scope.legacyScope.getModelComponentIfExist(compareCompId);
@@ -163,7 +270,20 @@ class ComponentCompareMain {
     const baseComponent = components?.[0];
     const compareComponent = components?.[1];
     const componentWithoutVersion = await host.get((baseCompId || compareCompId).changeVersion(undefined));
-    const diff = componentWithoutVersion ? await this.computeDiff(componentWithoutVersion, comparingWithLocalChanges ? undefined : baseVersion, comparingWithLocalChanges ? undefined : compareVersion, {}) : {
+
+    // When the compare side is the component currently checked out in the workspace, diff against the
+    // on-disk files rather than a stored snap: passing `undefined` as the compare version makes
+    // `computeDiff` fall back to `consumerComponent.files`, so uncommitted local changes are included.
+    // This covers two cases with one code path:
+    //   - base === compare (the classic "local changes" view): checked-out model → workspace files.
+    //   - base = an earlier version: that version's committed changes + any uncommitted changes on top.
+    // Without this, the default workspace compare resolves base and compare to the same checked-out
+    // snap and reports no changes, collapsing the compare view to only its always-on sections.
+    const checkedOutVersion = componentWithoutVersion?.id.version;
+    const compareIsLiveWorkspace = Boolean(this.workspace && checkedOutVersion && compareVersion === checkedOutVersion);
+    const effectiveBaseVersion = comparingWithLocalChanges ? undefined : baseVersion;
+    const effectiveCompareVersion = comparingWithLocalChanges || compareIsLiveWorkspace ? undefined : compareVersion;
+    const diff = componentWithoutVersion ? await this.computeDiff(componentWithoutVersion, effectiveBaseVersion, effectiveCompareVersion, {}) : {
       filesDiff: [],
       fieldsDiff: []
     };
@@ -177,10 +297,71 @@ class ComponentCompareMain {
       compareId: compareIdStr,
       code: diff.filesDiff || [],
       fields: diff.fieldsDiff || [],
-      tests: testFilesDiff
+      tests: testFilesDiff,
+      isLiveWorkspace: compareIsLiveWorkspace
     };
   }
+
+  /**
+   * compare a paginated slice of component pairs in one call.
+   * a pair that fails to compare (e.g. a component without versions) becomes `null` in the
+   * returned array rather than failing the whole batch. the array is aligned to the requested
+   * slice (`pairs[offset .. offset + limit]`).
+   */
+  async compareComponents(pairs, options) {
+    return (0, _compareComponentPairs().compareComponentPairs)(pairs, (baseId, compareId) => this.compare(baseId, compareId), {
+      offset: options?.offset,
+      limit: options?.limit,
+      concurrency: (0, _harmonyModules().concurrentComponentsLimit)(),
+      onError: (pair, err) => {
+        this.logger.warn(`compareComponents: failed to compare ${pair.baseId} <> ${pair.compareId}`, err);
+      }
+    });
+  }
+
+  /**
+   * api-diff a paginated slice of component pairs in one call — the bulk counterpart of the single
+   * `getAPIDiff`, mirroring `compareComponents`. reuses `getAPIDiff` per pair (so its disk memo +
+   * single-flight dedupe still apply), turning a pair whose diff throws into `null` rather than
+   * failing the whole batch. the returned array is aligned to the requested slice.
+   */
+  async apiDiffs(pairs, options) {
+    return (0, _compareComponentPairs().compareComponentPairs)(pairs, (baseId, compareId) => this.getAPIDiff(baseId, compareId), {
+      offset: options?.offset,
+      limit: options?.limit,
+      concurrency: (0, _harmonyModules().concurrentComponentsLimit)(),
+      onError: (pair, err) => {
+        this.logger.warn(`apiDiffs: failed to compute api diff ${pair.baseId} <> ${pair.compareId}`, err);
+      }
+    });
+  }
+  static isApiDiffCacheable(result) {
+    // a live-extracted side reflects the current working tree, not the snap the cache key names —
+    // persisting it would serve a stale (possibly degraded) diff for that pair forever.
+    if (result.base?.live || result.compare?.live) return false;
+    if (result.status === 'COMPUTED') return true;
+    // A non-COMPUTED result is only safe to persist (disk cache, keyed on the immutable snap pair, no
+    // TTL) when it can never change for that pair. FAILED is transient. NOT_BUILT is *pending*: the snap
+    // simply hasn't been built yet, and once CI builds it (same hash) the schema appears — caching the
+    // pre-build "unavailable" answer would keep the API view blank forever. NO_EXTRACTOR/DISABLED are
+    // stable properties of the snap's env, so they stay cacheable.
+    const pendingOrTransient = reason => reason === 'FAILED' || reason === 'NOT_BUILT';
+    return !pendingOrTransient(result.base?.reason) && !pendingOrTransient(result.compare?.reason);
+  }
   async getAPIDiff(baseIdStr, compareIdStr) {
+    // never persist a result that can still change: `null` (snaps couldn't load), FAILED (schema
+    // retrieval threw) and NOT_BUILT (snap not yet built) must recompute next call; NO_EXTRACTOR/
+    // DISABLED are stable env properties and safe to cache (see `isApiDiffCacheable`).
+    // the version namespace invalidates older computed results on engine changes:
+    // v2 — availability-aware results; v3 — self-referential-returnType display fix.
+    // skip the persistent cache when EITHER side is the live checkout: SchemaMain live-extracts the
+    // schema of a modified checkout of the exact same versioned id, so a snap-to-snap result cached
+    // under this key in a prior (unmodified) run would mask the user's on-disk API changes. both
+    // sides are checked (unlike `compare()`, where only the compare side can be live) because the
+    // checked-out version can appear on either side of an API diff pair.
+    return this.getOrCompute(this.apiDiffInflight, `component-compare:api-diff:v3:${baseIdStr}|${compareIdStr}`, () => this.computeAPIDiff(baseIdStr, compareIdStr), v => v !== null && ComponentCompareMain.isApiDiffCacheable(v), this.isLiveCheckout(baseIdStr) || this.isLiveCheckout(compareIdStr));
+  }
+  async computeAPIDiff(baseIdStr, compareIdStr) {
     const host = this.componentAspect.getHost();
     const [baseCompId, compareCompId] = await host.resolveMultipleComponentIds([baseIdStr, compareIdStr]);
     await this.importer.importObjectsFromMainIfExist([baseCompId, compareCompId], {
@@ -329,9 +510,9 @@ class ComponentCompareMain {
     await updateFieldsDiff(fromVersionComponent, toVersionComponent, diffResult, diffOpts);
     return diffResult;
   }
-  static async provider([graphql, component, scope, loggerMain, cli, workspace, tester, depResolver, importer, schema]) {
+  static async provider([graphql, component, scope, loggerMain, cli, workspace, tester, depResolver, importer, schema, cache]) {
     const logger = loggerMain.createLogger(_componentCompare2().ComponentCompareAspect.id);
-    const componentCompareMain = new ComponentCompareMain(component, scope, logger, tester, depResolver, importer, schema, workspace);
+    const componentCompareMain = new ComponentCompareMain(component, scope, logger, tester, depResolver, importer, schema, cache, workspace);
     cli.register(new (_diffCmd().DiffCmd)(componentCompareMain));
     graphql.register(() => (0, _componentCompare().componentCompareSchema)(componentCompareMain));
     return componentCompareMain;
@@ -339,7 +520,7 @@ class ComponentCompareMain {
 }
 exports.ComponentCompareMain = ComponentCompareMain;
 _defineProperty(ComponentCompareMain, "slots", []);
-_defineProperty(ComponentCompareMain, "dependencies", [_graphql().GraphqlAspect, _component().ComponentAspect, _scope().ScopeAspect, _logger().LoggerAspect, _cli().CLIAspect, _workspace().WorkspaceAspect, _tester().TesterAspect, _dependencyResolver().DependencyResolverAspect, _importer().ImporterAspect, _schema().SchemaAspect]);
+_defineProperty(ComponentCompareMain, "dependencies", [_graphql().GraphqlAspect, _component().ComponentAspect, _scope().ScopeAspect, _logger().LoggerAspect, _cli().CLIAspect, _workspace().WorkspaceAspect, _tester().TesterAspect, _dependencyResolver().DependencyResolverAspect, _importer().ImporterAspect, _schema().SchemaAspect, _cache().CacheAspect]);
 _defineProperty(ComponentCompareMain, "runtime", _cli().MainRuntime);
 function hasDiff(diffResult) {
   return !!(diffResult.filesDiff && diffResult.filesDiff.find(file => file.diffOutput) || diffResult.fieldsDiff);