@atlaspack/core 2.24.0 → 2.24.2-dev-ts-project-refs-d30e9754f.0

package/dist/Atlaspack.js

@@ -0,0 +1,656 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 _Atlaspack_requestTracker, _Atlaspack_config, _Atlaspack_farm, _Atlaspack_initialized, _Atlaspack_disposable, _Atlaspack_initialOptions, _Atlaspack_reporterRunner, _Atlaspack_resolvedOptions, _Atlaspack_optionsRef, _Atlaspack_watchAbortController, _Atlaspack_watchQueue, _Atlaspack_watchEvents, _Atlaspack_watcherSubscription, _Atlaspack_watcherCount, _Atlaspack_requestedAssetIds;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildError = exports.WORKER_PATH = exports.INTERNAL_RESOLVE = exports.INTERNAL_TRANSFORM = void 0;
+exports.createWorkerFarm = createWorkerFarm;
+const path_1 = __importDefault(require("path"));
+const assert_1 = __importDefault(require("assert"));
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const Asset_1 = require("./public/Asset");
+const Bundle_1 = require("./public/Bundle");
+const BundleGraph_1 = __importDefault(require("./public/BundleGraph"));
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const utils_1 = require("./utils");
+const AtlaspackConfigRequest_1 = require("./requests/AtlaspackConfigRequest");
+const ReporterRunner_1 = __importDefault(require("./ReporterRunner"));
+const dumpGraphToGraphViz_1 = __importDefault(require("./dumpGraphToGraphViz"));
+const resolveOptions_1 = __importDefault(require("./resolveOptions"));
+const events_1 = require("@atlaspack/events");
+const registerCoreWithSerializer_1 = require("./registerCoreWithSerializer");
+const utils_2 = require("@atlaspack/utils");
+const AtlaspackConfig_1 = require("./AtlaspackConfig");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
+const RequestTracker_1 = __importStar(require("./RequestTracker"));
+const ValidationRequest_1 = __importDefault(require("./requests/ValidationRequest"));
+const AtlaspackBuildRequest_1 = __importDefault(require("./requests/AtlaspackBuildRequest"));
+const AssetRequest_1 = __importDefault(require("./requests/AssetRequest"));
+const PathRequest_1 = __importDefault(require("./requests/PathRequest"));
+const Environment_1 = require("./Environment");
+const Dependency_1 = require("./Dependency");
+const events_2 = require("@atlaspack/events");
+const source_map_1 = require("@parcel/source-map");
+const cache_1 = require("@atlaspack/cache");
+const rust_1 = require("@atlaspack/rust");
+const projectPath_1 = require("./projectPath");
+const profiler_1 = require("@atlaspack/profiler");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const atlaspack_v3_1 = require("./atlaspack-v3");
+const AssetGraphRequest_1 = __importDefault(require("./requests/AssetGraphRequest"));
+const AssetGraphRequestRust_1 = require("./requests/AssetGraphRequestRust");
+const rustWorkerThreadDylibHack_1 = require("./rustWorkerThreadDylibHack");
+(0, registerCoreWithSerializer_1.registerCoreWithSerializer)();
+exports.INTERNAL_TRANSFORM = Symbol('internal_transform');
+exports.INTERNAL_RESOLVE = Symbol('internal_resolve');
+exports.WORKER_PATH = path_1.default.join(__dirname, 'worker.js');
+if (__filename.endsWith('.ts')) {
+    exports.WORKER_PATH = path_1.default.join(__dirname, 'worker.ts');
+}
+class Atlaspack {
+    constructor(options) {
+        // @ts-expect-error TS2564
+        _Atlaspack_requestTracker.set(this, void 0);
+        // @ts-expect-error TS2564
+        _Atlaspack_config.set(this, void 0);
+        // @ts-expect-error TS2564
+        _Atlaspack_farm.set(this, void 0);
+        _Atlaspack_initialized.set(this, false);
+        // @ts-expect-error TS2564
+        _Atlaspack_disposable.set(this, void 0);
+        _Atlaspack_initialOptions.set(this, void 0);
+        // @ts-expect-error TS2564
+        _Atlaspack_reporterRunner.set(this, void 0);
+        _Atlaspack_resolvedOptions.set(this, null);
+        // @ts-expect-error TS2564
+        _Atlaspack_optionsRef.set(this, void 0);
+        // @ts-expect-error TS2564
+        _Atlaspack_watchAbortController.set(this, void 0);
+        _Atlaspack_watchQueue.set(this, new utils_2.PromiseQueue({
+            maxConcurrent: 1,
+        }));
+        // @ts-expect-error TS2564
+        _Atlaspack_watchEvents.set(this, void 0);
+        _Atlaspack_watcherSubscription.set(this, void 0);
+        _Atlaspack_watcherCount.set(this, 0);
+        _Atlaspack_requestedAssetIds.set(this, new Set());
+        __classPrivateFieldSet(this, _Atlaspack_initialOptions, options, "f");
+    }
+    async _init() {
+        if (__classPrivateFieldGet(this, _Atlaspack_initialized, "f")) {
+            return;
+        }
+        const featureFlags = {
+            ...feature_flags_1.DEFAULT_FEATURE_FLAGS,
+            ...__classPrivateFieldGet(this, _Atlaspack_initialOptions, "f").featureFlags,
+        };
+        (0, feature_flags_1.setFeatureFlags)(featureFlags);
+        (0, rustWorkerThreadDylibHack_1.loadRustWorkerThreadDylibHack)();
+        await source_map_1.init;
+        await (0, rust_1.init)?.();
+        __classPrivateFieldSet(this, _Atlaspack_disposable, new events_2.Disposable(), "f");
+        try {
+            (0, rust_1.initializeMonitoring)?.();
+            const onExit = () => {
+                (0, rust_1.closeMonitoring)?.();
+            };
+            process.on('exit', onExit);
+            __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(() => {
+                process.off('exit', onExit);
+                onExit();
+            });
+        }
+        catch (e) {
+            // Fallthrough
+            // eslint-disable-next-line no-console
+            console.warn(e);
+        }
+        let resolvedOptions = await (0, resolveOptions_1.default)({
+            ...__classPrivateFieldGet(this, _Atlaspack_initialOptions, "f"),
+            featureFlags,
+        });
+        __classPrivateFieldSet(this, _Atlaspack_resolvedOptions, resolvedOptions, "f");
+        let rustAtlaspack;
+        if (resolvedOptions.featureFlags.atlaspackV3) {
+            // eslint-disable-next-line no-unused-vars
+            let { entries, inputFS, outputFS, ...options } = __classPrivateFieldGet(this, _Atlaspack_initialOptions, "f");
+            if (!(resolvedOptions.cache instanceof cache_1.LMDBLiteCache)) {
+                throw new Error('Atlaspack v3 must be run with lmdb lite cache');
+            }
+            const lmdb = resolvedOptions.cache.getNativeRef();
+            const version = require('../package.json').version;
+            await lmdb.put('current_session_version', Buffer.from(version));
+            let threads = undefined;
+            if (process.env.ATLASPACK_NATIVE_THREADS !== undefined) {
+                threads = parseInt(process.env.ATLASPACK_NATIVE_THREADS, 10);
+            }
+            else if (process.env.NODE_ENV === 'test') {
+                threads = 2;
+            }
+            rustAtlaspack = await atlaspack_v3_1.AtlaspackV3.create({
+                ...options,
+                // @ts-expect-error TS2353
+                corePath: path_1.default.join(__dirname, '..'),
+                threads,
+                entries: Array.isArray(entries)
+                    ? entries
+                    : entries == null
+                        ? undefined
+                        : [entries],
+                env: resolvedOptions.env,
+                fs: inputFS && new atlaspack_v3_1.FileSystemV3(inputFS),
+                defaultTargetOptions: resolvedOptions.defaultTargetOptions,
+                lmdb,
+                featureFlags: resolvedOptions.featureFlags,
+            });
+            __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(() => {
+                rustAtlaspack.end();
+            });
+        }
+        // @ts-expect-error TS2454
+        this.rustAtlaspack = rustAtlaspack;
+        let { config } = await (0, AtlaspackConfigRequest_1.loadAtlaspackConfig)(resolvedOptions);
+        __classPrivateFieldSet(this, _Atlaspack_config, new AtlaspackConfig_1.AtlaspackConfig(config, resolvedOptions), "f");
+        if (__classPrivateFieldGet(this, _Atlaspack_initialOptions, "f").workerFarm) {
+            if (__classPrivateFieldGet(this, _Atlaspack_initialOptions, "f").workerFarm.ending) {
+                throw new Error('Supplied WorkerFarm is ending');
+            }
+            __classPrivateFieldSet(this, _Atlaspack_farm, __classPrivateFieldGet(this, _Atlaspack_initialOptions, "f").workerFarm, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Atlaspack_farm, createWorkerFarm({
+                shouldPatchConsole: resolvedOptions.shouldPatchConsole,
+                shouldTrace: resolvedOptions.shouldTrace,
+            }), "f");
+        }
+        await resolvedOptions.cache.ensure();
+        let { dispose: disposeOptions, ref: optionsRef } = await __classPrivateFieldGet(this, _Atlaspack_farm, "f").createSharedReference(resolvedOptions, false);
+        __classPrivateFieldSet(this, _Atlaspack_optionsRef, optionsRef, "f");
+        if (__classPrivateFieldGet(this, _Atlaspack_initialOptions, "f").workerFarm) {
+            // If we don't own the farm, dispose of only these references when
+            // Atlaspack ends.
+            __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(disposeOptions);
+        }
+        else {
+            // Otherwise, when shutting down, end the entire farm we created.
+            __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(() => __classPrivateFieldGet(this, _Atlaspack_farm, "f").end());
+        }
+        __classPrivateFieldSet(this, _Atlaspack_watchEvents, new events_1.ValueEmitter(), "f");
+        __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(() => __classPrivateFieldGet(this, _Atlaspack_watchEvents, "f").dispose());
+        __classPrivateFieldSet(this, _Atlaspack_reporterRunner, new ReporterRunner_1.default({
+            options: resolvedOptions,
+            reporters: await __classPrivateFieldGet(this, _Atlaspack_config, "f").getReporters(),
+            workerFarm: __classPrivateFieldGet(this, _Atlaspack_farm, "f"),
+        }), "f");
+        __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(__classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f"));
+        logger_1.default.verbose({
+            origin: '@atlaspack/core',
+            message: 'Intializing request tracker...',
+        });
+        __classPrivateFieldSet(this, _Atlaspack_requestTracker, await RequestTracker_1.default.init({
+            farm: __classPrivateFieldGet(this, _Atlaspack_farm, "f"),
+            options: resolvedOptions,
+            // @ts-expect-error TS2454
+            rustAtlaspack,
+        }), "f");
+        __classPrivateFieldSet(this, _Atlaspack_initialized, true, "f");
+    }
+    async run() {
+        let startTime = Date.now();
+        if (!__classPrivateFieldGet(this, _Atlaspack_initialized, "f")) {
+            await this._init();
+        }
+        let result = await this._build({ startTime });
+        await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").writeToCache();
+        await this._end();
+        if (result.type === 'buildFailure') {
+            throw new BuildError(result.diagnostics);
+        }
+        return result;
+    }
+    async _end() {
+        __classPrivateFieldSet(this, _Atlaspack_initialized, false, "f");
+        await __classPrivateFieldGet(this, _Atlaspack_disposable, "f").dispose();
+    }
+    async writeRequestTrackerToCache() {
+        if (__classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").getNumWaiting() === 0) {
+            // If there's no queued events, we are safe to write the request graph to disk
+            const abortController = new AbortController();
+            const unsubscribe = __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").subscribeToAdd(() => {
+                abortController.abort();
+            });
+            try {
+                await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").writeToCache(abortController.signal);
+            }
+            catch (err) {
+                if (!abortController.signal.aborted) {
+                    // We expect abort errors if we interrupt the cache write
+                    throw err;
+                }
+            }
+            unsubscribe();
+        }
+    }
+    async _startNextBuild() {
+        __classPrivateFieldSet(this, _Atlaspack_watchAbortController, new AbortController(), "f");
+        await this.clearBuildCaches();
+        try {
+            let buildEvent = await this._build({
+                signal: __classPrivateFieldGet(this, _Atlaspack_watchAbortController, "f").signal,
+            });
+            __classPrivateFieldGet(this, _Atlaspack_watchEvents, "f").emit({
+                buildEvent,
+            });
+            return buildEvent;
+        }
+        catch (err) {
+            // Ignore BuildAbortErrors and only emit critical errors.
+            if (!(err instanceof utils_1.BuildAbortError)) {
+                throw err;
+            }
+        }
+        finally {
+            // If the build passes or fails, we want to cache the request graph
+            await this.writeRequestTrackerToCache();
+        }
+    }
+    async watch(cb) {
+        var _a;
+        if (!__classPrivateFieldGet(this, _Atlaspack_initialized, "f")) {
+            await this._init();
+        }
+        // @ts-expect-error TS7034
+        let watchEventsDisposable;
+        if (cb) {
+            watchEventsDisposable = __classPrivateFieldGet(this, _Atlaspack_watchEvents, "f").addListener(({ error, buildEvent }) => cb(error, buildEvent));
+        }
+        if (__classPrivateFieldGet(this, _Atlaspack_watcherCount, "f") === 0) {
+            __classPrivateFieldSet(this, _Atlaspack_watcherSubscription, await this._getWatcherSubscription(), "f");
+            await __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report({ type: 'watchStart' });
+            // Kick off a first build, but don't await its results. Its results will
+            // be provided to the callback.
+            __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").add(() => this._startNextBuild());
+            __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").run();
+        }
+        __classPrivateFieldSet(this, _Atlaspack_watcherCount, (_a = __classPrivateFieldGet(this, _Atlaspack_watcherCount, "f"), _a++, _a), "f");
+        // @ts-expect-error TS7034
+        let unsubscribePromise;
+        const unsubscribe = async () => {
+            var _a;
+            // @ts-expect-error TS7005
+            if (watchEventsDisposable) {
+                watchEventsDisposable.dispose();
+            }
+            __classPrivateFieldSet(this, _Atlaspack_watcherCount, (_a = __classPrivateFieldGet(this, _Atlaspack_watcherCount, "f"), _a--, _a), "f");
+            if (__classPrivateFieldGet(this, _Atlaspack_watcherCount, "f") === 0) {
+                await (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_watcherSubscription, "f")).unsubscribe();
+                __classPrivateFieldSet(this, _Atlaspack_watcherSubscription, null, "f");
+                await __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report({ type: 'watchEnd' });
+                __classPrivateFieldGet(this, _Atlaspack_watchAbortController, "f").abort();
+                await __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").run();
+                await this._end();
+            }
+        };
+        return {
+            unsubscribe() {
+                // @ts-expect-error TS7005
+                if (unsubscribePromise == null) {
+                    unsubscribePromise = unsubscribe();
+                }
+                // @ts-expect-error TS7005
+                return unsubscribePromise;
+            },
+        };
+    }
+    async _build({ signal, startTime = Date.now(), } = {
+    /*::...null*/
+    }) {
+        let options = (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f"));
+        try {
+            if (options.shouldProfile) {
+                await this.startProfiling();
+            }
+            if (options.shouldTrace) {
+                profiler_1.tracer.enable();
+                // We need to ensure the tracer is disabled when Atlaspack is disposed as it is a module level object.
+                // While rare (except for tests), if another instance is created later it should not have tracing enabled.
+                __classPrivateFieldGet(this, _Atlaspack_disposable, "f").add(() => {
+                    profiler_1.tracer.disable();
+                });
+            }
+            await __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report({
+                type: 'buildStart',
+            });
+            __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").graph.invalidateOnBuildNodes();
+            let request = (0, AtlaspackBuildRequest_1.default)({
+                optionsRef: __classPrivateFieldGet(this, _Atlaspack_optionsRef, "f"),
+                requestedAssetIds: __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f"),
+                signal,
+            });
+            let { bundleGraph, bundleInfo, changedAssets, assetRequests } = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(request, { force: true });
+            __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f").clear();
+            await (0, dumpGraphToGraphViz_1.default)(
+            // @ts-expect-error TS2345
+            __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").graph, 'RequestGraph', RequestTracker_1.requestGraphEdgeTypes);
+            let event = {
+                type: 'buildSuccess',
+                changedAssets: new Map(Array.from(changedAssets).map(([id, asset]) => [
+                    id,
+                    (0, Asset_1.assetFromValue)(asset, options),
+                ])),
+                bundleGraph: new BundleGraph_1.default(bundleGraph, (
+                // @ts-expect-error TS2304
+                bundle, 
+                // @ts-expect-error TS2314
+                bundleGraph, options) => Bundle_1.PackagedBundle.getWithInfo(bundle, bundleGraph, options, bundleInfo.get(bundle.id)), options),
+                buildTime: Date.now() - startTime,
+                // @ts-expect-error TS7006
+                requestBundle: async (bundle) => {
+                    let bundleNode = bundleGraph._graph.getNodeByContentKey(bundle.id);
+                    (0, assert_1.default)(bundleNode?.type === 'bundle', 'Bundle does not exist');
+                    if (!bundleNode.value.isPlaceholder) {
+                        // Nothing to do.
+                        return {
+                            type: 'buildSuccess',
+                            changedAssets: new Map(),
+                            bundleGraph: event.bundleGraph,
+                            buildTime: 0,
+                            requestBundle: event.requestBundle,
+                            unstable_requestStats: {},
+                        };
+                    }
+                    for (let assetId of bundleNode.value.entryAssetIds) {
+                        __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f").add(assetId);
+                    }
+                    if (__classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").getNumWaiting() === 0) {
+                        if (__classPrivateFieldGet(this, _Atlaspack_watchAbortController, "f")) {
+                            __classPrivateFieldGet(this, _Atlaspack_watchAbortController, "f").abort();
+                        }
+                        __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").add(() => this._startNextBuild());
+                    }
+                    let results = await __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").run();
+                    let result = results.filter(Boolean).pop();
+                    // @ts-expect-error TS18049
+                    if (result.type === 'buildFailure') {
+                        // @ts-expect-error TS18049
+                        throw new BuildError(result.diagnostics);
+                    }
+                    return result;
+                },
+                unstable_requestStats: __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").flushStats(),
+            };
+            // @ts-expect-error TS2345
+            await __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report(event);
+            await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(
+            // @ts-expect-error TS2345
+            (0, ValidationRequest_1.default)({ optionsRef: __classPrivateFieldGet(this, _Atlaspack_optionsRef, "f"), assetRequests }), { force: assetRequests.length > 0 });
+            if (__classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").errors.length) {
+                throw __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").errors;
+            }
+            // @ts-expect-error TS2322
+            return event;
+        }
+        catch (e) {
+            if (e instanceof utils_1.BuildAbortError) {
+                throw e;
+            }
+            let diagnostic = (0, diagnostic_1.anyToDiagnostic)(e);
+            let event = {
+                type: 'buildFailure',
+                diagnostics: Array.isArray(diagnostic) ? diagnostic : [diagnostic],
+                unstable_requestStats: __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").flushStats(),
+            };
+            // @ts-expect-error TS2345
+            await __classPrivateFieldGet(this, _Atlaspack_reporterRunner, "f").report(event);
+            // @ts-expect-error TS2322
+            return event;
+        }
+        finally {
+            if (this.isProfiling) {
+                await this.stopProfiling();
+            }
+            await this.clearBuildCaches();
+        }
+    }
+    async _getWatcherSubscription() {
+        (0, assert_1.default)(__classPrivateFieldGet(this, _Atlaspack_watcherSubscription, "f") == null);
+        let resolvedOptions = (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f"));
+        let opts = (0, RequestTracker_1.getWatcherOptions)(resolvedOptions);
+        let sub = await resolvedOptions.inputFS.watch(resolvedOptions.watchDir, async (err, events) => {
+            if (err) {
+                logger_1.default.warn({
+                    message: `File watch event error occured`,
+                    meta: {
+                        err,
+                        trackableEvent: 'watcher_error',
+                    },
+                });
+                __classPrivateFieldGet(this, _Atlaspack_watchEvents, "f").emit({ error: err });
+                return;
+            }
+            logger_1.default.verbose({
+                message: `File watch event emitted with ${events.length} events. Sample event: [${events[0]?.type}] ${events[0]?.path}`,
+            });
+            let nativeInvalid = false;
+            if (this.rustAtlaspack) {
+                nativeInvalid = await this.rustAtlaspack.respondToFsEvents(events);
+            }
+            let { didInvalidate: isInvalid } = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").respondToFSEvents(events, Number.POSITIVE_INFINITY);
+            if ((nativeInvalid || isInvalid) &&
+                __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").getNumWaiting() === 0) {
+                if (__classPrivateFieldGet(this, _Atlaspack_watchAbortController, "f")) {
+                    __classPrivateFieldGet(this, _Atlaspack_watchAbortController, "f").abort();
+                }
+                __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").add(() => this._startNextBuild());
+                __classPrivateFieldGet(this, _Atlaspack_watchQueue, "f").run();
+            }
+        }, opts);
+        return { unsubscribe: () => sub.unsubscribe() };
+    }
+    // This is mainly for integration tests and it not public api!
+    _getResolvedAtlaspackOptions() {
+        return (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f"), 'Resolved options is null, please let atlaspack initialize before accessing this.');
+    }
+    async startProfiling() {
+        if (this.isProfiling) {
+            throw new Error('Atlaspack is already profiling');
+        }
+        logger_1.default.info({ origin: '@atlaspack/core', message: 'Starting profiling...' });
+        this.isProfiling = true;
+        await __classPrivateFieldGet(this, _Atlaspack_farm, "f").startProfile();
+    }
+    stopProfiling() {
+        if (!this.isProfiling) {
+            throw new Error('Atlaspack is not profiling');
+        }
+        logger_1.default.info({ origin: '@atlaspack/core', message: 'Stopping profiling...' });
+        this.isProfiling = false;
+        return __classPrivateFieldGet(this, _Atlaspack_farm, "f").endProfile();
+    }
+    takeHeapSnapshot() {
+        logger_1.default.info({
+            origin: '@atlaspack/core',
+            message: 'Taking heap snapshot...',
+        });
+        return __classPrivateFieldGet(this, _Atlaspack_farm, "f").takeHeapSnapshot();
+    }
+    /**
+     * Must be called between builds otherwise there is global state that will
+     * break things unexpectedly.
+     */
+    async clearBuildCaches() {
+        await __classPrivateFieldGet(this, _Atlaspack_farm, "f")?.callAllWorkers('clearWorkerBuildCaches', []);
+    }
+    async unstable_invalidate() {
+        await this._init();
+    }
+    /**
+     * Build the asset graph
+     */
+    async unstable_buildAssetGraph(writeToCache = true) {
+        await this._init();
+        const origin = '@atlaspack/core';
+        const input = {
+            optionsRef: __classPrivateFieldGet(this, _Atlaspack_optionsRef, "f"),
+            name: 'Main',
+            entries: __classPrivateFieldGet(this, _Atlaspack_config, "f").options.entries,
+            shouldBuildLazily: false,
+            lazyIncludes: [],
+            lazyExcludes: [],
+            requestedAssetIds: __classPrivateFieldGet(this, _Atlaspack_requestedAssetIds, "f"),
+        };
+        const start = Date.now();
+        const result = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(this.rustAtlaspack != null
+            ? // @ts-expect-error TS2345
+                (0, AssetGraphRequestRust_1.createAssetGraphRequestRust)(this.rustAtlaspack)(input)
+            : // @ts-expect-error TS2345
+                (0, AssetGraphRequest_1.default)(input), { force: true });
+        const duration = Date.now() - start;
+        logger_1.default.info({
+            message: `Done building asset graph in ${duration / 1000}s!`,
+            origin,
+        });
+        if (writeToCache) {
+            logger_1.default.info({ message: 'Write request tracker to cache', origin });
+            await this.writeRequestTrackerToCache();
+            logger_1.default.info({ message: 'Done writing request tracker to cache', origin });
+        }
+        return result;
+    }
+    /**
+     * Copy the cache to a new directory and compact it.
+     */
+    async unstable_compactCache() {
+        await this._init();
+        const cache = (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f")).cache;
+        if (cache instanceof cache_1.LMDBLiteCache) {
+            await cache.compact('parcel-cache-compacted');
+        }
+        else {
+            throw new Error('Cache is not an LMDBLiteCache');
+        }
+    }
+    async unstable_transform(options) {
+        if (!__classPrivateFieldGet(this, _Atlaspack_initialized, "f")) {
+            await this._init();
+        }
+        let projectRoot = (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f")).projectRoot;
+        let request = (0, AssetRequest_1.default)({
+            ...options,
+            filePath: (0, projectPath_1.toProjectPath)(projectRoot, options.filePath),
+            optionsRef: __classPrivateFieldGet(this, _Atlaspack_optionsRef, "f"),
+            env: (0, Environment_1.createEnvironment)({
+                ...options.env,
+                loc: options.env?.loc != null
+                    ? {
+                        ...options.env.loc,
+                        filePath: (0, projectPath_1.toProjectPath)(projectRoot, options.env.loc.filePath),
+                    }
+                    : undefined,
+            }),
+        });
+        let res = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(request, {
+            force: true,
+        });
+        return res.map((asset) => (0, Asset_1.assetFromValue)(asset, (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f"))));
+    }
+    async unstable_resolve(request) {
+        if (!__classPrivateFieldGet(this, _Atlaspack_initialized, "f")) {
+            await this._init();
+        }
+        let projectRoot = (0, nullthrows_1.default)(__classPrivateFieldGet(this, _Atlaspack_resolvedOptions, "f")).projectRoot;
+        if (request.resolveFrom == null && path_1.default.isAbsolute(request.specifier)) {
+            request.specifier = (0, projectPath_1.fromProjectPathRelative)((0, projectPath_1.toProjectPath)(projectRoot, request.specifier));
+        }
+        let dependency = (0, Dependency_1.createDependency)(projectRoot, {
+            ...request,
+            env: (0, Environment_1.createEnvironment)({
+                ...request.env,
+                loc: request.env?.loc != null
+                    ? {
+                        ...request.env.loc,
+                        filePath: (0, projectPath_1.toProjectPath)(projectRoot, request.env.loc.filePath),
+                    }
+                    : undefined,
+            }),
+        });
+        let req = (0, PathRequest_1.default)({
+            dependency,
+            name: request.specifier,
+        });
+        let res = await __classPrivateFieldGet(this, _Atlaspack_requestTracker, "f").runRequest(req, {
+            force: true,
+        });
+        if (!res) {
+            return null;
+        }
+        return {
+            // @ts-expect-error TS2322
+            filePath: (0, projectPath_1.fromProjectPath)(projectRoot, res.filePath),
+            code: res.code,
+            query: res.query,
+            sideEffects: res.sideEffects,
+        };
+    }
+}
+_Atlaspack_requestTracker = new WeakMap(), _Atlaspack_config = new WeakMap(), _Atlaspack_farm = new WeakMap(), _Atlaspack_initialized = new WeakMap(), _Atlaspack_disposable = new WeakMap(), _Atlaspack_initialOptions = new WeakMap(), _Atlaspack_reporterRunner = new WeakMap(), _Atlaspack_resolvedOptions = new WeakMap(), _Atlaspack_optionsRef = new WeakMap(), _Atlaspack_watchAbortController = new WeakMap(), _Atlaspack_watchQueue = new WeakMap(), _Atlaspack_watchEvents = new WeakMap(), _Atlaspack_watcherSubscription = new WeakMap(), _Atlaspack_watcherCount = new WeakMap(), _Atlaspack_requestedAssetIds = new WeakMap();
+exports.default = Atlaspack;
+class BuildError extends diagnostic_1.default {
+    constructor(diagnostic) {
+        super({ diagnostic });
+        this.name = 'BuildError';
+    }
+}
+exports.BuildError = BuildError;
+function createWorkerFarm(options = {}) {
+    return new workers_1.default({
+        ...options,
+        workerPath: exports.WORKER_PATH,
+    });
+}