nx 22.7.0 → 23.0.0-beta.0

package/dist/src/project-graph/utils/project-configuration/target-merging.js

@@ -5,13 +5,10 @@ exports.resolveCommandSyntacticSugar = resolveCommandSyntacticSugar;
 exports.mergeMetadata = mergeMetadata;
 exports.mergeTargetConfigurations = mergeTargetConfigurations;
 exports.isCompatibleTarget = isCompatibleTarget;
-exports.mergeTargetDefaultWithTargetDefinition = mergeTargetDefaultWithTargetDefinition;
 exports.resolveNxTokensInOptions = resolveNxTokensInOptions;
-exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
 const logger_1 = require("../../../utils/logger");
-const globs_1 = require("../../../utils/globs");
 const source_maps_1 = require("./source-maps");
-const minimatch_1 = require("minimatch");
+const utils_1 = require("./utils");
 function deepClone(obj) {
     return structuredClone(obj);
 }
@@ -91,40 +88,154 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
     }
     return result;
 }
-function mergeOptions(newOptions, baseOptions, projectConfigSourceMap, sourceInformation, targetIdentifier) {
-    const mergedOptions = {
-        ...(baseOptions ?? {}),
-        ...(newOptions ?? {}),
-    };
-    // record new options & option properties in source map
-    if (projectConfigSourceMap) {
-        for (const newOption in newOptions) {
-            projectConfigSourceMap[`${targetIdentifier}.options.${newOption}`] =
-                sourceInformation;
-        }
+function mergeOptions(newOptions, baseOptions, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
+    // `'...'` at the options level uses object-spread semantics.
+    if (newOptions?.[utils_1.NX_SPREAD_TOKEN] === true) {
+        return (0, utils_1.getMergeValueResult)(baseOptions, newOptions, projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.options`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    const mergedOptionKeys = (0, utils_1.uniqueKeysInObjects)(baseOptions ?? {}, newOptions ?? {});
+    const mergedOptions = {};
+    for (const optionKey of mergedOptionKeys) {
+        mergedOptions[optionKey] = (0, utils_1.getMergeValueResult)(baseOptions ? baseOptions[optionKey] : undefined, newOptions ? newOptions[optionKey] : undefined, projectConfigSourceMap
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${targetIdentifier}.options.${optionKey}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
     }
     return mergedOptions;
 }
-function mergeConfigurations(newConfigurations, baseConfigurations, projectConfigSourceMap, sourceInformation, targetIdentifier) {
+// Merges a single named configuration, keyed under its own identifier
+// (e.g. `targets.build.configurations.prod`) rather than under `.options`.
+// Source-map correctness for the spread case is handled inside
+// `getMergeValueResult`'s object-spread path — no post-merge fix-up needed.
+function mergeConfigurationValue(newConfig, baseConfig, projectConfigSourceMap, sourceInformation, configIdentifier, deferSpreadsWithoutBase) {
+    if (newConfig?.[utils_1.NX_SPREAD_TOKEN] === true) {
+        return (0, utils_1.getMergeValueResult)(baseConfig, newConfig, projectConfigSourceMap && configIdentifier
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: configIdentifier,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    const mergedKeys = (0, utils_1.uniqueKeysInObjects)(baseConfig ?? {}, newConfig ?? {});
+    const merged = {};
+    for (const key of mergedKeys) {
+        merged[key] = (0, utils_1.getMergeValueResult)(baseConfig ? baseConfig[key] : undefined, newConfig ? newConfig[key] : undefined, projectConfigSourceMap && configIdentifier
+            ? {
+                sourceMap: projectConfigSourceMap,
+                key: `${configIdentifier}.${key}`,
+                sourceInformation,
+            }
+            : undefined, deferSpreadsWithoutBase);
+    }
+    return merged;
+}
+function mergeConfigurations(newConfigurations, baseConfigurations, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
     const mergedConfigurations = {};
-    const configurations = new Set([
-        ...Object.keys(baseConfigurations ?? {}),
-        ...Object.keys(newConfigurations ?? {}),
-    ]);
-    for (const configuration of configurations) {
-        mergedConfigurations[configuration] = {
-            ...(baseConfigurations?.[configuration] ?? {}),
-            ...(newConfigurations?.[configuration] ?? {}),
+    // Keys before '...' let base win for shared names; keys after '...'
+    // (or when there's no spread) merge normally with new winning.
+    const newKeys = Object.keys(newConfigurations ?? {});
+    const spreadPosInNew = newKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const hasSpread = spreadPosInNew >= 0;
+    const keysBeforeSpread = hasSpread
+        ? new Set(newKeys.slice(0, spreadPosInNew))
+        : new Set();
+    // Integer-like keys get hoisted to newKeys[0], making their position
+    // relative to '...' unrecoverable.
+    if (hasSpread && newKeys[0] && utils_1.INTEGER_LIKE_KEY_PATTERN.test(newKeys[0])) {
+        throw new utils_1.IntegerLikeSpreadKeyError(newKeys[0], targetIdentifier
+            ? `Configurations at "${targetIdentifier}.configurations"`
+            : 'Configurations');
+    }
+    // Preserving the unresolved `'...'` sentinel in authored position lets
+    // a later merge layer (which actually has a base) classify the keys as
+    // pre/post-spread correctly.
+    const preserveSpreadSentinel = hasSpread && deferSpreadsWithoutBase && baseConfigurations === undefined;
+    const processConfigName = (configName) => {
+        const configIdentifier = targetIdentifier
+            ? `${targetIdentifier}.configurations.${configName}`
+            : undefined;
+        const baseHasConfig = configName in (baseConfigurations ?? {});
+        const newHasConfig = !!newConfigurations && configName in newConfigurations;
+        if (hasSpread && keysBeforeSpread.has(configName)) {
+            // Before '...': base wins for shared names. Keep base's source-map
+            // entries when it owns the config.
+            if (baseHasConfig) {
+                mergedConfigurations[configName] = baseConfigurations[configName];
+            }
+            else {
+                mergedConfigurations[configName] = mergeConfigurationValue(newConfigurations?.[configName], undefined, projectConfigSourceMap, sourceInformation, configIdentifier, deferSpreadsWithoutBase);
+                if (projectConfigSourceMap && configIdentifier) {
+                    projectConfigSourceMap[configIdentifier] = sourceInformation;
+                }
+            }
+            return;
+        }
+        mergedConfigurations[configName] = mergeConfigurationValue(newConfigurations?.[configName], baseConfigurations?.[configName], projectConfigSourceMap, sourceInformation, configIdentifier, deferSpreadsWithoutBase);
+        // Only reattribute the config name when the new plugin introduced it.
+        if (projectConfigSourceMap &&
+            configIdentifier &&
+            newHasConfig &&
+            !baseHasConfig) {
+            projectConfigSourceMap[configIdentifier] = sourceInformation;
+        }
+    };
+    if (hasSpread) {
+        // Authored positions of new's own keys relative to `'...'` drive
+        // pre/post-spread classification, so those keys go in authored order.
+        // Base-only keys land right before `'...'` — they weren't authored by
+        // the new layer, so default semantics places them with the pre-spread
+        // keys (the "base layer" slot).
+        const baseOnlyKeys = baseConfigurations
+            ? Object.keys(baseConfigurations).filter((k) => k !== utils_1.NX_SPREAD_TOKEN && !(k in (newConfigurations ?? {})))
+            : [];
+        let baseOnlyInserted = false;
+        const insertBaseOnlyKeys = () => {
+            if (baseOnlyInserted)
+                return;
+            baseOnlyInserted = true;
+            for (const configName of baseOnlyKeys)
+                processConfigName(configName);
         };
+        for (const configName of newKeys) {
+            if (configName === utils_1.NX_SPREAD_TOKEN) {
+                insertBaseOnlyKeys();
+                if (preserveSpreadSentinel) {
+                    mergedConfigurations[utils_1.NX_SPREAD_TOKEN] =
+                        true;
+                }
+                continue;
+            }
+            processConfigName(configName);
+        }
+        insertBaseOnlyKeys();
     }
-    // record new configurations & configuration properties in source map
-    if (projectConfigSourceMap) {
-        for (const newConfiguration in newConfigurations) {
-            projectConfigSourceMap[`${targetIdentifier}.configurations.${newConfiguration}`] = sourceInformation;
-            for (const configurationProperty in newConfigurations[newConfiguration]) {
-                projectConfigSourceMap[`${targetIdentifier}.configurations.${newConfiguration}.${configurationProperty}`] = sourceInformation;
+    else {
+        // No spread — classic `{ ...base, ...new }` ordering: base keys
+        // first, new-only keys after. Shared configs stay at base's position.
+        if (baseConfigurations) {
+            for (const configName of Object.keys(baseConfigurations)) {
+                if (configName === utils_1.NX_SPREAD_TOKEN)
+                    continue;
+                processConfigName(configName);
             }
         }
+        for (const configName of newKeys) {
+            if (configName === utils_1.NX_SPREAD_TOKEN)
+                continue;
+            if (configName in mergedConfigurations)
+                continue;
+            processConfigName(configName);
+        }
     }
     return mergedConfigurations;
 }
@@ -141,7 +252,7 @@ function mergeConfigurations(newConfigurations, baseConfigurations, projectConfi
  * @param targetIdentifier The identifier for the target to merge, used for source map
  * @returns A merged target configuration
  */
-function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, sourceInformation, targetIdentifier) {
+function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase) {
     const { configurations: defaultConfigurations, options: defaultOptions, ...baseTargetProperties } = baseTarget ?? {};
     // Target is "compatible", e.g. executor is defined only once or is the same
     // in both places. This means that it is likely safe to merge
@@ -156,28 +267,136 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
         }
     }
     // merge top level properties if they're compatible
-    const result = {
-        ...(isCompatible ? baseTargetProperties : {}),
-        ...target,
+    const result = {};
+    const mergeBase = isCompatible ? baseTargetProperties : {};
+    // Keys before '...' let base win; keys after '...' (or when there's no
+    // spread) merge normally with target winning.
+    const targetKeys = Object.keys(target);
+    const spreadPosInTarget = targetKeys.indexOf(utils_1.NX_SPREAD_TOKEN);
+    const hasSpread = isCompatible && spreadPosInTarget >= 0;
+    const keysBeforeSpread = hasSpread
+        ? new Set(targetKeys.slice(0, spreadPosInTarget))
+        : new Set();
+    // Integer-like keys get hoisted to targetKeys[0], making their position
+    // relative to '...' unrecoverable.
+    if (hasSpread &&
+        targetKeys[0] &&
+        utils_1.INTEGER_LIKE_KEY_PATTERN.test(targetKeys[0])) {
+        throw new utils_1.IntegerLikeSpreadKeyError(targetKeys[0], targetIdentifier ? `Target at "${targetIdentifier}"` : 'Target');
+    }
+    // Preserving the unresolved `'...'` sentinel in authored position lets a
+    // later merge layer (which actually has a base) classify sibling keys as
+    // pre/post-spread correctly.
+    const preserveSpreadSentinel = spreadPosInTarget >= 0 &&
+        deferSpreadsWithoutBase &&
+        baseTarget === undefined;
+    const skipForOwnMerge = new Set([
+        'options',
+        'configurations',
+        utils_1.NX_SPREAD_TOKEN,
+    ]);
+    const processKey = (key) => {
+        if (skipForOwnMerge.has(key))
+            return;
+        if (hasSpread && keysBeforeSpread.has(key)) {
+            // Before '...': base wins; fall through to target only if base lacks it.
+            result[key] =
+                key in mergeBase
+                    ? mergeBase[key]
+                    : (0, utils_1.getMergeValueResult)(undefined, target[key], projectConfigSourceMap
+                        ? {
+                            sourceMap: projectConfigSourceMap,
+                            key: `${targetIdentifier}.${key}`,
+                            sourceInformation,
+                        }
+                        : undefined, deferSpreadsWithoutBase);
+            return;
+        }
+        if (key in target) {
+            result[key] = (0, utils_1.getMergeValueResult)(mergeBase[key], target[key], projectConfigSourceMap
+                ? {
+                    sourceMap: projectConfigSourceMap,
+                    key: `${targetIdentifier}.${key}`,
+                    sourceInformation,
+                }
+                : undefined, deferSpreadsWithoutBase);
+        }
+        else {
+            result[key] = mergeBase[key];
+        }
     };
-    // record top level properties in source map
+    if (isCompatible) {
+        if (hasSpread) {
+            // Authored positions of the target's own keys relative to `'...'`
+            // drive pre/post-spread classification, so those keys go in
+            // authored order. Base-only keys land right before `'...'` — they
+            // weren't authored, so default semantics ("base layer that yields
+            // to a higher-priority layer") places them with the rest of the
+            // pre-spread keys.
+            const baseOnlyKeys = Object.keys(baseTargetProperties).filter((k) => !skipForOwnMerge.has(k) && !(k in target));
+            let baseOnlyInserted = false;
+            const insertBaseOnlyKeys = () => {
+                if (baseOnlyInserted)
+                    return;
+                baseOnlyInserted = true;
+                for (const key of baseOnlyKeys)
+                    processKey(key);
+            };
+            for (const key of targetKeys) {
+                if (key === utils_1.NX_SPREAD_TOKEN) {
+                    insertBaseOnlyKeys();
+                    if (preserveSpreadSentinel) {
+                        result[utils_1.NX_SPREAD_TOKEN] = true;
+                    }
+                    continue;
+                }
+                if (skipForOwnMerge.has(key))
+                    continue;
+                processKey(key);
+            }
+            // Safety for a sentinel-less iteration (shouldn't happen when
+            // hasSpread is true, but keeps the base-only keys emitted).
+            insertBaseOnlyKeys();
+        }
+        else {
+            // No spread — classic `{ ...base, ...target }` ordering: base keys
+            // first (preserving their own-key order), target-only keys after.
+            // Shared keys stay at base's position with per-key merged value.
+            const mergedKeys = (0, utils_1.uniqueKeysInObjects)(baseTargetProperties, target);
+            for (const key of mergedKeys) {
+                if (skipForOwnMerge.has(key))
+                    continue;
+                processKey(key);
+            }
+        }
+    }
+    else {
+        for (const key of targetKeys) {
+            if (skipForOwnMerge.has(key))
+                continue;
+            processKey(key);
+        }
+    }
+    // Update source map once after loop
     if (projectConfigSourceMap) {
         projectConfigSourceMap[targetIdentifier] = sourceInformation;
-        // record root level target properties to source map
-        for (const targetProperty in target) {
-            const targetPropertyId = `${targetIdentifier}.${targetProperty}`;
-            projectConfigSourceMap[targetPropertyId] = sourceInformation;
-        }
     }
     // merge options if there are any
     // if the targets aren't compatible, we simply discard the old options during the merge
     if (target.options || defaultOptions) {
-        result.options = mergeOptions(target.options, isCompatible ? defaultOptions : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier);
+        result.options = mergeOptions(target.options, isCompatible ? defaultOptions : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (projectConfigSourceMap && target.options) {
+            projectConfigSourceMap[`${targetIdentifier}.options`] = sourceInformation;
+        }
     }
     // merge configurations if there are any
     // if the targets aren't compatible, we simply discard the old configurations during the merge
     if (target.configurations || defaultConfigurations) {
-        result.configurations = mergeConfigurations(target.configurations, isCompatible ? defaultConfigurations : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier);
+        result.configurations = mergeConfigurations(target.configurations, isCompatible ? defaultConfigurations : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier, deferSpreadsWithoutBase);
+        if (projectConfigSourceMap && target.configurations) {
+            projectConfigSourceMap[`${targetIdentifier}.configurations`] =
+                sourceInformation;
+        }
     }
     if (target.metadata) {
         result.metadata = mergeMetadata(projectConfigSourceMap, sourceInformation, `${targetIdentifier}.metadata`, target.metadata, baseTarget?.metadata);
@@ -216,73 +435,6 @@ function isCompatibleTarget(a, b) {
     }
     return true;
 }
-function targetDefaultShouldBeApplied(key, sourceMap) {
-    const sourceInfo = sourceMap[key];
-    if (!sourceInfo) {
-        return true;
-    }
-    // The defined value of the target is from a plugin that
-    // isn't part of Nx's core plugins, so target defaults are
-    // applied on top of it.
-    const [, plugin] = sourceInfo;
-    return !plugin?.startsWith('nx/');
-}
-function mergeTargetDefaultWithTargetDefinition(targetName, project, targetDefault, sourceMap) {
-    const targetDefinition = project.targets[targetName] ?? {};
-    const result = deepClone(targetDefinition);
-    for (const key in targetDefault) {
-        switch (key) {
-            case 'options': {
-                const normalizedDefaults = resolveNxTokensInOptions(targetDefault.options, project, targetName);
-                for (const optionKey in normalizedDefaults) {
-                    const sourceMapKey = (0, source_maps_1.targetOptionSourceMapKey)(targetName, optionKey);
-                    if (targetDefinition.options[optionKey] === undefined ||
-                        targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
-                        result.options[optionKey] = targetDefault.options[optionKey];
-                        sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
-                    }
-                }
-                break;
-            }
-            case 'configurations': {
-                if (!result.configurations) {
-                    result.configurations = {};
-                    sourceMap[(0, source_maps_1.targetConfigurationsSourceMapKey)(targetName)] = [
-                        'nx.json',
-                        'nx/target-defaults',
-                    ];
-                }
-                for (const configuration in targetDefault.configurations) {
-                    if (!result.configurations[configuration]) {
-                        result.configurations[configuration] = {};
-                        sourceMap[(0, source_maps_1.targetConfigurationsSourceMapKey)(targetName, configuration)] = ['nx.json', 'nx/target-defaults'];
-                    }
-                    const normalizedConfigurationDefaults = resolveNxTokensInOptions(targetDefault.configurations[configuration], project, targetName);
-                    for (const configurationKey in normalizedConfigurationDefaults) {
-                        const sourceMapKey = (0, source_maps_1.targetConfigurationsSourceMapKey)(targetName, configuration, configurationKey);
-                        if (targetDefinition.configurations?.[configuration]?.[configurationKey] === undefined ||
-                            targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
-                            result.configurations[configuration][configurationKey] =
-                                targetDefault.configurations[configuration][configurationKey];
-                            sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
-                        }
-                    }
-                }
-                break;
-            }
-            default: {
-                const sourceMapKey = `targets.${targetName}.${key}`;
-                if (targetDefinition[key] === undefined ||
-                    targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
-                    result[key] = targetDefault[key];
-                    sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
-                }
-                break;
-            }
-        }
-    }
-    return result;
-}
 function resolveNxTokensInOptions(object, project, key) {
     const result = Array.isArray(object) ? [...object] : { ...object };
     for (let [opt, value] of Object.entries(object ?? {})) {
@@ -303,30 +455,3 @@ function resolveNxTokensInOptions(object, project, key) {
     }
     return result;
 }
-function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
-    if (executor && targetDefaults?.[executor]) {
-        // If an executor is defined in project.json, defaults should be read
-        // from the most specific key that matches that executor.
-        // e.g. If executor === run-commands, and the target is named build:
-        // Use, use nx:run-commands if it is present
-        // If not, use build if it is present.
-        return targetDefaults?.[executor];
-    }
-    else if (targetDefaults?.[targetName]) {
-        // If the executor is not defined, the only key we have is the target name.
-        return targetDefaults?.[targetName];
-    }
-    let matchingTargetDefaultKey = null;
-    for (const key in targetDefaults ?? {}) {
-        if ((0, globs_1.isGlobPattern)(key) && (0, minimatch_1.minimatch)(targetName, key)) {
-            if (!matchingTargetDefaultKey ||
-                matchingTargetDefaultKey.length < key.length) {
-                matchingTargetDefaultKey = key;
-            }
-        }
-    }
-    if (matchingTargetDefaultKey) {
-        return targetDefaults[matchingTargetDefaultKey];
-    }
-    return null;
-}

package/dist/src/project-graph/utils/project-configuration/target-normalization.js

@@ -73,13 +73,6 @@ projects) {
     const targetErrorMessage = [];
     for (const targetName in project.targets) {
         project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
-        const projectSourceMaps = sourceMaps[project.root];
-        const targetConfig = project.targets[targetName];
-        const targetDefaults = (0, target_merging_1.deepClone)((0, target_merging_1.readTargetDefaultsForTarget)(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor));
-        // We only apply defaults if they exist
-        if (targetDefaults && (0, target_merging_1.isCompatibleTarget)(targetConfig, targetDefaults)) {
-            project.targets[targetName] = (0, target_merging_1.mergeTargetDefaultWithTargetDefinition)(targetName, project, normalizeTarget(targetDefaults, project, workspaceRoot, projects, ['nx.json[targetDefaults]', targetName].join(':')), projectSourceMaps);
-        }
         const target = project.targets[targetName];
         if (
         // If the target has no executor or command, it doesn't do anything

package/dist/src/project-graph/utils/project-configuration/utils.d.ts

@@ -0,0 +1,23 @@
+import { type SourceInformation } from './source-maps';
+export declare const NX_SPREAD_TOKEN = "...";
+/**
+ * Returns the union of keys across every provided object.
+ */
+export declare function uniqueKeysInObjects(...objs: Array<object | null | undefined>): Set<string>;
+export declare const INTEGER_LIKE_KEY_PATTERN: RegExp;
+export declare class IntegerLikeSpreadKeyError extends Error {
+    constructor(key: string, context: string);
+}
+type SourceMapContext = {
+    sourceMap: Record<string, SourceInformation>;
+    key: string;
+    sourceInformation: SourceInformation;
+};
+/**
+ * `"..."` in `newValue` (as an array element or a key set to `true`)
+ * expands the base at that position; otherwise `newValue` replaces
+ * `baseValue`. With `deferSpreadsWithoutBase`, an unresolvable spread is
+ * preserved so a later merge layer can expand it.
+ */
+export declare function getMergeValueResult<T>(baseValue: unknown, newValue: T | undefined, sourceMapContext?: SourceMapContext, deferSpreadsWithoutBase?: boolean): T | undefined;
+export {};

package/dist/src/project-graph/utils/project-configuration/utils.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerLikeSpreadKeyError = exports.INTEGER_LIKE_KEY_PATTERN = exports.NX_SPREAD_TOKEN = void 0;
+exports.uniqueKeysInObjects = uniqueKeysInObjects;
+exports.getMergeValueResult = getMergeValueResult;
+const source_maps_1 = require("./source-maps");
+exports.NX_SPREAD_TOKEN = '...';
+/**
+ * Returns the union of keys across every provided object.
+ */
+function uniqueKeysInObjects(...objs) {
+    const keys = new Set();
+    for (const obj of objs) {
+        if (obj) {
+            for (const key of Object.keys(obj)) {
+                keys.add(key);
+            }
+        }
+    }
+    return keys;
+}
+// Integer-like string keys (`"0"`, `"42"`) are enumerated before
+// insertion-order keys, so we can't tell if they were authored before or
+// after `'...'`. Spread sites reject them instead of guessing.
+exports.INTEGER_LIKE_KEY_PATTERN = /^(0|[1-9]\d*)$/;
+class IntegerLikeSpreadKeyError extends Error {
+    constructor(key, context) {
+        super(`${context} uses an integer-like key (${JSON.stringify(key)}) alongside the '...' spread token. Integer-like keys are enumerated before other keys regardless of authored order, so their position relative to '...' is ambiguous. Rename the key (e.g. add a non-numeric prefix) or restructure the object.`);
+        this.name = 'IntegerLikeSpreadKeyError';
+    }
+}
+exports.IntegerLikeSpreadKeyError = IntegerLikeSpreadKeyError;
+/**
+ * `"..."` in `newValue` (as an array element or a key set to `true`)
+ * expands the base at that position; otherwise `newValue` replaces
+ * `baseValue`. With `deferSpreadsWithoutBase`, an unresolvable spread is
+ * preserved so a later merge layer can expand it.
+ */
+function getMergeValueResult(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase) {
+    if (newValue === undefined && baseValue !== undefined) {
+        return baseValue;
+    }
+    if (Array.isArray(newValue)) {
+        return mergeArrayValue(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase);
+    }
+    if (isObject(newValue) && newValue[exports.NX_SPREAD_TOKEN] === true) {
+        return mergeObjectWithSpread(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase);
+    }
+    // Scalar / null / plain object replace — newValue fully wins.
+    writeTopLevelSourceMap(sourceMapContext);
+    return newValue;
+}
+function mergeArrayValue(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase) {
+    const newSpreadIndex = newValue.findIndex((v) => v === exports.NX_SPREAD_TOKEN);
+    if (newSpreadIndex === -1) {
+        // No spread: newValue replaces baseValue entirely.
+        if (sourceMapContext) {
+            for (let i = 0; i < newValue.length; i++) {
+                sourceMapContext.sourceMap[`${sourceMapContext.key}.${i}`] =
+                    sourceMapContext.sourceInformation;
+            }
+        }
+        writeTopLevelSourceMap(sourceMapContext);
+        return newValue;
+    }
+    const baseArray = Array.isArray(baseValue) ? baseValue : [];
+    // Snapshot per-index base sources before we start writing — the loop
+    // writes into the same `${key}.${i}` entries it needs to read back when
+    // the spread expands. Unlike object spread, array spreads can overwrite
+    // indices during their own expansion (when new authors a prefix before
+    // `'...'`), so lazy capture isn't sufficient here.
+    const basePerIndexSources = sourceMapContext
+        ? baseArray.map((_, i) => (0, source_maps_1.readArrayItemSourceInfo)(sourceMapContext.sourceMap, sourceMapContext.key, i))
+        : [];
+    const result = [];
+    const recordAt = (resultIdx, info) => {
+        if (sourceMapContext && info) {
+            sourceMapContext.sourceMap[`${sourceMapContext.key}.${resultIdx}`] = info;
+        }
+    };
+    for (let newValueIndex = 0; newValueIndex < newValue.length; newValueIndex++) {
+        const element = newValue[newValueIndex];
+        if (element === exports.NX_SPREAD_TOKEN) {
+            if (deferSpreadsWithoutBase && baseValue === undefined) {
+                recordAt(result.length, sourceMapContext?.sourceInformation);
+                result.push(exports.NX_SPREAD_TOKEN);
+            }
+            else {
+                for (let baseIndex = 0; baseIndex < baseArray.length; baseIndex++) {
+                    recordAt(result.length, basePerIndexSources[baseIndex]);
+                    result.push(baseArray[baseIndex]);
+                }
+            }
+            continue;
+        }
+        recordAt(result.length, sourceMapContext?.sourceInformation);
+        result.push(element);
+    }
+    writeTopLevelSourceMap(sourceMapContext);
+    return result;
+}
+function mergeObjectWithSpread(baseValue, newValue, sourceMapContext, deferSpreadsWithoutBase) {
+    const baseObj = isObject(baseValue) ? baseValue : {};
+    const result = {};
+    const errorContext = sourceMapContext?.key
+        ? `Object at "${sourceMapContext.key}"`
+        : 'Object';
+    const newKeys = Object.keys(newValue);
+    // Integer-like keys are hoisted to the front of enumeration, so if one
+    // exists alongside `'...'` it must be newKeys[0].
+    if (newKeys[0] && exports.INTEGER_LIKE_KEY_PATTERN.test(newKeys[0])) {
+        throw new IntegerLikeSpreadKeyError(newKeys[0], errorContext);
+    }
+    // Base per-key sources captured lazily — only for shared keys the new
+    // object overwrites before `'...'`, since writing their new source
+    // clobbers the base entry the spread will need to restore.
+    const capturedBaseSources = {};
+    for (const newKey of newKeys) {
+        if (newKey === exports.NX_SPREAD_TOKEN) {
+            if (deferSpreadsWithoutBase && baseValue === undefined) {
+                // Keep the sentinel for a later merge layer to resolve.
+                result[exports.NX_SPREAD_TOKEN] = true;
+                continue;
+            }
+            for (const baseKey of Object.keys(baseObj)) {
+                result[baseKey] = baseObj[baseKey];
+                if (sourceMapContext) {
+                    // If we captured a shared key pre-spread, use that; otherwise
+                    // the source map still holds the base entry untouched.
+                    const baseSource = Object.prototype.hasOwnProperty.call(capturedBaseSources, baseKey)
+                        ? capturedBaseSources[baseKey]
+                        : (0, source_maps_1.readObjectPropertySourceInfo)(sourceMapContext.sourceMap, sourceMapContext.key, baseKey);
+                    if (baseSource) {
+                        sourceMapContext.sourceMap[`${sourceMapContext.key}.${baseKey}`] =
+                            baseSource;
+                    }
+                }
+            }
+            continue;
+        }
+        // About to overwrite a base key's source — capture it first so the
+        // spread can restore it.
+        if (sourceMapContext &&
+            newKey in baseObj &&
+            !Object.prototype.hasOwnProperty.call(capturedBaseSources, newKey)) {
+            capturedBaseSources[newKey] = (0, source_maps_1.readObjectPropertySourceInfo)(sourceMapContext.sourceMap, sourceMapContext.key, newKey);
+        }
+        result[newKey] = newValue[newKey];
+        if (sourceMapContext) {
+            sourceMapContext.sourceMap[`${sourceMapContext.key}.${newKey}`] =
+                sourceMapContext.sourceInformation;
+        }
+    }
+    writeTopLevelSourceMap(sourceMapContext);
+    return result;
+}
+function writeTopLevelSourceMap(ctx) {
+    if (ctx) {
+        ctx.sourceMap[ctx.key] = ctx.sourceInformation;
+    }
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}