@atlaspack/core 2.30.2 → 2.31.0

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

@@ -46,9 +46,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _AtlaspackWorker_resolvers, _AtlaspackWorker_transformers, _AtlaspackWorker_fs, _AtlaspackWorker_packageManager;
+var _AtlaspackWorker_resolvers, _AtlaspackWorker_transformers, _AtlaspackWorker_fs, _AtlaspackWorker_packageManager, _AtlaspackWorker_options, _AtlaspackWorker_sideEffectDetector;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AtlaspackWorker = void 0;
+/* eslint-disable import/first */
+const side_effect_detector_1 = require("./side-effect-detector");
+// Install side effect detection patches BEFORE importing any modules that use fs
+const sideEffectDetector = new side_effect_detector_1.SideEffectDetector();
+sideEffectDetector.install();
 const assert_1 = __importDefault(require("assert"));
 const napi = __importStar(require("@atlaspack/rust"));
 const fs_1 = require("@atlaspack/fs");
@@ -64,7 +69,9 @@ class AtlaspackWorker {
         _AtlaspackWorker_transformers.set(this, void 0);
         _AtlaspackWorker_fs.set(this, void 0);
         _AtlaspackWorker_packageManager.set(this, void 0);
-        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom, featureFlags }) => {
+        _AtlaspackWorker_options.set(this, void 0);
+        _AtlaspackWorker_sideEffectDetector.set(this, void 0);
+        this.loadPlugin = (0, jsCallable_1.jsCallable)(async ({ kind, specifier, resolveFrom, options }) => {
             // Use packageManager.require() instead of dynamic import() to support TypeScript plugins
             let resolvedModule = await __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").require(specifier, resolveFrom, { shouldAutoInstall: false });
             let instance = undefined;
@@ -85,57 +92,48 @@ 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 (__classPrivateFieldGet(this, _AtlaspackWorker_options, "f") == null) {
+                __classPrivateFieldSet(this, _AtlaspackWorker_options, {
+                    ...options,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager: __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f"),
+                    shouldAutoInstall: false,
+                }, "f");
+            }
             // Set feature flags in the worker process
             let featureFlagsModule = await __classPrivateFieldGet(this, _AtlaspackWorker_packageManager, "f").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':
                     __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").set(specifier, { resolver: instance });
                     break;
-                case 'transformer':
-                    __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, { transformer: instance });
-                    break;
+                case 'transformer': {
+                    return this.initializeTransformer(instance, specifier);
+                }
             }
         });
-        this.runResolverResolve = (0, jsCallable_1.jsCallable)(async ({ key, dependency: napiDependency, specifier, pipeline, pluginOptions, }) => {
+        this.runResolverResolve = (0, jsCallable_1.jsCallable)(async ({ key, dependency: napiDependency, specifier, pipeline }) => {
             const state = __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").get(key);
             if (!state) {
                 throw new Error(`Resolver not found: ${key}`);
             }
-            let packageManager = state.packageManager;
-            if (!packageManager) {
-                packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), pluginOptions.projectRoot);
-                state.packageManager = packageManager;
-            }
             const env = new compat_1.Environment(napiDependency.env);
             const dependency = new compat_1.Dependency(napiDependency, env);
             const defaultOptions = {
                 logger: new compat_1.PluginLogger(),
                 tracer: new compat_1.PluginTracer(),
-                options: new compat_1.PluginOptions({
-                    ...pluginOptions,
-                    packageManager,
-                    shouldAutoInstall: false,
-                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
-                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
-                }),
+                options: new compat_1.PluginOptions(this.options),
             };
             if (!('config' in state)) {
                 // @ts-expect-error TS2345
                 state.config = await state.resolver.loadConfig?.({
                     config: new compat_1.PluginConfig({
-                        env,
+                        env: napiDependency.env,
+                        plugin: key,
                         isSource: true,
-                        searchPath: specifier,
-                        projectRoot: pluginOptions.projectRoot,
-                        fs: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
-                        packageManager,
-                    }),
+                        searchPath: 'index',
+                    }, this.options),
                     ...defaultOptions,
                 });
             }
