@atlaspack/core 2.34.0 → 2.36.0

package/dist/requests/AssetGraphRequest.js

@@ -8,7 +8,6 @@ exports.default = createAssetGraphRequest;
 const logger_1 = __importDefault(require("@atlaspack/logger"));
 const assert_1 = __importDefault(require("assert"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
-const feature_flags_1 = require("@atlaspack/feature-flags");
 const utils_1 = require("@atlaspack/utils");
 const rust_1 = require("@atlaspack/rust");
 const diagnostic_1 = __importDefault(require("@atlaspack/diagnostic"));
@@ -32,8 +31,10 @@ function createAssetGraphRequest(requestInput) {
             let builder = new AssetGraphBuilder(input, prevResult);
             let assetGraphRequest = await builder.build();
             // early break for incremental bundling if production or flag is off;
-            assetGraphRequest.assetGraph.setDisableIncrementalBundling(!input.options.shouldBundleIncrementally ||
-                input.options.mode === 'production');
+            if (!input.options.shouldBundleIncrementally ||
+                input.options.mode === 'production') {
+                assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
+            }
             if (!input.options.shouldBundleIncrementally ||
                 input.options.mode === 'production') {
                 assetGraphRequest.assetGraph.safeToIncrementallyBundle = false;
@@ -77,14 +78,8 @@ class AssetGraphBuilder {
         this.lazyIncludes = lazyIncludes ?? [];
         this.lazyExcludes = lazyExcludes ?? [];
         this.skipSymbolProp = input.skipSymbolProp ?? false;
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
-            this.cacheKey = `AssetGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
-        }
-        else {
-            this.cacheKey =
-                (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
-        }
+        this.cacheKey =
+            (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}${name}${JSON.stringify(entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-AssetGraph';
         this.isSingleChangeRebuild =
             api
                 .getInvalidSubRequests()
@@ -357,7 +352,6 @@ class AssetGraphBuilder {
                 prevEntries.every((entryId, index) => entryId === currentEntries[index]);
             if (didEntriesChange) {
                 this.assetGraph.safeToIncrementallyBundle = false;
-                this.assetGraph.setNeedsBundling();
             }
         }
     }
@@ -399,13 +393,11 @@ class AssetGraphBuilder {
                         (0, assert_1.default)(otherAsset.type === 'asset');
                         if (!this._areDependenciesEqualForAssets(asset, otherAsset.value)) {
                             this.assetGraph.safeToIncrementallyBundle = false;
-                            this.assetGraph.setNeedsBundling();
                         }
                     }
                     else {
                         // adding a new entry or dependency
                         this.assetGraph.safeToIncrementallyBundle = false;
-                        this.assetGraph.setNeedsBundling();
                     }
                 }
                 this.changedAssets.set(asset.id, asset);
@@ -415,7 +407,6 @@ class AssetGraphBuilder {
         }
         else {
             this.assetGraph.safeToIncrementallyBundle = false;
-            this.assetGraph.setNeedsBundling();
         }
         this.isSingleChangeRebuild = false;
     }

package/dist/requests/AssetGraphRequestRust.js

@@ -203,14 +203,58 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
         }
         return envId;
     };
-    function updateNode(newNode, isUpdateNode) {
+    function describeNode(node) {
+        const base = { type: node.type, id: node.id };
+        if (node.type === 'asset') {
+            return {
+                ...base,
+                filePath: node.value.filePath,
+                fileType: node.value.type,
+                pipeline: node.value.pipeline,
+            };
+        }
+        else if (node.type === 'dependency') {
+            return {
+                ...base,
+                specifier: node.value.specifier,
+                specifierType: node.value.specifierType,
+                sourceAssetId: node.value.sourceAssetId,
+                sourcePath: node.value.sourcePath,
+            };
+        }
+        return base;
+    }
+    function updateNode(newNode, isUpdateNode, index) {
         if (isUpdateNode) {
             let existingNode = graph.getNodeByContentKey(newNode.id);
             (0, assert_2.default)(existingNode && existingNode.type === newNode.type);
             Object.assign(existingNode, newNode);
         }
         else {
-            graph.addNodeByContentKey(newNode.id, newNode);
+            try {
+                graph.addNodeByContentKey(newNode.id, newNode);
+            }
+            catch (e) {
+                if (e instanceof Error &&
+                    e.message.includes('already has content key')) {
+                    let existingNode = graph.getNodeByContentKey(newNode.id);
+                    let diagnostics = {
+                        contentKey: newNode.id,
+                        newNode: describeNode(newNode),
+                        existingNode: existingNode ? describeNode(existingNode) : null,
+                        iterationIndex: index,
+                        totalSerializedNodes: nodesCount,
+                        newNodesCount: serializedGraph.nodes.length,
+                        updatesCount: serializedGraph.updates.length,
+                        edgesCount: serializedGraph.edges.length,
+                        hadPreviousGraph: !!prevAssetGraph,
+                        safeToSkipBundling: serializedGraph.safeToSkipBundling,
+                        graphNodeCount: graph._contentKeyToNodeId.size,
+                    };
+                    throw new Error(`Graph already has content key '${newNode.id}'. Diagnostics: ${JSON.stringify(diagnostics, null, 2)}`);
+                }
+                throw e;
+            }
         }
     }
     let nodeTypeSwitchoverIndex = serializedGraph.nodes.length;
@@ -257,7 +301,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
                 usedSymbolsUpDirty: true,
                 value: asset,
             };
-            updateNode(assetNode, isUpdateNode);
+            updateNode(assetNode, isUpdateNode, index);
         }
         else if (node.type === 'dependency') {
             let { dependency, id } = node.value;
@@ -274,12 +318,12 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
             let usedSymbolsUp = new Map();
             if (node.used_symbols_up) {
                 for (let usedSymbol of node.used_symbols_up) {
-                    // Transform Rust UsedSymbol { symbol: Symbol, asset: string }
-                    // to JS format { symbol: string, asset: string } where symbol is the exported name
+                    // Transform Rust UsedSymbol { symbol: Symbol, asset: string, resolved_symbol: string }
+                    // to JS format { symbol: string, asset: string } where symbol is the resolved name
                     const exportedName = usedSymbol.symbol.exported;
                     usedSymbolsUp.set(exportedName, {
                         asset: usedSymbol.asset,
-                        symbol: exportedName,
+                        symbol: usedSymbol.resolved_symbol ?? exportedName,
                     });
                 }
             }
@@ -301,7 +345,7 @@ function getAssetGraph(serializedGraph, prevAssetGraph) {
                 usedSymbolsUpDirtyUp: true,
                 value: dependency,
             };
-            updateNode(depNode, isUpdateNode);
+            updateNode(depNode, isUpdateNode, index);
         }
     }
     if (!reuseEdges) {

package/dist/requests/AtlaspackBuildRequest.js

@@ -39,7 +39,7 @@ async function run({ input, api, options, rustAtlaspack, }) {
             requestedAssetIds,
             signal,
         });
-    let { bundleGraph, changedAssets, assetRequests } = await api.runRequest(bundleGraphRequest, {
+    let { bundleGraph, changedAssets, assetRequests, didIncrementallyBundle, } = await api.runRequest(bundleGraphRequest, {
         force: Boolean(rustAtlaspack) ||
             (options.shouldBuildLazily && requestedAssetIds.size > 0),
     });
@@ -55,7 +55,13 @@ async function run({ input, api, options, rustAtlaspack, }) {
             }
         });
         if (hasSupportedTarget) {
-            await rustAtlaspack.loadBundleGraph(bundleGraph);
+            if (didIncrementallyBundle) {
+                const changedAssetIds = Array.from(changedAssets.keys());
+                await rustAtlaspack.updateBundleGraph(bundleGraph, changedAssetIds);
+            }
+            else {
+                await rustAtlaspack.loadBundleGraph(bundleGraph);
+            }
         }
     }
     // @ts-expect-error TS2345

package/dist/requests/BundleGraphRequest.js

@@ -157,7 +157,6 @@ function createBundleGraphRequest(input) {
                     .some((req) => !input.api.canSkipSubrequest(req.id));
             if (subRequestsInvalid) {
                 assetGraph.safeToIncrementallyBundle = false;
-                assetGraph.setNeedsBundling();
             }
             let configResult = (0, nullthrows_1.default)(await input.api.runRequest((0, AtlaspackConfigRequest_1.default)()));
             (0, utils_1.assertSignalNotAborted)(signal);
@@ -193,14 +192,8 @@ class BundlerRunner {
         this.devDepRequests = new Map();
         this.configs = new Map();
         this.pluginOptions = new PluginOptions_1.default((0, utils_1.optionsProxy)(this.options, api.invalidateOnOptionChange));
-        if ((0, feature_flags_1.getFeatureFlag)('cachePerformanceImprovements')) {
-            const key = (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`);
-            this.cacheKey = `BundleGraph/${constants_1.ATLASPACK_VERSION}/${options.mode}/${key}`;
-        }
-        else {
-            this.cacheKey =
-                (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
-        }
+        this.cacheKey =
+            (0, rust_1.hashString)(`${constants_1.ATLASPACK_VERSION}:BundleGraph:${JSON.stringify(options.entries) ?? ''}${options.mode}${options.shouldBuildLazily ? 'lazy' : 'eager'}`) + '-BundleGraph';
     }
     async loadConfigs() {
         // Load all configs up front so we can use them in the cache key
@@ -226,16 +219,15 @@ class BundlerRunner {
             type: 'buildProgress',
             phase: 'bundling',
         });
+        let didIncrementallyBundle = false;
         await this.loadConfigs();
         let plugin = await this.config.getBundler();
         let { plugin: bundler, name, resolveFrom } = plugin;
         // if a previous asset graph hash is passed in, check if the bundle graph is also available
         const previousBundleGraphResult = await this.api.getPreviousResult();
-        const canIncrementallyBundle = previousBundleGraphResult?.assetGraphBundlingVersion != null &&
-            graph.canIncrementallyBundle(previousBundleGraphResult.assetGraphBundlingVersion);
+        const canIncrementallyBundle = previousBundleGraphResult != null && graph.canIncrementallyBundle();
         if (graph.safeToIncrementallyBundle && previousBundleGraphResult == null) {
             graph.safeToIncrementallyBundle = false;
-            graph.setNeedsBundling();
         }
         let internalBundleGraph;
         let logger = new logger_1.PluginLogger({ origin: name });
@@ -252,6 +244,7 @@ class BundlerRunner {
                     (0, assert_1.default)(changedAssetNode.type === 'asset');
                     internalBundleGraph.updateAsset(changedAssetNode);
                 }
+                didIncrementallyBundle = true;
             }
             else {
                 internalBundleGraph = BundleGraph_1.default.fromAssetGraph(graph, this.options.mode === 'production');
@@ -270,14 +263,17 @@ class BundlerRunner {
                     measurement = tracer.createMeasurement(plugin.name, 'bundling:bundle', measurementFilename);
                 }
                 // this the normal bundle workflow (bundle, optimizing, run-times, naming)
-                await bundler.bundle({
-                    bundleGraph: mutableBundleGraph,
-                    config: this.configs.get(plugin.name)?.result,
-                    options: this.pluginOptions,
-                    logger,
-                    tracer,
+                await (0, logger_1.instrumentAsync)('bundle (V2)', async () => {
+                    await bundler.bundle({
+                        bundleGraph: mutableBundleGraph,
+                        config: this.configs.get(plugin.name)?.result,
+                        options: this.pluginOptions,
+                        logger,
+                        tracer,
+                    });
                 });
                 measurement && measurement.end();
+                (0, BundleGraphRequestUtils_1.dumpBundleGraphSnapshot)(internalBundleGraph, 'js');
                 if (this.pluginOptions.mode === 'production') {
                     let optimizeMeasurement;
                     try {
@@ -318,9 +314,9 @@ class BundlerRunner {
             if (internalBundleGraph != null) {
                 this.api.storeResult({
                     bundleGraph: internalBundleGraph,
-                    assetGraphBundlingVersion: graph.getBundlingVersion(),
                     changedAssets: new Map(),
                     assetRequests: [],
+                    didIncrementallyBundle,
                 }, this.cacheKey);
             }
             throw new diagnostic_1.default({
@@ -371,15 +367,15 @@ class BundlerRunner {
         internalBundleGraph._graph, 'after_runtimes', BundleGraph_1.bundleGraphEdgeTypes);
         this.api.storeResult({
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: new Map(),
             assetRequests: [],
+            didIncrementallyBundle,
         }, this.cacheKey);
         return {
             bundleGraph: internalBundleGraph,
-            assetGraphBundlingVersion: graph.getBundlingVersion(),
             changedAssets: changedRuntimes,
             assetRequests,
+            didIncrementallyBundle,
         };
     }
 }

package/dist/requests/BundleGraphRequestRust.js

@@ -71,6 +71,7 @@ function createBundleGraphRequestRust(input) {
             }
             // Don’t reuse previous JS result yet; we just rebuild from scratch.
             let { bundleGraph, changedAssets } = (0, logger_1.instrument)('atlaspack_v3_getBundleGraph', () => getBundleGraph(serializedBundleGraph));
+            (0, BundleGraphRequestUtils_1.dumpBundleGraphSnapshot)(bundleGraph, 'rust');
             const runner = new NativeBundlerRunner({ api, options }, input.optionsRef);
             await runner.loadConfigs();
             // Name all bundles
@@ -112,10 +113,9 @@ function createBundleGraphRequestRust(input) {
             }
             return {
                 bundleGraph,
-                // Not accurate yet — ok for now.
-                assetGraphBundlingVersion: 0,
                 changedAssets: changedRuntimes,
                 assetRequests: [],
+                didIncrementallyBundle: false,
             };
         },
         input,

package/dist/requests/BundleGraphRequestUtils.js

@@ -37,15 +37,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateBundles = validateBundles;
+exports.dumpBundleGraphSnapshot = dumpBundleGraphSnapshot;
 exports.nameBundle = nameBundle;
 exports.loadPluginConfigWithDevDeps = loadPluginConfigWithDevDeps;
 exports.runDevDepRequest = runDevDepRequest;
 const assert_1 = __importDefault(require("assert"));
+const fs_1 = __importDefault(require("fs"));
 const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
 const logger_1 = require("@atlaspack/logger");
 const diagnostic_1 = __importStar(require("@atlaspack/diagnostic"));
 const utils_1 = require("@atlaspack/utils");
-const BundleGraph_1 = __importDefault(require("../public/BundleGraph"));
+const BundleGraph_1 = require("../BundleGraph");
+const BundleGraph_2 = __importDefault(require("../public/BundleGraph"));
 const Bundle_1 = require("../public/Bundle");
 const InternalConfig_1 = require("../InternalConfig");
 const DevDepRequest_1 = require("./DevDepRequest");
@@ -64,12 +68,139 @@ function validateBundles(bundleGraph) {
             ...(0, utils_1.setSymmetricDifference)(new Set(bundleNames), new Set((0, utils_1.unique)(bundleNames))),
         ].join());
 }
+/**
+ * Dump a canonical JSON snapshot of the bundle graph for parity comparison.
+ * Gated by ATLASPACK_DUMP_BUNDLE_GRAPH environment variable which specifies the output directory.
+ * The snapshot captures bundle identity, type, contained assets, and bundle group structure
+ * in a deterministic, sorted format suitable for diffing.
+ */
+function dumpBundleGraphSnapshot(bundleGraph, variant) {
+    let outDir = process.env.ATLASPACK_DUMP_BUNDLE_GRAPH;
+    if (!outDir)
+        return;
+    let filename = variant === 'js' ? 'bundle-graph-js.json' : 'bundle-graph-rust.json';
+    let outPath = path_1.default.join(outDir, filename);
+    fs_1.default.mkdirSync(outDir, { recursive: true });
+    let bundles = bundleGraph.getBundles();
+    let bundlesSnapshot = bundles
+        .map((bundle) => {
+        let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.id);
+        let containedAssetNodeIds = bundleGraph._graph.getNodeIdsConnectedFrom(bundleNodeId, BundleGraph_1.bundleGraphEdgeTypes.contains);
+        let containedAssets = containedAssetNodeIds
+            .map((nodeId) => bundleGraph._graph.getNode(nodeId))
+            .flatMap((node) => {
+            if (node?.type !== 'asset')
+                return [];
+            return [
+                {
+                    id: node.value.id,
+                    filePath: (0, projectPath_1.fromProjectPathRelative)(node.value.filePath),
+                },
+            ];
+        })
+            .sort((a, b) => a.filePath.localeCompare(b.filePath));
+        // Resolve mainEntry and entry asset file paths
+        let mainEntryPath = null;
+        let entryAssetPaths = [];
+        if (bundle.mainEntryId) {
+            let mainEntryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundle.mainEntryId);
+            let mainEntryNode = bundleGraph._graph.getNode(mainEntryNodeId);
+            if (mainEntryNode?.type === 'asset') {
+                mainEntryPath = (0, projectPath_1.fromProjectPathRelative)(mainEntryNode.value.filePath);
+            }
+        }
+        for (let entryId of bundle.entryAssetIds) {
+            let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(entryId);
+            let entryNode = bundleGraph._graph.getNode(entryNodeId);
+            if (entryNode?.type === 'asset') {
+                entryAssetPaths.push((0, projectPath_1.fromProjectPathRelative)(entryNode.value.filePath));
+            }
+        }
+        entryAssetPaths.sort();
+        return {
+            id: bundle.id,
+            type: bundle.type,
+            bundleBehavior: bundle.bundleBehavior ?? null,
+            needsStableName: bundle.needsStableName,
+            isSplittable: bundle.isSplittable,
+            isPlaceholder: bundle.isPlaceholder,
+            mainEntryPath,
+            entryAssetPaths,
+            assets: containedAssets.map((a) => a.filePath),
+        };
+    })
+        .sort((a, b) => {
+        // Sort by mainEntryPath first, then by sorted assets as tiebreaker
+        let aKey = a.mainEntryPath || a.assets.join(',');
+        let bKey = b.mainEntryPath || b.assets.join(',');
+        return aKey.localeCompare(bKey);
+    });
+    let bundleGroupsSnapshot = bundleGraph._graph.nodes
+        .flatMap((node) => {
+        if (node?.type !== 'bundle_group')
+            return [];
+        let bundleGroup = node.value;
+        // Resolve entry asset file path
+        let entryAssetPath = null;
+        try {
+            let entryNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleGroup.entryAssetId);
+            let entryNode = bundleGraph._graph.getNode(entryNodeId);
+            if (entryNode?.type === 'asset') {
+                entryAssetPath = (0, projectPath_1.fromProjectPathRelative)(entryNode.value.filePath);
+            }
+        }
+        catch {
+            // Content key not found
+        }
+        let bundlesInGroup = bundleGraph.getBundlesInBundleGroup(bundleGroup);
+        let bundlePaths = bundlesInGroup
+            .map((b) => {
+            // Use mainEntry file path if available, otherwise bundle id as fallback
+            if (b.mainEntryId) {
+                try {
+                    let nodeId = bundleGraph._graph.getNodeIdByContentKey(b.mainEntryId);
+                    let node = bundleGraph._graph.getNode(nodeId);
+                    if (node?.type === 'asset') {
+                        return (0, projectPath_1.fromProjectPathRelative)(node.value.filePath);
+                    }
+                }
+                catch {
+                    // fallback
+                }
+            }
+            return `[bundle:${b.id}]`;
+        })
+            .sort();
+        return [
+            {
+                entryAssetPath: entryAssetPath ?? `[unknown:${bundleGroup.entryAssetId}]`,
+                bundlePaths,
+            },
+        ];
+    })
+        .sort((a, b) => a.entryAssetPath.localeCompare(b.entryAssetPath));
+    let totalAssets = bundleGraph._graph.nodes.filter((node) => node?.type === 'asset').length;
+    let snapshot = {
+        version: 1,
+        variant,
+        stats: {
+            totalBundles: bundlesSnapshot.length,
+            totalBundleGroups: bundleGroupsSnapshot.length,
+            totalAssets,
+        },
+        bundles: bundlesSnapshot,
+        bundleGroups: bundleGroupsSnapshot,
+    };
+    fs_1.default.writeFileSync(outPath, JSON.stringify(snapshot, null, 2), 'utf8');
+    // eslint-disable-next-line no-console
+    console.log(`[BundleGraphSnapshot] Wrote ${variant} snapshot to ${outPath}`);
+}
 /**
  * Names a bundle by running through the configured namers until one returns a name.
  */
 async function nameBundle(namers, internalBundle, internalBundleGraph, options, pluginOptions, configs) {
     const bundle = Bundle_1.Bundle.get(internalBundle, internalBundleGraph, options);
-    const bundleGraph = new BundleGraph_1.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options);
+    const bundleGraph = new BundleGraph_2.default(internalBundleGraph, Bundle_1.NamedBundle.get.bind(Bundle_1.NamedBundle), options);
     for (const namer of namers) {
         let measurement;
         try {

package/dist/requests/PackageRequest.js

@@ -34,7 +34,7 @@ async function run({ input, api, farm, rustAtlaspack }) {
         (0, EnvironmentManager_1.fromEnvironmentId)(bundle.env).context === 'tesseract' &&
         bundle.type === 'js') {
         // Once this actually does something, the code below will be in an `else` block (i.e. we'll only run one or the other)
-        let result = await rustAtlaspack.package(bundle.id);
+        let result = await rustAtlaspack.package(bundle.id, { inlineRequires: true });
         let error = null;
         [packagingResult, error] = result;
         if (error) {

package/dist/requests/TargetRequest.js

@@ -227,6 +227,7 @@ class TargetResolver {
                         distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.resolve(this.fs.cwd(), distDir)),
                         publicUrl: descriptor.publicUrl ??
                             this.options.defaultTargetOptions.publicUrl,
+                        inlineRequires: descriptor.inlineRequires ?? false,
                         env: (0, Environment_1.createEnvironment)({
                             engines: descriptor.engines,
                             context: descriptor.context,
@@ -299,6 +300,7 @@ class TargetResolver {
                         name: 'default',
                         distDir: (0, projectPath_1.toProjectPath)(this.options.projectRoot, this.options.serveOptions.distDir),
                         publicUrl: this.options.defaultTargetOptions.publicUrl ?? '/',
+                        inlineRequires: false,
                         env: (0, Environment_1.createEnvironment)({
                             context: 'browser',
                             engines: {
@@ -705,6 +707,7 @@ class TargetResolver {
                     distDir,
                     distEntry,
                     publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    inlineRequires: descriptor.inlineRequires ?? false,
                     env: (0, Environment_1.createEnvironment)({
                         engines: descriptor.engines ?? pkgEngines,
                         // @ts-expect-error TS2322
@@ -870,6 +873,7 @@ class TargetResolver {
                         : distDir),
                     distEntry,
                     publicUrl: descriptor.publicUrl ?? this.options.defaultTargetOptions.publicUrl,
+                    inlineRequires: descriptor.inlineRequires ?? false,
                     env: (0, Environment_1.createEnvironment)({
                         engines: descriptor.engines ?? pkgEngines,
                         context: descriptor.context,
@@ -932,6 +936,7 @@ class TargetResolver {
                 distDir: this.options.defaultTargetOptions.distDir ??
                     (0, projectPath_1.toProjectPath)(this.options.projectRoot, path_1.default.join(pkgDir, DEFAULT_DIST_DIRNAME)),
                 publicUrl: this.options.defaultTargetOptions.publicUrl,
+                inlineRequires: false,
                 env: (0, Environment_1.createEnvironment)({
                     engines: pkgEngines,
                     // @ts-expect-error TS2322