@aquex/cmos-mcp 1.0.0

package/dist/combination/merge-strategies.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Merge strategies for pack combination
+ *
+ * Provides different strategies for merging domain packs:
+ * - Deep Merge: Recursively merge objects and concatenate arrays
+ * - Override: Later packs completely override earlier packs
+ * - Selective: User controls which fields merge vs override
+ *
+ * @module combination/merge-strategies
+ */
+import { CombinationStrategy, CombinationOptions } from './types';
+/**
+ * MergeStrategy interface
+ * All merge strategies implement this interface
+ */
+export interface IMergeStrategy {
+    /**
+     * Merge multiple templates according to the strategy
+     *
+     * @param templates - Array of templates to merge (order matters)
+     * @returns Merged template
+     */
+    merge(templates: Record<string, unknown>[]): Record<string, unknown>;
+}
+/**
+ * Deep Merge Strategy
+ *
+ * Recursively merges objects and concatenates arrays.
+ * Later templates override/extend earlier ones.
+ */
+export declare class DeepMergeStrategy implements IMergeStrategy {
+    private merger;
+    constructor();
+    merge(templates: Record<string, unknown>[]): Record<string, unknown>;
+}
+/**
+ * Override Strategy
+ *
+ * Each subsequent template completely replaces the previous one.
+ * Only the last template's values are used.
+ */
+export declare class OverrideStrategy implements IMergeStrategy {
+    merge(templates: Record<string, unknown>[]): Record<string, unknown>;
+}
+/**
+ * Selective Merge Strategy
+ *
+ * Allows fine-grained control over which fields are merged vs overridden.
+ * Uses path patterns to determine behavior.
+ */
+export declare class SelectiveMergeStrategy implements IMergeStrategy {
+    private merger;
+    private overridePaths;
+    private mergePaths;
+    constructor(options: CombinationOptions);
+    merge(templates: Record<string, unknown>[]): Record<string, unknown>;
+    /**
+     * Selectively merge two objects based on path configuration
+     */
+    private mergeSelectively;
+    /**
+     * Check if a path should use override strategy
+     */
+    private shouldOverride;
+    /**
+     * Check if a path should use merge strategy
+     */
+    private shouldMerge;
+    /**
+     * Simple wildcard pattern matching
+     * Supports "*" as wildcard for any segment
+     */
+    private matchesPattern;
+    /**
+     * Type guard for plain objects
+     */
+    private isObject;
+}
+/**
+ * Strategy Factory
+ *
+ * Creates the appropriate merge strategy based on configuration
+ */
+export declare class MergeStrategyFactory {
+    static create(strategy: CombinationStrategy, options?: CombinationOptions): IMergeStrategy;
+}
+//# sourceMappingURL=merge-strategies.d.ts.map

package/dist/combination/merge-strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-strategies.d.ts","sourceRoot":"","sources":["../../src/combination/merge-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElE;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtE;AAED;;;;;GAKG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IACtD,OAAO,CAAC,MAAM,CAAgB;;IAM9B,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAoBrE;AAED;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,cAAc;IACrD,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAQrE;AAED;;;;;GAKG;AACH,qBAAa,sBAAuB,YAAW,cAAc;IAC3D,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,aAAa,CAAc;IACnC,OAAO,CAAC,UAAU,CAAc;gBAEpB,OAAO,EAAE,kBAAkB;IAMvC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAoBpE;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAmDxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAgBtB;;OAEG;IACH,OAAO,CAAC,WAAW;IAgBnB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAqBtB;;OAEG;IACH,OAAO,CAAC,QAAQ;CAGjB;AAED;;;;GAIG;AACH,qBAAa,oBAAoB;IAC/B,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,cAAc;CAkB3F"}

