@uipath/solution-packager 0.0.30

package/dist/src/browser-solution-packager-factory.d.ts

@@ -0,0 +1,27 @@
+import { type PackagerConfig } from "@uipath/project-packager";
+import { type ISolutionPackager } from "./services/solution-packager.js";
+/**
+ * Creates a SolutionPackager instance configured for browser usage.
+ *
+ * This is a convenience function that creates a BrowserSolutionPackagerFactory and calls createAsync.
+ * For more control, use the BrowserSolutionPackagerFactory class directly.
+ *
+ * @param options - Configuration options for the SolutionPackager
+ * @returns Promise<ISolutionPackager> - A fully configured SolutionPackager instance ready for use in the browser.
+ *
+ * @example
+ * ```typescript
+ * // Import tools (triggers self-registration)
+ * import '@uipath/packager-tool-connector';
+ * import '@uipath/packager-tool-flow';
+ *
+ * // Create SolutionPackager
+ * const packager = await createBrowserSolutionPackager({
+ *   logHandler: (message) => console.log(message)
+ * });
+ *
+ * // Tools are already registered and ready to use
+ * await packager.packSolutionAsync(options);
+ * ```
+ */
+export declare function createBrowserSolutionPackager(options?: PackagerConfig): Promise<ISolutionPackager>;

package/dist/src/i18n/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * i18n module for solutionpackager package.
+ * Registers solutionpackager-specific translations.
+ */
+import { en } from "./locales/en.js";
+export type { TranslationKeys } from "./locales/en.js";
+export { en };

package/dist/src/i18n/locales/en.d.ts

@@ -0,0 +1,26 @@
+/**
+ * English translations for solutionpackager package.
+ * These translations are registered alongside core translations via I18nManager.
+ */
+export declare const en: {
+    readonly solutionpackager: {
+        readonly solutionLoader: {
+            readonly errors: {
+                readonly pathRequired: "Solution directory path is required";
+                readonly fileNotFound: "Solution file not found: {path}";
+                readonly invalidSolution: "Invalid solution file: {path}";
+                readonly noSolutionFile: "No .uipx solution file found in directory: {path}";
+                readonly invalidStorageFile: "Invalid {fileName} file";
+            };
+        };
+        readonly optionsBuilder: {
+            readonly errors: {
+                readonly packageInfoRequired: "Package information is required for Pack command";
+                readonly outputPathRequired: "Output path is required for Pack command";
+                readonly invalidProjectIds: "The following project ids do not exist in the solution: {ids}";
+            };
+        };
+    };
+};
+/** @public */
+export type TranslationKeys = typeof en;

package/dist/src/index.d.ts

@@ -0,0 +1,8 @@
+import "./i18n/index.js";
+export type { PackagerConfig } from "@uipath/project-packager";
+export { RulesConfigFileType } from "@uipath/project-packager";
+export { BuildConfiguration, LogLevel, } from "@uipath/solutionpackager-tool-core";
+export { createBrowserSolutionPackager } from "./browser-solution-packager-factory.js";
+export { SolutionPackOptions } from "./models/solution-pack-options.js";
+export type { ISolutionPackager } from "./services/solution-packager.js";
+export { SolutionPackager } from "./services/solution-packager.js";

package/dist/src/models/loaded-uipath-solution.d.ts

@@ -0,0 +1,15 @@
+import type { UiPathSolution } from "@uipath/solutionpackager-tool-core";
+export type { UiPathSolution } from "@uipath/solutionpackager-tool-core";
+/**
+ * Represents a loaded UiPath solution with its file path and name
+ */
+export interface LoadedUiPathSolution extends UiPathSolution {
+    /**
+     * Solution file name without extension
+     */
+    Name: string;
+    /**
+     * Path to the solution file (.uipx)
+     */
+    filePath: string;
+}

package/dist/src/models/solution-pack-options.d.ts

