@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/dist/atlaspack-v3/worker/compat/mutable-asset.js

@@ -0,0 +1,152 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _MutableAsset_astDirty, _MutableAsset_ast, _MutableAsset_contents, _MutableAsset_inner, _MutableAsset_map, _MutableAsset_projectRoot, _MutableAsset_sourceMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutableAsset = void 0;
+const source_map_1 = __importDefault(require("@atlaspack/source-map"));
+const stream_1 = require("stream");
+const bitflags_1 = require("./bitflags");
+const asset_symbols_1 = require("./asset-symbols");
+class MutableAsset {
+    get astGenerator() {
+        throw new Error('get MutableAsset.astGenerator');
+    }
+    // @ts-expect-error TS1051
+    set astGenerator(value) {
+        throw new Error('set MutableAsset.astGenerator');
+    }
+    constructor(asset, contents, env, fs, map, projectRoot) {
+        _MutableAsset_astDirty.set(this, void 0);
+        _MutableAsset_ast.set(this, void 0);
+        _MutableAsset_contents.set(this, void 0);
+        _MutableAsset_inner.set(this, void 0);
+        _MutableAsset_map.set(this, void 0);
+        _MutableAsset_projectRoot.set(this, void 0);
+        _MutableAsset_sourceMap.set(this, void 0);
+        this.bundleBehavior = bitflags_1.bundleBehaviorMap.fromNullable(asset.bundleBehavior);
+        this.env = env;
+        this.filePath = asset.filePath;
+        this.fs = fs;
+        this.id = asset.id;
+        this.isBundleSplittable = asset.isBundleSplittable;
+        this.isSource = asset.isSource;
+        this.meta = asset.meta;
+        this.pipeline = asset.pipeline;
+        this.query = new URLSearchParams(asset.query);
+        this.sideEffects = asset.sideEffects;
+        this.stats = asset.stats;
+        this.symbols = new asset_symbols_1.MutableAssetSymbols(asset.symbols);
+        this.type = asset.type;
+        this.uniqueKey = asset.uniqueKey;
+        __classPrivateFieldSet(this, _MutableAsset_astDirty, false, "f");
+        __classPrivateFieldSet(this, _MutableAsset_contents, contents, "f");
+        __classPrivateFieldSet(this, _MutableAsset_inner, asset, "f");
+        __classPrivateFieldSet(this, _MutableAsset_map, map, "f");
+        __classPrivateFieldSet(this, _MutableAsset_projectRoot, projectRoot, "f");
+    }
+    // eslint-disable-next-line require-await
+    async getAST() {
+        return __classPrivateFieldGet(this, _MutableAsset_ast, "f");
+    }
+    setAST(ast) {
+        __classPrivateFieldSet(this, _MutableAsset_astDirty, true, "f");
+        __classPrivateFieldSet(this, _MutableAsset_ast, ast, "f");
+    }
+    isASTDirty() {
+        return __classPrivateFieldGet(this, _MutableAsset_astDirty, "f");
+    }
+    // eslint-disable-next-line require-await
+    async getCode() {
+        return __classPrivateFieldGet(this, _MutableAsset_contents, "f").toString();
+    }
+    setCode(code) {
+        __classPrivateFieldSet(this, _MutableAsset_contents, Buffer.from(code), "f");
+    }
+    // eslint-disable-next-line require-await
+    async getBuffer() {
+        return __classPrivateFieldGet(this, _MutableAsset_contents, "f");
+    }
+    setBuffer(buf) {
+        __classPrivateFieldSet(this, _MutableAsset_contents, buf, "f");
+    }
+    getStream() {
+        return stream_1.Readable.from(__classPrivateFieldGet(this, _MutableAsset_contents, "f"));
+    }
+    setStream(stream) {
+        const data = [];
+        stream.on('data', (chunk) => {
+            data.push(chunk);
+        });
+        stream.on('end', () => {
+            __classPrivateFieldSet(this, _MutableAsset_contents, Buffer.concat(data), "f");
+        });
+        stream.on('error', () => {
+            throw new Error('MutableAsset.setStream()');
+        });
+    }
+    getMap() {
+        // Only create the source map if it is requested
+        if (!__classPrivateFieldGet(this, _MutableAsset_sourceMap, "f") && __classPrivateFieldGet(this, _MutableAsset_map, "f") && typeof __classPrivateFieldGet(this, _MutableAsset_map, "f") === 'string') {
+            let sourceMap = new source_map_1.default(__classPrivateFieldGet(this, _MutableAsset_projectRoot, "f"));
+            sourceMap.addVLQMap(JSON.parse(__classPrivateFieldGet(this, _MutableAsset_map, "f")));
+            __classPrivateFieldSet(this, _MutableAsset_sourceMap, sourceMap, "f");
+        }
+        return Promise.resolve(__classPrivateFieldGet(this, _MutableAsset_sourceMap, "f"));
+    }
+    // eslint-disable-next-line no-unused-vars
+    setMap(sourceMap) {
+        this.isMapDirty = true;
+        __classPrivateFieldSet(this, _MutableAsset_sourceMap, sourceMap, "f");
+    }
+    getMapBuffer() {
+        throw new Error('getMapBuffer() is considered an internal implementation detail, please use getMap() instead');
+    }
+    getDependencies() {
+        throw new Error('MutableAsset.getDependencies');
+    }
+    // eslint-disable-next-line no-unused-vars
+    addDependency(options) {
+        throw new Error('MutableAsset.addDependency()');
+    }
+    // eslint-disable-next-line no-unused-vars
+    addURLDependency(url, opts) {
+        throw new Error('MutableAsset.addURLDependency()');
+    }
+    // eslint-disable-next-line no-unused-vars
+    setEnvironment(opts) {
+        throw new Error('MutableAsset.setEnvironment()');
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileChange(invalidation) {
+        // TODO: Forward invalidations to Rust
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileCreate(invalidation) {
+        // TODO: Forward invalidations to Rust
+    }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnEnvChange(invalidation) {
+        // TODO: Forward invalidations to Rust
+    }
+    invalidateOnStartup() {
+        // TODO: Forward invalidations to Rust
+    }
+    invalidateOnBuild() {
+        // TODO: Forward invalidations to Rust
+    }
+}
+exports.MutableAsset = MutableAsset;
+_MutableAsset_astDirty = new WeakMap(), _MutableAsset_ast = new WeakMap(), _MutableAsset_contents = new WeakMap(), _MutableAsset_inner = new WeakMap(), _MutableAsset_map = new WeakMap(), _MutableAsset_projectRoot = new WeakMap(), _MutableAsset_sourceMap = new WeakMap();

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

@@ -0,0 +1,64 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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(configOpts, options) {
+        _PluginConfig_inner.set(this, void 0);
+        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) { }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnFileCreate(invalidations) { }
+    // eslint-disable-next-line no-unused-vars
+    invalidateOnEnvChange(invalidation) { }
+    invalidateOnStartup() { }
+    invalidateOnBuild() { }
+    // eslint-disable-next-line no-unused-vars
+    addDevDependency(options) { }
+    // eslint-disable-next-line no-unused-vars
+    setCacheKey(key) { }
+    getConfig(
+    // eslint-disable-next-line no-unused-vars
+    filePaths, 
+    // eslint-disable-next-line no-unused-vars
+    options) {
+        return __classPrivateFieldGet(this, _PluginConfig_inner, "f").getConfig(filePaths, options);
+    }
+    getConfigFrom(
+    // eslint-disable-next-line no-unused-vars
+    searchPath, 
+    // eslint-disable-next-line no-unused-vars
+    filePaths, 
+    // eslint-disable-next-line no-unused-vars
+    options) {
+        return __classPrivateFieldGet(this, _PluginConfig_inner, "f").getConfigFrom(searchPath, filePaths, options);
+    }
+    getPackage() {
+        return __classPrivateFieldGet(this, _PluginConfig_inner, "f").getPackage();
+    }
+}
+exports.PluginConfig = PluginConfig;
+_PluginConfig_inner = new WeakMap();

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

@@ -0,0 +1,137 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _PluginOptions_options;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginOptions = void 0;
+class PluginOptions {
+    get env() {
+        if (!('env' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            return process.env;
+            // throw new Error('PluginOptions.env');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").env;
+    }
+    get projectRoot() {
+        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() {
+        if (!('parcelVersion' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            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() {
+        if (!('logLevel' in __classPrivateFieldGet(this, _PluginOptions_options, "f"))) {
+            throw new Error('PluginOptions.logLevel');
+        }
+        return __classPrivateFieldGet(this, _PluginOptions_options, "f").logLevel;
+    }
+    get cacheDir() {
+        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");
+    }
+}
+exports.PluginOptions = PluginOptions;
+_PluginOptions_options = new WeakMap();

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginTracer = void 0;
+class PluginTracer {
+    // @ts-expect-error TS2416
+    createMeasurement() {
+        throw new Error('PluginTracer.createMeasurement');
+    }
+}
+exports.PluginTracer = PluginTracer;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Target = void 0;
+class Target {
+    constructor(inner, env) {
+        this.distDir = inner.distDir;
+        this.distEntry = inner.distEntry;
+        this.name = inner.name;
+        this.publicUrl = inner.publicUrl;
+        this.loc = inner.loc;
+        this.env = env;
+    }
+}
+exports.Target = Target;

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();