@fgv/ts-res-cli 5.0.1-0 → 5.0.1-10

package/lib/cli.d.ts

@@ -28,13 +28,53 @@ export declare class TsResCliApp {
      * Handles the config command
      */
     private _handleConfigCommand;
+    /**
+     * Handles the delta command
+     */
+    private _handleDeltaCommand;
     /**
      * Handles the archive command
      */
     private _handleArchiveCommand;
+    /**
+     * Parses and validates delta options
+     */
+    private _parseDeltaOptions;
     /**
      * Parses and validates compile options
      */
     private _parseCompileOptions;
+    /**
+     * Generates delta between baseline and target resources
+     */
+    private _generateDelta;
+    /**
+     * Loads system configuration (reused from ResourceCompiler pattern)
+     */
+    private _loadSystemConfiguration;
+    /**
+     * Creates a resource manager from a path (reused from ResourceCompiler pattern)
+     */
+    private _createResourceManager;
+    /**
+     * Imports resources from a file path (reused from ResourceCompiler pattern)
+     */
+    private _importResourcesFromPath;
+    /**
+     * Creates a resource resolver from a resource manager and system configuration
+     */
+    private _createResourceResolver;
+    /**
+     * Generates output blob for delta resources
+     */
+    private _generateDeltaBlob;
+    /**
+     * Generates resource information for delta output
+     */
+    private _generateDeltaResourceInfo;
+    /**
+     * Writes delta output to file
+     */
+    private _writeDeltaOutput;
 }
 //# sourceMappingURL=cli.d.ts.map

package/lib/cli.js

@@ -153,6 +153,24 @@ class TsResCliApp {
             .action(async (options) => {
             await this._handleArchiveCommand(options);
         });
+        this._program
+            .command('delta')
+            .description('Generate delta between baseline and target resources')
+            .requiredOption('--baseline <path>', 'Baseline resource file or directory path')
+            .requiredOption('--target <path>', 'Target resource file or directory path')
+            .requiredOption('-o, --output <path>', 'Output file path')
+            .option('--config <name|path>', 'Predefined configuration name or system configuration file path (JSON, ISystemConfiguration format)')
+            .option('--context-filter <token>', 'Context filter token (pipe-separated, e.g., "language=en-US|territory=US")')
+            .option('--qualifier-defaults <token>', 'Qualifier default values token (pipe-separated, e.g., "language=en-US,en-CA|territory=US")')
+            .option('--resource-ids <ids>', 'Comma-separated list of specific resource IDs to include in delta generation')
+            .option('--skip-unchanged', 'Skip resources that have not changed between baseline and target', true)
+            .option('-f, --format <format>', 'Output format (compiled, source, js, ts, binary, bundle)', 'compiled')
+            .option('-v, --verbose', 'Verbose output', false)
+            .option('-q, --quiet', 'Quiet output', false)
+            .option('--include-metadata', 'Include resource metadata in output', false)
+            .action(async (options) => {
+            await this._handleDeltaCommand(options);
+        });
     }
     /**
      * Handles the compile command
@@ -424,6 +442,24 @@ class TsResCliApp {
             process.exit(1);
         }
     }
+    /**
+     * Handles the delta command
+     */
+    async _handleDeltaCommand(options) {
+        const deltaOptions = this._parseDeltaOptions(options);
+        if (deltaOptions.isFailure()) {
+            console.error(`Error: ${deltaOptions.message}`);
+            process.exit(1);
+        }
+        const result = await this._generateDelta(deltaOptions.value);
+        if (result.isFailure()) {
+            console.error(`Error: ${result.message}`);
+            process.exit(1);
+        }
+        if (!options.quiet) {
+            console.log(`Successfully generated delta to ${options.output}`);
+        }
+    }
     /**
      * Handles the archive command
      */
@@ -479,6 +515,47 @@ class TsResCliApp {
             process.exit(1);
         }
     }