@@ -0,0 +1,44 @@
+import type { PackageSigningInfo, PackOptions, PublishInfo, ValidateOptions } from "@uipath/project-packager";
+import { PackagerParameters } from "@uipath/project-packager";
+import { BuildConfiguration, type NugetPackageInfo } from "@uipath/solutionpackager-tool-core";
+/**
+ * Solution-specific parameters extending base packager parameters
+ */
+export declare class SolutionPackOptions extends PackagerParameters {
+    /**
+     * URL to download the solution snapshot for remote packing
+     */
+    downloadUrl?: string;
+    /**
+     * Path to the folder where the packed output will be stored.
+     */
+    destinationPath: string;
+    /**
+     * Array of project names/paths to build
+     */
+    projectsToBuild?: string[];
+    /**
+     * Validate options
+     */
+    validateOptions: ValidateOptions;
+    /**
+     * NuGet package information
+     */
+    package: NugetPackageInfo;
+    /**
+     * Build configuration (Debug or Release)
+     */
+    configuration: BuildConfiguration;
+    /**
+     * Package signing information
+     */
+    signingInfo?: PackageSigningInfo;
+    /**
+     * Pack options
+     */
+    packOptions?: PackOptions;
+    /**
+     * Publish information
+     */
+    publishInfo?: PublishInfo;
+}

package/dist/src/node-solution-packager-factory.d.ts

@@ -0,0 +1,23 @@
+import { type PackagerConfig } from "@uipath/project-packager/node";
+import { type ISolutionPackager } from "./services/solution-packager.js";
+/**
+ * Creates a SolutionPackager instance configured for Node.js usage.
+ *
+ * This is a convenience function that creates a NodeSolutionPackagerFactory and calls createAsync.
+ * For more control, use the NodeSolutionPackagerFactory class directly.
+ *
+ * @param options - Configuration options for the SolutionPackager
+ * @returns Promise<ISolutionPackager> - A fully configured SolutionPackager instance ready for use in Node.js.
+ *
+ * @example
+ * ```typescript
+ * // Simple usage with default tools
+ * const packager = await createNodeSolutionPackager();
+ *
+ * // With custom log handler
+ * const packager = await createNodeSolutionPackager({
+ *   logHandler: (message) => console.log(message)
+ * });
+ * ```
+ */
+export declare function createNodeSolutionPackager(options?: PackagerConfig): Promise<ISolutionPackager>;

package/dist/src/node.d.ts

@@ -0,0 +1,5 @@
+import "./i18n/index.js";
+export { SolutionPackOptions } from "./models/solution-pack-options.js";
+export { createNodeSolutionPackager } from "./node-solution-packager-factory.js";
+export type { ISolutionPackager } from "./services/solution-packager.js";
+export { SolutionPackager } from "./services/solution-packager.js";

package/dist/src/services/options-builder.d.ts

@@ -0,0 +1,42 @@
+import type { IPackService, UiPathProject } from "@uipath/project-packager";
+import { type IFileSystem, type IProjectPackOptions, type ISolutionPackOptions } from "@uipath/solutionpackager-tool-core";
+import type { LoadedUiPathSolution } from "../models/loaded-uipath-solution.js";
+import type { SolutionPackOptions } from "../models/solution-pack-options.js";
+import type { IPackageIdReader } from "./package-id-reader.js";
+/**
+ * Interface for building pack options from solution parameters
+ */
+export interface IOptionsBuilder {
+    /**
+     * Build solution pack options from solution parameters
+     */
+    buildSolutionPackOptions(parameters: SolutionPackOptions, solution: LoadedUiPathSolution): Promise<ISolutionPackOptions>;
+    /**
+     * Build project pack options from solution parameters, for a specific project
+     */
+    buildProjectPackOptions(options: SolutionPackOptions, project: UiPathProject): Promise<IProjectPackOptions>;
+}
+export declare class OptionsBuilder implements IOptionsBuilder {
+    private readonly packageIdReader;
+    private readonly packService;
+    private readonly fileSystem;
+    constructor(packageIdReader: IPackageIdReader, packService: IPackService, fileSystem: IFileSystem);
+    private static readonly FILES_DIRECTORY_NAME;
+    buildSolutionPackOptions(parameters: SolutionPackOptions, solution: LoadedUiPathSolution): Promise<ISolutionPackOptions>;
+    private createOutputFilesDirectoryAsync;
+    /**
+     * Build project pack options from solution parameters for a specific project
+     */
+    buildProjectPackOptions(solutionOptions: SolutionPackOptions, project: UiPathProject): Promise<IProjectPackOptions>;
+    /**
+     * Build the output path for a project
+     * Path structure: {solutionOutputFolder}/files/{projectId}
+     * @param project The project to build output path for
+     * @returns The output path for the project
+     */
+    private buildProjectOutputPath;
+    /**
+     * Get the list of project IDs to build based on parameters and solution
+     */
+    private getProjectIdsToBuild;
+}