@@ -174,49 +172,48 @@ class AtlaspackWorker {
                 },
             };
         });
-        this.runTransformerTransform = (0, jsCallable_1.jsCallable)(async ({ key, env: napiEnv, options, asset: innerAsset }, contents, map) => {
-            const state = __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").get(key);
-            if (!state) {
+        this.runTransformerTransform = (0, jsCallable_1.jsCallable)(async ({ key, asset: innerAsset }, contents, map) => {
+            const instance = __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").get(key);
+            if (!instance) {
                 throw new Error(`Transformer not found: ${key}`);
             }
-            let packageManager = state.packageManager;
-            if (!packageManager) {
-                packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), 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_1.Environment(napiEnv);
-            const mutableAsset = new compat_1.MutableAsset(innerAsset, 
+            const env = new compat_1.Environment(innerAsset.env);
+            let mutableAsset = new compat_1.MutableAsset(innerAsset, 
             // @ts-expect-error TS2345
-            contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, options.projectRoot);
+            contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, this.options.projectRoot);
+            const pluginOptions = new compat_1.PluginOptions(this.options);
             const defaultOptions = {
                 logger: new compat_1.PluginLogger(),
                 tracer: new compat_1.PluginTracer(),
-                options: new compat_1.PluginOptions({
-                    ...options,
-                    packageManager,
-                    shouldAutoInstall: false,
-                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
-                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
-                }),
+                options: pluginOptions,
             };
-            // @ts-expect-error TS2345
-            const config = await transformer.loadConfig?.({
-                config: new compat_1.PluginConfig({
-                    env,
-                    isSource: true,
-                    searchPath: innerAsset.filePath,
-                    projectRoot: options.projectRoot,
-                    fs: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
-                    packageManager,
-                }),
-                ...defaultOptions,
-            });
+            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_1.PluginConfig({
+                        plugin: key,
+                        isSource: innerAsset.isSource,
+                        searchPath: innerAsset.filePath,
+                        env,
+                    }, this.options),
+                    ...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
@@ -228,14 +225,29 @@ class AtlaspackWorker {
                 if (ast) {
                     mutableAsset.setAST(ast);
                 }
+                cacheBailouts.push(`Transformer.parse`);
             }
-            const result = await state.transformer.transform({
+            const [result, sideEffects] = await __classPrivateFieldGet(this, _AtlaspackWorker_sideEffectDetector, "f").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_1.default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
+            (0, assert_1.default)(result[0] === mutableAsset, '[V3] Unimplemented: New asset returned from Node transformer');
             if (transformer.generate) {
                 const ast = await mutableAsset.getAST();
                 if (ast) {
@@ -260,14 +272,16 @@ class AtlaspackWorker {
                     }
                 }
             }
-            (0, assert_1.default)(result.length === 1, '[V3] Unimplemented: Multiple asset return from Node transformer');
-            (0, assert_1.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
             // detect in Rust, to avoid passing back an empty buffer, which we can't.
             if (assetBuffer.length === 0) {
                 assetBuffer = null;
             }
+            if (pluginOptions.used) {
+                // Plugin options accessed, so not cachable
+                cacheBailouts.push(`Plugin options accessed`);
+            }
             return [
                 {
                     id: mutableAsset.id,
@@ -291,17 +305,77 @@ class AtlaspackWorker {
                     ? // @ts-expect-error TS2533
                         JSON.stringify((await mutableAsset.getMap()).toVLQ())
                     : '',
+                // Limit to first 10 bailouts
+                cacheBailouts.slice(0, 10),
             ];
         });
         __classPrivateFieldSet(this, _AtlaspackWorker_resolvers, new Map(), "f");
         __classPrivateFieldSet(this, _AtlaspackWorker_transformers, new Map(), "f");
         __classPrivateFieldSet(this, _AtlaspackWorker_fs, new fs_1.NodeFS(), "f");
         __classPrivateFieldSet(this, _AtlaspackWorker_packageManager, new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), '/'), "f");
+        __classPrivateFieldSet(this, _AtlaspackWorker_sideEffectDetector, sideEffectDetector, "f"); // Use the global detector that was installed before imports
+    }
+    clearState() {
+        __classPrivateFieldGet(this, _AtlaspackWorker_resolvers, "f").clear();
+        __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").clear();
+        __classPrivateFieldSet(this, _AtlaspackWorker_options, undefined, "f");
+    }
+    get options() {
+        if (__classPrivateFieldGet(this, _AtlaspackWorker_options, "f") == null) {
+            throw new Error('Plugin options have not been initialized');
+        }
+        return __classPrivateFieldGet(this, _AtlaspackWorker_options, "f");
+    }
+    async initializeTransformer(instance, specifier) {
+        let transformer = instance;
+        let setup, config, allowedEnv;
+        let packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), this.options.projectRoot);
+        if (transformer.setup) {
+            let setupResult = await transformer.setup({
+                logger: new compat_1.PluginLogger(),
+                options: new compat_1.PluginOptions({
+                    ...this.options,
+                    shouldAutoInstall: false,
+                    inputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    outputFS: __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"),
+                    packageManager,
+                }),
+                config: new compat_1.PluginConfig({
+                    plugin: specifier,
+                    searchPath: 'index',
+                    // Consider project setup config as source
+                    isSource: true,
+                }, this.options),
+            });
+            config = setupResult?.config;
+            allowedEnv = Object.fromEntries(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?.conditions,
+                config,
+                env: allowedEnv,
+            };
+        }
+        __classPrivateFieldGet(this, _AtlaspackWorker_transformers, "f").set(specifier, {
+            transformer,
+            config,
+            packageManager,
+            allowedEnv,
+        });
+        return setup;
     }
 }
 exports.AtlaspackWorker = AtlaspackWorker;
-_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap();
+_AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap(), _AtlaspackWorker_options = new WeakMap(), _AtlaspackWorker_sideEffectDetector = new WeakMap();
 // Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);
 worker_threads_1.parentPort?.postMessage(napiWorker);
+worker_threads_1.parentPort?.setMaxListeners(worker_threads_1.parentPort.getMaxListeners() + 1);
+worker_threads_1.parentPort?.addListener('message', (message) => {
+    if (message === 'clearState') {
+        worker.clearState();
+        worker_threads_1.parentPort?.postMessage('stateCleared');
+    }
+});

package/dist/requests/ConfigRequest.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadPluginConfig = loadPluginConfig;
+exports.loadPluginSetup = loadPluginSetup;
 exports.getValueAtPath = getValueAtPath;
 exports.getConfigKeyContentHash = getConfigKeyContentHash;
 exports.runConfigRequest = runConfigRequest;
@@ -80,6 +81,29 @@ async function loadPluginConfig(loadedPlugin, config, options) {
         });
     }
 }
