@atlaspack/core 2.34.0 → 2.35.0

package/lib/types/atlaspack-v3/AtlaspackV3.d.ts

@@ -1,4 +1,4 @@
-import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
+import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats, PackageOptions } from '@atlaspack/rust';
 import { Diagnostic } from '@atlaspack/diagnostic';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
@@ -27,7 +27,8 @@ export declare class AtlaspackV3 {
     buildAssetGraph(): Promise<any>;
     buildBundleGraph(): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
-    package(bundleId: string): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
+    updateBundleGraph(bundleGraph: BundleGraph, changedAssetIds: string[]): Promise<void>;
+    package(bundleId: string, options?: PackageOptions): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;
 }

package/lib/types/requests/BundleGraphRequest.d.ts

@@ -14,9 +14,9 @@ type RunInput = {
 } & StaticRunOpts<BundleGraphResult>;
 export type BundleGraphResult = {
     bundleGraph: InternalBundleGraph;
-    assetGraphBundlingVersion: number;
     changedAssets: Map<string, Asset>;
     assetRequests: Array<AssetGroup>;
+    didIncrementallyBundle: boolean;
 };
 type BundleGraphRequest = {
     id: string;

package/lib/types/types.d.ts

@@ -70,6 +70,7 @@ export type Target = {
     loc?: InternalSourceLocation | null | undefined;
     pipeline?: string;
     source?: FilePath | Array<FilePath>;
+    inlineRequires?: boolean;
 };
 export declare const SpecifierType: {
     readonly esm: 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.34.0",
+  "version": "2.35.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -23,22 +23,22 @@
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.12",
-    "@atlaspack/cache": "3.2.49",
+    "@atlaspack/build-cache": "2.13.13",
+    "@atlaspack/cache": "3.2.50",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.30.0",
-    "@atlaspack/fs": "2.15.49",
-    "@atlaspack/graph": "3.6.16",
-    "@atlaspack/logger": "2.14.46",
-    "@atlaspack/package-manager": "2.14.54",
-    "@atlaspack/plugin": "2.14.54",
-    "@atlaspack/profiler": "2.15.15",
-    "@atlaspack/rust": "3.23.0",
-    "@atlaspack/types": "2.15.44",
-    "@atlaspack/utils": "3.3.6",
-    "@atlaspack/workers": "2.14.54",
-    "@atlaspack/source-map": "3.2.9",
+    "@atlaspack/feature-flags": "2.30.1",
+    "@atlaspack/fs": "2.15.50",
+    "@atlaspack/graph": "3.6.17",
+    "@atlaspack/logger": "2.14.47",
+    "@atlaspack/package-manager": "2.14.55",
+    "@atlaspack/plugin": "2.14.55",
+    "@atlaspack/profiler": "2.15.16",
+    "@atlaspack/rust": "3.24.0",
+    "@atlaspack/types": "2.15.45",
+    "@atlaspack/utils": "3.3.7",
+    "@atlaspack/workers": "2.14.55",
+    "@atlaspack/source-map": "3.2.10",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/AssetGraph.ts

@@ -41,14 +41,10 @@ type InitOpts = {
 };
 
 type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
-  bundlingVersion?: number;
-  disableIncrementalBundling?: boolean;
   hash?: string | null | undefined;
 };
 
 type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
-  bundlingVersion: number;
-  disableIncrementalBundling: boolean;
   hash?: string | null | undefined;
 };
 
@@ -121,30 +117,16 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   hash: string | null | undefined;
   envCache: Map<string, Environment>;
 