package/dist/src/services/package-id-reader.d.ts

@@ -0,0 +1,61 @@
+import type { IPackService, UiPathProject } from "@uipath/project-packager";
+import { type IFileSystem } from "@uipath/solutionpackager-tool-core";
+/**
+ * Interface for reading package IDs from projects
+ */
+export interface IPackageIdReader {
+    /**
+     * Read the package ID from a project
+     */
+    read(project: UiPathProject, solutionPath?: string | null, solutionName?: string | null): Promise<string | null>;
+}
+/**
+ * Reader for package IDs from project and solution metadata
+ */
+export declare class PackageIdReader implements IPackageIdReader {
+    private readonly fileSystem;
+    private readonly packService;
+    private readonly projectTypesToFolderNameMapping;
+    private static readonly projectTypeMap;
+    constructor(fileSystem: IFileSystem, packService: IPackService);
+    /**
+     * Read the package ID for a project
+     */
+    read(project: UiPathProject, solutionPath?: string | null, solutionName?: string | null): Promise<string | null>;
+    /**
+     * Default to using the project folder name as package ID
+     */
+    private defaultToProjectFolder;
+    /**
+     * Get the full package ID with solution prefix
+     */
+    private getPackageId;
+    /**
+     * Compose the package ID from solution name, project type, and root ID
+     */
+    private composePackageId;
+    /**
+     * Normalize project type to short form
+     */
+    private static normalizeProjectType;
+    /**
+     * Derive solution name from a file or directory path
+     */
+    private deriveSolutionName;
+    /**
+     * Read package ID from legacy resources.json file
+     */
+    private readFromLegacyResourcesJson;
+    /**
+     * Extract project ID from legacy resources JSON
+     */
+    private getProjectIdFromJson;
+    /**
+     * Read package ID from resources directory structure
+     */
+    private readFromResourcesDirectory;
+    /**
+     * Get property from object with case-insensitive key matching
+     */
+    private getProperty;
+}

package/dist/src/services/solution-loader.d.ts

@@ -0,0 +1,19 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { LoadedUiPathSolution } from "../models/loaded-uipath-solution.js";
+/**
+ * Interface for loading solutions from the file system
+ */
+export interface ISolutionLoader {
+    /**
+     * Load a solution from a directory path (searches for .uipx file)
+     */
+    loadSolution(solutionPath: string): Promise<LoadedUiPathSolution>;
+}
+export declare class SolutionLoader implements ISolutionLoader {
+    private readonly fileSystem;
+    static readonly SolutionStorageFileName = ".storage";
+    constructor(fileSystem: IFileSystem);
+    loadSolution(solutionPath: string): Promise<LoadedUiPathSolution>;
+    private getSolutionFilePathAsync;
+    private populateStorageIds;
+}

package/dist/src/services/solution-pack-options-validator.d.ts

