@atlaspack/core 2.30.3-dev-swc44-3ef36b21e.0 → 2.31.1-dev-swc44-b0b390313.0

package/CHANGELOG.md

@@ -1,5 +1,34 @@
 # @atlaspack/core
 
+## 2.31.0
+
+### Minor Changes
+
+- [#934](https://github.com/atlassian-labs/atlaspack/pull/934) [`02cc8b3`](https://github.com/atlassian-labs/atlaspack/commit/02cc8b32c06ca6b51806b33f6f707ca06e55e957) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add experimental native persistent cache for Atlaspack V3.
+
+- [#934](https://github.com/atlassian-labs/atlaspack/pull/934) [`02cc8b3`](https://github.com/atlassian-labs/atlaspack/commit/02cc8b32c06ca6b51806b33f6f707ca06e55e957) Thanks [@mattcompiles](https://github.com/mattcompiles)! - Add new Transformer `setup` method and deprecate `loadConfig`.
+
+  Atlaspack is moving to a pure Transformer model to improve caching performance and consistency.
+  The old `loadConfig` method which ran once per Asset goes against this behaviour is now deprecated.
+  The new `setup` method runs once per Transformer instance, allowing for better caching and performance optimizations.
+
+### Patch Changes
+
+- Updated dependencies [[`515149d`](https://github.com/atlassian-labs/atlaspack/commit/515149d0a0767d844af803efdc611646780ad0fe), [`02cc8b3`](https://github.com/atlassian-labs/atlaspack/commit/02cc8b32c06ca6b51806b33f6f707ca06e55e957), [`02cc8b3`](https://github.com/atlassian-labs/atlaspack/commit/02cc8b32c06ca6b51806b33f6f707ca06e55e957)]:
+  - @atlaspack/rust@3.16.0
+  - @atlaspack/feature-flags@2.27.5
+  - @atlaspack/cache@3.2.41
+  - @atlaspack/fs@2.15.41
+  - @atlaspack/logger@2.14.38
+  - @atlaspack/source-map@3.2.1
+  - @atlaspack/utils@3.2.7
+  - @atlaspack/graph@3.6.8
+  - @atlaspack/plugin@2.14.46
+  - @atlaspack/profiler@2.15.7
+  - @atlaspack/types@2.15.36
+  - @atlaspack/workers@2.14.46
+  - @atlaspack/package-manager@2.14.46
+
 ## 2.30.2
 
 ### Patch Changes

package/dist/Atlaspack.js

@@ -430,6 +430,7 @@ class Atlaspack {
                     return result;
                 },
                 unstable_requestStats: __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").flushStats(),
+                nativeCacheStats: await this.rustAtlaspack?.completeCacheSession(),
                 scopeHoistingStats,
             };
             // @ts-expect-error TS2345
@@ -452,6 +453,7 @@ class Atlaspack {
                 type: 'buildFailure',
                 diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
                 unstable_requestStats: __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").flushStats(),
+                nativeCacheStats: await this.rustAtlaspack?.completeCacheSession(),
             };
             // @ts-expect-error TS2345
             await __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report(event);

package/dist/Transformation.js

@@ -60,6 +60,10 @@ const assert_1 = __importDefault(require("assert"));
 const profiler_1 = require("@atlaspack/profiler");
 const source_map_1 = __importDefault(require("@atlaspack/source-map"));
 const feature_flags_1 = require("@atlaspack/feature-flags");
+const build_cache_1 = require("@atlaspack/build-cache");
+// Global setup config are not file-specific, so we only need to
+// load them once per build.
+const setupConfig = (0, build_cache_1.createBuildCache)();
 class Transformation {
     constructor({ request, options, config, workerApi }) {
         this.configs = new Map();
@@ -357,11 +361,30 @@ class Transformation {
         return nextPipeline;
     }
     async loadTransformerConfig(transformer, isSource) {
+        // Only load setup config for a transformer once per build.
+        let config = setupConfig.get(transformer.name);
+        if (config == null && transformer.plugin.setup != null) {
+            config = (0, InternalConfig_1.createConfig)({
+                plugin: transformer.name,
+                searchPath: (0, projectPath_1.toProjectPathUnsafe)('index'),
+                // Consider project setup config as source
+                isSource: true,
+            });
+            await (0, ConfigRequest_1.loadPluginSetup)(transformer.name, transformer.plugin.setup, config, this.options);
+            setupConfig.set(transformer.name, config);
+        }
+        if (config != null) {
+            for (let devDep of config.devDeps) {
+                await this.addDevDependency(devDep);
+            }
+            // `loadConfig` is not called for setup configs
+            return config;
+        }
         let loadConfig = transformer.plugin.loadConfig;
         if (!loadConfig) {
             return;
         }
-        let config = (0, InternalConfig_1.createConfig)({
+        config = (0, InternalConfig_1.createConfig)({
             plugin: transformer.name,
             isSource,
             // @ts-expect-error TS2322

package/dist/atlaspack-v3/AtlaspackV3.js

@@ -59,5 +59,8 @@ class AtlaspackV3 {
         }
         return needsRebuild;
     }
+    async completeCacheSession() {
+        return (await (0, rust_1.atlaspackNapiCompleteSession)(this._atlaspack_napi));
+    }
 }
 exports.AtlaspackV3 = AtlaspackV3;

package/dist/atlaspack-v3/NapiWorkerPool.js

@@ -45,6 +45,16 @@ class NapiWorkerPool {
             __classPrivateFieldGet(this, _NapiWorkerPool_napiWorkers, "f").push(new Promise((res) => worker.once('message', res)));
         }
     }
+    clearAllWorkerState() {
+        return Promise.all(__classPrivateFieldGet(this, _NapiWorkerPool_workers, "f").map((worker) => new Promise((res) => {
+            worker.postMessage('clearState');
+            worker.once('message', (message) => {
+                if (message == 'stateCleared') {
+                    res();
+                }
+            });
+        })));
+    }
     workerCount() {
         return __classPrivateFieldGet(this, _NapiWorkerPool_workerCount, "f");
     }

package/dist/atlaspack-v3/worker/compat/plugin-config.js

@@ -13,32 +13,20 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _PluginConfig_projectRoot, _PluginConfig_inner;
+var _PluginConfig_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginConfig = void 0;
 const Config_1 = __importDefault(require("../../../public/Config"));
+const InternalConfig_1 = require("../../../InternalConfig");
 class PluginConfig {
-    constructor({ env, isSource, searchPath, projectRoot, fs, packageManager, }) {
-        // @ts-expect-error TS2564
-        _PluginConfig_projectRoot.set(this, void 0);
+    constructor(configOpts, options) {
         _PluginConfig_inner.set(this, void 0);
-        this.env = env;
-        this.isSource = isSource;
-        this.searchPath = searchPath;
-        __classPrivateFieldSet(this, _PluginConfig_inner, new Config_1.default(
-        // @ts-expect-error TS2345
-        {
-            invalidateOnConfigKeyChange: [],
-            invalidateOnFileCreate: [],
-            invalidateOnFileChange: new Set(),
-            devDeps: [],
-            searchPath: searchPath.replace(projectRoot + '/', ''),
-        }, {
-            projectRoot,
-            inputFS: fs,
-            outputFS: fs,
-            packageManager,
-        }), "f");
+        let internalConfig = (0, InternalConfig_1.createConfig)(configOpts);
+        this.isSource = internalConfig.isSource;
+        this.searchPath = internalConfig.searchPath;
+        // @ts-expect-error TS2564
+        this.env = internalConfig.env;
+        __classPrivateFieldSet(this, _PluginConfig_inner, new Config_1.default(internalConfig, options), "f");
     }
     // eslint-disable-next-line no-unused-vars
     invalidateOnFileChange(filePath) { }
@@ -73,4 +61,4 @@ class PluginConfig {
     }
 }
 exports.PluginConfig = PluginConfig;
-_PluginConfig_projectRoot = new WeakMap(), _PluginConfig_inner = new WeakMap();
+_PluginConfig_inner = new WeakMap();

package/dist/atlaspack-v3/worker/compat/plugin-options.js

@@ -25,18 +25,21 @@ class PluginOptions {
         if (!('projectRoot' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.projectRoot');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").projectRoot;
     }
     get packageManager() {
         if (!('packageManager' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.packageManager');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").packageManager;
     }
     get mode() {
         if (!('mode' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.mode');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").mode;
     }
     get parcelVersion() {
@@ -44,30 +47,35 @@ class PluginOptions {
             return 'UNKNOWN VERSION';
             // throw new Error('PluginOptions.parcelVersion');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").parcelVersion;
     }
     get hmrOptions() {
         if (!('hmrOptions' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.hmrOptions');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").hmrOptions;
     }
     get serveOptions() {
         if (!('serveOptions' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.serveOptions');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").serveOptions;
     }
     get shouldBuildLazily() {
         if (!('shouldBuildLazily' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.shouldBuildLazily');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").shouldBuildLazily;
     }
     get shouldAutoInstall() {
         if (!('shouldAutoInstall' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.shouldAutoInstall');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").shouldAutoInstall;
     }
     get logLevel() {
@@ -80,40 +88,47 @@ class PluginOptions {
         if (!('cacheDir' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.cacheDir');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").cacheDir;
     }
     get inputFS() {
         if (!('inputFS' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.inputFS');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").inputFS;
     }
     get outputFS() {
         if (!('outputFS' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.outputFS');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").outputFS;
     }
     get instanceId() {
         if (!('instanceId' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.instanceId');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").instanceId;
     }
     get detailedReport() {
         if (!('detailedReport' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.detailedReport');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").detailedReport;
     }
     get featureFlags() {
         if (!('featureFlags' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
             throw new Error('PluginOptions.featureFlags');
         }
+        this.used = true;
         return __classPrivateFieldGet(this, _PluginOptions_options, "f").featureFlags;
     }
     constructor(options) {
         _PluginOptions_options.set(this, void 0);
+        this.used = false;
         // @ts-expect-error TS2322
         __classPrivateFieldSet(this, _PluginOptions_options, options, "f");
     }

package/dist/atlaspack-v3/worker/side-effect-detector.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultDetector = exports.SideEffectDetector = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * Side effect detector using AsyncLocalStorage to track filesystem and environment variable
+ * access across concurrent async operations in a Node.js worker thread.
+ *
+ * Usage:
+ *   const detector = new SideEffectDetector();
+ *   detector.install();
+ *
+ *   const [result, sideEffects] = await detector.monitorSideEffects(async () => {
+ *     return await someOperation();
+ *   });
+ *
+ *   console.log(sideEffects.fsUsage);   // Array of filesystem accesses
+ *   console.log(sideEffects.envUsage);  // Array of environment variable accesses
+ */
+class SideEffectDetector {
+    constructor() {
+        this.asyncStorage = new async_hooks_1.AsyncLocalStorage();
+        this.patchesInstalled = false;
+        this.originalMethods = {};
+    }
+    /**
+     * Install global patches for filesystem and environment variable monitoring.
+     * This should be called once when the worker starts up.
+     */
+    install() {
+        if (this.patchesInstalled) {
+            return;
+        }
+        this._patchFilesystem();
+        this._patchProcessEnv();
+        this.patchesInstalled = true;
+    }
+    /**
+     * Monitor side effects for an async operation.
+     *
+     * @param {Function} fn - Async function to monitor
+     * @param {Object} options - Optional configuration
+     * @param {string} options.label - Optional label for debugging
+     * @returns {Promise<[any, SideEffects]>} Tuple of [result, sideEffects]
+     */
+    monitorSideEffects(packageName, fn) {
+        if (!this.patchesInstalled) {
+            throw new Error('SideEffectDetector: install() must be called before monitorSideEffects()');
+        }
+        const context = {
+            fsUsage: [],
+            envUsage: {
+                vars: new Set(),
+                didEnumerate: false,
+            },
+            packageName: packageName,
+        };
+        return this.asyncStorage.run(context, async () => {
+            const result = await fn();
+            return [result, context];
+        });
+    }
+    /**
+     * Get the current monitoring context, if any.
+     * Useful for debugging or custom instrumentation.
+     *
+     * @returns {Object|null} Current context or null if not monitoring
+     */
+    getCurrentContext() {
+        return this.asyncStorage.getStore() || null;
+    }
+    /**
+     * Check if currently monitoring side effects.
+     *
+     * @returns {boolean}
+     */
+    isMonitoring() {
+        return this.asyncStorage.getStore() !== undefined;
+    }
+    /**
+     * Patch filesystem methods to record access.
+     * @private
+     */
+    _patchFilesystem() {
+        // Inline require this to avoid babel transformer issue
+        const fs = require('fs');
+        const methodsToPatch = [
+            // Sync methods
+            'readFileSync',
+            'writeFileSync',
+            'appendFileSync',
+            'existsSync',
+            'statSync',
+            'lstatSync',
+            'readdirSync',
+            'mkdirSync',
+            'rmdirSync',
+            'unlinkSync',
+            'copyFileSync',
+            'renameSync',
+            'chmodSync',
+            'chownSync',
+            // Async methods
+            'readFile',
+            'writeFile',
+            'appendFile',
+            'stat',
+            'lstat',
+            'readdir',
+            'mkdir',
+            'rmdir',
+            'unlink',
+            'copyFile',
+            'rename',
+            'chmod',
+            'chown',
+        ];
+        methodsToPatch.forEach((method) => {
+            if (typeof fs[method] === 'function') {
+                this.originalMethods[method] = fs[method];
+                const self = this;
+                // @ts-expect-error Dynamic method patching
+                fs[method] = function (path, ...args) {
+                    // Record filesystem access in current context
+                    const context = self.asyncStorage.getStore();
+                    if (context) {
+                        context.fsUsage.push({
+                            method,
+                            path: typeof path === 'string' ? path : path?.toString(),
+                        });
+                    }
+                    return self.originalMethods[method].call(this, path, ...args);
+                };
+            }
+        });
+        // Handle fs.promises methods
+        if (fs.promises) {
+            const promiseMethodsToPatch = [
+                'readFile',
+                'writeFile',
+                'appendFile',
+                'stat',
+                'lstat',
+                'readdir',
+                'mkdir',
+                'rmdir',
+                'unlink',
+                'copyFile',
+                'rename',
+                'chmod',
+                'chown',
+            ];
+            const promises = fs.promises;
+            promiseMethodsToPatch.forEach((method) => {
+                if (typeof promises[method] === 'function') {
+                    const originalKey = `promises_${method}`;
+                    this.originalMethods[originalKey] = promises[method];
+                    // eslint-disable-next-line @typescript-eslint/no-this-alias
+                    const self = this;
+                    promises[method] = function (path, ...args) {
+                        const context = self.asyncStorage.getStore();
+                        if (context) {
+                            context.fsUsage.push({
+                                method: `promises.${method}`,
+                                path: typeof path === 'string' ? path : String(path),
+                            });
+                        }
+                        return self.originalMethods[originalKey].call(this, path, ...args);
+                    };
+                }
+            });
+        }
+    }
+    /**
+     * Patch process.env to record environment variable access.
+     * @private
+     */
+    _patchProcessEnv() {
+        if (this.originalMethods.processEnv) {
+            return; // Already patched
+        }
+        this.originalMethods.processEnv = process.env;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        // The following environment variables are allowed to be accessed by transformers
+        const allowedVars = new Set([
+            'ATLASPACK_ENABLE_SENTRY',
+            // TODO we should also add the other atlaspack env vars here
+            'NODE_V8_COVERAGE',
+            'VSCODE_INSPECTOR_OPTIONS',
+            'NODE_INSPECTOR_IPC',
+            'FORCE_COLOR',
+            'NO_COLOR',
+            'TTY',
+        ]);
+        // Create a proxy that intercepts property access
+        process.env = new Proxy(this.originalMethods.processEnv, {
+            get(target, property) {
+                const context = self.asyncStorage.getStore();
+                if (context && typeof property === 'string') {
+                    // Only record if this is a real environment variable access
+                    // (not internal properties like 'constructor', 'valueOf', etc.)
+                    if (!allowedVars.has(property) &&
+                        (property in target || !property.startsWith('_'))) {
+                        context.envUsage.vars.add(property);
+                    }
+                }
+                return target[property];
+            },
+            set(target, property, value) {
+                const context = self.asyncStorage.getStore();
+                if (context && typeof property === 'string') {
+                    if (!allowedVars.has(property) && property in target) {
+                        context.envUsage.vars.add(property);
+                    }
+                }
+                target[property] = value;
+                return true;
+            },
+            has(target, property) {
+                const context = self.asyncStorage.getStore();
+                if (context && typeof property === 'string') {
+                    if (!allowedVars.has(property) && property in target) {
+                        context.envUsage.vars.add(property);
+                    }
+                }
+                return property in target;
+            },
+            ownKeys(target) {
+                const context = self.asyncStorage.getStore();
+                if (context) {
+                    context.envUsage.didEnumerate = true;
+                }
+                return Object.keys(target);
+            },
+        });
+    }
+}
+exports.SideEffectDetector = SideEffectDetector;
+/**
+ * Default instance for convenience. Most workers will only need one detector.
+ */
+exports.defaultDetector = new SideEffectDetector();