package/dist/combination/merge-strategies.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Merge strategies for pack combination
+ *
+ * Provides different strategies for merging domain packs:
+ * - Deep Merge: Recursively merge objects and concatenate arrays
+ * - Override: Later packs completely override earlier packs
+ * - Selective: User controls which fields merge vs override
+ *
+ * @module combination/merge-strategies
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeStrategyFactory = exports.SelectiveMergeStrategy = exports.OverrideStrategy = exports.DeepMergeStrategy = void 0;
+const deep_merge_1 = require("../merge/deep-merge");
+/**
+ * Deep Merge Strategy
+ *
+ * Recursively merges objects and concatenates arrays.
+ * Later templates override/extend earlier ones.
+ */
+class DeepMergeStrategy {
+    constructor() {
+        this.merger = new deep_merge_1.MissionMerger();
+    }
+    merge(templates) {
+        if (templates.length === 0) {
+            return {};
+        }
+        if (templates.length === 1) {
+            return { ...templates[0] };
+        }
+        // Merge templates left to right
+        let result = { ...templates[0] };
+        for (let i = 1; i < templates.length; i++) {
+            result = this.merger.merge(result, templates[i], {
+                arrayStrategy: 'concat',
+                listStrategy: 'append',
+            });
+        }
+        return result;
+    }
+}
+exports.DeepMergeStrategy = DeepMergeStrategy;
+/**
+ * Override Strategy
+ *
+ * Each subsequent template completely replaces the previous one.
+ * Only the last template's values are used.
+ */
+class OverrideStrategy {
+    merge(templates) {
+        if (templates.length === 0) {
+            return {};
+        }
+        // Return a copy of the last template
+        return { ...templates[templates.length - 1] };
+    }
+}
+exports.OverrideStrategy = OverrideStrategy;
+/**
+ * Selective Merge Strategy
+ *
+ * Allows fine-grained control over which fields are merged vs overridden.
+ * Uses path patterns to determine behavior.
+ */
+class SelectiveMergeStrategy {
+    constructor(options) {
+        this.merger = new deep_merge_1.MissionMerger();
+        this.overridePaths = new Set(options.overridePaths || []);
+        this.mergePaths = new Set(options.mergePaths || []);
+    }
+    merge(templates) {
+        if (templates.length === 0) {
+            return {};
+        }
+        if (templates.length === 1) {
+            return { ...templates[0] };
+        }
+        // Start with first template
+        let result = { ...templates[0] };
+        // Merge each subsequent template
+        for (let i = 1; i < templates.length; i++) {
+            result = this.mergeSelectively(result, templates[i]);
+        }
+        return result;
+    }
+    /**
+     * Selectively merge two objects based on path configuration
+     */
+    mergeSelectively(base, extension, currentPath = '') {
+        const result = { ...base };
+        for (const [key, value] of Object.entries(extension)) {
+            const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+            // Check if this path should be overridden
+            if (this.shouldOverride(fieldPath)) {
+                result[key] = value;
+                continue;
+            }
+            // Check if this path should be merged
+            if (this.shouldMerge(fieldPath)) {
+                const baseValue = base[key];
+                // Merge arrays by concatenation
+                if (Array.isArray(baseValue) && Array.isArray(value)) {
+                    result[key] = [...baseValue, ...value];
+                }
+                // Merge objects recursively
+                else if (this.isObject(baseValue) && this.isObject(value)) {
+                    result[key] = this.mergeSelectively(baseValue, value, fieldPath);
+                }
+                // Scalars: extension overrides
+                else {
+                    result[key] = value;
+                }
+                continue;
+            }
+            // Default behavior: deep merge
+            const baseValue = base[key];
+            if (baseValue === undefined) {
+                result[key] = value;
+            }
+            else {
+                result[key] = this.merger.merge(baseValue, value);
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if a path should use override strategy
+     */
+    shouldOverride(path) {
+        // Exact match or wildcard match
+        if (this.overridePaths.has(path)) {
+            return true;
+        }
+        // Check wildcard patterns (e.g., "spec.resources.*")
+        for (const pattern of this.overridePaths) {
+            if (this.matchesPattern(path, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a path should use merge strategy
+     */
+    shouldMerge(path) {
+        // Exact match or wildcard match
+        if (this.mergePaths.has(path)) {
+            return true;
+        }
+        // Check wildcard patterns
+        for (const pattern of this.mergePaths) {
+            if (this.matchesPattern(path, pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Simple wildcard pattern matching
+     * Supports "*" as wildcard for any segment
+     */
+    matchesPattern(path, pattern) {
+        if (pattern === '*') {
+            return true;
+        }
+        const pathParts = path.split('.');
+        const patternParts = pattern.split('.');
+        if (pathParts.length !== patternParts.length) {
+            return false;
+        }
+        for (let i = 0; i < patternParts.length; i++) {
+            if (patternParts[i] !== '*' && patternParts[i] !== pathParts[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Type guard for plain objects
+     */
+    isObject(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+}
+exports.SelectiveMergeStrategy = SelectiveMergeStrategy;
+/**
+ * Strategy Factory
+ *
+ * Creates the appropriate merge strategy based on configuration
+ */
+class MergeStrategyFactory {
+    static create(strategy, options) {
+        switch (strategy) {
+            case 'deep-merge':
+                return new DeepMergeStrategy();
+            case 'override':
+                return new OverrideStrategy();
+            case 'selective':
+                if (!options) {
+                    throw new Error('Selective merge strategy requires options with merge/override paths');
+                }
+                return new SelectiveMergeStrategy(options);
+            default:
+                throw new Error(`Unknown merge strategy: ${strategy}`);
+        }
+    }
+}
+exports.MergeStrategyFactory = MergeStrategyFactory;
+//# sourceMappingURL=merge-strategies.js.map

package/dist/combination/merge-strategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-strategies.js","sourceRoot":"","sources":["../../src/combination/merge-strategies.ts"],"names":[],"mappings":"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"}

package/dist/combination/pack-combiner.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Pack Combiner - Combines multiple domain packs into a single cohesive pack
+ *
+ * Supports multiple merge strategies and handles dependency resolution.
+ * Integrates with DependencyResolver for correct load order and circular
+ * dependency detection.
+ *
+ * Algorithm:
+ * 1. Resolve dependencies and determine load order
+ * 2. Load all required packs in dependency order
+ * 3. Merge packs using selected strategy
+ * 4. Validate combined result
+ * 5. Return combined pack
+ *
+ * @module combination/pack-combiner
+ */
+import { DomainPack } from '../domains/types';
+import { CombinationOptions, CombinationResult, ResolvedDependencies } from './types';
+/**
+ * PackCombiner
+ *
+ * Combines multiple domain packs with dependency resolution and merge strategies
+ */
+export declare class PackCombiner {
+    private resolver;
+    constructor();
+    /**
+     * Combine multiple domain packs into a single pack
+     *
+     * @param packs - Array of packs to combine
+     * @param availablePacks - All available packs (for dependency resolution)
+     * @param options - Combination options
+     * @returns Combination result
+     */
+    combine(packs: DomainPack[], availablePacks: DomainPack[], options?: CombinationOptions): CombinationResult;
+    /**
+     * Merge packs using the provided strategy
+     */
+    private mergePacks;
+    /**
+     * Merge dependencies from all packs, removing duplicates
+     */
+    private mergeDependencies;
+    /**
+     * Validate a combined pack
+     */
+    private validateCombinedPack;
+    /**
+     * Combine packs by name, looking them up in available packs
+     *
+     * Convenience method that accepts pack names instead of pack objects
+     *
+     * @param packNames - Names of packs to combine
+     * @param availablePacks - All available packs
+     * @param options - Combination options
+     * @returns Combination result
+     */
+    combineByName(packNames: string[], availablePacks: DomainPack[], options?: CombinationOptions): CombinationResult;
+    /**
+     * Preview combination without actually performing it
+     *
+     * Returns what the combination would produce without creating the combined pack
+     *
+     * @param packs - Packs to preview
+     * @param availablePacks - Available packs
+     * @param options - Combination options
+     * @returns Preview result with load order and validation
+     */
+    preview(packs: DomainPack[], availablePacks: DomainPack[], _options?: CombinationOptions): {
+        loadOrder: string[];
+        dependencies: ResolvedDependencies;
+        warnings: string[];
+    };
+}
+/**
+ * Convenience function for combining packs
+ *
+ * @param packs - Packs to combine
+ * @param availablePacks - Available packs for dependency resolution
+ * @param options - Combination options
+ * @returns Combination result
+ */
+export declare function combinePacks(packs: DomainPack[], availablePacks: DomainPack[], options?: CombinationOptions): CombinationResult;
+//# sourceMappingURL=pack-combiner.d.ts.map

package/dist/combination/pack-combiner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-combiner.d.ts","sourceRoot":"","sources":["../../src/combination/pack-combiner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAgB,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpG;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAqB;;IAMrC;;;;;;;OAOG;IACH,OAAO,CACL,KAAK,EAAE,UAAU,EAAE,EACnB,cAAc,EAAE,UAAU,EAAE,EAC5B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,iBAAiB;IAgGpB;;OAEG;IACH,OAAO,CAAC,UAAU;IA6BlB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAoBzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA8C5B;;;;;;;;;OASG;IACH,aAAa,CACX,SAAS,EAAE,MAAM,EAAE,EACnB,cAAc,EAAE,UAAU,EAAE,EAC5B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,iBAAiB;IAyBpB;;;;;;;;;OASG;IACH,OAAO,CACL,KAAK,EAAE,UAAU,EAAE,EACnB,cAAc,EAAE,UAAU,EAAE,EAC5B,QAAQ,CAAC,EAAE,kBAAkB,GAC5B;QACD,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,YAAY,EAAE,oBAAoB,CAAC;QACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB;CA6BF;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,UAAU,EAAE,EACnB,cAAc,EAAE,UAAU,EAAE,EAC5B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,iBAAiB,CAGnB"}

package/dist/combination/pack-combiner.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * Pack Combiner - Combines multiple domain packs into a single cohesive pack
+ *
+ * Supports multiple merge strategies and handles dependency resolution.
+ * Integrates with DependencyResolver for correct load order and circular
+ * dependency detection.
+ *
+ * Algorithm:
+ * 1. Resolve dependencies and determine load order
+ * 2. Load all required packs in dependency order
+ * 3. Merge packs using selected strategy
+ * 4. Validate combined result
+ * 5. Return combined pack
+ *
+ * @module combination/pack-combiner
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackCombiner = void 0;
+exports.combinePacks = combinePacks;
+const dependency_resolver_1 = require("./dependency-resolver");
+const merge_strategies_1 = require("./merge-strategies");
+/**
+ * PackCombiner
+ *
+ * Combines multiple domain packs with dependency resolution and merge strategies
+ */
+class PackCombiner {
+    constructor() {
+        this.resolver = new dependency_resolver_1.DependencyResolver();
+    }
+    /**
+     * Combine multiple domain packs into a single pack
+     *
+     * @param packs - Array of packs to combine
+     * @param availablePacks - All available packs (for dependency resolution)
+     * @param options - Combination options
+     * @returns Combination result
+     */
+    combine(packs, availablePacks, options) {
+        const opts = {
+            strategy: options?.strategy || 'deep-merge',
+            overridePaths: options?.overridePaths || [],
+            mergePaths: options?.mergePaths || [],
+            validate: options?.validate ?? true,
+            resolveDependencies: options?.resolveDependencies ?? true,
+        };
+        const errors = [];
+        const warnings = [];
+        // Validate inputs
+        if (packs.length === 0) {
+            return {
+                success: false,
+                errors: ['No packs provided for combination'],
+                warnings: [],
+            };
+        }
+        // Step 1: Resolve dependencies
+        let packsToLoad = packs;
+        let dependencyResolution;
+        if (opts.resolveDependencies) {
+            dependencyResolution = this.resolver.resolve(packs, availablePacks);
+            if (!dependencyResolution.success) {
+                return {
+                    success: false,
+                    dependencyResolution,
+                    errors: dependencyResolution.errors,
+                    warnings,
+                };
+            }
+            // Load packs in dependency order
+            const packMap = new Map();
+            for (const pack of [...packs, ...availablePacks]) {
+                packMap.set(pack.manifest.name, pack);
+            }
+            packsToLoad = dependencyResolution.loadOrder
+                .map((name) => packMap.get(name))
+                .filter((p) => p !== undefined);
+            if (packsToLoad.length !== dependencyResolution.loadOrder.length) {
+                const missing = dependencyResolution.loadOrder.filter((name) => !packMap.has(name));
+                errors.push(`Failed to load packs: ${missing.join(', ')}`);
+                return {
+                    success: false,
+                    dependencyResolution,
+                    errors,
+                    warnings,
+                };
+            }
+        }
+        // Step 2: Merge packs using selected strategy
+        try {
+            const mergeStrategy = merge_strategies_1.MergeStrategyFactory.create(opts.strategy, options);
+            const combinedPack = this.mergePacks(packsToLoad, mergeStrategy);
+            // Step 3: Validate if requested
+            if (opts.validate) {
+                const validationResult = this.validateCombinedPack(combinedPack);
+                if (!validationResult.valid) {
+                    errors.push(...validationResult.errors);
+                    warnings.push(...validationResult.warnings);
+                }
+            }
+            return {
+                success: errors.length === 0,
+                combinedPack,
+                dependencyResolution,
+                errors,
+                warnings,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                errors.push(`Pack combination failed: ${error.message}`);
+            }
+            else {
+                errors.push('Pack combination failed: Unknown error');
+            }
+            return {
+                success: false,
+                dependencyResolution,
+                errors,
+                warnings,
+            };
+        }
+    }
+    /**
+     * Merge packs using the provided strategy
+     */
+    mergePacks(packs, strategy) {
+        // Extract templates from all packs
+        const templates = packs.map((pack) => pack.template);
+        // Merge templates using strategy
+        const combinedTemplate = strategy.merge(templates);
+        // Combine manifests
+        const firstPack = packs[0];
+        const packNames = packs.map((p) => p.manifest.name);
+        const allDependencies = this.mergeDependencies(packs);
+        const combinedManifest = {
+            name: `combined-${packNames.join('-')}`,
+            version: '1.0.0', // Combined packs get a new version
+            displayName: `Combined: ${packs.map((p) => p.manifest.displayName).join(' + ')}`,
+            description: `Combined pack from: ${packNames.join(', ')}`,
+            author: firstPack.manifest.author || 'System',
+            combinedFrom: packNames,
+        };
+        return {
+            manifest: combinedManifest,
+            template: combinedTemplate,
+            dependencies: allDependencies,
+            combinationOrder: packNames,
+        };
+    }
+    /**
+     * Merge dependencies from all packs, removing duplicates
+     */
+    mergeDependencies(packs) {
+        const depMap = new Map();
+        for (const pack of packs) {
+            if (pack.manifest.dependencies) {
+                for (const dep of pack.manifest.dependencies) {
+                    // Keep the first version encountered (from dependency order)
+                    if (!depMap.has(dep.name)) {
+                        depMap.set(dep.name, dep.version);
+                    }
+                }
+            }
+        }
+        return Array.from(depMap.entries()).map(([name, version]) => ({
+            name,
+            version,
+        }));
+    }
+    /**
+     * Validate a combined pack
+     */
+    validateCombinedPack(pack) {
+        const errors = [];
+        const warnings = [];
+        // Validate manifest
+        if (!pack.manifest.name || pack.manifest.name.trim().length === 0) {
+            errors.push('Combined pack name is required');
+        }
+        if (!pack.manifest.version || pack.manifest.version.trim().length === 0) {
+            errors.push('Combined pack version is required');
+        }
+        if (!pack.manifest.combinedFrom || pack.manifest.combinedFrom.length === 0) {
+            errors.push('Combined pack must specify source packs');
+        }
+        // Validate template
+        if (typeof pack.template !== 'object' || pack.template === null) {
+            errors.push('Combined template must be an object');
+        }
+        // Validate combination order matches source packs
+        if (pack.combinationOrder.length !== pack.manifest.combinedFrom.length ||
+            !pack.combinationOrder.every((name, i) => name === pack.manifest.combinedFrom[i])) {
+            warnings.push('Combination order does not match manifest source packs');
+        }
+        // Warn if template is empty
+        if (Object.keys(pack.template).length === 0) {
+            warnings.push('Combined template is empty');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Combine packs by name, looking them up in available packs
+     *
+     * Convenience method that accepts pack names instead of pack objects
+     *
+     * @param packNames - Names of packs to combine
+     * @param availablePacks - All available packs
+     * @param options - Combination options
+     * @returns Combination result
+     */
+    combineByName(packNames, availablePacks, options) {
+        const packMap = new Map(availablePacks.map((p) => [p.manifest.name, p]));
+        const packs = [];
+        const errors = [];
+        for (const name of packNames) {
+            const pack = packMap.get(name);
+            if (!pack) {
+                errors.push(`Pack "${name}" not found in available packs`);
+            }
+            else {
+                packs.push(pack);
+            }
+        }
+        if (errors.length > 0) {
+            return {
+                success: false,
+                errors,
+                warnings: [],
+            };
+        }
+        return this.combine(packs, availablePacks, options);
+    }
+    /**
+     * Preview combination without actually performing it
+     *
+     * Returns what the combination would produce without creating the combined pack
+     *
+     * @param packs - Packs to preview
+     * @param availablePacks - Available packs
+     * @param options - Combination options
+     * @returns Preview result with load order and validation
+     */
+    preview(packs, availablePacks, _options) {
+        const warnings = [];
+        // Resolve dependencies
+        const dependencies = this.resolver.resolve(packs, availablePacks);
+        if (!dependencies.success) {
+            warnings.push(...dependencies.errors);
+            return {
+                loadOrder: [],
+                dependencies,
+                warnings,
+            };
+        }
+        // Validate each pack's dependencies
+        for (const pack of packs) {
+            const validation = this.resolver.validateDependencies(pack, availablePacks);
+            if (!validation.valid) {
+                warnings.push(...validation.errors.map((e) => `${pack.manifest.name}: ${e}`));
+            }
+        }
+        return {
+            loadOrder: dependencies.loadOrder,
+            dependencies,
+            warnings,
+        };
+    }
+}
+exports.PackCombiner = PackCombiner;
+/**
+ * Convenience function for combining packs
+ *
+ * @param packs - Packs to combine
+ * @param availablePacks - Available packs for dependency resolution
+ * @param options - Combination options
+ * @returns Combination result
+ */
+function combinePacks(packs, availablePacks, options) {
+    const combiner = new PackCombiner();
+    return combiner.combine(packs, availablePacks, options);
+}
+//# sourceMappingURL=pack-combiner.js.map