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

package/dist/requests/ValidationRequest.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createValidationRequest;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const AtlaspackConfig_1 = require("../AtlaspackConfig");
+const ReporterRunner_1 = require("../ReporterRunner");
+const Validation_1 = __importDefault(require("../Validation"));
+const AtlaspackConfigRequest_1 = __importDefault(require("./AtlaspackConfigRequest"));
+const RequestTracker_1 = require("../RequestTracker");
+function createValidationRequest(input) {
+    return {
+        id: 'validation',
+        type: RequestTracker_1.requestTypes.validation_request,
+        run: async ({ input: { assetRequests, optionsRef }, api, options, farm }) => {
+            let { config: processedConfig, cachePath } = (0, nullthrows_1.default)(await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+            let config = new AtlaspackConfig_1.AtlaspackConfig(processedConfig, options);
+            let trackedRequestsDesc = assetRequests.filter((request) => {
+                // @ts-expect-error TS2345
+                return config.getValidatorNames(request.filePath).length > 0;
+            });
+            // Schedule validations on workers for all plugins that implement the one-asset-at-a-time "validate" method.
+            let promises = trackedRequestsDesc.map(async (request) => (await farm.createHandle('runValidate'))({
+                requests: [request],
+                optionsRef: optionsRef,
+                configCachePath: cachePath,
+            }));
+            // Skip sending validation requests if no validators were configured
+            if (trackedRequestsDesc.length === 0) {
+                return;
+            }
+            // Schedule validations on the main thread for all validation plugins that implement "validateAll".
+            promises.push(
+            // @ts-expect-error TS2345
+            new Validation_1.default({
+                requests: trackedRequestsDesc,
+                options,
+                config,
+                // @ts-expect-error TS2322
+                report: ReporterRunner_1.report,
+                dedicatedThread: true,
+            }).run());
+            await Promise.all(promises);
+        },
+        input,
+    };
+}

package/dist/requests/WriteBundleRequest.js

@@ -0,0 +1,254 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createWriteBundleRequest;
+const constants_1 = require("../constants");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const Bundle_1 = require("../public/Bundle");
+const utils_1 = require("@atlaspack/utils");
+const stream_1 = require("stream");
+const projectPath_1 = require("../projectPath");
+const AtlaspackConfigRequest_1 = __importStar(require("./AtlaspackConfigRequest"));
+const PluginOptions_1 = __importDefault(require("../public/PluginOptions"));
+const logger_1 = require("@atlaspack/logger");
+const DevDepRequest_1 = require("./DevDepRequest");
+const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
+const profiler_1 = require("@atlaspack/profiler");
+const RequestTracker_1 = require("../RequestTracker");
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const EnvironmentManager_1 = require("../EnvironmentManager");
+const HASH_REF_PREFIX_LEN = constants_1.HASH_REF_PREFIX.length;
+const BOUNDARY_LENGTH = constants_1.HASH_REF_PREFIX.length + 32 - 1;
+/**
+ * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
+ */
+function createWriteBundleRequest(input) {
+    let name = (0, nullthrows_1.default)(input.bundle.name);
+    let nameHash = (0, nullthrows_1.default)(input.hashRefToNameHash.get(input.bundle.hashReference));
+    return {
+        id: `${input.bundle.id}:${input.info.hash}:${nameHash}:${name}`,
+        type: RequestTracker_1.requestTypes.write_bundle_request,
+        run,
+        input,
+    };
+}
+// @ts-expect-error TS7031
+async function run({ input, options, api }) {
+    let { bundleGraph, bundle, info, hashRefToNameHash } = input;
+    let { inputFS, outputFS } = options;
+    let name = (0, nullthrows_1.default)(bundle.name);
+    let thisHashReference = bundle.hashReference;
+    if (info.type !== bundle.type) {
+        name = name.slice(0, -path_1.default.extname(name).length) + '.' + info.type;
+    }
+    if (name.includes(thisHashReference)) {
+        let thisNameHash = (0, nullthrows_1.default)(hashRefToNameHash.get(thisHashReference));
+        name = name.replace(thisHashReference, thisNameHash);
+    }
+    let filePath = (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name);
+    // Watch the bundle and source map for deletion.
+    // Also watch the dist dir because invalidateOnFileDelete does not currently
+    // invalidate when a parent directory is deleted.
+    // TODO: do we want to also watch for file edits?
+    api.invalidateOnFileDelete(bundle.target.distDir);
+    api.invalidateOnFileDelete(filePath);
+    let cacheKeys = info.cacheKeys;
+    let mapKey = cacheKeys.map;
+    let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
+    const env = (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env);
+    if (mapKey && env.sourceMap && !env.sourceMap.inline) {
+        api.invalidateOnFileDelete((0, projectPath_1.toProjectPath)(options.projectRoot, fullPath + '.map'));
+    }
+    let dir = path_1.default.dirname(fullPath);
+    await outputFS.mkdirp(dir); // ? Got rid of dist exists, is this an expensive operation
+    // Use the file mode from the entry asset as the file mode for the bundle.
+    // Don't do this for browser builds, as the executable bit in particular is unnecessary.
+    let publicBundle = Bundle_1.NamedBundle.get(bundle, bundleGraph, options);
+    let mainEntry = publicBundle.getMainEntry();
+    let writeOptions = publicBundle.env.isBrowser() || !mainEntry
+        ? undefined
+        : {
+            mode: (await inputFS.stat(mainEntry.filePath)).mode,
+        };
+    let contentStream;
+    if (info.isLargeBlob) {
+        contentStream = options.cache.getStream(cacheKeys.content);
+    }
+    else {
+        contentStream = (0, utils_1.blobToStream)(await options.cache.getBlob(cacheKeys.content));
+    }
+    let size = 0;
+    contentStream = contentStream.pipe(
+    // @ts-expect-error TS2554
+    new utils_1.TapStream((buf) => {
+        size += buf.length;
+    }));
+    let configResult = (0, nullthrows_1.default)(
+    // @ts-expect-error TS2347
+    await api.runRequest((0, AtlaspackConfigRequest_1.default)()));
+    let config = (0, AtlaspackConfigRequest_1.getCachedAtlaspackConfig)(configResult, options);
+    let { devDeps, invalidDevDeps } = await (0, DevDepRequest_1.getDevDepRequests)(api);
+    (0, DevDepRequest_1.invalidateDevDeps)(invalidDevDeps, options, config);
+    await writeFiles(contentStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api);
+    const hasSourceMap = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+        ? await options.cache.hasLargeBlob(mapKey)
+        : await options.cache.has(mapKey);
+    if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
+        const mapEntry = (0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')
+            ? await options.cache.getLargeBlob(mapKey)
+            : await options.cache.getBlob(mapKey);
+        await writeFiles((0, utils_1.blobToStream)(mapEntry), info, hashRefToNameHash, options, config, outputFS, (0, projectPath_1.toProjectPathUnsafe)((0, projectPath_1.fromProjectPathRelative)(filePath) + '.map'), writeOptions, devDeps, api);
+    }
+    let res = {
+        filePath,
+        bundleId: bundle.id,
+        type: info.type,
+        stats: {
+            size,
+            time: info.time ?? 0,
+        },
+    };
+    api.storeResult(res);
+    return res;
+}
+async function writeFiles(
+// @ts-expect-error TS2503
+inputStream, info, hashRefToNameHash, options, config, outputFS, filePath, writeOptions, devDeps, api) {
+    let compressors = await config.getCompressors((0, projectPath_1.fromProjectPathRelative)(filePath));
+    let fullPath = (0, projectPath_1.fromProjectPath)(options.projectRoot, filePath);
+    let stream = info.hashReferences.length
+        ? inputStream.pipe(replaceStream(hashRefToNameHash))
+        : inputStream;
+    let promises = [];
+    for (let compressor of compressors) {
+        promises.push(
+        // @ts-expect-error TS2345
+        runCompressor(compressor, cloneStream(stream), options, outputFS, fullPath, writeOptions, devDeps, api));
+    }
+    await Promise.all(promises);
+}
+async function runCompressor(compressor, 
+// @ts-expect-error TS2503
+stream, options, outputFS, filePath, writeOptions, devDeps, api) {
+    let measurement;
+    try {
+        measurement = profiler_1.tracer.createMeasurement(compressor.name, 'compress', path_1.default.relative(options.projectRoot, filePath));
+        let res = await compressor.plugin.compress({
+            stream,
+            options: new PluginOptions_1.default(options),
+            logger: new logger_1.PluginLogger({ origin: compressor.name }),
+            tracer: new profiler_1.PluginTracer({ origin: compressor.name, category: 'compress' }),
+        });
+        if (res != null) {
+            await new Promise((resolve, reject) => (0, stream_1.pipeline)(res.stream, outputFS.createWriteStream(filePath + (res.type != null ? '.' + res.type : ''), writeOptions), (err) => {
+                if (err)
+                    reject(err);
+                // @ts-expect-error TS2794
+                else
+                    resolve();
+            }));
+        }
+    }
+    catch (err) {
+        throw new diagnostic_1.default({
+            diagnostic: (0, diagnostic_1.errorToDiagnostic)(err, {
+                origin: compressor.name,
+            }),
+        });
+    }
+    finally {
+        measurement && measurement.end();
+        // Add dev deps for compressor plugins AFTER running them, to account for lazy require().
+        let devDepRequest = await (0, DevDepRequest_1.createDevDependency)({
+            specifier: compressor.name,
+            resolveFrom: compressor.resolveFrom,
+        }, devDeps, options);
+        await (0, DevDepRequest_1.runDevDepRequest)(api, devDepRequest);
+    }
+}
+function replaceStream(hashRefToNameHash) {
+    let boundaryStr = Buffer.alloc(0);
+    let replaced = Buffer.alloc(0);
+    return new stream_1.Transform({
+        transform(chunk, encoding, cb) {
+            let str = Buffer.concat([boundaryStr, Buffer.from(chunk)]);
+            let lastMatchI = 0;
+            if (replaced.length < str.byteLength) {
+                replaced = Buffer.alloc(str.byteLength);
+            }
+            let replacedLength = 0;
+            while (lastMatchI < str.byteLength) {
+                let matchI = str.indexOf(constants_1.HASH_REF_PREFIX, lastMatchI);
+                if (matchI === -1) {
+                    replaced.set(str.subarray(lastMatchI, str.byteLength), replacedLength);
+                    replacedLength += str.byteLength - lastMatchI;
+                    break;
+                }
+                else {
+                    let match = str
+                        .subarray(matchI, matchI + HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN)
+                        .toString();
+                    let replacement = Buffer.from(hashRefToNameHash.get(match) ?? match);
+                    replaced.set(str.subarray(lastMatchI, matchI), replacedLength);
+                    replacedLength += matchI - lastMatchI;
+                    replaced.set(replacement, replacedLength);
+                    replacedLength += replacement.byteLength;
+                    lastMatchI = matchI + HASH_REF_PREFIX_LEN + constants_1.HASH_REF_HASH_LEN;
+                }
+            }
+            boundaryStr = replaced.subarray(replacedLength - BOUNDARY_LENGTH, replacedLength);
+            let strUpToBoundary = replaced.subarray(0, replacedLength - BOUNDARY_LENGTH);
+            cb(null, strUpToBoundary);
+        },
+        flush(cb) {
+            cb(null, boundaryStr);
+        },
+    });
+}
+// @ts-expect-error TS2503
+function cloneStream(readable) {
+    let res = new stream_1.Readable();
+    res._read = () => { };
+    // @ts-expect-error TS7006
+    readable.on('data', (chunk) => res.push(chunk));
+    readable.on('end', () => res.push(null));
+    // @ts-expect-error TS7006
+    readable.on('error', (err) => res.emit('error', err));
+    return res;
+}

package/dist/requests/WriteBundlesRequest.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createWriteBundlesRequest;
+const feature_flags_1 = require("@atlaspack/feature-flags");
+const RequestTracker_1 = require("../RequestTracker");
+const types_1 = require("../types");
+const ReporterRunner_1 = require("../ReporterRunner");
+const constants_1 = require("../constants");
+const projectPath_1 = require("../projectPath");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const rust_1 = require("@atlaspack/rust");
+const PackageRequest_1 = require("./PackageRequest");
+const WriteBundleRequest_1 = __importDefault(require("./WriteBundleRequest"));
+function reportPackagingProgress(completeBundles, totalBundles) {
+    if (!(0, feature_flags_1.getFeatureFlag)('cliProgressReportingImprovements')) {
+        return;
+    }
+    (0, ReporterRunner_1.report)({
+        type: 'buildProgress',
+        phase: 'packagingAndOptimizing',
+        totalBundles,
+        completeBundles,
+    });
+}
+/**
+ * Packages, optimizes, and writes all bundles to the dist directory.
+ */
+function createWriteBundlesRequest(input) {
+    return {
+        type: RequestTracker_1.requestTypes.write_bundles_request,
+        id: 'write_bundles:' + input.bundleGraph.getBundleGraphHash(),
+        run,
+        input,
+    };
+}
+async function run({ input, api, farm, options, }) {
+    let { bundleGraph, optionsRef } = input;
+    let { ref, dispose } = await farm.createSharedReference(bundleGraph);
+    api.invalidateOnOptionChange('shouldContentHash');
+    let res = new Map();
+    let bundleInfoMap = {};
+    let writeEarlyPromises = {};
+    let hashRefToNameHash = new Map();
+    // Include inline bundles so that non-inline bundles referenced from inline bundles are written to
+    // separate files. This ensures that source maps are written and work.
+    const allBundles = bundleGraph.getBundles({
+        includeInline: (0, feature_flags_1.getFeatureFlag)('inlineBundlesSourceMapFixes'),
+    });
+    const bundles = allBundles
+        .filter((bundle) => bundle.bundleBehavior !== types_1.BundleBehavior.inline &&
+        bundle.bundleBehavior !== types_1.BundleBehavior.inlineIsolated)
+        .filter((bundle) => {
+        // Do not package and write placeholder bundles to disk. We just
+        // need to update the name so other bundles can reference it.
+        if (bundle.isPlaceholder) {
+            let hash = bundle.id.slice(-8);
+            hashRefToNameHash.set(bundle.hashReference, hash);
+            let name = (0, nullthrows_1.default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, hash);
+            res.set(bundle.id, {
+                filePath: (0, projectPath_1.joinProjectPath)(bundle.target.distDir, name),
+                bundleId: bundle.id,
+                type: bundle.type, // FIXME: this is wrong if the packager changes the type...
+                stats: {
+                    time: 0,
+                    size: 0,
+                },
+            });
+            return false;
+        }
+        return true;
+    });
+    let cachedBundles = new Set(bundles.filter((b) => api.canSkipSubrequest(bundleGraph.getHash(b))));
+    // Package on the main thread if there is only one bundle to package.
+    // This avoids the cost of serializing the bundle graph for single file change builds.
+    let useMainThread = bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
+    try {
+        let completeBundles = cachedBundles.size;
+        reportPackagingProgress(completeBundles, bundles.length);
+        await Promise.all(bundles.map(async (bundle) => {
+            let request = (0, PackageRequest_1.createPackageRequest)({
+                bundle,
+                bundleGraph,
+                bundleGraphReference: ref,
+                optionsRef,
+                useMainThread,
+            });
+            let info = await api.runRequest(request);
+            if (!cachedBundles.has(bundle)) {
+                completeBundles++;
+                reportPackagingProgress(completeBundles, bundles.length);
+            }
+            if (!useMainThread) {
+                // Force a refresh of the cache to avoid a race condition
+                // between threaded reads and writes that can result in an LMDB cache miss:
+                //   1. The main thread has read some value from cache, necessitating a read transaction.
+                //   2. Concurrently, Thread A finishes a packaging request.
+                //   3. Subsequently, the main thread is tasked with this request, but fails because the read transaction is stale.
+                // This only occurs if the reading thread has a transaction that was created before the writing thread committed,
+                // and the transaction is still live when the reading thread attempts to get the written value.
+                // See https://github.com/parcel-bundler/parcel/issues/9121
+                options.cache.refresh();
+            }
+            bundleInfoMap[bundle.id] = info;
+            if (!info.hashReferences.length) {
+                hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash
+                    ? info.hash.slice(-8)
+                    : bundle.id.slice(-8));
+                let writeBundleRequest = (0, WriteBundleRequest_1.default)({
+                    bundle,
+                    info,
+                    hashRefToNameHash,
+                    bundleGraph,
+                });
+                let promise = api.runRequest(writeBundleRequest);
+                // If the promise rejects before we await it (below), we don't want to crash the build.
+                promise.catch(() => { });
+                writeEarlyPromises[bundle.id] = promise;
+            }
+        }));
+        assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options);
+        await Promise.all(bundles.map((bundle) => {
+            let promise = writeEarlyPromises[bundle.id] ??
+                api.runRequest((0, WriteBundleRequest_1.default)({
+                    bundle,
+                    info: bundleInfoMap[bundle.id],
+                    hashRefToNameHash,
+                    bundleGraph,
+                }));
+            return promise.then((r) => res.set(bundle.id, r));
+        }));
+        api.storeResult(res);
+        return res;
+    }
+    finally {
+        await dispose();
+    }
+}
+function assignComplexNameHashes(hashRefToNameHash, bundles, bundleInfoMap, options) {
+    for (let bundle of bundles) {
+        if (hashRefToNameHash.get(bundle.hashReference) != null) {
+            continue;
+        }
+        hashRefToNameHash.set(bundle.hashReference, options.shouldContentHash
+            ? (0, rust_1.hashString)([...getBundlesIncludedInHash(bundle.id, bundleInfoMap)]
+                .map((bundleId) => bundleInfoMap[bundleId].hash)
+                .join(':')).slice(-8)
+            : bundle.id.slice(-8));
+    }
+}
+function getBundlesIncludedInHash(bundleId, bundleInfoMap, included = new Set()) {
+    included.add(bundleId);
+    for (let hashRef of bundleInfoMap[bundleId]?.hashReferences ?? []) {
+        let referencedId = getIdFromHashRef(hashRef);
+        if (!included.has(referencedId)) {
+            getBundlesIncludedInHash(referencedId, bundleInfoMap, included);
+        }
+    }
+    return included;
+}
+function getIdFromHashRef(hashRef) {
+    return hashRef.slice(constants_1.HASH_REF_PREFIX.length);
+}