-  /**
-   * Incremented when the asset graph is modified such that it requires a bundling pass.
-   */
-  #bundlingVersion: number = 0;
-  /**
-   * Force incremental bundling to be disabled.
-   */
-  #disableIncrementalBundling: boolean = false;
-
-  /**
-   * @deprecated
-   */
   safeToIncrementallyBundle: boolean = true;
 
   undeferredDependencies: Set<Dependency>;
 
   constructor(opts?: AssetGraphOpts | null) {
     if (opts) {
-      let {hash, bundlingVersion, disableIncrementalBundling, ...rest} = opts;
+      let {hash, ...rest} = opts;
       // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
-      this.#bundlingVersion = bundlingVersion ?? 0;
-      this.#disableIncrementalBundling = disableIncrementalBundling ?? false;
     } else {
       super();
       this.setRootNodeId(
@@ -167,64 +149,16 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   serialize(): SerializedAssetGraph {
     return {
       ...super.serialize(),
-      bundlingVersion: this.#bundlingVersion,
-      disableIncrementalBundling: this.#disableIncrementalBundling,
       hash: this.hash,
     };
   }
 
   /**
-   * Force incremental bundling to be disabled.
-   */
-  setDisableIncrementalBundling(disable: boolean) {
-    this.#disableIncrementalBundling = disable;
-  }
-
-  testing_getDisableIncrementalBundling(): boolean {
-    return this.#disableIncrementalBundling;
-  }
-
-  /**
-   * Make sure this asset graph is marked as needing a full bundling pass.
-   */
-  setNeedsBundling() {
-    if (!getFeatureFlag('incrementalBundlingVersioning')) {
-      // In legacy mode, we rely solely on safeToIncrementallyBundle to
-      // invalidate incremental bundling, so we skip bumping the version.
-      return;
-    }
-    this.#bundlingVersion += 1;
-  }
-
-  /**
-   * Get the current bundling version.
-   *
-   * Each bundle pass should keep this version around. Whenever an asset graph has a new version,
-   * bundling should be re-run.
-   */
-  getBundlingVersion(): number {
-    if (!getFeatureFlag('incrementalBundlingVersioning')) {
-      return 0;
-    }
-    return this.#bundlingVersion;
-  }
-
-  /**
-   * If the `bundlingVersion` has not changed since the last bundling pass,
-   * we can incrementally bundle, which will not require a full bundling pass
+   * Determine if we can incrementally bundle, which will not require a full bundling pass
    * but just update assets into the bundle graph output.
    */
-  canIncrementallyBundle(lastVersion: number): boolean {
-    if (!getFeatureFlag('incrementalBundlingVersioning')) {
-      return (
-        this.safeToIncrementallyBundle && !this.#disableIncrementalBundling
-      );
-    }
-    return (
-      this.safeToIncrementallyBundle &&
-      this.#bundlingVersion === lastVersion &&
-      !this.#disableIncrementalBundling
-    );
+  canIncrementallyBundle(): boolean {
+    return this.safeToIncrementallyBundle;
   }
 
   // Deduplicates Environments by making them referentially equal
@@ -447,13 +381,11 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
         // @ts-expect-error TS2339
         if (!ctx?.hasDeferred) {
           this.safeToIncrementallyBundle = false;
-          this.setNeedsBundling();
           delete traversedNode.hasDeferred;
         }
         actions.skipChildren();
       } else if (traversedNode.type === 'dependency') {
         this.safeToIncrementallyBundle = false;
-        this.setNeedsBundling();
         traversedNode.hasDeferred = false;
       } else if (nodeId !== traversedNodeId) {
         actions.skipChildren();

package/src/BundleGraph.ts

@@ -654,6 +654,45 @@ export default class BundleGraph {
     return {nodesJson, edges, publicIdByAssetId, environmentsJson};
   }
 
+  /**
+   * Serialize only the given asset nodes for native incremental update.
+   * Same node shape and env/omit logic as serializeForNative.
+   */
+  serializeAssetNodesForNative(assetIds: Array<string>): string {
+    const start = performance.now();
+
+    if (assetIds.length === 0) {
+      return '[]';
+    }
+
+    const nodes: Array<BundleGraphNode> = [];
+    for (const assetId of assetIds) {
+      const node = this._graph.getNodeByContentKey(assetId);
+      if (node?.type !== 'asset') {
+        continue;
+      }
+      const processedNode = {...node};
+      if (node.value?.env) {
+        processedNode.value = {
+          ...node.value,
+          env: fromEnvironmentId(node.value.env).id,
+        };
+      }
+      nodes.push(processedNode);
+    }
+    const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+    const nodesJson = JSON.stringify(optimizedNodes);
+
+    const duration = performance.now() - start;
+    const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+
+    logger.verbose({
+      origin: '@atlaspack/core',
+      message: `serializeAssetNodesForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${nodes.length} nodes`,
+    });
+    return nodesJson;
+  }
+
   /**
    * Remove null and undefined values from an object to reduce JSON size.
    * Preserves false, 0, empty strings, and arrays.

package/src/PackagerRunner.ts

@@ -62,7 +62,6 @@ import {invalidateDevDeps} from './requests/DevDepRequest';
 import {computeSourceMapRoot} from './requests/WriteBundleRequest';
 import {tracer, PluginTracer} from '@atlaspack/profiler';
 import {fromEnvironmentId} from './EnvironmentManager';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
 
 type Opts = {
   config: AtlaspackConfig;
@@ -654,21 +653,6 @@ export default class PackagerRunner {
       this.options,
     );
 
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const hash = hashString(
-        ATLASPACK_VERSION +
-          devDepHashes +
-          invalidationHash +
-          bundle.target.publicUrl +
-          bundleGraph.getHash(bundle) +
-          JSON.stringify(configResults) +
-          JSON.stringify(globalInfoResults) +
-          this.options.mode +
-          (this.options.shouldBuildLazily ? 'lazy' : 'eager'),
-      );
-      return path.join(bundle.displayName ?? bundle.name ?? bundle.id, hash);
-    }
-
     return hashString(
       ATLASPACK_VERSION +
         devDepHashes +
@@ -715,27 +699,20 @@ export default class PackagerRunner {
     let mapKey = PackagerRunner.getMapKey(cacheKey);
 
     let isLargeBlob = await this.options.cache.hasLargeBlob(contentKey);
-    let contentExists = getFeatureFlag('cachePerformanceImprovements')
-      ? isLargeBlob
-      : isLargeBlob || (await this.options.cache.has(contentKey));
+    let contentExists =
+      isLargeBlob || (await this.options.cache.has(contentKey));
     if (!contentExists) {
       return null;
     }
 
-    let mapExists = getFeatureFlag('cachePerformanceImprovements')
-      ? await this.options.cache.hasLargeBlob(mapKey)
-      : await this.options.cache.has(mapKey);
+    let mapExists = await this.options.cache.has(mapKey);
 
     return {
       contents: isLargeBlob
         ? this.options.cache.getStream(contentKey)
         : blobToStream(await this.options.cache.getBlob(contentKey)),
       map: mapExists
-        ? blobToStream(
-            getFeatureFlag('cachePerformanceImprovements')
-              ? await this.options.cache.getLargeBlob(mapKey)
-              : await this.options.cache.getBlob(mapKey),
-          )
+        ? blobToStream(await this.options.cache.getBlob(mapKey))
         : null,
     };
   }
@@ -750,13 +727,11 @@ export default class PackagerRunner {
     let hash;
     // @ts-expect-error TS2702
     let hashReferences: RegExp.matchResult | Array<string> = [];
-    let isLargeBlob = getFeatureFlag('cachePerformanceImprovements');
+    let isLargeBlob = false;
 
     // TODO: don't replace hash references in binary files??
     if (contents instanceof Readable) {
-      if (!getFeatureFlag('cachePerformanceImprovements')) {
-        isLargeBlob = true;
-      }
+      isLargeBlob = true;
 
       let boundaryStr = '';
       let h = new Hash();
@@ -782,29 +757,17 @@ export default class PackagerRunner {
       hash = hashBuffer(buffer);
       hashReferences = contents.match(HASH_REF_REGEX) ?? [];
 
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, buffer);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, buffer);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, buffer);
     } else {
       size = contents.length;
       hash = hashBuffer(contents);
       hashReferences = contents.toString().match(HASH_REF_REGEX) ?? [];
 
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.content, contents);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.content, contents);
-      }
+      await this.options.cache.setBlob(cacheKeys.content, contents);
     }
 
     if (map != null) {
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        await this.options.cache.setLargeBlob(cacheKeys.map, map);
-      } else {
-        await this.options.cache.setBlob(cacheKeys.map, map);
-      }
+      await this.options.cache.setBlob(cacheKeys.map, map);
     }
 
     let info = {
@@ -821,23 +784,14 @@ export default class PackagerRunner {
   }
 
   static getContentKey(cacheKey: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/content`;
-    }
     return hashString(`${cacheKey}:content`);
   }
 
   static getMapKey(cacheKey: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/map`;
-    }
     return hashString(`${cacheKey}:map`);
   }
 
   static getInfoKey(cacheKey: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      return `PackagerRunner/${ATLASPACK_VERSION}/${cacheKey}/info`;
-    }
     return hashString(`${cacheKey}:info`);
   }
 }

package/src/RequestTracker.ts

@@ -2,7 +2,7 @@ import invariant, {AssertionError} from 'assert';
 import path from 'path';
 
 import {deserialize, serialize} from '@atlaspack/build-cache';
-import {LMDBLiteCache, Cache} from '@atlaspack/cache';
+import {Cache} from '@atlaspack/cache';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {ContentGraph} from '@atlaspack/graph';
 import type {
@@ -12,7 +12,7 @@ import type {
   SerializedContentGraph,
   Graph,
 } from '@atlaspack/graph';
-import logger, {instrument} from '@atlaspack/logger';
+import logger from '@atlaspack/logger';
 import {hashString} from '@atlaspack/rust';
 import type {Async, EnvMap} from '@atlaspack/types';
 import {
@@ -1315,13 +1315,11 @@ export default class RequestTracker {
       return result;
     } else if (node.resultCacheKey != null && ifMatch == null) {
       let key = node.resultCacheKey;
-      if (!getFeatureFlag('cachePerformanceImprovements')) {
-        invariant(this.options.cache.hasLargeBlob(key));
-      }
+      invariant(this.options.cache.hasLargeBlob(key));
 
-      let cachedResult: T = getFeatureFlag('cachePerformanceImprovements')
-        ? nullthrows(await this.options.cache.get<T>(key))
-        : deserialize(await this.options.cache.getLargeBlob(key));
+      let cachedResult: T = deserialize(
+        await this.options.cache.getLargeBlob(key),
+      );
       node.result = cachedResult;
       return cachedResult;
     }
@@ -1559,40 +1557,15 @@ export default class RequestTracker {
   }
 
   async writeToCache(signal?: AbortSignal) {
-    const options = this.options;
-    async function runCacheImprovements<T>(
-      newPath: (cache: LMDBLiteCache) => Promise<T>,
-      oldPath: () => Promise<T>,
-    ): Promise<T> {
-      if (getFeatureFlag('cachePerformanceImprovements')) {
-        invariant(options.cache instanceof LMDBLiteCache);
-        const result = await newPath(options.cache);
-        return result;
-      } else {
-        const result = await oldPath();
-        return result;
-      }
-    }
-
     let cacheKey = getCacheKey(this.options);
-    let requestGraphKey = getFeatureFlag('cachePerformanceImprovements')
-      ? `${cacheKey}/RequestGraph`
-      : `requestGraph-${cacheKey}`;
-    let snapshotKey = getFeatureFlag('cachePerformanceImprovements')
-      ? `${cacheKey}/snapshot`
-      : `snapshot-${cacheKey}`;
+    let requestGraphKey = `requestGraph-${cacheKey}`;
+    let snapshotKey = `snapshot-${cacheKey}`;
 
     if (this.options.shouldDisableCache) {
       return;
     }
 
     let total = 0;
-    await runCacheImprovements(
-      async (cache) => {
-        await cache.getNativeRef().startWriteTransaction();
-      },
-      () => Promise.resolve(),
-    );
     try {
       report({
         type: 'cache',
@@ -1602,7 +1575,7 @@ export default class RequestTracker {
       });
 
       if (getFeatureFlag('environmentDeduplication')) {
-        await writeEnvironmentsToCache(options.cache);
+        await writeEnvironmentsToCache(this.options.cache);
       }
 
       let serialisedGraph = this.graph.serialize();
@@ -1618,27 +1591,14 @@ export default class RequestTracker {
           throw new Error('Serialization was aborted');
         }
 
-        await runCacheImprovements(
-          (cache) => {
-            instrument(
-              `RequestTracker::writeToCache::cache.put(${key})`,
-              () => {
-                cache.getNativeRef().putNoConfirm(key, serialize(contents));
-              },
-            );
-            return Promise.resolve();
-          },
-          async () => {
-            await this.options.cache.setLargeBlob(
-              key,
-              serialize(contents),
-              signal
-                ? {
-                    signal: signal,
-                  }
-                : undefined,
-            );
-          },
+        await this.options.cache.setLargeBlob(
+          key,
+          serialize(contents),
+          signal
+            ? {
+                signal: signal,
+              }
+            : undefined,
         );
 
         total += 1;
@@ -1720,18 +1680,6 @@ export default class RequestTracker {
         nodes: undefined,
       });
 
-      await runCacheImprovements(
-        () =>
-          serialiseAndSet(`${cacheKey}/cache_metadata`, {
-            version: ATLASPACK_VERSION,
-            entries: this.options.entries,
-            mode: this.options.mode,
-            shouldBuildLazily: this.options.shouldBuildLazily,
-            watchBackend: this.options.watchBackend,
-          }),
-        () => Promise.resolve(),
-      );
-
       let opts = getWatcherOptions(this.options);
       let snapshotPath = path.join(this.options.cacheDir, snapshotKey + '.txt');
 
@@ -1743,13 +1691,6 @@ export default class RequestTracker {
     } catch (err: any) {
       // If we have aborted, ignore the error and continue
       if (!signal?.aborted) throw err;
-    } finally {
-      await runCacheImprovements(
-        async (cache) => {
-          await cache.getNativeRef().commitWriteTransaction();
-        },
-        () => Promise.resolve(),
-      );
     }
 
     report({type: 'cache', phase: 'end', total, size: this.graph.nodes.length});
@@ -1783,18 +1724,6 @@ export function getWatcherOptions({
 }
 
 function getCacheKey(options: AtlaspackOptions) {
-  if (getFeatureFlag('cachePerformanceImprovements')) {
-    const hash = hashString(
-      `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${
-        options.mode
-      }:${options.shouldBuildLazily ? 'lazy' : 'eager'}:${
-        options.watchBackend ?? ''
-      }`,
-    );
-
-    return `RequestTracker/${ATLASPACK_VERSION}/${hash}`;
-  }
-
   return hashString(
     `${ATLASPACK_VERSION}:${JSON.stringify(options.entries)}:${options.mode}:${
       options.shouldBuildLazily ? 'lazy' : 'eager'
@@ -1803,10 +1732,6 @@ function getCacheKey(options: AtlaspackOptions) {
 }
 
 function getRequestGraphNodeKey(index: number, cacheKey: string) {
-  if (getFeatureFlag('cachePerformanceImprovements')) {
-    return `${cacheKey}/RequestGraph/nodes/${index}`;
-  }
-
   return `requestGraph-nodes-${index}-${cacheKey}`;
 }
 
@@ -1823,15 +1748,9 @@ export async function readAndDeserializeRequestGraph(
   let bufferLength = 0;
 
   const getAndDeserialize = async (key: string) => {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const buffer = await cache.getBlob(key);
-      bufferLength += Buffer.byteLength(buffer);
-      return deserialize(buffer);
-    } else {
-      const buffer = await cache.getLargeBlob(key);
-      bufferLength += Buffer.byteLength(buffer);
-      return deserialize(buffer);
-    }
+    const buffer = await cache.getLargeBlob(key);
+    bufferLength += Buffer.byteLength(buffer);
+    return deserialize(buffer);
   };
 
   let serializedRequestGraph = await getAndDeserialize(requestGraphKey);
@@ -1867,14 +1786,10 @@ async function loadRequestGraph(
   }
 
   let cacheKey = getCacheKey(options);
-  let requestGraphKey = getFeatureFlag('cachePerformanceImprovements')
-    ? `${cacheKey}/RequestGraph`
-    : `requestGraph-${cacheKey}`;
+  let requestGraphKey = `requestGraph-${cacheKey}`;
 
   let timeout;
-  const snapshotKey = getFeatureFlag('cachePerformanceImprovements')
-    ? `${cacheKey}/snapshot`
-    : `snapshot-${cacheKey}`;
+  const snapshotKey = `snapshot-${cacheKey}`;
   const snapshotPath = path.join(options.cacheDir, snapshotKey + '.txt');
 
   const commonMeta = {
@@ -1901,9 +1816,8 @@ async function loadRequestGraph(
     await loadEnvironmentsFromCache(options.cache);
   }
 
-  const hasRequestGraphInCache = getFeatureFlag('cachePerformanceImprovements')
-    ? await options.cache.has(requestGraphKey)
-    : await options.cache.hasLargeBlob(requestGraphKey);
+  const hasRequestGraphInCache =
+    await options.cache.hasLargeBlob(requestGraphKey);
 
   if (hasRequestGraphInCache) {
     try {

package/src/TargetDescriptor.schema.ts

@@ -121,6 +121,9 @@ export const PACKAGE_DESCRIPTOR_SCHEMA: SchemaObject = {
         type: 'string',
       },
     },
+    inlineRequires: {
+      type: 'boolean',
+    },
   },
   additionalProperties: false,
 };

package/src/UncommittedAsset.ts

@@ -28,12 +28,7 @@ import {ATLASPACK_VERSION} from './constants';
 import {createAsset, createAssetIdFromOptions} from './assetUtils';
 import {BundleBehaviorNames} from './types';
 import {invalidateOnFileCreateToInternal, createInvalidations} from './utils';
-import {
-  ProjectPath,
-  fromProjectPath,
-  fromProjectPathRelative,
-} from './projectPath';
-import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {ProjectPath, fromProjectPath} from './projectPath';
 import {fromEnvironmentId} from './EnvironmentManager';
 
 type UncommittedAssetOptions = {
@@ -308,11 +303,6 @@ export default class UncommittedAsset {
   }
 
   getCacheKey(key: string): string {
-    if (getFeatureFlag('cachePerformanceImprovements')) {
-      const filePath = fromProjectPathRelative(this.value.filePath);
-      return `Asset/${ATLASPACK_VERSION}/${filePath}/${this.value.id}/${key}`;
-    }
-
     return hashString(ATLASPACK_VERSION + key + this.value.id);
   }