+async function loadPluginSetup(pluginName, setup, config, options) {
+    try {
+        let result = await setup({
+            config: new Config_1.default(config, options),
+            options: new PluginOptions_1.default((0, utils_2.optionsProxy)(options, (option) => {
+                config.invalidateOnOptionChange.add(option);
+            })),
+            logger: new logger_1.PluginLogger({ origin: pluginName }),
+            tracer: new profiler_1.PluginTracer({
+                origin: pluginName,
+                category: 'setup',
+            }),
+        });
+        config.result = result.config;
+    }
+    catch (e) {
+        throw new diagnostic_1.default({
+            diagnostic: (0, diagnostic_1.errorToDiagnostic)(e, {
+                origin: pluginName,
+            }),
+        });
+    }
+}
 /**
  * Return value at a given key path within an object.
  *

package/lib/Atlaspack.js

@@ -408,6 +408,7 @@ class Atlaspack {
   }) {
     let options = (0, _nullthrows().default)(this.#resolvedOptions);
     try {
+      var _this$rustAtlaspack;
       if (options.shouldProfile) {
         await this.startProfiling();
       }
@@ -485,6 +486,7 @@ class Atlaspack {
           return result;
         },
         unstable_requestStats: this.#requestTracker.flushStats(),
+        nativeCacheStats: await ((_this$rustAtlaspack = this.rustAtlaspack) === null || _this$rustAtlaspack === void 0 ? void 0 : _this$rustAtlaspack.completeCacheSession()),
         scopeHoistingStats
       };
 
@@ -505,6 +507,7 @@ class Atlaspack {
       // @ts-expect-error TS2322
       return event;
     } catch (e) {
+      var _this$rustAtlaspack2;
       if (e instanceof _utils.BuildAbortError) {
         throw e;
       }
@@ -512,7 +515,8 @@ class Atlaspack {
       let event = {
         type: 'buildFailure',
         diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
-        unstable_requestStats: this.#requestTracker.flushStats()
+        unstable_requestStats: this.#requestTracker.flushStats(),
+        nativeCacheStats: await ((_this$rustAtlaspack2 = this.rustAtlaspack) === null || _this$rustAtlaspack2 === void 0 ? void 0 : _this$rustAtlaspack2.completeCacheSession())
       };
 
       // @ts-expect-error TS2345

package/lib/Transformation.js

@@ -86,11 +86,21 @@ function _featureFlags() {
   };
   return data;
 }
+function _buildCache() {
+  const data = require("@atlaspack/build-cache");
+  _buildCache = function () {
+    return data;
+  };
+  return data;
+}
 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 }; }
 // TODO: eventually call path request as sub requests
 
+// Global setup config are not file-specific, so we only need to
+// load them once per build.
+const setupConfig = (0, _buildCache().createBuildCache)();
 class Transformation {
   constructor({
     request,
@@ -399,11 +409,31 @@ 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.createConfig)({
+        plugin: transformer.name,
+        searchPath: (0, _projectPath.toProjectPathUnsafe)('index'),
+        // Consider project setup config as source
+        isSource: true
+      });
+      await (0, _ConfigRequest.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.createConfig)({
+    config = (0, _InternalConfig.createConfig)({
       plugin: transformer.name,
       isSource,
       // @ts-expect-error TS2322

package/lib/atlaspack-v3/AtlaspackV3.js

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

package/lib/atlaspack-v3/NapiWorkerPool.js

@@ -62,6 +62,16 @@ class NapiWorkerPool {
       this.#napiWorkers.push(new Promise(res => worker.once('message', res)));
     }
   }
+  clearAllWorkerState() {
+    return Promise.all(this.#workers.map(worker => new Promise(res => {
+      worker.postMessage('clearState');
+      worker.once('message', message => {
+        if (message == 'stateCleared') {
+          res();
+        }
+      });
+    })));
+  }
   workerCount() {
     return this.#workerCount;
   }

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

@@ -5,36 +5,17 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.PluginConfig = void 0;
 var _Config = _interopRequireDefault(require("../../../public/Config"));
+var _InternalConfig = require("../../../InternalConfig");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class PluginConfig {
-  // @ts-expect-error TS2564
-  #projectRoot;
   #inner;
-  constructor({
-    env,
-    isSource,
-    searchPath,
-    projectRoot,
-    fs,
-    packageManager
-  }) {
-    this.env = env;
-    this.isSource = isSource;
-    this.searchPath = searchPath;
-    this.#inner = new _Config.default(
-    // @ts-expect-error TS2345
-    {
-      invalidateOnConfigKeyChange: [],
-      invalidateOnFileCreate: [],
-      invalidateOnFileChange: new Set(),
-      devDeps: [],
-      searchPath: searchPath.replace(projectRoot + '/', '')
-    }, {
-      projectRoot,
-      inputFS: fs,
-      outputFS: fs,
-      packageManager
-    });
+  constructor(configOpts, options) {
+    let internalConfig = (0, _InternalConfig.createConfig)(configOpts);
+    this.isSource = internalConfig.isSource;
+    this.searchPath = internalConfig.searchPath;
+    // @ts-expect-error TS2564
+    this.env = internalConfig.env;
+    this.#inner = new _Config.default(internalConfig, options);
   }
 
   // eslint-disable-next-line no-unused-vars

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.PluginOptions = void 0;
 class PluginOptions {
   #options;
+  used = false;
   get env() {
     if (!('env' in this.#options)) {
       return process.env;
@@ -18,18 +19,21 @@ class PluginOptions {
     if (!('projectRoot' in this.#options)) {
       throw new Error('PluginOptions.projectRoot');
     }
+    this.used = true;
     return this.#options.projectRoot;
   }
   get packageManager() {
     if (!('packageManager' in this.#options)) {
       throw new Error('PluginOptions.packageManager');
     }
+    this.used = true;
     return this.#options.packageManager;
   }
   get mode() {
     if (!('mode' in this.#options)) {
       throw new Error('PluginOptions.mode');
     }
+    this.used = true;
     return this.#options.mode;
   }
   get parcelVersion() {
@@ -38,30 +42,35 @@ class PluginOptions {
       // throw new Error('PluginOptions.parcelVersion');
     }
 
+    this.used = true;
     return this.#options.parcelVersion;
   }
   get hmrOptions() {
     if (!('hmrOptions' in this.#options)) {
       throw new Error('PluginOptions.hmrOptions');
     }
+    this.used = true;
     return this.#options.hmrOptions;
   }
   get serveOptions() {
     if (!('serveOptions' in this.#options)) {
       throw new Error('PluginOptions.serveOptions');
     }
+    this.used = true;
     return this.#options.serveOptions;
   }
   get shouldBuildLazily() {
     if (!('shouldBuildLazily' in this.#options)) {
       throw new Error('PluginOptions.shouldBuildLazily');
     }
+    this.used = true;
     return this.#options.shouldBuildLazily;
   }
   get shouldAutoInstall() {
     if (!('shouldAutoInstall' in this.#options)) {
       throw new Error('PluginOptions.shouldAutoInstall');
     }
+    this.used = true;
     return this.#options.shouldAutoInstall;
   }
   get logLevel() {
@@ -74,36 +83,42 @@ class PluginOptions {
     if (!('cacheDir' in this.#options)) {
       throw new Error('PluginOptions.cacheDir');
     }
+    this.used = true;
     return this.#options.cacheDir;
   }
   get inputFS() {
     if (!('inputFS' in this.#options)) {
       throw new Error('PluginOptions.inputFS');
     }
+    this.used = true;
     return this.#options.inputFS;
   }
   get outputFS() {
     if (!('outputFS' in this.#options)) {
       throw new Error('PluginOptions.outputFS');
     }
+    this.used = true;
     return this.#options.outputFS;
   }
   get instanceId() {
     if (!('instanceId' in this.#options)) {
       throw new Error('PluginOptions.instanceId');
     }
+    this.used = true;
     return this.#options.instanceId;
   }
   get detailedReport() {
     if (!('detailedReport' in this.#options)) {
       throw new Error('PluginOptions.detailedReport');
     }
+    this.used = true;
     return this.#options.detailedReport;
   }
   get featureFlags() {
     if (!('featureFlags' in this.#options)) {
       throw new Error('PluginOptions.featureFlags');
     }
+    this.used = true;
     return this.#options.featureFlags;
   }
   constructor(options) {