@atlaspack/core 2.30.2 → 2.31.0

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

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultDetector = exports.SideEffectDetector = void 0;
+function _async_hooks() {
+  const data = require("async_hooks");
+  _async_hooks = function () {
+    return data;
+  };
+  return data;
+}
+/**
+ * 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().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 === null || path === void 0 ? void 0 : 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);
+      }
+    });
+  }
+}
+
+/**
+ * Default instance for convenience. Most workers will only need one detector.
+ */
+exports.SideEffectDetector = SideEffectDetector;
+const defaultDetector = exports.defaultDetector = new SideEffectDetector();

package/lib/atlaspack-v3/worker/worker.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.AtlaspackWorker = void 0;
+var _sideEffectDetector = require("./side-effect-detector");
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -51,6 +52,12 @@ var _compat = require("./compat");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable import/first */
+
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new _sideEffectDetector.SideEffectDetector();
+sideEffectDetector.install();
+
 // @ts-expect-error TS2305
 
 const CONFIG = Symbol.for('parcel-plugin-config');
@@ -59,17 +66,26 @@ class AtlaspackWorker {
   #transformers;
   #fs;
   #packageManager;
+  #options;
+  #sideEffectDetector;
   constructor() {
     this.#resolvers = new Map();
     this.#transformers = new Map();
     this.#fs = new (_fs().NodeFS)();
     this.#packageManager = new (_packageManager().NodePackageManager)(this.#fs, '/');
+    this.#sideEffectDetector = sideEffectDetector; // Use the global detector that was installed before imports
+  }
+
+  clearState() {
+    this.#resolvers.clear();
+    this.#transformers.clear();
+    this.#options = undefined;
   }
   loadPlugin = (0, _jsCallable.jsCallable)(async ({
     kind,
     specifier,
     resolveFrom,
-    featureFlags
+    options
   }) => {
     // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
     let resolvedModule = await this.#packageManager.require(specifier, resolveFrom, {
@@ -88,17 +104,21 @@ class AtlaspackWorker {
     } else {
       throw new Error(`Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`);
     }
-    // Set feature flags in the worker process
-    // if (featureFlags) {
+    if (this.#options == null) {
+      this.#options = {
+        ...options,
+        inputFS: this.#fs,
+        outputFS: this.#fs,
+        packageManager: this.#packageManager,
+        shouldAutoInstall: false
+      };
+    }
+
     // Set feature flags in the worker process
     let featureFlagsModule = await this.#packageManager.require('@atlaspack/feature-flags', __filename, {
       shouldAutoInstall: false
     });
-    featureFlagsModule.setFeatureFlags(featureFlags);
-    // const {setFeatureFlags} = await import('@atlaspack/feature-flags');
-    // setFeatureFlags(featureFlags);
-    // }
-
+    featureFlagsModule.setFeatureFlags(options.featureFlags);
     switch (kind) {
       case 'resolver':
         this.#resolvers.set(specifier, {
@@ -106,53 +126,38 @@ class AtlaspackWorker {
         });
         break;
       case 'transformer':
-        this.#transformers.set(specifier, {
-          transformer: instance
-        });
-        break;
+        {
+          return this.initializeTransformer(instance, specifier);
+        }
     }
   });
   runResolverResolve = (0, _jsCallable.jsCallable)(async ({
     key,
     dependency: napiDependency,
     specifier,
-    pipeline,
-    pluginOptions
+    pipeline
   }) => {
     const state = this.#resolvers.get(key);
     if (!state) {
       throw new Error(`Resolver not found: ${key}`);
     }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, pluginOptions.projectRoot);
-      state.packageManager = packageManager;
-    }
     const env = new _compat.Environment(napiDependency.env);
     const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...pluginOptions,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
+      options: new _compat.PluginOptions(this.options)
     };
     if (!('config' in state)) {
       var _state$resolver$loadC, _state$resolver;
       // @ts-expect-error TS2345
       state.config = await ((_state$resolver$loadC = (_state$resolver = state.resolver).loadConfig) === null || _state$resolver$loadC === void 0 ? void 0 : _state$resolver$loadC.call(_state$resolver, {
         config: new _compat.PluginConfig({
-          env,
+          env: napiDependency.env,
+          plugin: key,
           isSource: true,
-          searchPath: specifier,
-          projectRoot: pluginOptions.projectRoot,
-          fs: this.#fs,
-          packageManager
-        }),
+          searchPath: 'index'
+        }, this.options),
         ...defaultOptions
       }));
     }