+    /**
+     * Parses and validates delta options
+     */
+    _parseDeltaOptions(options) {
+        var _a;
+        try {
+            const format = options.format;
+            if (!['compiled', 'source', 'js', 'ts', 'binary', 'bundle'].includes(format)) {
+                return (0, ts_utils_1.fail)(`Invalid format: ${format}`);
+            }
+            // Parse resource IDs if provided
+            let resourceIds;
+            if (options.resourceIds) {
+                resourceIds = options.resourceIds
+                    .split(',')
+                    .map((id) => id.trim())
+                    .filter((id) => id.length > 0);
+                if (resourceIds.length === 0) {
+                    return (0, ts_utils_1.fail)('Resource IDs list cannot be empty');
+                }
+            }
+            const deltaOptions = {
+                baseline: options.baseline,
+                target: options.target,
+                output: options.output,
+                config: options.config,
+                contextFilter: options.contextFilter,
+                qualifierDefaults: options.qualifierDefaults,
+                resourceIds,
+                skipUnchanged: (_a = options.skipUnchanged) !== null && _a !== void 0 ? _a : true,
+                format,
+                verbose: options.verbose || false,
+                quiet: options.quiet || false,
+                includeMetadata: options.includeMetadata || false
+            };
+            return (0, ts_utils_1.succeed)(deltaOptions);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to parse delta options: ${error}`);
+        }
+    }
     /**
      * Parses and validates compile options
      */
@@ -525,6 +602,426 @@ class TsResCliApp {
             return (0, ts_utils_1.fail)(`Failed to parse options: ${error}`);
         }
     }
+    /**
+     * Generates delta between baseline and target resources
+     */
+    async _generateDelta(options) {
+        try {
+            if (options.verbose) {
+                console.error('Starting delta generation...');
+                console.error(`Baseline: ${options.baseline}`);
+                console.error(`Target: ${options.target}`);
+                console.error(`Output: ${options.output}`);
+            }
+            // Load system configuration
+            const config = await this._loadSystemConfiguration(options.config, options.verbose);
+            if (config.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to load configuration: ${config.message}`);
+            }
+            if (options.verbose) {
+                console.error('Configuration loaded successfully');
+            }
+            // Create resource managers for baseline and target
+            const baselineManager = await this._createResourceManager(config.value, options.baseline, options.qualifierDefaults, options.verbose);
+            if (baselineManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to load baseline resources: ${baselineManager.message}`);
+            }
+            const targetManager = await this._createResourceManager(config.value, options.target, options.qualifierDefaults, options.verbose);
+            if (targetManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to load target resources: ${targetManager.message}`);
+            }
+            if (options.verbose) {
+                console.error(`Baseline loaded: ${baselineManager.value.numResources} resources, ${baselineManager.value.numCandidates} candidates`);
+                console.error(`Target loaded: ${targetManager.value.numResources} resources, ${targetManager.value.numCandidates} candidates`);
+            }
+            // Create resource resolvers
+            const baselineResolver = await this._createResourceResolver(baselineManager.value, options.contextFilter, options.verbose, config.value);
+            if (baselineResolver.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create baseline resolver: ${baselineResolver.message}`);
+            }
+            const targetResolver = await this._createResourceResolver(targetManager.value, options.contextFilter, options.verbose, config.value);
+            if (targetResolver.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create target resolver: ${targetResolver.message}`);
+            }
+            // Create delta generator
+            const deltaGenerator = TsRes.Resources.DeltaGenerator.create({
+                baselineResolver: baselineResolver.value,
+                deltaResolver: targetResolver.value,
+                resourceManager: baselineManager.value,
+                logger: options.verbose ? new ts_utils_1.Logging.ConsoleLogger() : undefined
+            });
+            if (deltaGenerator.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create delta generator: ${deltaGenerator.message}`);
+            }
+            // Parse context filter for delta generation options
+            let context;
+            if (options.contextFilter) {
+                const contextTokens = new TsRes.Context.ContextTokens(baselineManager.value.qualifiers);
+                const contextResult = contextTokens.contextTokenToPartialContext(options.contextFilter);
+                if (contextResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to parse context filter: ${contextResult.message}`);
+                }
+                context = contextResult.value;
+            }
+            // Generate delta
+            const deltaOptions = {
+                context,
+                resourceIds: options.resourceIds,
+                skipUnchanged: options.skipUnchanged
+            };
+            if (options.verbose) {
+                console.error('Generating delta...');
+            }
+            const deltaResult = deltaGenerator.value.generate(deltaOptions);
+            if (deltaResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Delta generation failed: ${deltaResult.message}`);
+            }
+            const deltaManager = deltaResult.value;
+            if (options.verbose) {
+                console.error(`Delta generated: ${deltaManager.numResources} resources, ${deltaManager.numCandidates} candidates`);
+            }
+            // Generate output blob
+            const blob = await this._generateDeltaBlob(deltaManager, options, config.value);
+            if (blob.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to generate output blob: ${blob.message}`);
+            }
+            // Write output
+            const writeResult = await this._writeDeltaOutput(blob.value, options);
+            if (writeResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to write output: ${writeResult.message}`);
+            }
+            if (options.verbose) {
+                console.error(`Delta output written to: ${options.output}`);
+            }
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Delta generation failed: ${error}`);
+        }
+    }
+    /**
+     * Loads system configuration (reused from ResourceCompiler pattern)
+     */
+    async _loadSystemConfiguration(configOption, verbose) {
+        try {
+            if (configOption) {
+                // Check if it's a predefined configuration name
+                const predefinedNames = [
+                    'default',
+                    'language-priority',
+                    'territory-priority',
+                    'extended-example'
+                ];
+                if (predefinedNames.includes(configOption)) {
+                    const predefinedResult = TsRes.Config.getPredefinedDeclaration(configOption);
+                    if (predefinedResult.isSuccess()) {
+                        if (verbose) {
+                            console.error(`Using predefined configuration: ${predefinedResult.value.name}`);
+                        }
+                        return (0, ts_utils_1.succeed)(predefinedResult.value);
+                    }
+                }
+                // Try to load as file path
+                try {
+                    const path = await Promise.resolve().then(() => __importStar(require('path')));
+                    const fs = await Promise.resolve().then(() => __importStar(require('fs'))).then((m) => m.promises);
+                    const configPath = path.resolve(configOption);
+                    const configContent = await fs.readFile(configPath, 'utf-8');
+                    const configData = JSON.parse(configContent);
+                    const configResult = TsRes.Config.Convert.systemConfiguration.convert(configData);
+                    if (configResult.isFailure()) {
+                        return (0, ts_utils_1.fail)(`Invalid configuration file: ${configResult.message}`);
+                    }
+                    if (verbose) {
+                        console.error(`Using custom configuration: ${configResult.value.name}`);
+                    }
+                    return (0, ts_utils_1.succeed)(configResult.value);
+                }
+                catch (fileError) {
+                    return (0, ts_utils_1.fail)(`Configuration '${configOption}' is not a predefined configuration name and failed to load as file: ${fileError}`);
+                }
+            }
+            else {
+                // Use default configuration
+                const defaultResult = TsRes.Config.getPredefinedDeclaration('default');
+                if (defaultResult.isSuccess()) {
+                    if (verbose) {
+                        console.error(`Using default configuration: ${defaultResult.value.name}`);
+                    }
+                    return (0, ts_utils_1.succeed)(defaultResult.value);
+                }
+                else {
+                    return (0, ts_utils_1.fail)('Failed to load default configuration');
+                }
+            }
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to load system configuration: ${error}`);
+        }
+    }
+    /**
+     * Creates a resource manager from a path (reused from ResourceCompiler pattern)
+     */
+    async _createResourceManager(systemConfig, inputPath, qualifierDefaults, verbose) {
+        try {
+            // Parse qualifier defaults if provided
+            let qualifierDefaultValues;
+            if (qualifierDefaults) {
+                const tempSystemConfigResult = TsRes.Config.SystemConfiguration.create(systemConfig);
+                if (tempSystemConfigResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to create temporary system configuration: ${tempSystemConfigResult.message}`);
+                }
+                const tokens = new TsRes.Qualifiers.QualifierDefaultValueTokens(tempSystemConfigResult.value.qualifiers);
+                const defaultsResult = tokens.qualifierDefaultValuesTokenToDecl(qualifierDefaults);
+                if (defaultsResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to parse qualifier defaults: ${defaultsResult.message}`);
+                }
+                qualifierDefaultValues = defaultsResult.value;
+            }
+            // Create system configuration
+            const systemConfigResult = TsRes.Config.SystemConfiguration.create(systemConfig, qualifierDefaultValues ? { qualifierDefaultValues } : undefined);
+            if (systemConfigResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create system configuration: ${systemConfigResult.message}`);
+            }
+            const config = systemConfigResult.value;
+            // Create resource manager
+            const manager = TsRes.Resources.ResourceManagerBuilder.create({
+                qualifiers: config.qualifiers,
+                resourceTypes: config.resourceTypes
+            });
+            if (manager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create resource manager: ${manager.message}`);
+            }
+            // Import resources from path
+            const importResult = await this._importResourcesFromPath(manager.value, inputPath, verbose);
+            if (importResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to import resources from ${inputPath}: ${importResult.message}`);
+            }
+            return (0, ts_utils_1.succeed)(manager.value);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to create resource manager: ${error}`);
+        }
+    }
+    /**
+     * Imports resources from a file path (reused from ResourceCompiler pattern)
+     */
+    async _importResourcesFromPath(manager, inputPath, verbose) {
+        try {
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const { FileTree } = await Promise.resolve().then(() => __importStar(require('@fgv/ts-json-base')));
+            const resolvedPath = path.resolve(inputPath);
+            // Create FileTree for file system operations
+            const fileTree = FileTree.forFilesystem();
+            if (fileTree.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create file tree: ${fileTree.message}`);
+            }
+            // Create ImportManager
+            const importManager = TsRes.Import.ImportManager.create({
+                resources: manager,
+                fileTree: fileTree.value
+            });
+            if (importManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create import manager: ${importManager.message}`);
+            }
+            // Import resources
+            if (verbose) {
+                console.error(`Importing resources from: ${resolvedPath}`);
+            }
+            const importResult = importManager.value.importFromFileSystem(resolvedPath);
+            if (importResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to import from ${resolvedPath}: ${importResult.message}`);
+            }
+            if (verbose) {
+                console.error(`Successfully imported resources from: ${resolvedPath}`);
+            }
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to import resources: ${error}`);
+        }
+    }
+    /**
+     * Creates a resource resolver from a resource manager and system configuration
+     */
+    async _createResourceResolver(manager, contextFilter, verbose, systemConfig) {
+        try {
+            // Apply context filtering if specified
+            let finalManager = manager;
+            if (contextFilter) {
+                const contextTokens = new TsRes.Context.ContextTokens(manager.qualifiers);
+                const contextResult = contextTokens.contextTokenToPartialContext(contextFilter);
+                if (contextResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to parse context filter: ${contextResult.message}`);
+                }
+                const filteredManagerResult = manager.clone({
+                    filterForContext: contextResult.value,
+                    reduceQualifiers: false // Don't reduce qualifiers for delta generation
+                });
+                if (filteredManagerResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to apply context filter: ${filteredManagerResult.message}`);
+                }
+                finalManager = filteredManagerResult.value;
+                if (verbose) {
+                    console.error(`After context filtering: ${finalManager.numResources} resources, ${finalManager.numCandidates} candidates`);
+                }
+            }
+            // Build the manager to create the resolver
+            const builtManager = finalManager.build();
+            if (builtManager.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to build resource manager: ${builtManager.message}`);
+            }
+            // Create qualifier types from system config or use default
+            const qualifierTypesResult = systemConfig
+                ? TsRes.Config.SystemConfiguration.create(systemConfig).onSuccess((config) => (0, ts_utils_1.succeed)(config.qualifierTypes))
+                : TsRes.QualifierTypes.QualifierTypeCollector.create({
+                    qualifierTypes: [
+                        TsRes.QualifierTypes.LanguageQualifierType.create().orThrow(),
+                        TsRes.QualifierTypes.TerritoryQualifierType.create().orThrow()
+                    ]
+                });
+            if (qualifierTypesResult.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create qualifier types: ${qualifierTypesResult.message}`);
+            }
+            // Create context provider - use empty context for default
+            const contextProvider = TsRes.Runtime.ValidatingSimpleContextQualifierProvider.create({
+                qualifiers: finalManager.qualifiers,
+                qualifierValues: {} // Empty context for most general resolution
+            });
+            if (contextProvider.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create context provider: ${contextProvider.message}`);
+            }
+            // Create resolver with required parameters
+            const resolver = TsRes.Runtime.ResourceResolver.create({
+                resourceManager: builtManager.value,
+                qualifierTypes: qualifierTypesResult.value,
+                contextQualifierProvider: contextProvider.value
+            });
+            if (resolver.isFailure()) {
+                return (0, ts_utils_1.fail)(`Failed to create resource resolver: ${resolver.message}`);
+            }
+            return (0, ts_utils_1.succeed)(resolver.value);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to create resource resolver: ${error}`);
+        }
+    }
+    /**
+     * Generates output blob for delta resources
+     */
+    async _generateDeltaBlob(deltaManager, options, systemConfig) {
+        try {
+            if (options.format === 'compiled') {
+                return deltaManager.getCompiledResourceCollection().onSuccess((compiled) => {
+                    const blob = {
+                        compiledCollection: compiled
+                    };
+                    if (options.includeMetadata) {
+                        blob.metadata = this._generateDeltaResourceInfo(deltaManager);
+                    }
+                    return (0, ts_utils_1.succeed)(blob);
+                });
+            }
+            else if (options.format === 'bundle') {
+                // Create bundle using BundleBuilder
+                const systemConfigResult = TsRes.Config.SystemConfiguration.create(systemConfig);
+                if (systemConfigResult.isFailure()) {
+                    return (0, ts_utils_1.fail)(`Failed to create system configuration for bundle: ${systemConfigResult.message}`);
+                }
+                const bundleParams = {
+                    version: '1.0.0',
+                    description: 'Generated delta bundle from ts-res-cli',
+                    normalize: true
+                };
+                return TsRes.Bundle.BundleBuilder.create(deltaManager, systemConfigResult.value, bundleParams).onSuccess((bundle) => {
+                    const blob = {
+                        bundle
+                    };
+                    if (options.includeMetadata) {
+                        blob.metadata = this._generateDeltaResourceInfo(deltaManager);
+                    }
+                    return (0, ts_utils_1.succeed)(blob);
+                });
+            }
+            else {
+                // Source format
+                return deltaManager.getResourceCollectionDecl().onSuccess((resources) => {
+                    const blob = {
+                        resources
+                    };
+                    if (options.includeMetadata) {
+                        blob.metadata = this._generateDeltaResourceInfo(deltaManager);
+                    }
+                    return (0, ts_utils_1.succeed)(blob);
+                });
+            }
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to generate delta blob: ${error}`);
+        }
+    }
+    /**
+     * Generates resource information for delta output
+     */
+    _generateDeltaResourceInfo(deltaManager) {
+        const resourceTypes = Array.from(new Set(deltaManager
+            .getAllCandidates()
+            .map((c) => { var _a; return (_a = c.resourceType) === null || _a === void 0 ? void 0 : _a.key; })
+            .filter(Boolean)));
+        const qualifiers = Array.from(deltaManager.qualifiers.keys());
+        return {
+            totalResources: deltaManager.numResources,
+            totalCandidates: deltaManager.numCandidates,
+            resourceTypes,
+            qualifiers
+        };
+    }
+    /**
+     * Writes delta output to file
+     */
+    async _writeDeltaOutput(blob, options) {
+        try {
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const fs = await Promise.resolve().then(() => __importStar(require('fs'))).then((m) => m.promises);
+            const outputPath = path.resolve(options.output);
+            const outputDir = path.dirname(outputPath);
+            // Ensure output directory exists
+            await fs.mkdir(outputDir, { recursive: true });
+            let content;
+            switch (options.format) {
+                case 'compiled':
+                    const compiledData = options.includeMetadata ? blob : blob.compiledCollection;
+                    content = JSON.stringify(compiledData, null, 2);
+                    break;
+                case 'source':
+                    content = JSON.stringify(blob, null, 2);
+                    break;
+                case 'js':
+                    const jsData = blob.compiledCollection || blob;
+                    content = `module.exports = ${JSON.stringify(jsData, null, 2)};`;
+                    break;
+                case 'ts':
+                    const tsData = blob.compiledCollection || blob;
+                    content = `export const resources = ${JSON.stringify(tsData, null, 2)} as const;`;
+                    break;
+                case 'binary':
+                    const binaryData = blob.compiledCollection || blob;
+                    content = JSON.stringify(binaryData);
+                    break;
+                case 'bundle':
+                    const bundleData = options.includeMetadata ? blob : blob.bundle;
+                    content = JSON.stringify(bundleData, null, 2);
+                    break;
+                default:
+                    return (0, ts_utils_1.fail)(`Unsupported output format: ${options.format}`);
+            }
+            await fs.writeFile(outputPath, content, 'utf-8');
+            return (0, ts_utils_1.succeed)(undefined);
+        }
+        catch (error) {
+            return (0, ts_utils_1.fail)(`Failed to write delta output: ${error}`);
+        }
+    }
 }
 exports.TsResCliApp = TsResCliApp;
 //# sourceMappingURL=cli.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-res-cli",