@@ -0,0 +1,14 @@
+import { type IPackagerParametersValidator, PackagerParametersValidator } from "@uipath/project-packager";
+import type { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { SolutionPackOptions } from "../models/solution-pack-options.js";
+/**
+ * Interface for the solution pack options validator
+ */
+export type ISolutionPackOptionsValidator = IPackagerParametersValidator<SolutionPackOptions>;
+/**
+ * Validator for solution pack options.
+ * Validates destination path and governance options required for pack operations.
+ */
+export declare class SolutionPackOptionsValidator extends PackagerParametersValidator<SolutionPackOptions> implements ISolutionPackOptionsValidator {
+    validateAsync(options: SolutionPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+}

package/dist/src/services/solution-pack-service.d.ts

@@ -0,0 +1,60 @@
+import type { IProjectToolExecutor, ITelemetryService, IToolsFactory } from "@uipath/project-packager";
+import { type IFileSystem, type IZipService, type ProjectOperationContext, ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { LoadedUiPathSolution } from "../models/loaded-uipath-solution.js";
+import type { SolutionPackOptions } from "../models/solution-pack-options.js";
+import type { IOptionsBuilder } from "./options-builder.js";
+/**
+ * Interface for the service responsible for packing a solutions
+ */
+export interface ISolutionPackService {
+    /**
+     * Pack a solution with all its projects
+     */
+    packAsync(parameters: SolutionPackOptions, solution: LoadedUiPathSolution, context: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+}
+export declare class SolutionPackService implements ISolutionPackService {
+    private readonly optionsBuilder;
+    private readonly toolsFactory;
+    private readonly projectExecutor;
+    private readonly zipService;
+    private readonly fileSystem;
+    private readonly telemetry;
+    constructor(optionsBuilder: IOptionsBuilder, toolsFactory: IToolsFactory, projectExecutor: IProjectToolExecutor, zipService: IZipService, fileSystem: IFileSystem, telemetry: ITelemetryService);
+    packAsync(parameters: SolutionPackOptions, solution: LoadedUiPathSolution, context: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Pack all projects in parallel
+     * @param parameters Solution pack parameters
+     * @param projects Array of projects to pack
+     * @param cancellationToken Optional cancellation token
+     * @returns Array of promises for packing each project
+     */
+    private packAllProjectsAsync;
+    /**
+     * Pack a single project
+     * @param parameters Solution pack parameters
+     * @param project Project to pack
+     * @param cancellationToken Optional cancellation token
+     * @param context Optional operation context
+     * @returns Result of the pack operation
+     */
+    private packSingleProjectAsync;
+    /**
+     * Check if any results in the array have failed
+     * @param results Array of tool results
+     * @returns True if any result has failed, false otherwise
+     */
+    private hasFailedResults;
+    /**
+     * Get a combined error message from all failed results
+     * @param results Array of tool results
+     * @returns Combined error message
+     */
+    private getFailedResultsMessage;
+    /**
+     * Compress the solution output folder into a zip archive
+     * @param parameters Solution pack parameters
+     * @param outputPath Path to the solution output folder
+     * @returns Path to the created archive file
+     */
+    private compressSolutionAsync;
+}

package/dist/src/services/solution-packager.d.ts

@@ -0,0 +1,101 @@
+import { type IPackageSignService, type ITelemetryService, type PackageStream } from "@uipath/project-packager";
+import { type IFileSystem, ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { SolutionPackOptions } from "../models/solution-pack-options.js";
+/**
+ * Interface for the SolutionPackager component.
+ * Provides methods to setup and pack UiPath solutions.
+ */
+export interface ISolutionPackager {
+    /**
+     * File system instance
+     */
+    readonly fileSystem: IFileSystem;
+    /**
+     * Check if the solution can be packed by verifying all project types have registered tools.
+     * @param solutionPath Path to the solution folder
+     * @returns True if all project types in the solution have registered tool factories
+     */
+    canPackSolutionAsync(solutionPath: string): Promise<boolean>;
+    /**
+     * Setup the temporary storage.
+     * @param input The solution folder as a zip Uint8Array (extracts to temp folder) or a path string (uses as-is)
+     * @param operationId Optional operation ID for telemetry correlation
+     * @returns The path to the solution folder
+     */
+    setupAsync(input: Uint8Array | string, operationId?: string): Promise<string>;
+    /**
+     * Setup the temporary storage by downloading the solution from a URL.
+     * @param downloadUrl The URL to download the solution zip from
+     * @param accessToken Optional bearer token for authentication
+     * @param operationId Optional operation ID for telemetry correlation
+     * @returns The path to the solution folder
+     */
+    setupWithUrlAsync(downloadUrl: string, accessToken?: string, operationId?: string): Promise<string>;
+    /**
+     * Pack a solution using the provided options.
+     * @param options Solution pack options containing all parameters
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult with the path to the created solution package
+     */
+    packSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Convert a successful ToolResult to a list of package streams.
+     * @param result The ToolResult to convert
+     * @returns A promise that resolves to an array of PackageStream objects
+     * @throws Error if the result is not successful or if any package file cannot be read
+     */
+    getPackageStreamsAsync(result: ToolResult): Promise<PackageStream[]>;
+}
+export declare class SolutionPackager implements ISolutionPackager {
+    readonly fileSystem: IFileSystem;
+    private readonly telemetryService;
+    private readonly packageSignService?;
+    private readonly repository;
+    private readonly temporaryStorage;
+    private readonly zipService;
+    private readonly logger;
+    private readonly optionsBuilder;
+    private readonly toolsFactory;
+    private readonly projectExecutor;
+    private readonly solutionLoader;
+    private readonly solutionPackService;
+    private readonly optionsValidator;
+    private readonly governancePolicyService;
+    constructor(fileSystem: IFileSystem, telemetryService: ITelemetryService, packageSignService?: IPackageSignService | undefined);
+    /**
+     * Check if the solution can be packed by verifying all project types have registered tools.
+     * @param solutionPath Path to the solution folder
+     * @returns True if all project types in the solution have registered tool factories
+     */
+    canPackSolutionAsync(solutionPath: string): Promise<boolean>;
+    /**
+     * Setup the temporary storage.
+     * @param input The solution folder as a zip Uint8Array (extracts to temp folder) or a path string (uses as-is)
+     * @param operationId Optional operation ID for telemetry correlation
+     * @returns The path to the solution folder
+     */
+    setupAsync(input: Uint8Array | string, operationId?: string): Promise<string>;
+    /**
+     * Setup the temporary storage by downloading the solution from a URL.
+     * @param downloadUrl The URL to download the solution zip from
+     * @param accessToken Optional bearer token for authentication
+     * @param operationId Optional operation ID for telemetry correlation
+     * @returns The path to the solution folder
+     */
+    setupWithUrlAsync(downloadUrl: string, accessToken?: string, operationId?: string): Promise<string>;
+    /**
+     * Pack a solution using the provided options.
+     * @param options Solution pack options containing all parameters
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult with the path to the created solution package
+     */
+    packSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    private createOperationContext;
+    /**
+     * Convert a successful ToolResult to a list of package streams.
+     * @param result The ToolResult to convert
+     * @returns A promise that resolves to an array of PackageStream objects
+     * @throws Error if the result is not successful or if any package file cannot be read
+     */
+    getPackageStreamsAsync(result: ToolResult): Promise<PackageStream[]>;
+}

package/dist/src/telemetry-names.d.ts

@@ -0,0 +1,5 @@
+export declare enum TelemetryNames {
+    SolutionPackagerPackSolution = "SolutionPackager.PackSolution",
+    SolutionPack = "SolutionPackager.Solution.Pack",
+    SolutionCompress = "SolutionPackager.Solution.Compress"
+}

package/dist/tests/browser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/common.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/node.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/shared-browser-fs.d.ts

@@ -0,0 +1,8 @@
+import { BrowserFileSystem } from "@uipath/filesystem/browser";
+/**
+ * Creates and initializes a BrowserFileSystem instance.
+ * Handles the case where ZenFS is already configured from another test file
+ * running in the same browser context (ZenFS module state is shared across
+ * Vitest browser test files, but each file gets its own module scope).
+ */
+export declare function createInitializedBrowserFileSystem(): Promise<BrowserFileSystem>;

package/dist/tests/solution-loader.test.d.ts

@@ -0,0 +1 @@
+import "../src/i18n/index.js";

package/dist/tests/solution-pack-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/solution-packager-e2e.test.d.ts

@@ -0,0 +1,9 @@
+import "@uipath/packager-tool-connector";
+import "@uipath/packager-tool-workflowcompiler";
+import "@uipath/packager-tool-apiworkflow";
+import "@uipath/packager-tool-bpmn";
+import "@uipath/packager-tool-case";
+import "@uipath/packager-tool-flow";
+import "@uipath/tool-agent";
+import "@uipath/packager-tool-webapp";
+import "@uipath/resource-builder-tool";

package/dist/tests/solution-packager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/zip-temp-storage-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,76 @@
+{
+    "name": "@uipath/solution-packager",
+    "version": "0.0.30",
+    "description": "UiPath Solution Packager - core library for packing UiPath solutions",
+    "type": "module",
+    "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/src/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./node": {
+            "types": "./dist/src/node.d.ts",
+            "default": "./dist/node.js"
+        }
+    },
+    "types": "./dist/src/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/cli.git",
+        "directory": "packages/packager/solution-packager"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "files": [
+        "dist",
+        "!dist/**/*.map"
+    ],
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external '@uipath/project-packager/*' --external @uipath/project-packager --external '@uipath/filesystem/*' --external @uipath/filesystem --external '@uipath/telemetry/*' --external @uipath/telemetry && bun build ./src/node.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core --external '@uipath/project-packager/*' --external @uipath/project-packager --external '@uipath/telemetry/*' --external @uipath/telemetry --external '@uipath/filesystem/*' --external @uipath/filesystem && tsc --emitDeclarationOnly --outDir dist",
+        "clean": "rimraf dist",
+        "test": "vitest run",
+        "e2e": "vitest run --config vitest.e2e.config.ts",
+        "test:browser": "vitest run --config=vitest.browser.config.ts",
+        "test:coverage": "vitest run --coverage",
+        "test:browser:coverage": "vitest run --config=vitest.browser.config.ts --coverage",
+        "test:all": "bun run test && bun run test:browser",
+        "test:all:coverage": "bun run test:coverage && bun run test:browser:coverage",
+        "prepack": "bun run build",
+        "publish:dry": "bun publish --dry-run",
+        "publish:gh": "bun publish",
+        "version:patch": "bun version patch --no-git-tag-version",
+        "version:minor": "bun version minor --no-git-tag-version",
+        "version:major": "bun version major --no-git-tag-version",
+        "lint": "biome check ."
+    },
+    "dependencies": {
+        "@uipath/project-packager": "1.1.10",
+        "@uipath/telemetry": "0.0.6",
+        "@uipath/filesystem": "0.1.7",
+        "@uipath/solutionpackager-tool-core": "0.0.31"
+    },
+    "peerDependencies": {
+        "fflate": "^0.8.2"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "@uipath/resource-builder-tool": "^2025.11.0-alpha2430-2948",
+        "@uipath/tool-agent": "^1.0.1",
+        "@uipath/packager-tool-apiworkflow": "0.0.17",
+        "@uipath/packager-tool-bpmn": "0.0.7",
+        "@uipath/packager-tool-case": "0.0.7",
+        "@uipath/packager-tool-connector": "0.0.17",
+        "@uipath/packager-tool-flow": "0.0.17",
+        "@uipath/packager-tool-webapp": "1.0.4",
+        "@uipath/packager-tool-workflowcompiler": "0.0.14",
+        "@vitest/browser": "^4.0.14",
+        "@vitest/browser-playwright": "^4.0.14",
+        "@vitest/coverage-v8": "^4.0.14",
+        "playwright": "^1.57.0",
+        "typescript": "^5.9.3",
+        "vite-tsconfig-paths": "^6.1.1",
+        "vitest": "^4.0.14"
+    }
+}