@uipath/project-packager 1.1.10 → 1.196.0

package/dist/browser.js

@@ -0,0 +1,2380 @@
+// src/i18n/index.ts
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+// src/i18n/locales/de.json
+var de_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/es.json
+var es_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/es-MX.json
+var es_MX_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/fr.json
+var fr_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ja.json
+var ja_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ko.json
+var ko_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/pt.json
+var pt_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ro.json
+var ro_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ru.json
+var ru_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/tr.json
+var tr_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zu.json
+var zu_default = {
+  solutionpackager: {
+    projectLoader: {
+      errors: {
+        pathRequired: "Project directory path is required",
+        noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+        readFailed: "Failed to read project file: {path}",
+        invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+      }
+    },
+    validator: {
+      errors: {
+        destinationNotDefined: "Destination path is not defined",
+        governanceRequired: "Governance file path is required when governance file type is not Default",
+        governanceFileInfo: "Unable to get file information: {path}",
+        governanceInvalidFile: "Governance file path is not a valid file: {path}"
+      }
+    },
+    packager: {
+      errors: {
+        failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+        failedToReadPackage: "Failed to read package file: {path}"
+      }
+    },
+    governance: {
+      info: {
+        alreadyProvided: "Governance policy file already provided, skipping download.",
+        saved: "Governance policy saved to {path}",
+        downloading: "Downloading governance policy from {url}",
+        noPolicyFound: "No governance policy found for this configuration.",
+        responseNotJson: "Policy response is not JSON, treating as no policy.",
+        licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+        licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+        licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+      },
+      errors: {
+        connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+        failedToGetPolicy: "Failed to download governance policy: {content}",
+        failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+        failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+      }
+    },
+    signing: {
+      errors: {
+        dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+      }
+    },
+    dotnet: {
+      info: {
+        available: "dotnet CLI is available (version {version})."
+      },
+      warnings: {
+        notAvailable: "dotnet CLI is not available. Workflow compiler functionality and package signing will not be available."
+      }
+    },
+    publish: {
+      errors: {
+        atLeastOnePackage: "At least one package path is required.",
+        packageNotFound: "Package file not found: {path}",
+        unknownDestination: "Unknown publish destination: {destination}",
+        publishFailed: "Publish failed: {message}",
+        failedToReadPackage: "Failed to read package file: {path}",
+        localFolderRequired: "Local folder destination requires a folderPath.",
+        localFolderFileExists: "File already exists at destination and overwrite is disabled: {path}",
+        nugetFeedUrlRequired: "NuGet feed destination requires a feedUrl.",
+        nugetPushFailed: "NuGet push failed for {fileName}: {status} {statusText}{body}",
+        nugetPushUrlResolutionFailed: "Failed to resolve NuGet push URL from {feedUrl}: {message}",
+        orchestratorCloudUrlRequired: "Orchestrator destination requires connectionInfo.cloudUrl.",
+        orchestratorCustomPublishUrlRequired: "OrchestratorCustom destination requires a publishUrl.",
+        orchestratorFeedResolutionFailed: "Could not resolve a target Orchestrator feed: {message}",
+        orchestratorFeedNotFound: "No accessible Orchestrator feed matches destination {kind}. Available feeds: {available}",
+        orchestratorPersonalWorkspaceFolderNotFound: "No personal-workspace folder is accessible — make sure the authenticated user has a personal workspace. Folders returned: {folders}",
+        orchestratorNoPackages: "No package files were provided to publish.",
+        orchestratorPublishFailed: "Orchestrator publish failed: {status} {statusText}{body}",
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}",
+        getFoldersForCurrentUserFailed: "GetAllFoldersForCurrentUser failed: {status} {statusText}{body}"
+      }
+    }
+  }
+};
+
+// src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+
+// ../../common/dist/telemetry/index.js
+class BrowserContextStorage {
+  contextStack = [];
+  run(context, fn) {
+    this.contextStack.push(context);
+    try {
+      const result = fn();
+      if (result !== null && typeof result === "object" && typeof result.then === "function") {
+        return result.finally(() => {
+          this.contextStack.pop();
+        });
+      }
+      this.contextStack.pop();
+      return result;
+    } catch (error) {
+      this.contextStack.pop();
+      throw error;
+    }
+  }
+  getContext() {
+    return this.contextStack.length > 0 ? this.contextStack[this.contextStack.length - 1] : undefined;
+  }
+}
+
+class ConsoleTelemetryProvider {
+  async trackEvent(eventName, _properties) {
+    console.debug(`[Telemetry] Event: ${eventName}`);
+  }
+  async trackException(error, _properties) {
+    console.error(`[Telemetry] Exception: ${error.message}`);
+  }
+  async trackRequest(name, duration, success, _properties) {
+    console.debug(`[Telemetry] Request: ${name} (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+  async trackDependency(name, type, duration, success, _properties) {
+    console.debug(`[Telemetry] Dependency: ${name} [${type}] (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+}
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+var telemetryPropsSlot = singleton("TelemetryDefaultProps");
+function getGlobalTelemetryProperties() {
+  return telemetryPropsSlot.get();
+}
+
+class TelemetryService {
+  telemetryProvider;
+  contextStorage;
+  operationId;
+  defaultProperties;
+  constructor(telemetryProvider, contextStorage) {
+    this.telemetryProvider = telemetryProvider;
+    this.contextStorage = contextStorage;
+  }
+  setOperationId(operationId) {
+    this.operationId = operationId;
+  }
+  setProvider(provider) {
+    this.telemetryProvider = provider;
+  }
+  setDefaultProperties(properties) {
+    this.defaultProperties = properties === undefined ? undefined : { ...this.defaultProperties, ...properties };
+  }
+  trackEvent(name, properties) {
+    const context = this.getCurrentContext();
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackEvent(name, enrichedProperties);
+  }
+  trackException(error, properties) {
+    const context = this.getCurrentContext();
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackException(error, enrichedProperties);
+  }
+  async trackRequest(name, fn, properties) {
+    const context = {
+      operationId: this.operationId ?? this.generateId(),
+      id: this.generateId()
+    };
+    const startTime = performance.now();
+    try {
+      const result = await this.contextStorage.run(context, fn);
+      const durationMs = performance.now() - startTime;
+      const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+      await this.telemetryProvider.trackRequest(name, durationMs, true, enrichedProperties);
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error));
+      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, context);
+      await this.telemetryProvider.trackRequest(name, durationMs, false, enrichedProperties);
+      throw error;
+    }
+  }
+  async trackDependencyOperation(name, type, fn, properties) {
+    const parentContext = this.getCurrentContext();
+    if (!parentContext) {
+      throw new Error("trackDependencyOperation must be called within a trackRequest block.");
+    }
+    const childContext = {
+      operationId: parentContext.operationId,
+      parentId: parentContext.id,
+      id: this.generateId()
+    };
+    const startTime = performance.now();
+    try {
+      const result = await this.contextStorage.run(childContext, fn);
+      const durationMs = performance.now() - startTime;
+      const enrichedProperties = this.enrichPropertiesWithContext(properties, childContext);
+      await this.telemetryProvider.trackDependency(name, type, durationMs, true, enrichedProperties);
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error));
+      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, childContext);
+      await this.telemetryProvider.trackDependency(name, type, durationMs, false, enrichedProperties);
+      throw error;
+    }
+  }
+  getCurrentContext() {
+    return this.contextStorage.getContext();
+  }
+  enrichPropertiesWithContext(properties, context) {
+    return {
+      ...getGlobalTelemetryProperties(),
+      ...this.defaultProperties,
+      ...properties,
+      ...context
+    };
+  }
+  generateId() {
+    return crypto.randomUUID().replaceAll("-", "");
+  }
+}
+
+// src/base-browser-packager-factory.ts
+import { BrowserFileSystem } from "@uipath/filesystem/browser";
+import { translate } from "@uipath/solutionpackager-tool-core";
+
+// src/services/tool-logger.ts
+import {
+  LogLevel,
+  LogMessage
+} from "@uipath/solutionpackager-tool-core";
+var globalLogHandler = (logMessage) => {
+  const formattedMessage = logMessage.toFormattedString();
+  switch (logMessage.logLevel) {
+    case LogLevel.Debug:
+      console.debug(formattedMessage);
+      break;
+    case LogLevel.Info:
+      console.info(formattedMessage);
+      break;
+    case LogLevel.Warn:
+      console.warn(formattedMessage);
+      break;
+    case LogLevel.Error:
+      console.error(formattedMessage);
+      break;
+  }
+};
+function setGlobalLogHandler(handler) {
+  globalLogHandler = handler;
+}
+
+class ToolLogger {
+  source;
+  sourceTarget;
+  constructor(source, sourceTarget) {
+    this.source = source;
+    this.sourceTarget = sourceTarget;
+  }
+  debug(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Debug, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  info(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Info, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  warn(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Warn, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  error(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Error, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  progress(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Info, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  log(message, logLevel, options) {
+    const logMessage = new LogMessage(message, logLevel, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  logMessage(message) {
+    globalLogHandler(message);
+  }
+}
+
+// src/base-browser-packager-factory.ts
+var sharedFileSystem = null;
+var GLOBAL_FS_KEY = "__uipath_sharedFileSystem";
+
+class BaseBrowserPackagerFactory {
+  async getOrCreateFileSystem(config) {
+    if (config?.fileSystem) {
+      return config.fileSystem;
+    }
+    const globalRecord = globalThis;
+    if (!sharedFileSystem) {
+      sharedFileSystem = globalRecord[GLOBAL_FS_KEY] ?? null;
+    }
+    if (!sharedFileSystem) {
+      const fs = new BrowserFileSystem;
+      try {
+        await fs.init();
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Mount point is already in use")) {
+          fs.initialized = true;
+        } else {
+          throw error;
+        }
+      }
+      sharedFileSystem = fs;
+      globalRecord[GLOBAL_FS_KEY] = fs;
+    }
+    return sharedFileSystem;
+  }
+  getOrCreateTelemetryService(config) {
+    if (config?.telemetryService) {
+      return config.telemetryService;
+    }
+    const provider = new ConsoleTelemetryProvider;
+    const contextStorage = new BrowserContextStorage;
+    return new TelemetryService(provider, contextStorage);
+  }
+  configureLogHandler(config) {
+    if (config?.logHandler) {
+      setGlobalLogHandler(config.logHandler);
+    }
+  }
+  configureLanguage(config) {
+    const language = config?.language ?? "en";
+    translate.setLocale(language);
+  }
+}
+// src/services/project-packager.ts
+import {
+  toolsFactoryRepository as defaultToolsFactoryRepository,
+  NugetPackager,
+  Path as Path3,
+  TargetFramework,
+  TemporaryStorageService,
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3,
+  translate as translate5,
+  ZipService
+} from "@uipath/solutionpackager-tool-core";
+
+// src/services/governance-policy-service.ts
+import {
+  Path,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+
+// src/models/packager-parameters.ts
+import {
+  LogLevel as LogLevel2
+} from "@uipath/solutionpackager-tool-core";
+class PackagerParameters {
+  inputPath;
+  downloadUrl;
+  logLevel = LogLevel2.Warn;
+  outputPath;
+  targetFramework;
+  excludeConfiguredSources = false;
+  nuGetSourcesConfigPath;
+  detailedLogPath;
+  connection;
+  workflowCompilerVersion;
+}
+
+// src/services/governance-policy-service.ts
+var LICENSE_TYPES = {
+  NoLicense: "NoLicense",
+  Development: "Development",
+  Attended: "Attended",
+  Unattended: "Unattended",
+  StudioX: "StudioX",
+  StudioPro: "StudioPro",
+  AutomationKit: "AutomationKit"
+};
+var DEFAULT_PROFILE_KEY = "StudioWeb";
+var ACQUIRE_LICENSE_PATH = "/orchestrator_/api/StudioWeb/AcquireLicense";
+var GOVERNANCE_SUBFOLDER = "governance";
+var GOVERNANCE_FILE_NAME = "governance-policy.json";
+var errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var t = (key, params) => translate2.t(`solutionpackager.governance.${key}`, params);
+
+class GovernancePolicyService {
+  fileSystem;
+  temporaryStorage;
+  fetchFn;
+  logger = new ToolLogger("GovernancePolicyService", "ResolvePolicy");
+  constructor(fileSystem, temporaryStorage, fetchFn = fetch.bind(globalThis)) {
+    this.fileSystem = fileSystem;
+    this.temporaryStorage = temporaryStorage;
+    this.fetchFn = fetchFn;
+  }
+  async resolveGovernancePolicyAsync(validateOptions, connectionInfo, cancellationToken) {
+    if (validateOptions.governanceFileType !== "AutomationOps" /* AutomationOps */) {
+      return;
+    }
+    if (validateOptions.governanceFilePath) {
+      this.logger.info(t("info.alreadyProvided"));
+      return;
+    }
+    let cloudUrl = connectionInfo?.cloudUrl;
+    const organizationId = connectionInfo?.organizationId;
+    const tenantId = connectionInfo?.tenantId;
+    const accessToken = connectionInfo?.accessToken;
+    if (!cloudUrl || !organizationId || !tenantId || !accessToken) {
+      this.logger.warn(t("errors.connectionIncomplete"));
+      validateOptions.governanceFileType = "Default" /* Default */;
+      return;
+    }
+    const profileKey = validateOptions.profileKey ?? DEFAULT_PROFILE_KEY;
+    let cloudOrigin;
+    try {
+      cloudOrigin = new URL(cloudUrl).origin;
+      cloudUrl = cloudUrl.replace(/\/+$/, "");
+    } catch {
+      this.logger.warn(t("errors.connectionIncomplete"));
+      validateOptions.governanceFileType = "Default" /* Default */;
+      return;
+    }
+    const licenseType = await this.resolveLicenseTypeAsync(profileKey, cloudUrl, accessToken, cancellationToken);
+    const policy = await this.downloadPolicyAsync(cloudOrigin, organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken);
+    if (!policy) {
+      validateOptions.governanceFileType = "Default" /* Default */;
+      return;
+    }
+    try {
+      const dir = await this.temporaryStorage.getTempSubfolderPathAsync(GOVERNANCE_SUBFOLDER);
+      const filePath = Path.join(dir, GOVERNANCE_FILE_NAME);
+      await this.fileSystem.writeFile(filePath, policy);
+      this.logger.info(t("info.saved", { path: filePath }));
+      validateOptions.governanceFilePath = filePath;
+    } catch (error) {
+      this.logger.warn(t("errors.failedToSave", {
+        error: errorMessage(error)
+      }));
+      validateOptions.governanceFileType = "Default" /* Default */;
+    }
+  }
+  async downloadPolicyAsync(cloudOrigin, organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken) {
+    const policyUrl = `${cloudOrigin}/${organizationId}/roboticsops_` + `/api/Policy/license/${licenseType}/product/${profileKey}/tenant/${tenantId}`;
+    this.logger.info(t("info.downloading", { url: policyUrl }));
+    try {
+      const response = await this.fetchFn(policyUrl, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          AccountId: organizationId
+        },
+        signal: cancellationToken
+      });
+      if (response.status === 204 || response.status === 404) {
+        this.logger.info(t("info.noPolicyFound"));
+        return null;
+      }
+      if (!response.ok) {
+        const body = await response.text();
+        this.logger.warn(t("errors.failedToGetPolicy", { content: body }));
+        return null;
+      }
+      const content = await response.text();
+      if (!content?.trimStart().startsWith("{")) {
+        this.logger.info(t("info.responseNotJson"));
+        return null;
+      }
+      return content;
+    } catch (error) {
+      this.logger.warn(t("errors.failedToDownload", {
+        error: errorMessage(error)
+      }));
+      return null;
+    }
+  }
+  async resolveLicenseTypeAsync(profileKey, cloudUrl, accessToken, cancellationToken) {
+    const isStudioWeb = profileKey === DEFAULT_PROFILE_KEY;
+    const fallback = isStudioWeb ? LICENSE_TYPES.NoLicense : LICENSE_TYPES.Development;
+    try {
+      const response = await this.fetchFn(`${cloudUrl}${ACQUIRE_LICENSE_PATH}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${accessToken}` },
+        signal: cancellationToken
+      });
+      if (!response.ok) {
+        this.logger.info(t("info.licenseStatus", {
+          status: response.status,
+          fallback
+        }));
+        return fallback;
+      }
+      const { isLicensed, robotType } = await response.json();
+      this.logger.info(t("info.licenseResponse", {
+        isLicensed: String(isLicensed),
+        robotType: String(robotType)
+      }));
+      if (!isLicensed || !robotType) {
+        return fallback;
+      }
+      if (isStudioWeb) {
+        return robotType === LICENSE_TYPES.AutomationKit ? LICENSE_TYPES.AutomationKit : LICENSE_TYPES.NoLicense;
+      }
+      return robotType;
+    } catch (error) {
+      this.logger.info(t("info.licenseFailed", {
+        error: errorMessage(error),
+        fallback
+      }));
+      return fallback;
+    }
+  }
+}
+
+// src/services/pack-service.ts
+class PackService {
+  disallowedCharsRegex = /[^\p{L}\p{N}_.-]/gu;
+  spacesDotRegex = /[\s.]+/g;
+  dotDashRegex = /\.{0,10}[-:]\.{0,10}/g;
+  MaxPackageIdLength = 100;
+  sanitizePackageId(packageId) {
+    packageId = packageId.trim();
+    packageId = packageId.replace(this.spacesDotRegex, ".");
+    packageId = packageId.replace(this.dotDashRegex, "-");
+    packageId = packageId.replace(this.disallowedCharsRegex, "_");
+    if (packageId.length > this.MaxPackageIdLength) {
+      throw new Error(`Package id ${packageId} exceeds the characters limit of ${this.MaxPackageIdLength}`);
+    }
+    return packageId;
+  }
+}
+
+// src/services/packager-parameters-validator.ts
+import {
+  ToolErrorCodes,
+  ToolResult,
+  translate as translate3
+} from "@uipath/solutionpackager-tool-core";
+class PackagerParametersValidator {
+  logger;
+  fileSystem;
+  constructor(logger, fileSystem) {
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(_options, _cancellationToken) {
+    return ToolResult.success();
+  }
+  validateDestinationPath(destinationPath) {
+    if (!destinationPath) {
+      const error = translate3.t("solutionpackager.validator.errors.destinationNotDefined");
+      this.logger.error(error);
+      return ToolResult.error(ToolErrorCodes.InternalError, error);
+    }
+    return ToolResult.success();
+  }
+  async validateGovernanceOptions(validateOptions) {
+    if (validateOptions.governanceFileType === "Default" /* Default */) {
+      if (validateOptions.governanceFilePath) {
+        this.logger.warn(`Governance file path '${validateOptions.governanceFilePath}' will be ignored when governance file type is Default`);
+      }
+      return ToolResult.success();
+    }
+    if (!validateOptions.governanceFilePath) {
+      const error = translate3.t("solutionpackager.validator.errors.governanceRequired");
+      this.logger.error(error);
+      return ToolResult.error(ToolErrorCodes.InternalError, error);
+    }
+    try {
+      const stat = await this.fileSystem.stat(validateOptions.governanceFilePath);
+      if (!stat) {
+        const error = translate3.t("solutionpackager.validator.errors.governanceFileInfo", {
+          path: validateOptions.governanceFilePath
+        });
+        this.logger.error(error);
+        return ToolResult.error(ToolErrorCodes.InternalError, error);
+      }
+      if (stat.isDirectory()) {
+        const error = translate3.t("solutionpackager.validator.errors.governanceInvalidFile", {
+          path: validateOptions.governanceFilePath
+        });
+        this.logger.error(error);
+        return ToolResult.error(ToolErrorCodes.InternalError, error);
+      }
+    } catch (error) {
+      const errorMessage2 = error instanceof Error ? error.message : String(error);
+      const errorLog = `Governance file not found or inaccessible: ${validateOptions.governanceFilePath}. Error: ${errorMessage2}`;
+      this.logger.error(errorLog);
+      return ToolResult.error(ToolErrorCodes.InternalError, errorLog);
+    }
+    this.logger.info(`Using Studio governance file: ${validateOptions.governanceFilePath}`);
+    return ToolResult.success();
+  }
+}
+
+// src/services/project-build-options-validator.ts
+class ProjectBuildOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// src/services/project-loader.ts
+import {
+  Path as Path2,
+  ProjectTool,
+  ProjectTypes,
+  translate as translate4
+} from "@uipath/solutionpackager-tool-core";
+
+class ProjectLoader {
+  fileSystem;
+  static WebAppManifestFileName = "webAppManifest.json";
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async loadProject(projectPath) {
+    if (!projectPath) {
+      throw new Error(translate4.t("solutionpackager.projectLoader.errors.pathRequired"));
+    }
+    const projectFilePath = Path2.join(projectPath, ProjectTool.ProjectFileName);
+    const projectFileExists = await this.fileSystem.exists(projectFilePath);
+    if (projectFileExists) {
+      return await this.loadFromProjectFile(projectPath, projectFilePath);
+    }
+    const webAppManifestPath = Path2.join(projectPath, ProjectLoader.WebAppManifestFileName);
+    const webAppManifestExists = await this.fileSystem.exists(webAppManifestPath);
+    if (webAppManifestExists) {
+      return this.loadFromWebAppManifest(projectPath, webAppManifestPath);
+    }
+    throw new Error(translate4.t("solutionpackager.projectLoader.errors.noProjectFile", {
+      projectFile: ProjectTool.ProjectFileName,
+      manifestFile: ProjectLoader.WebAppManifestFileName,
+      path: projectPath
+    }));
+  }
+  async loadFromProjectFile(projectPath, projectFilePath) {
+    const fileContent = await this.fileSystem.readFile(projectFilePath);
+    if (!fileContent) {
+      throw new Error(translate4.t("solutionpackager.projectLoader.errors.readFailed", {
+        path: projectFilePath
+      }));
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const projectData = JSON.parse(json);
+    const projectType = projectData?.ProjectType || projectData?.type;
+    if (!projectData || !projectType) {
+      throw new Error(translate4.t("solutionpackager.projectLoader.errors.invalidProject", {
+        path: projectFilePath
+      }));
+    }
+    return {
+      type: projectType,
+      name: projectData.Name || Path2.basename(projectPath),
+      projectPath,
+      projectFilePath
+    };
+  }
+  loadFromWebAppManifest(projectPath, webAppManifestPath) {
+    const folderName = Path2.basename(projectPath);
+    return {
+      type: ProjectTypes.AppV2,
+      name: folderName,
+      projectPath,
+      projectFilePath: webAppManifestPath
+    };
+  }
+}
+
+// src/services/project-pack-options-builder.ts
+class ProjectPackOptionsBuilder {
+  packService;
+  fileSystem;
+  constructor(packService, fileSystem) {
+    this.packService = packService;
+    this.fileSystem = fileSystem;
+  }
+  async buildProjectPackOptions(parameters, project) {
+    if (!parameters.outputPath) {
+      throw new Error("Output path is required for Pack command");
+    }
+    await this.fileSystem.mkdir(parameters.outputPath);
+    const packageId = !parameters.package.id || parameters.package.id.trim() === "" ? project.name : parameters.package.id;
+    const packageInfo = {
+      ...parameters.package,
+      id: this.packService.sanitizePackageId(packageId)
+    };
+    return {
+      projectPath: project.projectPath,
+      excludeConfiguredSources: parameters.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: parameters.nuGetSourcesConfigPath,
+      logLevel: parameters.logLevel,
+      skipAnalyze: parameters.validateOptions.skipAnalyze,
+      skipValidate: parameters.validateOptions.skipValidate,
+      detailedLogPath: parameters.detailedLogPath,
+      policyFilePath: parameters.validateOptions.governanceFilePath,
+      policyFileType: parameters.validateOptions.governanceFileType,
+      outputPath: parameters.outputPath,
+      outputType: parameters.outputType,
+      projectType: project.type,
+      package: packageInfo,
+      skipDependencyOptimization: parameters.packOptions?.skipDependencyOptimization ?? false,
+      includeSources: parameters.packOptions?.includeSources ?? false,
+      splitPackages: parameters.packOptions?.splitPackages ?? false
+    };
+  }
+}
+
+// src/services/project-pack-options-validator.ts
+class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator {
+  async validateAsync(options, cancellationToken) {
+    const destinationResult = this.validateDestinationPath(options.destinationPath);
+    if (!destinationResult.isSuccess) {
+      return destinationResult;
+    }
+    return await super.validateAsync(options, cancellationToken);
+  }
+}
+
+// src/services/project-tool-executor.ts
+import {
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2
+} from "@uipath/solutionpackager-tool-core";
+class ProjectToolExecutor {
+  toolsFactory;
+  telemetry;
+  packageSignService;
+  constructor(toolsFactory, telemetry, packageSignService) {
+    this.toolsFactory = toolsFactory;
+    this.telemetry = telemetry;
+    this.packageSignService = packageSignService;
+  }
+  async restoreAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Restore" /* ProjectToolRestore */, project.Type, async () => tool.restoreAsync(options, cancellationToken), {
+      projectId: project.Id,
+      projectType: project.Type
+    }));
+  }
+  async validateAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Validate" /* ProjectToolValidate */, project.Type, async () => tool.validateAsync(options, cancellationToken), {
+      projectId: project.Id,
+      projectType: project.Type
+    }));
+  }
+  async buildAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Build" /* ProjectToolBuild */, project.Type, async () => tool.buildAsync(options, cancellationToken), {
+      projectId: project.Id,
+      projectType: project.Type
+    }));
+  }
+  async packAsync(options, project, context, signingInfo, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, async (tool) => {
+      const result = await this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Pack" /* ProjectToolPack */, project.Type, async () => {
+        return await tool.packAsync(options, cancellationToken);
+      }, {
+        projectId: project.Id,
+        projectType: project.Type
+      });
+      if (result.isSuccess && signingInfo?.certificatePath && result.packages.length > 0) {
+        const signResult = await this.signPackagesAsync(result.packages, signingInfo);
+        if (!signResult.isSuccess) {
+          return signResult;
+        }
+      }
+      return result;
+    });
+  }
+  async executeToolOperationAsync(project, context, operation) {
+    try {
+      const tool = await this.toolsFactory.createProjectToolAsync(project, context);
+      try {
+        return await operation(tool);
+      } finally {
+        const disposeResult = tool.dispose();
+        if (disposeResult instanceof Promise) {
+          await disposeResult;
+        }
+      }
+    } catch (error) {
+      return ToolResult2.error(ToolErrorCodes2.InternalError, error instanceof Error ? error.message : String(error));
+    }
+  }
+  async signPackagesAsync(packages, signingInfo) {
+    if (!this.packageSignService) {
+      return ToolResult2.error(ToolErrorCodes2.InternalError, "Package signing is required but signing service is not available. Package signing requires dotnet CLI to be installed in Node.js environment.");
+    }
+    const certificatePath = signingInfo.certificatePath;
+    const signResults = await Promise.all(packages.map((packagePath) => this.packageSignService?.signPackageAsync(packagePath, certificatePath, signingInfo.certificatePassword, signingInfo.timestampServer)));
+    const failedResult = signResults.find((result) => result && !result.isSuccess);
+    if (failedResult) {
+      return failedResult;
+    }
+    return ToolResult2.success();
+  }
+}
+
+// src/services/project-validate-options-validator.ts
+class ProjectValidateOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// src/services/tools-factory.ts
+class ToolsFactory {
+  repository;
+  fileSystem;
+  constructor(repository, fileSystem) {
+    this.repository = repository;
+    this.fileSystem = fileSystem;
+  }
+  async createSolutionToolAsync(solutionName) {
+    const logger = new ToolLogger("ResourceBuilder", solutionName);
+    const factory = this.repository.getSolutionToolFactory();
+    return await factory.createAsync(logger, this.fileSystem);
+  }
+  async createProjectToolAsync(project, context) {
+    const sourceTarget = getSourceTarget();
+    const logger = new ToolLogger(project.Type, sourceTarget);
+    if (!project.ProjectPath) {
+      throw new Error(`Project path not set for project: ${project.Id}`);
+    }
+    const factory = this.repository.getProjectToolFactory(project.Type);
+    return await factory.createAsync(logger, this.fileSystem, context);
+    function getSourceTarget() {
+      const segments = project.ProjectRelativePath.split(/[/\\]/);
+      if (segments.length > 1) {
+        return segments[0];
+      }
+      return project.Id;
+    }
+  }
+}
+
+// src/services/project-packager.ts
+class ProjectPackager {
+  fileSystem;
+  telemetryService;
+  packageSignService;
+  repository;
+  temporaryStorage;
+  zipService;
+  logger;
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  projectLoader;
+  validateOptionsValidator;
+  buildOptionsValidator;
+  packOptionsValidator;
+  nugetPackager;
+  governancePolicyService;
+  constructor(fileSystem, telemetryService, packageSignService) {
+    this.fileSystem = fileSystem;
+    this.telemetryService = telemetryService;
+    this.packageSignService = packageSignService;
+    this.repository = defaultToolsFactoryRepository;
+    this.temporaryStorage = new TemporaryStorageService(this.fileSystem);
+    this.zipService = new ZipService(this.fileSystem);
+    this.nugetPackager = new NugetPackager(this.fileSystem);
+    this.logger = new ToolLogger("ProjectPackager", "PackProject");
+    this.validateOptionsValidator = new ProjectValidateOptionsValidator(this.logger, this.fileSystem);
+    this.buildOptionsValidator = new ProjectBuildOptionsValidator(this.logger, this.fileSystem);
+    this.packOptionsValidator = new ProjectPackOptionsValidator(this.logger, this.fileSystem);
+    const packService = new PackService;
+    this.optionsBuilder = new ProjectPackOptionsBuilder(packService, this.fileSystem);
+    this.toolsFactory = new ToolsFactory(this.repository, this.fileSystem);
+    this.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService, this.packageSignService);
+    this.projectLoader = new ProjectLoader(this.fileSystem);
+    this.governancePolicyService = new GovernancePolicyService(this.fileSystem, this.temporaryStorage);
+  }
+  async setupAsync(input, operationId) {
+    this.telemetryService.setOperationId(operationId);
+    await this.temporaryStorage.cleanup();
+    if (typeof input === "string") {
+      return input;
+    }
+    const inputPath = await this.temporaryStorage.getTempSubfolderPathAsync("input");
+    await this.zipService.extractAsync(input, inputPath);
+    const entries = await this.fileSystem.readdir(inputPath);
+    if (entries.length === 1) {
+      const innerPath = Path3.join(inputPath, entries[0]);
+      const stat = await this.fileSystem.stat(innerPath);
+      if (stat?.isDirectory()) {
+        return innerPath;
+      }
+    }
+    return inputPath;
+  }
+  async restoreProjectAsync(options, cancellationToken) {
+    return await this.executeProjectOperationAsync(options, "Restore", "ProjectPackager.Restore" /* ProjectPackagerRestore */, async (uiPathProject, loadedProject) => {
+      const restoreOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        logLevel: options.logLevel,
+        outputPath: options.outputPath
+      };
+      return await this.projectExecutor.restoreAsync(restoreOptions, uiPathProject, undefined, cancellationToken);
+    }, cancellationToken);
+  }
+  async validateProjectAsync(options, cancellationToken) {
+    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+    const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
+    if (!validationResult.isSuccess) {
+      return validationResult;
+    }
+    return await this.executeProjectOperationAsync(options, "Validate", "ProjectPackager.Validate" /* ProjectPackagerValidate */, async (uiPathProject, loadedProject) => {
+      const validateOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        logLevel: options.logLevel,
+        skipAnalyze: options.validateOptions.skipAnalyze,
+        skipValidate: options.validateOptions.skipValidate,
+        defaultSeverity: options.validateOptions.defaultSeverity,
+        detailedLogPath: options.detailedLogPath,
+        policyFilePath: options.validateOptions.governanceFilePath,
+        policyFileType: options.validateOptions.governanceFileType
+      };
+      const context = this.createOperationContext(options, uiPathProject);
+      return await this.projectExecutor.validateAsync(validateOptions, uiPathProject, context, cancellationToken);
+    }, cancellationToken);
+  }
+  async buildProjectAsync(options, cancellationToken) {
+    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+    const validationResult = await this.buildOptionsValidator.validateAsync(options, cancellationToken);
+    if (!validationResult.isSuccess) {
+      return validationResult;
+    }
+    return await this.executeProjectOperationAsync(options, "Build", "ProjectPackager.Build" /* ProjectPackagerBuild */, async (uiPathProject, loadedProject) => {
+      if (!options.outputPath) {
+        options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+      }
+      const buildOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        logLevel: options.logLevel,
+        skipAnalyze: options.validateOptions.skipAnalyze,
+        skipValidate: options.validateOptions.skipValidate,
+        detailedLogPath: options.detailedLogPath,
+        policyFilePath: options.validateOptions.governanceFilePath,
+        policyFileType: options.validateOptions.governanceFileType,
+        outputPath: options.outputPath,
+        outputType: options.outputType,
+        projectType: uiPathProject.Type
+      };
+      return await this.projectExecutor.buildAsync(buildOptions, uiPathProject, undefined, cancellationToken);
+    }, cancellationToken);
+  }
+  async packProjectAsync(options, cancellationToken) {
+    return await this.telemetryService.trackRequest("ProjectPackager.Pack" /* ProjectPackagerPack */, async () => {
+      try {
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        let result = await this.packOptionsValidator.validateAsync(options, cancellationToken);
+        if (!result.isSuccess) {
+          return result;
+        }
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+        }
+        const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+        this.telemetryService.trackEvent("ProjectPackager.ProjectLoaded" /* ProjectPackagerProjectLoaded */, { projectId: loadedProject.name });
+        const projectPackOptions = await this.optionsBuilder.buildProjectPackOptions(options, loadedProject);
+        const uiPathProject = {
+          Type: loadedProject.type,
+          ProjectRelativePath: Path3.basename(loadedProject.projectFilePath),
+          ProjectPath: loadedProject.projectPath,
+          Id: loadedProject.name
+        };
+        const context = this.createOperationContext(options, uiPathProject);
+        result = await this.projectExecutor.packAsync(projectPackOptions, uiPathProject, context, options.signingInfo, cancellationToken);
+        if (result.isSuccess && result.packages.length > 0) {
+          const destinationPackages = await this.copyPackagesToDestination(result.packages, options.destinationPath, projectPackOptions.package);
+          result = new ToolResult3(ToolErrorCodes3.Success, undefined, destinationPackages);
+        }
+        if (result.isSuccess) {
+          this.logger.info(`Project pack completed successfully. Packages: ${result.packages.join(", ")}`);
+        } else {
+          this.logger.error(`Project pack failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage2}`);
+        return ToolResult3.error(ToolErrorCodes3.InternalError, `Project pack failed: ${errorMessage2}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async getPackageStreamsAsync(result) {
+    if (!result.isSuccess) {
+      throw new Error(translate5.t("solutionpackager.packager.errors.failedToGetStreams", {
+        errorCode: result.errorCode,
+        message: result.message ?? ""
+      }));
+    }
+    if (!result.packages || result.packages.length === 0) {
+      return [];
+    }
+    const packageStreams = [];
+    for (const packagePath of result.packages) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        throw new Error(translate5.t("solutionpackager.packager.errors.failedToReadPackage", {
+          path: packagePath
+        }));
+      }
+      const name = packagePath.split(/[\\/]/).pop() || packagePath;
+      packageStreams.push({ name, data });
+    }
+    return packageStreams;
+  }
+  async executeProjectOperationAsync(options, operationName, telemetryName, operation, _cancellationToken) {
+    return await this.telemetryService.trackRequest(telemetryName, async () => {
+      try {
+        const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+        const uiPathProject = {
+          Type: loadedProject.type,
+          ProjectRelativePath: Path3.basename(loadedProject.projectFilePath),
+          ProjectPath: loadedProject.projectPath,
+          Id: loadedProject.name
+        };
+        const operationResult = await operation(uiPathProject, loadedProject);
+        if (operationResult.isSuccess) {
+          this.logger.info(`Project ${operationName.toLowerCase()} completed successfully.`);
+        } else {
+          this.logger.error(`Project ${operationName.toLowerCase()} failed with error code ${operationResult.errorCode}: ${operationResult.message}`);
+        }
+        return operationResult;
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage2}`);
+        return ToolResult3.error(ToolErrorCodes3.InternalError, `Project ${operationName.toLowerCase()} failed: ${errorMessage2}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  createOperationContext(options, uiPathProject) {
+    return {
+      id: crypto.randomUUID(),
+      projects: [uiPathProject],
+      downloadUrl: options.downloadUrl,
+      targetFramework: options.targetFramework ?? TargetFramework.Portable,
+      connection: options.connection,
+      logger: this.logger,
+      workflowCompilerVersion: options.workflowCompilerVersion
+    };
+  }
+  async findNupkgInParentDir(packagePath) {
+    const dirName = Path3.basename(packagePath);
+    const parentDir = Path3.dirname(packagePath);
+    const parentFiles = await this.fileSystem.readdir(parentDir);
+    const matchingFiles = parentFiles.filter((f) => f.endsWith(".nupkg") && f.startsWith(`${dirName}.`));
+    return { dir: parentDir, files: matchingFiles };
+  }
+  async copyFileToDestination(sourcePath, destinationPath) {
+    const fileName = Path3.basename(sourcePath);
+    const destPath = Path3.join(destinationPath, fileName);
+    const data = await this.fileSystem.readFile(sourcePath);
+    if (!data) {
+      throw new Error(translate5.t("solutionpackager.packager.errors.failedToReadPackage", { path: sourcePath }));
+    }
+    await this.fileSystem.writeFile(destPath, data);
+    return destPath;
+  }
+  async copyPackagesToDestination(packagePaths, destinationPath, packageInfo) {
+    await this.fileSystem.mkdir(destinationPath);
+    const destinationPackages = [];
+    for (const packagePath of packagePaths) {
+      const stat = await this.fileSystem.stat(packagePath);
+      if (stat?.isDirectory()) {
+        const files = await this.fileSystem.readdir(packagePath);
+        const nupkgFiles = files.filter((f) => f.endsWith(".nupkg"));
+        if (nupkgFiles.length > 0) {
+          for (const nupkgFile of nupkgFiles) {
+            const filePath = Path3.join(packagePath, nupkgFile);
+            const dest = await this.copyFileToDestination(filePath, destinationPath);
+            destinationPackages.push(dest);
+          }
+        } else {
+          const parent = await this.findNupkgInParentDir(packagePath);
+          if (parent.files.length > 0) {
+            for (const nupkgFile of parent.files) {
+              const filePath = Path3.join(parent.dir, nupkgFile);
+              const dest = await this.copyFileToDestination(filePath, destinationPath);
+              destinationPackages.push(dest);
+            }
+          } else {
+            const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+            const destPath = Path3.join(destinationPath, nupkgFileName);
+            const packResult = await this.nugetPackager.packAsync(packagePath, packageInfo, destPath);
+            destinationPackages.push(packResult.outputPath);
+          }
+        }
+      } else {
+        const dest = await this.copyFileToDestination(packagePath, destinationPath);
+        destinationPackages.push(dest);
+      }
+    }
+    return destinationPackages;
+  }
+}
+
+// src/browser-project-packager-factory.ts
+class BrowserProjectPackagerFactory extends BaseBrowserPackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("ProjectPackagerFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating ProjectPackager instance...");
+    const fileSystem = await this.getOrCreateFileSystem(config);
+    const telemetryService = this.getOrCreateTelemetryService(config);
+    const projectPackager = new ProjectPackager(fileSystem, telemetryService);
+    logger.info("ProjectPackager created successfully.");
+    return projectPackager;
+  }
+}
+async function createBrowserProjectPackager(options) {
+  const factory = new BrowserProjectPackagerFactory;
+  return factory.createAsync(options);
+}
+export {
+  createBrowserProjectPackager,
+  BaseBrowserPackagerFactory
+};