package/dist/requests/asset-graph-diff.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+// @ts-expect-error missing types
+const default_1 = __importDefault(require("rfdc/default"));
+const jest_diff_1 = require("jest-diff");
+const projectPath_1 = require("../projectPath");
+function filterNode(node) {
+    let clone = (0, default_1.default)(node);
+    // Clean up anything you don't want to see in the diff
+    // delete clone.id;
+    delete clone.value.id;
+    delete clone.value.meta.id;
+    delete clone.value.sourceAssetId;
+    delete clone.value.env.id;
+    delete clone.value.isEsm;
+    delete clone.value.shouldWrap;
+    delete clone.value.contentKey;
+    delete clone.value.placeholder;
+    delete clone.value.code;
+    delete clone.value.hasCjsExports;
+    delete clone.value.staticExports;
+    delete clone.value.isConstantModule;
+    delete clone.value.hasNodeReplacements;
+    delete clone.value.stats;
+    delete clone.value.astKey;
+    delete clone.value.astGenerator;
+    delete clone.value.dependencies;
+    return clone;
+}
+// @ts-expect-error missing return type
+function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
+    if (obj instanceof Map) {
+        const copy = {};
+        Array.from(obj.entries()).forEach(([k, v]) => {
+            if (v != null) {
+                copy[k] = compactDeep(v, ignoredPatterns, `${currentPath}.${k}`);
+            }
+        });
+        return copy;
+    }
+    else if (Array.isArray(obj)) {
+        // @ts-expect-error implicit any
+        return obj.map((v) => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
+    }
+    else if (typeof obj === 'object') {
+        const copy = {};
+        Object.entries(obj ?? {}).forEach(([key, value]) => {
+            const path = `${currentPath}.${key}`;
+            if (ignoredPatterns.some((pattern) => path.includes(pattern))) {
+                return;
+            }
+            // Equivalent false == null
+            if (key === 'isWeak' && value === false) {
+                return;
+            }
+            if (value != null) {
+                copy[key] = compactDeep(value, ignoredPatterns, path);
+            }
+        });
+        return copy;
+    }
+    else if (obj != null) {
+        return obj;
+    }
+}
+function assetGraphDiff(jsAssetGraph, rustAssetGraph) {
+    const getNodes = (graph) => {
+        let nodes = {};
+        // @ts-expect-error implicit any
+        graph.traverse((nodeId) => {
+            let node = graph.getNode(nodeId) ?? null;
+            if (!node)
+                return;
+            if (node.type === 'dependency') {
+                let sourcePath = node.value.sourcePath ?? (0, projectPath_1.toProjectPath)('', 'entry');
+                nodes[`dep:${(0, projectPath_1.fromProjectPathRelative)(sourcePath)}:${node.value.specifier}`] = filterNode(node);
+            }
+            else if (node.type === 'asset') {
+                nodes[`asset:${(0, projectPath_1.fromProjectPathRelative)(node.value.filePath)}`] =
+                    filterNode(node);
+            }
+        });
+        return nodes;
+    };
+    const jsNodes = getNodes(jsAssetGraph);
+    const rustNodes = getNodes(rustAssetGraph);
+    const all = new Set([...Object.keys(jsNodes), ...Object.keys(rustNodes)]);
+    const missing = [];
+    const extra = [];
+    for (const key of all.keys()) {
+        if (process.env.NATIVE_COMPARE !== 'true') {
+            continue;
+        }
+        let jsNode = jsNodes[key];
+        let rustNode = rustNodes[key];
+        if (!rustNode) {
+            missing.push(key);
+            continue;
+        }
+        if (!jsNode) {
+            extra.push(key);
+            continue;
+        }
+        console.log(key);
+        const ignoredPatterns = [
+            // ignored because we don't copy the environment ID back from rust
+            // in the target value
+            '$.value.target.env.id',
+            // ignore asset.mapKey because we don't do persistence on rust yet
+            '$.value.mapKey',
+            // ignore this because it's just the output hash. We don't need to compute
+            // this yet
+            '$.value.outputHash',
+            // ignore correspondingRequest from all nodes
+            '$.correspondingRequest',
+        ];
+        console.log((0, jest_diff_1.diff)(compactDeep(jsNode, ignoredPatterns), compactDeep(rustNode, ignoredPatterns)));
+    }
+    console.log('Missing', missing);
+    console.log('Extra', extra);
+}
+module.exports = assetGraphDiff;