@@ -198,54 +203,55 @@ class AtlaspackWorker {
   });
   runTransformerTransform = (0, _jsCallable.jsCallable)(async ({
     key,
-    env: napiEnv,
-    options,
     asset: innerAsset
   }, contents, map) => {
-    var _transformer$loadConf;
-    const state = this.#transformers.get(key);
-    if (!state) {
+    const instance = this.#transformers.get(key);
+    if (!instance) {
       throw new Error(`Transformer not found: ${key}`);
     }
-    let packageManager = state.packageManager;
-    if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
-      state.packageManager = packageManager;
-    }
-    const transformer = state.transformer;
+    let {
+      transformer,
+      config,
+      allowedEnv = new Set()
+    } = instance;
+    let cacheBailouts = [];
     const resolveFunc = (from, to) => {
       let customRequire = _module().createRequire(from);
       let resolvedPath = customRequire.resolve(to);
+      // Tranformer not cacheable due to use of the resolve function
+
+      cacheBailouts.push(`resolve(${from}, ${to})`);
       return Promise.resolve(resolvedPath);
     };
-    const env = new _compat.Environment(napiEnv);
-    const mutableAsset = new _compat.MutableAsset(innerAsset,
+    const env = new _compat.Environment(innerAsset.env);
+    let mutableAsset = new _compat.MutableAsset(innerAsset,
     // @ts-expect-error TS2345
-    contents, env, this.#fs, map, options.projectRoot);
+    contents, env, this.#fs, map, this.options.projectRoot);
+    const pluginOptions = new _compat.PluginOptions(this.options);
     const defaultOptions = {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
-      options: new _compat.PluginOptions({
-        ...options,
-        packageManager,
-        shouldAutoInstall: false,
-        inputFS: this.#fs,
-        outputFS: this.#fs
-      })
+      options: pluginOptions
     };
+    if (transformer.loadConfig) {
+      if (config != null) {
+        throw new Error(`Transformer (${key}) should not implement 'setup' and 'loadConfig'`);
+      }
+      // @ts-expect-error TS2345
+      config = await transformer.loadConfig({
+        config: new _compat.PluginConfig({
+          plugin: key,
+          isSource: innerAsset.isSource,
+          searchPath: innerAsset.filePath,
+          env
+        }, this.options),
+        ...defaultOptions
+      });
 
-    // @ts-expect-error TS2345
-    const config = await ((_transformer$loadConf = transformer.loadConfig) === null || _transformer$loadConf === void 0 ? void 0 : _transformer$loadConf.call(transformer, {
-      config: new _compat.PluginConfig({
-        env,
-        isSource: true,
-        searchPath: innerAsset.filePath,
-        projectRoot: options.projectRoot,
-        fs: this.#fs,
-        packageManager
-      }),
-      ...defaultOptions
-    }));
+      // Transformer uses the deprecated loadConfig API, so mark as not
+      // cachable
+      cacheBailouts.push(`Transformer.loadConfig`);
+    }
     if (transformer.parse) {
       const ast = await transformer.parse({
         // @ts-expect-error TS2322
@@ -257,14 +263,32 @@ class AtlaspackWorker {
       if (ast) {
         mutableAsset.setAST(ast);
       }
+      cacheBailouts.push(`Transformer.parse`);
     }
-    const result = await state.transformer.transform({
+    const [result, sideEffects] = await this.#sideEffectDetector.monitorSideEffects(key, () => transformer.transform({
       // @ts-expect-error TS2322
       asset: mutableAsset,
       config,
       resolve: resolveFunc,
       ...defaultOptions
-    });
+    }));
+    if (sideEffects.envUsage.didEnumerate) {
+      cacheBailouts.push(`Env access: enumeration of process.env`);
+    }
+    for (let variable of sideEffects.envUsage.vars) {
+      if (variable in allowedEnv) {
+        continue;
+      }
+      cacheBailouts.push(`Env access: ${variable}`);
+    }
+    for (let {
+      method,
+      path
+    } of sideEffects.fsUsage) {
+      cacheBailouts.push(`FS usage: ${method}(${path})`);
+    }
+    (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+    (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
     if (transformer.generate) {
       const ast = await mutableAsset.getAST();
       if (ast) {
@@ -287,8 +311,6 @@ class AtlaspackWorker {
         }
       }
     }
-    (0, _assert().default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
-    (0, _assert().default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
     let assetBuffer = await mutableAsset.getBuffer();
 
     // If the asset has no code, we set the buffer to null, which we can
@@ -296,6 +318,10 @@ class AtlaspackWorker {
     if (assetBuffer.length === 0) {
       assetBuffer = null;
     }
+    if (pluginOptions.used) {
+      // Plugin options accessed, so not cachable
+      cacheBailouts.push(`Plugin options accessed`);
+    }
     return [{
       id: mutableAsset.id,
       bundleBehavior: _compat.bundleBehaviorMap.intoNullable(mutableAsset.bundleBehavior),
@@ -315,8 +341,57 @@ class AtlaspackWorker {
     // Only send back the map if it has changed
     mutableAsset.isMapDirty ?
     // @ts-expect-error TS2533
-    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : ''];
+    JSON.stringify((await mutableAsset.getMap()).toVLQ()) : '',
+    // Limit to first 10 bailouts
+    cacheBailouts.slice(0, 10)];
   });
+  get options() {
+    if (this.#options == null) {
+      throw new Error('Plugin options have not been initialized');
+    }
+    return this.#options;
+  }
+  async initializeTransformer(instance, specifier) {
+    let transformer = instance;
+    let setup, config, allowedEnv;
+    let packageManager = new (_packageManager().NodePackageManager)(this.#fs, this.options.projectRoot);
+    if (transformer.setup) {
+      var _setupResult$env;
+      let setupResult = await transformer.setup({
+        logger: new _compat.PluginLogger(),
+        options: new _compat.PluginOptions({
+          ...this.options,
+          shouldAutoInstall: false,
+          inputFS: this.#fs,
+          outputFS: this.#fs,
+          packageManager
+        }),
+        config: new _compat.PluginConfig({
+          plugin: specifier,
+          searchPath: 'index',
+          // Consider project setup config as source
+          isSource: true
+        }, this.options)
+      });
+      config = setupResult === null || setupResult === void 0 ? void 0 : setupResult.config;
+      allowedEnv = Object.fromEntries((setupResult === null || setupResult === void 0 || (_setupResult$env = setupResult.env) === null || _setupResult$env === void 0 ? void 0 : _setupResult$env.map(env => [env, process.env[env]])) || []);
+
+      // Always add the following env vars to the cache key
+      allowedEnv['NODE_ENV'] = process.env['NODE_ENV'];
+      setup = {
+        conditions: setupResult === null || setupResult === void 0 ? void 0 : setupResult.conditions,
+        config,
+        env: allowedEnv
+      };
+    }
+    this.#transformers.set(specifier, {
+      transformer,
+      config,
+      packageManager,
+      allowedEnv
+    });
+    return setup;
+  }
 }
 
 // Create napi worker and send it back to main thread
@@ -324,5 +399,10 @@ exports.AtlaspackWorker = AtlaspackWorker;
 const worker = new AtlaspackWorker();
 const napiWorker = napi().newNodejsWorker(worker);
 _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);
-
-// @ts-expect-error TS2694
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.setMaxListeners(_worker_threads().parentPort.getMaxListeners() + 1);
+_worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.addListener('message', message => {
+  if (message === 'clearState') {
+    worker.clearState();
+    _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage('stateCleared');
+  }
+});

package/lib/requests/ConfigRequest.js

@@ -8,6 +8,7 @@ exports.getConfigKeyContentHash = getConfigKeyContentHash;
 exports.getConfigRequests = getConfigRequests;
 exports.getValueAtPath = getValueAtPath;
 exports.loadPluginConfig = loadPluginConfig;
+exports.loadPluginSetup = loadPluginSetup;
 exports.runConfigRequest = runConfigRequest;
 function _utils() {
   const data = require("@atlaspack/utils");
@@ -87,6 +88,30 @@ async function loadPluginConfig(loadedPlugin, config, options) {
     });
   }
 }
+async function loadPluginSetup(pluginName, setup, config, options) {
+  try {
+    let result = await setup({
+      config: new _Config.default(config, options),
+      options: new _PluginOptions.default((0, _utils2.optionsProxy)(options, option => {
+        config.invalidateOnOptionChange.add(option);
+      })),
+      logger: new (_logger().PluginLogger)({
+        origin: pluginName
+      }),
+      tracer: new (_profiler().PluginTracer)({
+        origin: pluginName,
+        category: 'setup'
+      })
+    });
+    config.result = result.config;
+  } catch (e) {
+    throw new (_diagnostic().default)({
+      diagnostic: (0, _diagnostic().errorToDiagnostic)(e, {
+        origin: pluginName
+      })
+    });
+  }
+}
 
 /**
  * Return value at a given key path within an object.

package/lib/types/InternalConfig.d.ts

@@ -2,7 +2,7 @@ import type { PackageName, ConfigResult } from '@atlaspack/types';
 import type { Config, InternalFileCreateInvalidation, InternalDevDepOptions } from './types';
 import type { ProjectPath } from './projectPath';
 import type { EnvironmentRef } from './EnvironmentManager';
-type ConfigOpts = {
+export type ConfigOpts = {
     plugin: PackageName;
     searchPath: ProjectPath;
     isSource?: boolean;
@@ -21,4 +21,3 @@ type ConfigOpts = {
     invalidateOnBuild?: boolean;
 };
 export declare function createConfig({ plugin, isSource, searchPath, env, result, invalidateOnFileChange, invalidateOnConfigKeyChange, invalidateOnFileCreate, invalidateOnEnvChange, invalidateOnOptionChange, devDeps, invalidateOnStartup, invalidateOnBuild, }: ConfigOpts): Config;
-export {};

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

@@ -1,4 +1,4 @@
-import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions } from '@atlaspack/rust';
+import { AtlaspackNapi, Lmdb, AtlaspackNapiOptions, CacheStats } from '@atlaspack/rust';
 import type { Event } from '@parcel/watcher';
 import type { NapiWorkerPool as INapiWorkerPool } from '@atlaspack/types';
 export type AtlaspackV3Options = {
@@ -23,4 +23,5 @@ export declare class AtlaspackV3 {
     end(): void;
     buildAssetGraph(): Promise<any>;
     respondToFsEvents(events: Array<Event>): Promise<boolean>;
+    completeCacheSession(): Promise<CacheStats>;
 }

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

@@ -6,6 +6,7 @@ export type NapiWorkerPoolOptions = {
 export declare class NapiWorkerPool implements INapiWorkerPool {
     #private;
     constructor({ workerCount }?: NapiWorkerPoolOptions);
+    clearAllWorkerState(): Promise<void[]>;
     workerCount(): number;
     getWorkers(): Promise<Array<Transferable>>;
     shutdown(): void;

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

@@ -3,3 +3,4 @@ export { AtlaspackV3 } from './AtlaspackV3';
 export { NapiWorkerPool } from './NapiWorkerPool';
 export * from './AtlaspackV3';
 export * from './NapiWorkerPool';
+export type { CacheStats } from '@atlaspack/rust';

package/lib/types/atlaspack-v3/worker/compat/plugin-config.d.ts

@@ -1,19 +1,11 @@
-import type { Config as IPluginConfig, DevDepOptions, FilePath, Environment, FileCreateInvalidation, ConfigResultWithFilePath, PackageJSON, PackageManager as IPackageManager } from '@atlaspack/types';
-import type { FileSystem as IFileSystem } from '@atlaspack/fs';
-export type PluginConfigOptions = {
-    isSource: boolean;
-    searchPath: FilePath;
-    projectRoot: FilePath;
-    env: Environment;
-    fs: IFileSystem;
-    packageManager: IPackageManager;
-};
+import type { Config as IPluginConfig, DevDepOptions, FilePath, Environment, FileCreateInvalidation, ConfigResultWithFilePath, PackageJSON } from '@atlaspack/types';
+import { type ConfigOpts } from '../../../InternalConfig';
 export declare class PluginConfig implements IPluginConfig {
     #private;
     isSource: boolean;
     searchPath: FilePath;
     env: Environment;
-    constructor({ env, isSource, searchPath, projectRoot, fs, packageManager, }: PluginConfigOptions);
+    constructor(configOpts: ConfigOpts, options: any);
     invalidateOnFileChange(filePath: FilePath): void;
     invalidateOnFileCreate(invalidations: FileCreateInvalidation): void;
     invalidateOnEnvChange(invalidation: string): void;

package/lib/types/atlaspack-v3/worker/compat/plugin-options.d.ts

@@ -2,6 +2,7 @@ import type { PluginOptions as IPluginOptions, LogLevel, FileSystem, PackageMana
 import type { FeatureFlags } from '@atlaspack/feature-flags';
 export declare class PluginOptions implements IPluginOptions {
     #private;
+    used: boolean;
     get env(): EnvMap;
     get projectRoot(): FilePath;
     get packageManager(): PackageManager;