-  "version": "5.0.1-0",
+  "version": "5.0.1-10",
   "description": "Command-line interface for ts-res resource compilation and management",
   "main": "lib/index.js",
   "bin": {
@@ -18,30 +18,27 @@
   "license": "MIT",
   "dependencies": {
     "commander": "^11.0.0",
-    "@fgv/ts-res": "5.0.1-0",
-    "@fgv/ts-utils": "5.0.1-0",
-    "@fgv/ts-extras": "5.0.1-0",
-    "@fgv/ts-json": "5.0.1-0",
-    "@fgv/ts-json-base": "5.0.1-0"
+    "@fgv/ts-res": "5.0.1-10",
+    "@fgv/ts-utils": "5.0.1-10",
+    "@fgv/ts-json": "5.0.1-10",
+    "@fgv/ts-extras": "5.0.1-10",
+    "@fgv/ts-json-base": "5.0.1-10"
   },
   "devDependencies": {
-    "@rushstack/heft": "0.74.4",
-    "@rushstack/heft-node-rig": "2.9.5",
-    "@rushstack/eslint-config": "4.4.0",
+    "@rushstack/heft": "1.1.3",
+    "@rushstack/heft-node-rig": "2.11.4",
+    "@rushstack/eslint-config": "4.5.3",
     "@types/heft-jest": "1.0.6",
     "@types/jest": "^29.5.14",
     "@types/node": "^20.14.9",
-    "@typescript-eslint/eslint-plugin": "^8.42.0",
-    "@typescript-eslint/parser": "^8.42.0",
-    "eslint": "^9.35.0",
+    "@typescript-eslint/eslint-plugin": "^8.46.2",
+    "@typescript-eslint/parser": "^8.46.2",
+    "eslint": "^9.39.0",
     "jest": "^29.7.0",
-    "ts-jest": "^29.4.1",
-    "typescript": "5.8.3",
-    "@rushstack/heft-jest-plugin": "0.16.13",
-    "@fgv/ts-utils-jest": "5.0.1-0"
-  },
-  "peerDependencies": {
-    "typescript": "^5.7.3"
+    "ts-jest": "^29.4.5",
+    "typescript": "5.9.3",
+    "@rushstack/heft-jest-plugin": "1.1.3",
+    "@fgv/ts-utils-jest": "5.0.1-10"
   },
   "scripts": {
     "build": "heft build --clean",