@atlaspack/core 2.32.0 → 2.32.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @atlaspack/core
 
+## 2.32.1
+
+### Patch Changes
+
+- [#988](https://github.com/atlassian-labs/atlaspack/pull/988) [`a631dcd`](https://github.com/atlassian-labs/atlaspack/commit/a631dcd961112db072b0f8de0831efd178f355a7) Thanks [@marcins](https://github.com/marcins)! - Implement a basic package() method for the native packager
+
+- [#990](https://github.com/atlassian-labs/atlaspack/pull/990) [`5755a11`](https://github.com/atlassian-labs/atlaspack/commit/5755a114903bbf660e2ada3ae2e7ff6ceac7565b) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - changes conditional bundleGraphEdgeType value
+
+- [#987](https://github.com/atlassian-labs/atlaspack/pull/987) [`fcaf517`](https://github.com/atlassian-labs/atlaspack/commit/fcaf517010d15c9300393bcad3f9b465689d9d16) Thanks [@vykimnguyen](https://github.com/vykimnguyen)! - add get_bundle_assets
+
+- Updated dependencies [[`a631dcd`](https://github.com/atlassian-labs/atlaspack/commit/a631dcd961112db072b0f8de0831efd178f355a7), [`e9dce31`](https://github.com/atlassian-labs/atlaspack/commit/e9dce3168a8e6727a994bf2a6ac6041eb29f6027), [`59e1345`](https://github.com/atlassian-labs/atlaspack/commit/59e1345f84f43e0632d434ab42c06bf748241985), [`783118c`](https://github.com/atlassian-labs/atlaspack/commit/783118c772f45a0cf6a3b6b447fb9a0e225b25a6), [`fcaf517`](https://github.com/atlassian-labs/atlaspack/commit/fcaf517010d15c9300393bcad3f9b465689d9d16)]:
+  - @atlaspack/rust@3.21.0
+  - @atlaspack/cache@3.2.46
+  - @atlaspack/fs@2.15.46
+  - @atlaspack/logger@2.14.43
+  - @atlaspack/source-map@3.2.6
+  - @atlaspack/utils@3.3.3
+  - @atlaspack/package-manager@2.14.51
+  - @atlaspack/profiler@2.15.12
+  - @atlaspack/workers@2.14.51
+  - @atlaspack/types@2.15.41
+  - @atlaspack/graph@3.6.13
+  - @atlaspack/plugin@2.14.51
+
 ## 2.32.0
 
 ### Minor Changes

package/dist/BundleGraph.js

@@ -43,7 +43,7 @@ exports.bundleGraphEdgeTypes = {
     internal_async: 5,
     // This type is used to mark an edge between a bundle and a conditional bundle.
     // This allows efficient discovery of conditional bundles in packaging
-    conditional: 5,
+    conditional: 6,
 };
 function makeReadOnlySet(set) {
     return new Proxy(set, {
@@ -383,7 +383,7 @@ class BundleGraph {
     }
     /**
      * Serialize the bundle graph for efficient transfer to native Rust code.
-     * Returns a JSON string of nodes and an array of edges.
+     * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
      */
     serializeForNative() {
         const start = performance.now();
@@ -396,16 +396,58 @@ class BundleGraph {
             edges.push([edge.from, edge.to, edge.type]);
             next = edgeIterator.next();
         }
+        // Extract and deduplicate environments
+        const environmentMap = new Map();
+        const extractEnvironment = (envRef) => {
+            const env = (0, EnvironmentManager_1.fromEnvironmentId)(envRef);
+            const envId = env.id;
+            if (!environmentMap.has(envId)) {
+                environmentMap.set(envId, env);
+            }
+            return envId;
+        };
+        // Replace env objects with env IDs in nodes
+        const processedNodes = nodes.map((node) => {
+            const processedNode = { ...node };
+            if (node.type === 'asset' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'dependency' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            else if (node.type === 'bundle' && node.value?.env) {
+                processedNode.value = {
+                    ...node.value,
+                    env: extractEnvironment(node.value.env),
+                };
+            }
+            return processedNode;
+        });
         // Optimize nodes by omitting null/undefined values to reduce JSON size
-        const optimizedNodes = nodes.map((node) => this._omitNulls(node));
+        const optimizedNodes = processedNodes.map((node) => this._omitNulls(node));
         const nodesJson = JSON.stringify(optimizedNodes);
+        // Serialize environments as array
+        const environments = Array.from(environmentMap.values());
+        const environmentsJson = JSON.stringify(environments);
+        // Convert Map to plain object for serialization
+        const publicIdByAssetId = {};
+        for (const [assetId, publicId] of this._publicIdByAssetId) {
+            publicIdByAssetId[assetId] = publicId;
+        }
         const duration = performance.now() - start;
-        const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+        const envsSizeMB = (environmentsJson.length / (1024 * 1024)).toFixed(2);
         logger_1.default.verbose({
             origin: '@atlaspack/core',
-            message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`,
+            message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`,
         });
-        return { nodesJson, edges };
+        return { nodesJson, edges, publicIdByAssetId, environmentsJson };
     }
     /**
      * Remove null and undefined values from an object to reduce JSON size.
@@ -1164,8 +1206,36 @@ class BundleGraph {
         });
     }
     /**
-     * TODO: Document why this works like this & why visitor order matters
-     * on these use-cases.
+     * Performs a depth-first traversal of all assets and dependencies contained
+     * within a bundle. Only visits nodes that are directly contained in the bundle
+     * (connected via a `contains` edge).
+     *
+     * Entry Asset Ordering:
+     * The traversal guarantees that entry assets are visited in the exact order they
+     * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+     *
+     * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+     *    DevPackager) use this traversal to concatenate assets into the final bundle.
+     *    The traversal order determines the execution order of code in the output.
+     *    Entry assets must be processed in their defined order to ensure correct
+     *    initialization sequences.
+     *
+     * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+     *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+     *    array order, runtimes are guaranteed to be visited (and thus output) before
+     *    application entry points, ensuring the runtime infrastructure is available
+     *    when application code executes.
+     *
+     * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+     *    bundle output, which is essential for caching and build verification.
+     *
+     * The sorting only applies at the first traversal level (direct children of the
+     * start node). Subsequent levels follow standard DFS order based on the graph's
+     * edge structure.
+     *
+     * @param bundle - The bundle to traverse
+     * @param visit - Visitor callback receiving asset or dependency nodes
+     * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
      */
     traverseBundle(bundle, visit, startAsset) {
         let entries = !startAsset;

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -52,11 +52,11 @@ class AtlaspackV3 {
         return (0, rust_1.atlaspackNapiBuildAssetGraph)(this._atlaspack_napi);
     }
     loadBundleGraph(bundleGraph) {
-        const { nodesJson, edges } = bundleGraph.serializeForNative();
-        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
+        const { nodesJson, edges, publicIdByAssetId, environmentsJson } = bundleGraph.serializeForNative();
+        return (0, rust_1.atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
     }
-    package() {
-        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi);
+    package(bundleId) {
+        return (0, rust_1.atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
     }
     async respondToFsEvents(events) {
         // @ts-expect-error TS2488

package/dist/requests/PackageRequest.js

@@ -11,6 +11,8 @@ const DevDepRequest_1 = require("./DevDepRequest");
 const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
 const EnvironmentManager_1 = require("../EnvironmentManager");
 const feature_flags_1 = require("@atlaspack/feature-flags");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
 function createPackageRequest(input) {
     return {
         type: RequestTracker_1.requestTypes.package_request,
@@ -25,23 +27,38 @@ async function run({ input, api, farm, rustAtlaspack }) {
     let start = Date.now();
     let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
     let { cachePath } = (0, nullthrows_1.default)(await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let packagingResult;
     if ((0, feature_flags_1.getFeatureFlag)('nativePackager') &&
         (0, feature_flags_1.getFeatureFlag)('nativePackagerSSRDev') &&
         rustAtlaspack &&
         (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context === 'tesseract' &&
         bundle.type === 'js') {
         // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
-        await rustAtlaspack.package();
+        let result = await rustAtlaspack.package(bundle.id);
+        let error = null;
+        [packagingResult, error] = result;
+        if (error) {
+            throw new diagnostic_1.default({
+                diagnostic: error,
+            });
+        }
+        logger_1.default.verbose({
+            message: JSON.stringify(packagingResult, null, 2),
+            origin: '@atlaspack/core',
+        });
+    }
+    else {
+        packagingResult = (await runPackage({
+            bundle,
+            bundleGraphReference,
+            optionsRef,
+            configCachePath: cachePath,
+            previousDevDeps: devDeps,
+            invalidDevDeps,
+            previousInvalidations: api.getInvalidations(),
+        }));
     }
-    let { devDepRequests, configRequests, bundleInfo, invalidations } = (await runPackage({
-        bundle,
-        bundleGraphReference,
-        optionsRef,
-        configCachePath: cachePath,
-        previousDevDeps: devDeps,
-        invalidDevDeps,
-        previousInvalidations: api.getInvalidations(),
-    }));
+    let { devDepRequests, configRequests, bundleInfo, invalidations } = packagingResult;
     for (let devDepRequest of devDepRequests) {
         await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
     }

package/lib/BundleGraph.js

@@ -85,7 +85,7 @@ const bundleGraphEdgeTypes = exports.bundleGraphEdgeTypes = {
   internal_async: 5,
   // This type is used to mark an edge between a bundle and a conditional bundle.
   // This allows efficient discovery of conditional bundles in packaging
-  conditional: 5
+  conditional: 6
 };
 function makeReadOnlySet(set) {
   return new Proxy(set, {
@@ -438,7 +438,7 @@ class BundleGraph {
 
   /**
    * Serialize the bundle graph for efficient transfer to native Rust code.
-   * Returns a JSON string of nodes and an array of edges.
+   * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
    */
   serializeForNative() {
     const start = performance.now();
@@ -452,18 +452,67 @@ class BundleGraph {
       next = edgeIterator.next();
     }
 
+    // Extract and deduplicate environments
+    const environmentMap = new Map();
+    const extractEnvironment = envRef => {
+      const env = (0, _EnvironmentManager.fromEnvironmentId)(envRef);
+      const envId = env.id;
+      if (!environmentMap.has(envId)) {
+        environmentMap.set(envId, env);
+      }
+      return envId;
+    };
+
+    // Replace env objects with env IDs in nodes
+    const processedNodes = nodes.map(node => {
+      var _node$value, _node$value2, _node$value3;
+      const processedNode = {
+        ...node
+      };
+      if (node.type === 'asset' && (_node$value = node.value) !== null && _node$value !== void 0 && _node$value.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      } else if (node.type === 'dependency' && (_node$value2 = node.value) !== null && _node$value2 !== void 0 && _node$value2.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      } else if (node.type === 'bundle' && (_node$value3 = node.value) !== null && _node$value3 !== void 0 && _node$value3.env) {
+        processedNode.value = {
+          ...node.value,
+          env: extractEnvironment(node.value.env)
+        };
+      }
+      return processedNode;
+    });
+
     // Optimize nodes by omitting null/undefined values to reduce JSON size
-    const optimizedNodes = nodes.map(node => this._omitNulls(node));
+    const optimizedNodes = processedNodes.map(node => this._omitNulls(node));
     const nodesJson = JSON.stringify(optimizedNodes);
+
+    // Serialize environments as array
+    const environments = Array.from(environmentMap.values());
+    const environmentsJson = JSON.stringify(environments);
+
+    // Convert Map to plain object for serialization
+    const publicIdByAssetId = {};
+    for (const [assetId, publicId] of this._publicIdByAssetId) {
+      publicIdByAssetId[assetId] = publicId;
+    }
     const duration = performance.now() - start;
-    const sizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    const nodesSizeMB = (nodesJson.length / (1024 * 1024)).toFixed(2);
+    const envsSizeMB = (environmentsJson.length / (1024 * 1024)).toFixed(2);
     _logger().default.verbose({
       origin: '@atlaspack/core',
-      message: `serializeForNative: ${duration.toFixed(1)}ms, ${sizeMB}MB JSON, ${nodes.length} nodes, ${edges.length} edges`
+      message: `serializeForNative: ${duration.toFixed(1)}ms, ${nodesSizeMB}MB nodes, ${envsSizeMB}MB envs (${environmentMap.size} unique), ${nodes.length} nodes, ${edges.length} edges`
     });
     return {
       nodesJson,
-      edges
+      edges,
+      publicIdByAssetId,
+      environmentsJson
     };
   }
 
@@ -1152,8 +1201,36 @@ class BundleGraph {
   }
 
   /**
-   * TODO: Document why this works like this & why visitor order matters
-   * on these use-cases.
+   * Performs a depth-first traversal of all assets and dependencies contained
+   * within a bundle. Only visits nodes that are directly contained in the bundle
+   * (connected via a `contains` edge).
+   *
+   * Entry Asset Ordering:
+   * The traversal guarantees that entry assets are visited in the exact order they
+   * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+   *
+   * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+   *    DevPackager) use this traversal to concatenate assets into the final bundle.
+   *    The traversal order determines the execution order of code in the output.
+   *    Entry assets must be processed in their defined order to ensure correct
+   *    initialization sequences.
+   *
+   * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+   *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+   *    array order, runtimes are guaranteed to be visited (and thus output) before
+   *    application entry points, ensuring the runtime infrastructure is available
+   *    when application code executes.
+   *
+   * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+   *    bundle output, which is essential for caching and build verification.
+   *
+   * The sorting only applies at the first traversal level (direct children of the
+   * start node). Subsequent levels follow standard DFS order based on the graph's
+   * edge structure.
+   *
+   * @param bundle - The bundle to traverse
+   * @param visit - Visitor callback receiving asset or dependency nodes
+   * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
    */
   traverseBundle(bundle, visit, startAsset) {
     let entries = !startAsset;

package/lib/atlaspack-v3/AtlaspackV3.js

@@ -75,12 +75,14 @@ class AtlaspackV3 {
   loadBundleGraph(bundleGraph) {
     const {
       nodesJson,
-      edges
+      edges,
+      publicIdByAssetId,
+      environmentsJson
     } = bundleGraph.serializeForNative();
-    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges);
+    return (0, _rust().atlaspackNapiLoadBundleGraph)(this._atlaspack_napi, nodesJson, edges, publicIdByAssetId, environmentsJson);
   }
-  package() {
-    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi);
+  package(bundleId) {
+    return (0, _rust().atlaspackNapiPackage)(this._atlaspack_napi, bundleId);
   }
   async respondToFsEvents(events) {
     // @ts-expect-error TS2488

package/lib/requests/PackageRequest.js

@@ -23,6 +23,20 @@ function _featureFlags() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function createPackageRequest(input) {
   return {
@@ -53,24 +67,38 @@ async function run({
   let {
     cachePath
   } = (0, _nullthrows().default)(await api.runRequest((0, _AtlaspackConfigRequest.default)()));
+  let packagingResult;
   if ((0, _featureFlags().getFeatureFlag)('nativePackager') && (0, _featureFlags().getFeatureFlag)('nativePackagerSSRDev') && rustAtlaspack && (0, _EnvironmentManager.fromEnvironmentId)(bundle.env).context === 'tesseract' && bundle.type === 'js') {
     // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
-    await rustAtlaspack.package();
+    let result = await rustAtlaspack.package(bundle.id);
+    let error = null;
+    [packagingResult, error] = result;
+    if (error) {
+      throw new (_diagnostic().default)({
+        diagnostic: error
+      });
+    }
+    _logger().default.verbose({
+      message: JSON.stringify(packagingResult, null, 2),
+      origin: '@atlaspack/core'
+    });
+  } else {
+    packagingResult = await runPackage({
+      bundle,
+      bundleGraphReference,
+      optionsRef,
+      configCachePath: cachePath,
+      previousDevDeps: devDeps,
+      invalidDevDeps,
+      previousInvalidations: api.getInvalidations()
+    });
   }
   let {
     devDepRequests,
     configRequests,
     bundleInfo,
     invalidations
-  } = await runPackage({
-    bundle,
-    bundleGraphReference,
-    optionsRef,
-    configCachePath: cachePath,
-    previousDevDeps: devDeps,
-    invalidDevDeps,
-    previousInvalidations: api.getInvalidations()
-  });
+  } = packagingResult;
   for (let devDepRequest of devDepRequests) {
     await (0, _DevDepRequest.runDevDepRequest)(api, devDepRequest);
   }

package/lib/types/BundleGraph.d.ts

@@ -11,7 +11,7 @@ export declare const bundleGraphEdgeTypes: {
     readonly bundle: 3;
     readonly references: 4;
     readonly internal_async: 5;
-    readonly conditional: 5;
+    readonly conditional: 6;
 };
 export type BundleGraphEdgeType = (typeof bundleGraphEdgeTypes)[keyof typeof bundleGraphEdgeTypes];
 type InternalSymbolResolution = {
@@ -79,11 +79,13 @@ export default class BundleGraph {
     static deserialize(serialized: BundleGraphOpts): BundleGraph;
     /**
      * Serialize the bundle graph for efficient transfer to native Rust code.
-     * Returns a JSON string of nodes and an array of edges.
+     * Returns a JSON string of nodes, an array of edges, and a map of asset IDs to public IDs.
      */
     serializeForNative(): {
         nodesJson: string;
         edges: [number, number, BundleGraphEdgeType][];
+        publicIdByAssetId: Record<string, string>;
+        environmentsJson: string;
     };
     /**
      * Remove null and undefined values from an object to reduce JSON size.
@@ -148,8 +150,36 @@ export default class BundleGraph {
     getParentBundles(bundle: Bundle): Array<Bundle>;
     isAssetReachableFromBundle(asset: Asset, bundle: Bundle): boolean;
     /**
-     * TODO: Document why this works like this & why visitor order matters
-     * on these use-cases.
+     * Performs a depth-first traversal of all assets and dependencies contained
+     * within a bundle. Only visits nodes that are directly contained in the bundle
+     * (connected via a `contains` edge).
+     *
+     * Entry Asset Ordering:
+     * The traversal guarantees that entry assets are visited in the exact order they
+     * appear in `bundle.entryAssetIds`. This ordering is critical for several reasons:
+     *
+     * 1. **Code Execution Order in Packagers**: Packagers (ScopeHoistingPackager,
+     *    DevPackager) use this traversal to concatenate assets into the final bundle.
+     *    The traversal order determines the execution order of code in the output.
+     *    Entry assets must be processed in their defined order to ensure correct
+     *    initialization sequences.
+     *
+     * 2. **Runtime Injection**: Runtime assets (HMR, bundle manifests) are prepended
+     *    to `entryAssetIds` via `unshift()` in `applyRuntimes.ts`. By honoring the
+     *    array order, runtimes are guaranteed to be visited (and thus output) before
+     *    application entry points, ensuring the runtime infrastructure is available
+     *    when application code executes.
+     *
+     * 3. **Deterministic Builds**: Consistent traversal order ensures reproducible
+     *    bundle output, which is essential for caching and build verification.
+     *
+     * The sorting only applies at the first traversal level (direct children of the
+     * start node). Subsequent levels follow standard DFS order based on the graph's
+     * edge structure.
+     *
+     * @param bundle - The bundle to traverse
+     * @param visit - Visitor callback receiving asset or dependency nodes
+     * @param startAsset - Optional asset to start traversal from (defaults to bundle root)
      */
     traverseBundle<TContext>(bundle: Bundle, visit: GraphVisitor<AssetNode | DependencyNode, TContext>, startAsset?: Asset): TContext | null | undefined;
     traverse<TContext>(visit: GraphVisitor<AssetNode | DependencyNode, TContext>, start?: Asset): TContext | null | undefined;

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

@@ -1,7 +1,9 @@
 import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
+import { Diagnostic } from '@atlaspack/diagnostic';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
 import type BundleGraph from '../BundleGraph';
+import { RunPackagerRunnerResult } from '../PackagerRunner';
 export type AtlaspackV3Options = {
     fs?: AtlaspackNapiOptions['fs'];
     packageManager?: AtlaspackNapiOptions['packageManager'];
@@ -24,7 +26,7 @@ export declare class AtlaspackV3 {
     end(): void;
     buildAssetGraph(): Promise<any>;
     loadBundleGraph(bundleGraph: BundleGraph): Promise<void>;
-    package(): Promise<any>;
+    package(bundleId: string): Promise<[RunPackagerRunnerResult, Diagnostic | null]>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
     completeCacheSession(): Promise<CacheStats>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.32.0",
+  "version": "2.32.1",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -24,21 +24,21 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.9",
-    "@atlaspack/cache": "3.2.45",
+    "@atlaspack/cache": "3.2.46",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
     "@atlaspack/feature-flags": "2.28.0",
-    "@atlaspack/fs": "2.15.45",
-    "@atlaspack/graph": "3.6.12",
-    "@atlaspack/logger": "2.14.42",
-    "@atlaspack/package-manager": "2.14.50",
-    "@atlaspack/plugin": "2.14.50",
-    "@atlaspack/profiler": "2.15.11",
-    "@atlaspack/rust": "3.20.0",
-    "@atlaspack/types": "2.15.40",
-    "@atlaspack/utils": "3.3.2",
-    "@atlaspack/workers": "2.14.50",
-    "@atlaspack/source-map": "3.2.5",
+    "@atlaspack/fs": "2.15.46",
+    "@atlaspack/graph": "3.6.13",
+    "@atlaspack/logger": "2.14.43",
+    "@atlaspack/package-manager": "2.14.51",
+    "@atlaspack/plugin": "2.14.51",
+    "@atlaspack/profiler": "2.15.12",
+    "@atlaspack/rust": "3.21.0",
+    "@atlaspack/types": "2.15.41",
+    "@atlaspack/utils": "3.3.3",
+    "@atlaspack/workers": "2.14.51",
+    "@atlaspack/source-map": "3.2.6",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",