@salesforce/webapp-template-cli-experimental 1.3.3

package/dist/commands/apply-patches.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Apply feature patches to create a new app
+ *
+ * @param featurePath - Path to the feature directory containing feature.ts
+ * @param appPath - Path to the base app directory (used as reference, remains unchanged)
+ * @param options - Configuration options
+ * @param options.targetDirName - Required. Target directory where feature will be applied
+ * @param options.skipDependencyChanges - Optional. Skip npm dependency installation
+ * @param options.reset - Optional. Reset target directory to base app state before applying (preserves node_modules)
+ *
+ * @example
+ * await applyPatchesCommand(
+ *   'packages/feature-navigation-menu',
+ *   'packages/base-react-app',
+ *   { targetDirName: 'my-app' }
+ * );
+ */
+export declare function applyPatchesCommand(featurePath: string, appPath: string, options: {
+    targetDirName: string;
+    skipDependencyChanges?: boolean;
+    reset?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=apply-patches.d.ts.map

package/dist/commands/apply-patches.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patches.d.ts","sourceRoot":"","sources":["../../src/commands/apply-patches.ts"],"names":[],"mappings":"AAulBA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CACxC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAClF,OAAO,CAAC,IAAI,CAAC,CAwLf"}

package/dist/commands/apply-patches.js

@@ -0,0 +1,650 @@
+/**
+ * Copyright (c) 2026, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+import { randomBytes } from "crypto";
+import { cpSync, existsSync, rmSync, readdirSync, mkdirSync, readFileSync } from "fs";
+import { tmpdir } from "os";
+import { join, relative, basename, dirname, isAbsolute } from "path";
+import { resolveDependencies } from "../core/dependency-resolver.js";
+import { applyFile, copySiteContainerTemplate, deleteFile, prependToFile, appendToFile, processWebApplicationMetaFile, } from "../core/file-operations.js";
+import { mergePackageJson } from "../core/package-json-merger.js";
+import * as logger from "../utils/logger.js";
+import { getEffectivePathMappings, applyPathMappings } from "../utils/path-mappings.js";
+import { getMonorepoRoot, getSfdxProjectTemplatePath, getSiteContainerTemplatePath, translatePathToBaseApp, translatePathToTargetApp, } from "../utils/paths.js";
+import { validateAndResolveFeaturePath, validateAndResolveAppPath, getWebApplicationPath, } from "../utils/validation.js";
+/**
+ * Recursively discover all files in a directory
+ */
+function discoverFiles(dir, baseDir = dir) {
+    const files = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...discoverFiles(fullPath, baseDir));
+        }
+        else if (entry.isFile()) {
+            // Get relative path from baseDir
+            files.push(relative(baseDir, fullPath));
+        }
+    }
+    return files;
+}
+const WEBAPPLICATION_META_PATTERN = /^_webapplication\.webapplication-meta\.xml$/i;
+/**
+ * Process the webapplication meta file in the target app dir after a base copy:
+ * replace <%= masterLabel %> with app name and rename _webapplication.*-meta.xml to <appName>.webapplication-meta.xml.
+ */
+function processWebApplicationMetaInDir(targetAppDir, appName) {
+    if (!existsSync(targetAppDir))
+        return;
+    const entries = readdirSync(targetAppDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile() && WEBAPPLICATION_META_PATTERN.test(entry.name)) {
+            processWebApplicationMetaFile(join(targetAppDir, entry.name), appName);
+            return;
+        }
+    }
+}
+/**
+ * Reset target directory to match base app state (excluding node_modules).
+ * This syncs the target directory with the base app before applying features.
+ */
+function resetTargetToBaseApp(targetDir, baseAppPath, targetAppName) {
+    const targetAppDir = join(targetDir, "force-app", "main", "default", "webapplications", targetAppName);
+    const sourceWebAppPath = getWebApplicationPath(baseAppPath);
+    // Helper to check if path contains node_modules
+    const isNodeModulesPath = (path) => {
+        return path.split("/").includes("node_modules");
+    };
+    // Step 1: Remove files/directories from target that don't exist in base app
+    const removeExtraFiles = (targetPath, sourcePath) => {
+        if (!existsSync(targetPath))
+            return;
+        const entries = readdirSync(targetPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const targetEntryPath = join(targetPath, entry.name);
+            const sourceEntryPath = join(sourcePath, entry.name);
+            const relativeFromTarget = relative(targetAppDir, targetEntryPath);
+            // Skip node_modules
+            if (isNodeModulesPath(relativeFromTarget)) {
+                continue;
+            }
+            if (!existsSync(sourceEntryPath)) {
+                // Doesn't exist in base app, remove it
+                rmSync(targetEntryPath, { recursive: true, force: true });
+                const suffix = entry.isDirectory() ? "/" : "";
+                logger.info(`Removed: ${relativeFromTarget}${suffix}`);
+            }
+            else if (entry.isDirectory()) {
+                // Recurse into directory
+                removeExtraFiles(targetEntryPath, sourceEntryPath);
+            }
+        }
+    };
+    // Step 2: Copy/update files from base app to target
+    const syncFiles = (sourcePath, targetPath) => {
+        if (!existsSync(sourcePath))
+            return;
+        const entries = readdirSync(sourcePath, { withFileTypes: true });
+        for (const entry of entries) {
+            const sourceEntryPath = join(sourcePath, entry.name);
+            const targetEntryPath = join(targetPath, entry.name);
+            const relativeFromTarget = relative(targetAppDir, targetEntryPath);
+            // Skip node_modules
+            if (isNodeModulesPath(relativeFromTarget)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                // Ensure directory exists in target
+                if (!existsSync(targetEntryPath)) {
+                    mkdirSync(targetEntryPath, { recursive: true });
+                }
+                // Recurse into directory
+                syncFiles(sourceEntryPath, targetEntryPath);
+            }
+            else if (entry.isFile()) {
+                // Copy file if it doesn't exist or is different
+                let shouldCopy = false;
+                if (!existsSync(targetEntryPath)) {
+                    shouldCopy = true;
+                }
+                else {
+                    // Compare file contents
+                    const sourceContent = readFileSync(sourceEntryPath);
+                    const targetContent = readFileSync(targetEntryPath);
+                    shouldCopy = !sourceContent.equals(targetContent);
+                }
+                if (shouldCopy) {
+                    cpSync(sourceEntryPath, targetEntryPath);
+                    logger.info(`Synced: ${relativeFromTarget}`);
+                }
+            }
+        }
+    };
+    logger.info("Resetting target directory to base app state...");
+    removeExtraFiles(targetAppDir, sourceWebAppPath);
+    syncFiles(sourceWebAppPath, targetAppDir);
+    processWebApplicationMetaInDir(targetAppDir, targetAppName);
+    logger.success("Target directory reset complete");
+}
+const DELETE_PREFIX = "__delete__";
+const INHERIT_PREFIX = "__inherit__";
+const PREPEND_PREFIX = "__prepend__";
+const APPEND_PREFIX = "__append__";
+/**
+ * Check if a path component has the delete prefix and return the actual path
+ * Returns null if no delete prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/__delete__routes.tsx" -> "src/routes.tsx"
+ * - "src/__delete__pages" -> "src/pages"
+ * - "__delete__src/routes.tsx" -> "src/routes.tsx"
+ * - "src/routes.tsx" -> null (no prefix)
+ */
+function extractDeletePath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasDeletePrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(DELETE_PREFIX)) {
+            hasDeletePrefix = true;
+            return part.substring(DELETE_PREFIX.length);
+        }
+        return part;
+    });
+    return hasDeletePrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Check if a path component has the inherit prefix and return the actual path
+ * Returns null if no inherit prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/__inherit__routes.tsx" -> "src/routes.tsx"
+ * - "__inherit__src/routes.tsx" -> "src/routes.tsx"
+ * - "src/routes.tsx" -> null (no prefix)
+ */
+function extractInheritPath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasInheritPrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(INHERIT_PREFIX)) {
+            hasInheritPrefix = true;
+            return part.substring(INHERIT_PREFIX.length);
+        }
+        return part;
+    });
+    return hasInheritPrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Check if a path component has the prepend prefix and return the actual path
+ * Returns null if no prepend prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/styles/__prepend__global.css" -> "src/styles/global.css"
+ * - "__prepend__file.txt" -> "file.txt"
+ * - "src/file.tsx" -> null (no prefix)
+ */
+function extractPrependPath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasPrependPrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(PREPEND_PREFIX)) {
+            hasPrependPrefix = true;
+            return part.substring(PREPEND_PREFIX.length);
+        }
+        return part;
+    });
+    return hasPrependPrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Check if a path component has the append prefix and return the actual path
+ * Returns null if no append prefix is found, otherwise returns the actual path
+ *
+ * Examples:
+ * - "src/styles/__append__global.css" -> "src/styles/global.css"
+ * - "__append__file.txt" -> "file.txt"
+ * - "src/file.tsx" -> null (no prefix)
+ */
+function extractAppendPath(relativePath) {
+    const parts = relativePath.split("/");
+    let hasAppendPrefix = false;
+    const transformedParts = parts.map((part) => {
+        if (part.startsWith(APPEND_PREFIX)) {
+            hasAppendPrefix = true;
+            return part.substring(APPEND_PREFIX.length);
+        }
+        return part;
+    });
+    return hasAppendPrefix ? transformedParts.join("/") : null;
+}
+/**
+ * Apply a single feature's files to the target directory
+ * This is the core application logic extracted for reuse
+ */
+async function applySingleFeature(resolvedFeature, baseAppPath, targetDir, targetAppName) {
+    const { featureDir, config, featurePath } = resolvedFeature;
+    const { templateDir, routeFilePath, pathMappings } = config;
+    // Extract feature name for path translation
+    const featureName = basename(featurePath);
+    // Get effective path mappings for this feature
+    const effectiveMappings = getEffectivePathMappings(featureName, pathMappings);
+    // Discover and apply files from feature's template directory
+    const templatePath = join(featureDir, templateDir);
+    if (!existsSync(templatePath)) {
+        throw new Error(`Template directory '${templateDir}' does not exist in feature path '${featurePath}'`);
+    }
+    logger.heading(`\nApplying: ${featurePath}`);
+    logger.info("Discovering files...");
+    const discoveredFiles = discoverFiles(templatePath);
+    if (discoveredFiles.length === 0) {
+        throw new Error(`Feature '${featurePath}' has no files in ${templateDir} directory`);
+    }
+    logger.info(`Found ${discoveredFiles.length} file(s)`);
+    // Validate that there are no conflicting paths and that base files exist
+    logger.info("Validating paths...");
+    const normalizedPaths = new Map();
+    const deleteFiles = [];
+    const inheritFiles = [];
+    const prependFiles = [];
+    const appendFiles = [];
+    for (const relativePath of discoveredFiles) {
+        // Apply path mappings to transform template path
+        const mappedPath = applyPathMappings(relativePath, effectiveMappings);
+        const deleteTargetPath = extractDeletePath(mappedPath);
+        const inheritTargetPath = extractInheritPath(mappedPath);
+        const prependTargetPath = extractPrependPath(mappedPath);
+        const appendTargetPath = extractAppendPath(mappedPath);
+        let normalizedPath;
+        let type;
+        if (deleteTargetPath) {
+            normalizedPath = deleteTargetPath;
+            type = "delete";
+            deleteFiles.push(deleteTargetPath);
+        }
+        else if (inheritTargetPath) {
+            normalizedPath = inheritTargetPath;
+            type = "inherit";
+            inheritFiles.push(inheritTargetPath);
+        }
+        else if (prependTargetPath) {
+            normalizedPath = prependTargetPath;
+            type = "prepend";
+            prependFiles.push(prependTargetPath);
+        }
+        else if (appendTargetPath) {
+            normalizedPath = appendTargetPath;
+            type = "append";
+            appendFiles.push(appendTargetPath);
+        }
+        else {
+            normalizedPath = mappedPath;
+            type = "normal";
+        }
+        // Check for conflicts
+        if (normalizedPaths.has(normalizedPath)) {
+            const existing = normalizedPaths.get(normalizedPath);
+            logger.error("\nPath conflict detected!\n");
+            logger.info(`The following paths resolve to the same target file:`);
+            logger.info(`  1. ${existing.path} (${existing.type})`);
+            logger.info(`  2. ${relativePath} (${type})`);
+            logger.info(`  → Both target: ${normalizedPath}\n`);
+            logger.warning("You cannot have multiple files targeting the same path.");
+            logger.info("Please remove one of these files from the template directory.\n");
+            throw new Error("Path conflict - cannot proceed");
+        }
+        normalizedPaths.set(normalizedPath, { path: relativePath, type });
+    }
+    // Validate that files marked for deletion exist
+    // Note: Files may exist in target (from dependencies) or will be inherited from base app
+    for (const deleteFile of deleteFiles) {
+        // Translate feature path to target app path
+        const targetPath = translatePathToTargetApp(deleteFile, featureName, targetAppName);
+        const targetFilePath = join(targetDir, targetPath);
+        // If file doesn't exist in target yet, check if it will be copied from base app during deletion
+        if (!existsSync(targetFilePath)) {
+            // Check if file exists in base app (will be inherited during delete operation)
+            const translatedPath = translatePathToBaseApp(deleteFile, featureName, baseAppPath);
+            const baseFilePath = join(baseAppPath, translatedPath);
+            if (!existsSync(baseFilePath)) {
+                logger.error(`\nValidation error: Cannot delete file that doesn't exist!\n`);
+                logger.info(`File marked for deletion: ${deleteFile}`);
+                logger.info(`Not found in target: ${targetFilePath}`);
+                logger.info(`Not found in base app: ${baseFilePath}`);
+                logger.warning(`The file must exist in target or base app to be deleted.\n`);
+                throw new Error("Delete validation failed - cannot proceed");
+            }
+        }
+    }
+    // Validate that files marked for inheritance exist in base app
+    for (const inheritFile of inheritFiles) {
+        // Translate feature path to target app path
+        const targetPath = translatePathToTargetApp(inheritFile, featureName, targetAppName);
+        const targetFilePath = join(targetDir, targetPath);
+        // If file doesn't exist in target yet, check if it will be copied from base app during inheritance
+        if (!existsSync(targetFilePath)) {
+            // Translate feature path to base app path (we inherit from base app)
+            const translatedPath = translatePathToBaseApp(inheritFile, featureName, baseAppPath);
+            const baseFilePath = join(baseAppPath, translatedPath);
+            if (!existsSync(baseFilePath)) {
+                logger.error(`\nValidation error: Cannot inherit file that doesn't exist!\n`);
+                logger.info(`File marked for inheritance: ${inheritFile}`);
+                logger.info(`Translated to: ${translatedPath}`);
+                logger.info(`Expected location in base app: ${baseFilePath}`);
+                logger.warning(`The file doesn't exist in the base app.\n`);
+                throw new Error("Inherit validation failed - cannot proceed");
+            }
+        }
+    }
+    // Validate that files marked for prepending exist in base app
+    for (const prependFile of prependFiles) {
+        // Translate feature path to base app path (we prepend to base app files)
+        const translatedPath = translatePathToBaseApp(prependFile, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedPath);
+        if (!existsSync(baseFilePath)) {
+            logger.error(`\nValidation error: Cannot prepend to file that doesn't exist!\n`);
+            logger.info(`File marked for prepending: ${prependFile}`);
+            logger.info(`Translated to: ${translatedPath}`);
+            logger.info(`Expected location in base app: ${baseFilePath}`);
+            logger.warning(`The file doesn't exist in the base app.\n`);
+            throw new Error("Prepend validation failed - cannot proceed");
+        }
+    }
+    // Validate that files marked for appending exist in base app
+    for (const appendFile of appendFiles) {
+        // Translate feature path to base app path (we append to base app files)
+        const translatedPath = translatePathToBaseApp(appendFile, featureName, baseAppPath);
+        const baseFilePath = join(baseAppPath, translatedPath);
+        if (!existsSync(baseFilePath)) {
+            logger.error(`\nValidation error: Cannot append to file that doesn't exist!\n`);
+            logger.info(`File marked for appending: ${appendFile}`);
+            logger.info(`Translated to: ${translatedPath}`);
+            logger.info(`Expected location in base app: ${baseFilePath}`);
+            logger.warning(`The file doesn't exist in the base app.\n`);
+            throw new Error("Append validation failed - cannot proceed");
+        }
+    }
+    logger.success("Paths validated");
+    // Apply each discovered file
+    for (const relativePath of discoveredFiles) {
+        // Apply path mappings to transform template path
+        const mappedPath = applyPathMappings(relativePath, effectiveMappings);
+        // Translate feature path to base app path (for finding base files)
+        const translatedPath = translatePathToBaseApp(mappedPath, featureName, baseAppPath);
+        // Translate feature path to target app path (for writing files)
+        const targetPath = translatePathToTargetApp(mappedPath, featureName, targetAppName);
+        // Check if this is a special operation
+        const deleteTargetPath = extractDeletePath(mappedPath);
+        const inheritTargetPath = extractInheritPath(mappedPath);
+        const prependTargetPath = extractPrependPath(mappedPath);
+        const appendTargetPath = extractAppendPath(mappedPath);
+        if (deleteTargetPath) {
+            // This is a delete operation - delete the target file/directory
+            const targetDeletePath = translatePathToTargetApp(deleteTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetDeletePath);
+            await deleteFile(targetFilePath, targetDeletePath);
+        }
+        else if (inheritTargetPath) {
+            // This is an inherit operation - copy from base app if target doesn't have it
+            const targetInheritPath = translatePathToTargetApp(inheritTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetInheritPath);
+            if (!existsSync(targetFilePath)) {
+                // Copy from base app to preserve inherited file in new target structure
+                const translatedInheritPath = translatePathToBaseApp(inheritTargetPath, featureName, baseAppPath);
+                const baseFilePath = join(baseAppPath, translatedInheritPath);
+                if (existsSync(baseFilePath)) {
+                    const targetFileDir = dirname(targetFilePath);
+                    if (!existsSync(targetFileDir)) {
+                        mkdirSync(targetFileDir, { recursive: true });
+                    }
+                    cpSync(baseFilePath, targetFilePath);
+                    logger.info(`Copied ${targetInheritPath} (inherited from base app)`);
+                }
+                else {
+                    logger.info(`Skipped ${targetInheritPath} (file not in base app)`);
+                }
+            }
+            else {
+                logger.info(`Skipped ${targetInheritPath} (already exists in target)`);
+            }
+        }
+        else if (prependTargetPath) {
+            // This is a prepend operation - ensure target file exists first
+            const featureFilePath = join(templatePath, relativePath);
+            const targetPrependPath = translatePathToTargetApp(prependTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetPrependPath);
+            // Copy from base app if target doesn't have the file yet
+            if (!existsSync(targetFilePath)) {
+                const translatedPrependPath = translatePathToBaseApp(prependTargetPath, featureName, baseAppPath);
+                const baseFilePath = join(baseAppPath, translatedPrependPath);
+                if (existsSync(baseFilePath)) {
+                    const targetFileDir = dirname(targetFilePath);
+                    if (!existsSync(targetFileDir)) {
+                        mkdirSync(targetFileDir, { recursive: true });
+                    }
+                    cpSync(baseFilePath, targetFilePath);
+                }
+            }
+            await prependToFile(featureFilePath, targetFilePath, targetPrependPath);
+        }
+        else if (appendTargetPath) {
+            // This is an append operation - ensure target file exists first
+            const featureFilePath = join(templatePath, relativePath);
+            const targetAppendPath = translatePathToTargetApp(appendTargetPath, featureName, targetAppName);
+            const targetFilePath = join(targetDir, targetAppendPath);
+            // Copy from base app if target doesn't have the file yet
+            if (!existsSync(targetFilePath)) {
+                const translatedAppendPath = translatePathToBaseApp(appendTargetPath, featureName, baseAppPath);
+                const baseFilePath = join(baseAppPath, translatedAppendPath);
+                if (existsSync(baseFilePath)) {
+                    const targetFileDir = dirname(targetFilePath);
+                    if (!existsSync(targetFileDir)) {
+                        mkdirSync(targetFileDir, { recursive: true });
+                    }
+                    cpSync(baseFilePath, targetFilePath);
+                }
+            }
+            await appendToFile(featureFilePath, targetFilePath, targetAppendPath);
+        }
+        else {
+            // Normal file operation - add/update/merge
+            const patchFilePath = join(templatePath, relativePath);
+            // Use target app path to ensure all features write to same location
+            const targetFilePath = join(targetDir, targetPath);
+            // Determine if this should be merged (only for the routes file)
+            // The routeFilePath from config includes the full path from template root
+            const shouldMerge = mappedPath === routeFilePath;
+            // For route merging with dependencies:
+            // - Use target file as base if it exists (accumulates routes from previous features)
+            // - Otherwise use base app file (first feature merges with base app)
+            // Create a temp copy of target to avoid ts-morph issues with same file as base and target
+            let baseFilePath = join(baseAppPath, translatedPath);
+            let tempFilePath;
+            if (shouldMerge && existsSync(targetFilePath)) {
+                // Create temp copy of target to use as base
+                tempFilePath = join(tmpdir(), `route-merge-${randomBytes(8).toString("hex")}.tsx`);
+                cpSync(targetFilePath, tempFilePath);
+                baseFilePath = tempFilePath;
+            }
+            try {
+                await applyFile(patchFilePath, baseFilePath, targetFilePath, targetPath, shouldMerge, targetAppName);
+            }
+            finally {
+                // Clean up temp file
+                if (tempFilePath && existsSync(tempFilePath)) {
+                    rmSync(tempFilePath, { force: true });
+                }
+            }
+        }
+    }
+}
+/**
+ * Apply feature patches to create a new app
+ *
+ * @param featurePath - Path to the feature directory containing feature.ts
+ * @param appPath - Path to the base app directory (used as reference, remains unchanged)
+ * @param options - Configuration options
+ * @param options.targetDirName - Required. Target directory where feature will be applied
+ * @param options.skipDependencyChanges - Optional. Skip npm dependency installation
+ * @param options.reset - Optional. Reset target directory to base app state before applying (preserves node_modules)
+ *
+ * @example
+ * await applyPatchesCommand(
+ *   'packages/feature-navigation-menu',
+ *   'packages/base-react-app',
+ *   { targetDirName: 'my-app' }
+ * );
+ */
+export async function applyPatchesCommand(featurePath, appPath, options) {
+    try {
+        logger.heading(`Applying patches: ${featurePath} → ${options.targetDirName}`);
+        // Step 1: Validate inputs
+        logger.info("Validating paths...");
+        validateAndResolveFeaturePath(featurePath); // Fast-fail validation
+        const baseAppPath = validateAndResolveAppPath(appPath);
+        logger.success("Validation passed");
+        // Step 2: Prepare target directory
+        // Extract target app name from the main feature path for nested structure
+        const mainFeatureName = basename(featurePath);
+        const targetAppName = mainFeatureName;
+        // Resolve target directory - if absolute, use as-is; otherwise resolve relative to monorepo root
+        const resolvedTargetDir = isAbsolute(options.targetDirName)
+            ? options.targetDirName
+            : join(getMonorepoRoot(), options.targetDirName);
+        // Calculate target app directory path (SFDX structure so deploy has meta xml, webapplication.json, etc.)
+        const targetAppDir = join(resolvedTargetDir, "force-app", "main", "default", "webapplications", targetAppName);
+        if (existsSync(resolvedTargetDir)) {
+            if (options.reset) {
+                // Reset target to base app state (preserving node_modules)
+                resetTargetToBaseApp(resolvedTargetDir, baseAppPath, targetAppName);
+            }
+        }
+        else {
+            logger.info(`Creating target directory ${options.targetDirName}...`);
+            mkdirSync(resolvedTargetDir, { recursive: true });
+            logger.success("Target directory created");
+            // Copy SFDX project template base (config/, sfdx-project.json, .forceignore, etc.) into target
+            const sfdxTemplatePath = getSfdxProjectTemplatePath();
+            if (existsSync(sfdxTemplatePath)) {
+                logger.info(`Copying SFDX project template base to ${options.targetDirName}...`);
+                cpSync(sfdxTemplatePath, resolvedTargetDir, {
+                    recursive: true,
+                    filter: (src) => !src.includes("node_modules"),
+                });
+                logger.success("SFDX project template base copied");
+            }
+            // Copy base app to target directory with nested structure
+            logger.info(`Copying base app to ${options.targetDirName}...`);
+            const sourceWebAppPath = getWebApplicationPath(baseAppPath);
+            mkdirSync(dirname(targetAppDir), { recursive: true });
+            cpSync(sourceWebAppPath, targetAppDir, { recursive: true });
+            processWebApplicationMetaInDir(targetAppDir, targetAppName);
+            logger.success("Base app copied");
+        }
+        const targetDir = resolvedTargetDir;
+        // Step 3: Resolve dependencies
+        logger.heading("\nResolving Dependencies");
+        const { orderedFeatures } = await resolveDependencies(featurePath);
+        if (orderedFeatures.length > 1) {
+            logger.info(`Resolved dependency chain (${orderedFeatures.length} features):`);
+            for (let i = 0; i < orderedFeatures.length; i++) {
+                const { featurePath: path } = orderedFeatures[i];
+                const isMainFeature = i === orderedFeatures.length - 1;
+                const prefix = isMainFeature ? "└─" : "├─";
+                const label = isMainFeature ? " (main)" : " (dependency)";
+                logger.info(`  ${prefix} ${path}${label}`);
+            }
+            logger.success("Dependency resolution complete");
+        }
+        else {
+            logger.info("No dependencies found");
+        }
+        // Step 4: Apply all features in dependency order
+        for (const resolvedFeature of orderedFeatures) {
+            await applySingleFeature(resolvedFeature, baseAppPath, targetDir, targetAppName);
+        }
+        // Step 4b: Copy site-container metadata from template if main feature has siteContainer
+        const mainFeature = orderedFeatures[orderedFeatures.length - 1];
+        if (mainFeature?.config.siteContainer) {
+            const siteContainerTemplatePath = getSiteContainerTemplatePath();
+            const targetForceAppDefault = join(targetDir, "force-app", "main", "default");
+            if (existsSync(siteContainerTemplatePath)) {
+                logger.info("Copying site-container metadata from template-site-container...");
+                copySiteContainerTemplate(siteContainerTemplatePath, targetForceAppDefault, targetAppName);
+                logger.success("Site-container metadata applied");
+            }
+        }
+        // Step 5: Aggregate and install all dependencies once
+        if (options.skipDependencyChanges) {
+            logger.info("\n⏭  Skipping dependency installation");
+        }
+        else {
+            // Aggregate all dependencies from all resolved features, checking for conflicts
+            const aggregatedDependencies = {};
+            const aggregatedDevDependencies = {};
+            // Collect all features from all resolved features
+            const allFeatures = orderedFeatures.flatMap((rf) => rf.config.features);
+            // First pass: collect all regular dependencies
+            for (const feature of allFeatures) {
+                if (feature.packageJson?.dependencies) {
+                    for (const [name, version] of Object.entries(feature.packageJson.dependencies)) {
+                        if (aggregatedDependencies[name] && aggregatedDependencies[name] !== version) {
+                            throw new Error(`Dependency version conflict for '${name}': feature requires '${version}' but another feature requires '${aggregatedDependencies[name]}'`);
+                        }
+                        aggregatedDependencies[name] = version;
+                    }
+                }
+            }
+            // Second pass: collect dev dependencies (skip if already in dependencies)
+            for (const feature of allFeatures) {
+                if (feature.packageJson?.devDependencies) {
+                    for (const [name, version] of Object.entries(feature.packageJson.devDependencies)) {
+                        // Skip if already in regular dependencies
+                        if (aggregatedDependencies[name]) {
+                            continue;
+                        }
+                        if (aggregatedDevDependencies[name] && aggregatedDevDependencies[name] !== version) {
+                            throw new Error(`Dev dependency version conflict for '${name}': feature requires '${version}' but another feature requires '${aggregatedDevDependencies[name]}'`);
+                        }
+                        aggregatedDevDependencies[name] = version;
+                    }
+                }
+            }
+            const hasAnyDependencies = Object.keys(aggregatedDependencies).length > 0 ||
+                Object.keys(aggregatedDevDependencies).length > 0;
+            if (hasAnyDependencies) {
+                logger.heading("\nInstalling Dependencies");
+                await mergePackageJson(targetDir, {
+                    dependencies: Object.keys(aggregatedDependencies).length > 0 ? aggregatedDependencies : undefined,
+                    devDependencies: Object.keys(aggregatedDevDependencies).length > 0
+                        ? aggregatedDevDependencies
+                        : undefined,
+                }, targetAppDir);
+            }
+            else {
+                logger.info("\n✓ No dependencies to install");
+            }
+        }
+        // Step 6: Success message
+        logger.heading("\n✓ Success");
+        logger.success(`Created: ${targetDir}`);
+    }
+    catch (err) {
+        // Only log error if it's not already been logged (check for our custom error messages)
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const skipLogging = [
+            "Path conflict - cannot proceed",
+            "Delete validation failed - cannot proceed",
+            "Inherit validation failed - cannot proceed",
+            "Prepend validation failed - cannot proceed",
+            "Append validation failed - cannot proceed",
+            "Route deletion failed - cannot proceed",
+        ].includes(errorMessage);
+        if (!skipLogging) {
+            logger.error(`Failed to apply feature: ${errorMessage}`);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=apply-patches.js.map