@uipath/project-packager 1.1.10 → 1.196.0

package/dist/index.js

@@ -46,9 +46,38 @@ var de_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -100,9 +129,38 @@ var en = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -153,9 +211,38 @@ var es_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -206,9 +293,38 @@ var es_MX_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -259,9 +375,38 @@ var fr_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -312,9 +457,38 @@ var ja_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -365,9 +539,38 @@ var ko_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -418,9 +621,38 @@ var pt_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -471,9 +703,38 @@ var pt_BR_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -524,9 +785,38 @@ var ro_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -577,9 +867,38 @@ var ru_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -630,9 +949,38 @@ var tr_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -683,9 +1031,38 @@ var zh_CN_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -736,9 +1113,38 @@ var zh_TW_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -789,9 +1195,38 @@ var zu_default = {
     signing: {
       errors: {
         dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
-      },
+      }
+    },
+    dotnet: {
       info: {
-        dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        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}"
       }
     }
   }
@@ -814,22 +1249,7 @@ I18nManager.registerTranslations("zh-CN", zh_CN_default);
 I18nManager.registerTranslations("zh-TW", zh_TW_default);
 I18nManager.registerTranslations("zu", zu_default);
 
-// ../../telemetry/dist/index.js
-class ConsoleTelemetryProvider {
-  async trackEvent(eventName, _properties) {
-    console.log(`[Telemetry] Event: ${eventName}`);
-  }
-  async trackException(error, _properties) {
-    console.log(`[Telemetry] Exception: ${error.message}`);
-  }
-  async trackRequest(name, duration, success, _properties) {
-    console.log(`[Telemetry] Request: ${name} (${duration}ms, ${success ? "ok" : "fail"})`);
-  }
-  async trackDependency(name, type, duration, success, _properties) {
-    console.log(`[Telemetry] Dependency: ${name} [${type}] (${duration}ms, ${success ? "ok" : "fail"})`);
-  }
-}
-
+// ../../common/dist/telemetry/index.js
 class BrowserContextStorage {
   contextStack = [];
   run(context, fn) {
@@ -853,6 +1273,89 @@ class BrowserContextStorage {
   }
 }
 
+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;
@@ -869,7 +1372,7 @@ class TelemetryService {
     this.telemetryProvider = provider;
   }
   setDefaultProperties(properties) {
-    this.defaultProperties = properties;
+    this.defaultProperties = properties === undefined ? undefined : { ...this.defaultProperties, ...properties };
   }
   trackEvent(name, properties) {
     const context = this.getCurrentContext();
@@ -931,6 +1434,7 @@ class TelemetryService {
   }
   enrichPropertiesWithContext(properties, context) {
     return {
+      ...getGlobalTelemetryProperties(),
       ...this.defaultProperties,
       ...properties,
       ...context
@@ -953,6 +1457,7 @@ var RulesConfigFileType;
 
 class PackagerParameters {
   inputPath;
+  downloadUrl;
   logLevel = LogLevel.Warn;
   outputPath;
   targetFramework;
@@ -970,12 +1475,14 @@ class ProjectRestoreOptions extends PackagerParameters {
 class ProjectValidateOptions extends ProjectRestoreOptions {
   validateOptions = {
     skipAnalyze: false,
+    skipValidate: false,
     governanceFileType: "Default" /* Default */
   };
 }
 
 // src/models/project-build-options.ts
 class ProjectBuildOptions extends ProjectValidateOptions {
+  outputType;
 }
 // src/models/project-pack-options.ts
 class ProjectPackOptions extends ProjectBuildOptions {
@@ -984,11 +1491,30 @@ class ProjectPackOptions extends ProjectBuildOptions {
   signingInfo;
   packOptions;
 }
-// src/services/governance-policy-service.ts
+// src/publish/models/publish-options.ts
+var PublishDestinationKind;
+((PublishDestinationKind2) => {
+  PublishDestinationKind2["LocalFolder"] = "LocalFolder";
+  PublishDestinationKind2["NugetFeed"] = "NugetFeed";
+  PublishDestinationKind2["OrchestratorPersonalWorkspace"] = "OrchestratorPersonalWorkspace";
+  PublishDestinationKind2["OrchestratorTenantProcesses"] = "OrchestratorTenantProcesses";
+  PublishDestinationKind2["OrchestratorSharedLibraries"] = "OrchestratorSharedLibraries";
+  PublishDestinationKind2["OrchestratorCustom"] = "OrchestratorCustom";
+})(PublishDestinationKind ||= {});
+
+class ProjectPublishOptions {
+  packagePaths;
+  destination;
+  constructor(packagePaths, destination) {
+    this.packagePaths = packagePaths;
+    this.destination = destination;
+  }
+}
+// src/publish/services/project-publisher.ts
 import {
-  Path,
-  toRelativeUrl,
-  translate
+  ToolErrorCodes as ToolErrorCodes4,
+  ToolResult as ToolResult4,
+  translate as translate5
 } from "@uipath/solutionpackager-tool-core";
 
 // src/services/tool-logger.ts
@@ -1077,7 +1603,648 @@ class ToolLogger {
   }
 }
 
+// src/publish/services/local-folder-publisher.ts
+import {
+  ToolErrorCodes,
+  ToolResult,
+  translate
+} from "@uipath/solutionpackager-tool-core";
+class LocalFolderPublisher {
+  fileSystem;
+  logger;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "LocalFolder");
+  }
+  async publishAsync(packagePaths, destination) {
+    const overwrite = destination.overwrite ?? true;
+    if (!destination.folderPath) {
+      return ToolResult.error(ToolErrorCodes.InternalError, translate.t("solutionpackager.publish.errors.localFolderRequired"));
+    }
+    if (!await this.fileSystem.exists(destination.folderPath)) {
+      await this.fileSystem.mkdir(destination.folderPath);
+    }
+    const written = [];
+    for (const sourcePath of packagePaths) {
+      const fileName = this.fileSystem.path.basename(sourcePath);
+      const destPath = this.fileSystem.path.join(destination.folderPath, fileName);
+      if (!overwrite && await this.fileSystem.exists(destPath)) {
+        return ToolResult.error(ToolErrorCodes.InternalError, translate.t("solutionpackager.publish.errors.localFolderFileExists", { path: destPath }));
+      }
+      const data = await this.fileSystem.readFile(sourcePath);
+      if (!data) {
+        return ToolResult.error(ToolErrorCodes.InternalError, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: sourcePath }));
+      }
+      await this.fileSystem.writeFile(destPath, data);
+      written.push(destPath);
+      this.logger.info(`Copied package to ${destPath}`);
+    }
+    return new ToolResult(ToolErrorCodes.Success, undefined, written);
+  }
+}
+
+// src/publish/services/nuget-feed-publisher.ts
+import {
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+var NUGET_V3_PACKAGE_PUBLISH_TYPE = "PackagePublish/2.0.0";
+
+class NugetFeedPublisher {
+  fileSystem;
+  logger;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "NugetFeed");
+  }
+  async publishAsync(packagePaths, destination) {
+    if (!destination.feedUrl) {
+      return ToolResult2.error(ToolErrorCodes2.InternalError, translate2.t("solutionpackager.publish.errors.nugetFeedUrlRequired"));
+    }
+    let pushUrl;
+    try {
+      pushUrl = await this.resolvePushUrl(destination.feedUrl, destination.apiKey);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return ToolResult2.error(ToolErrorCodes2.InternalError, translate2.t("solutionpackager.publish.errors.nugetPushUrlResolutionFailed", { feedUrl: destination.feedUrl, message }));
+    }
+    const published = [];
+    for (const packagePath of packagePaths) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        return ToolResult2.error(ToolErrorCodes2.InternalError, translate2.t("solutionpackager.publish.errors.failedToReadPackage", { path: packagePath }));
+      }
+      const fileName = this.fileSystem.path.basename(packagePath);
+      const form = new FormData;
+      form.append("package", new Blob([data], {
+        type: "application/octet-stream"
+      }), fileName);
+      const headers = {};
+      if (destination.apiKey) {
+        headers["X-NuGet-ApiKey"] = destination.apiKey;
+      }
+      this.logger.info(`Pushing ${fileName} to ${pushUrl}`);
+      const response = await fetch(pushUrl, {
+        method: "PUT",
+        headers,
+        body: form
+      });
+      if (!response.ok) {
+        const body = await this.safeReadBody(response);
+        return ToolResult2.error(ToolErrorCodes2.InternalError, translate2.t("solutionpackager.publish.errors.nugetPushFailed", {
+          fileName,
+          status: response.status,
+          statusText: response.statusText,
+          body: body ? ` - ${body}` : ""
+        }));
+      }
+      published.push(packagePath);
+      this.logger.info(`Pushed ${fileName} successfully.`);
+    }
+    return new ToolResult2(ToolErrorCodes2.Success, undefined, published);
+  }
+  async resolvePushUrl(feedUrl, apiKey) {
+    let end = feedUrl.length;
+    while (end > 0 && feedUrl.charCodeAt(end - 1) === 47)
+      end--;
+    const trimmed = feedUrl.slice(0, end);
+    if (/\/api\/v2\/package\/?$/i.test(trimmed)) {
+      return trimmed;
+    }
+    if (/\.json$/i.test(trimmed)) {
+      return this.resolveFromServiceIndex(trimmed, apiKey);
+    }
+    return `${trimmed}/api/v2/package`;
+  }
+  async resolveFromServiceIndex(serviceIndexUrl, apiKey) {
+    const headers = { Accept: "application/json" };
+    if (apiKey) {
+      headers["X-NuGet-ApiKey"] = apiKey;
+    }
+    const response = await fetch(serviceIndexUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`service index returned ${response.status} ${response.statusText}`);
+    }
+    const index = await response.json();
+    const resource = index.resources?.find((r) => r["@type"] === NUGET_V3_PACKAGE_PUBLISH_TYPE);
+    if (!resource?.["@id"]) {
+      throw new Error(`service index has no ${NUGET_V3_PACKAGE_PUBLISH_TYPE} resource`);
+    }
+    return resource["@id"];
+  }
+  async safeReadBody(response) {
+    try {
+      const text = await response.text();
+      return text.slice(0, 500);
+    } catch {
+      return "";
+    }
+  }
+}
+
+// src/publish/services/orchestrator-publisher.ts
+import {
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3,
+  translate as translate4
+} from "@uipath/solutionpackager-tool-core";
+
+// src/publish/services/orchestrator-feed-types.ts
+var PackageFeedDtoPurposeEnum = {
+  Undefined: "Undefined",
+  Processes: "Processes",
+  Libraries: "Libraries",
+  PersonalWorkspace: "PersonalWorkspace",
+  FolderHierarchy: "FolderHierarchy"
+};
+var PackageFeedDtoAuthenticationTypeEnum = {
+  Secure: "Secure",
+  ApiKey: "ApiKey",
+  Basic: "Basic"
+};
+var ExtendedFolderDtoFeedTypeEnum = {
+  Undefined: "Undefined",
+  Processes: "Processes",
+  Libraries: "Libraries",
+  PersonalWorkspace: "PersonalWorkspace",
+  FolderHierarchy: "FolderHierarchy"
+};
+
+// ../../common/dist/sdk-user-agent.js
+var PREFIX2 = "@uipath/common/";
+var _g2 = globalThis;
+function singleton2(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX2 + name);
+  return {
+    get(fallback) {
+      return _g2[key] ?? fallback;
+    },
+    set(value) {
+      _g2[key] = value;
+    },
+    clear() {
+      delete _g2[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g2[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g2[key] = instance;
+      return instance;
+    }
+  };
+}
+var USER_AGENT_HEADER = "User-Agent";
+var sdkUserAgentHostToken = singleton2("SdkUserAgentHostToken");
+function splitUserAgentTokens(value) {
+  return value?.trim().split(/\s+/).filter(Boolean) ?? [];
+}
+function appendUserAgentToken(value, userAgent) {
+  const tokens = splitUserAgentTokens(value);
+  const seen = new Set(tokens);
+  for (const token of splitUserAgentTokens(userAgent)) {
+    if (!seen.has(token)) {
+      tokens.push(token);
+      seen.add(token);
+    }
+  }
+  return tokens.join(" ");
+}
+function getEffectiveUserAgent(userAgent) {
+  return appendUserAgentToken(sdkUserAgentHostToken.get(), userAgent);
+}
+function addSdkUserAgentHeader(headers, userAgent) {
+  const result = { ...headers ?? {} };
+  const effectiveUserAgent = getEffectiveUserAgent(userAgent);
+  const headerName = Object.keys(result).find((key) => key.toLowerCase() === USER_AGENT_HEADER.toLowerCase());
+  if (headerName) {
+    result[headerName] = appendUserAgentToken(result[headerName], effectiveUserAgent);
+  } else {
+    result[USER_AGENT_HEADER] = effectiveUserAgent;
+  }
+  return result;
+}
+
+// src/publish/services/orchestrator-feeds-service.ts
+import { translate as translate3 } from "@uipath/solutionpackager-tool-core";
+// package.json
+var package_default = {
+  name: "@uipath/project-packager",
+  license: "MIT",
+  version: "1.196.0",
+  description: "UiPath Project Packager - core library for packing individual UiPath projects",
+  type: "module",
+  main: "./dist/index.js",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./node": {
+      types: "./dist/src/node.d.ts",
+      default: "./dist/node.js"
+    },
+    "./browser": {
+      types: "./dist/src/browser.d.ts",
+      default: "./dist/browser.js"
+    }
+  },
+  types: "./dist/src/index.d.ts",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/packager/project-packager"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/"
+  },
+  files: [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external '@uipath/filesystem/*' --external @uipath/filesystem && bun build ./src/browser.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external '@uipath/filesystem/*' --external @uipath/filesystem && bun build ./src/node.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core --external '@uipath/common/*' --external @uipath/common --external '@uipath/filesystem/*' --external @uipath/filesystem && tsc --emitDeclarationOnly --outDir dist",
+    clean: "rimraf dist",
+    test: "vitest run",
+    e2e: "vitest run --config vitest.e2e.config.ts",
+    "test:coverage": "vitest run --coverage",
+    prepack: "bun run build",
+    "publish:dry": "bun publish --dry-run",
+    "publish:gh": "bun publish",
+    "version:patch": "bun version patch --no-git-tag-version",
+    "version:minor": "bun version minor --no-git-tag-version",
+    "version:major": "bun version major --no-git-tag-version",
+    lint: "biome check ."
+  },
+  dependencies: {
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/common": "workspace:*"
+  },
+  peerDependencies: {
+    fflate: "^0.8.2"
+  },
+  devDependencies: {
+    "@types/node": "^25.5.2",
+    "@uipath/resource-builder-tool": "2025.11.0-alpha2928-3101",
+    "@uipath/tool-agent": "^1.2.6",
+    "@uipath/packager-tool-apiworkflow": "workspace:*",
+    "@uipath/packager-tool-connector": "workspace:*",
+    "@uipath/packager-tool-flow": "workspace:*",
+    "@uipath/packager-tool-functions": "workspace:*",
+    "@uipath/packager-tool-webapp": "workspace:*",
+    "@uipath/packager-tool-workflowcompiler": "workspace:*",
+    "@vitest/coverage-v8": "^4.1.6",
+    jsdom: "^29.0.0",
+    typescript: "^6.0.2",
+    "vite-tsconfig-paths": "^6.1.1",
+    vitest: "^4.1.6"
+  }
+};
+
+// src/publish/services/orchestrator-feeds-service.ts
+var HEADER_TENANT_ID = "X-UIPATH-TenantId";
+var FEEDS_PATH = "/api/PackageFeeds/GetFeeds";
+var FOLDERS_PATH = "/api/FoldersNavigation/GetAllFoldersForCurrentUser";
+var SDK_USER_AGENT = `${package_default.name.replace(/^@uipath\//, "")}/${package_default.version}`;
+
+class OrchestratorFeedsService {
+  logger;
+  constructor() {
+    this.logger = new ToolLogger("OrchestratorFeedsService", "Feeds");
+  }
+  async getAccessibleFeedsAsync(connection) {
+    this.ensureOrchestratorUrl(connection);
+    this.logger.info(`Fetching accessible feeds from ${connection.orchestratorUrl}`);
+    try {
+      const json = await orchestratorGet(connection, FEEDS_PATH);
+      return Array.isArray(json) ? json : [];
+    } catch (error) {
+      const { status, statusText, body } = await describeResponseError(error);
+      throw new Error(translate3.t("solutionpackager.publish.errors.getAccessibleFeedsFailed", { status, statusText, body }));
+    }
+  }
+  async getFoldersForCurrentUserAsync(connection) {
+    this.ensureOrchestratorUrl(connection);
+    this.logger.info(`Fetching folders from ${connection.orchestratorUrl}`);
+    try {
+      const json = await orchestratorGet(connection, FOLDERS_PATH);
+      return Array.isArray(json) ? json.map(mapExtendedFolder) : [];
+    } catch (error) {
+      const { status, statusText, body } = await describeResponseError(error);
+      throw new Error(translate3.t("solutionpackager.publish.errors.getFoldersForCurrentUserFailed", { status, statusText, body }));
+    }
+  }
+  ensureOrchestratorUrl(connection) {
+    if (!connection.orchestratorUrl) {
+      throw new Error(translate3.t("solutionpackager.publish.errors.orchestratorUrlRequired"));
+    }
+  }
+}
+function mapExtendedFolder(json) {
+  return {
+    isSelectable: json.IsSelectable,
+    hasChildren: json.HasChildren,
+    level: json.Level,
+    key: json.Key,
+    displayName: json.DisplayName,
+    fullyQualifiedName: json.FullyQualifiedName,
+    description: json.Description,
+    folderType: json.FolderType,
+    isPersonal: json.IsPersonal,
+    provisionType: json.ProvisionType,
+    permissionModel: json.PermissionModel,
+    parentId: json.ParentId,
+    parentKey: json.ParentKey,
+    feedType: json.FeedType,
+    id: json.Id
+  };
+}
+
+class OrchestratorResponseError extends Error {
+  response;
+  constructor(response) {
+    super(`Orchestrator request failed with status ${response.status}.`);
+    this.response = response;
+    this.name = "OrchestratorResponseError";
+  }
+}
+async function orchestratorGet(connection, relativePath) {
+  const url = `${normalizeOrchestratorBasePath(connection.orchestratorUrl)}${relativePath}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: buildHeaders(connection)
+  });
+  if (!response.ok) {
+    throw new OrchestratorResponseError(response);
+  }
+  const text = await response.text();
+  if (text === "" || text === "null") {
+    return null;
+  }
+  return JSON.parse(text);
+}
+function buildHeaders(connection) {
+  const headers = {};
+  if (connection.accessToken) {
+    headers.Authorization = `Bearer ${connection.accessToken}`;
+  }
+  if (connection.tenantId) {
+    headers[HEADER_TENANT_ID] = connection.tenantId;
+  }
+  return addSdkUserAgentHeader(headers, SDK_USER_AGENT);
+}
+function normalizeOrchestratorBasePath(orchestratorUrl) {
+  let end = orchestratorUrl.length;
+  while (end > 0 && orchestratorUrl.charCodeAt(end - 1) === 47)
+    end--;
+  const trimmed = orchestratorUrl.slice(0, end);
+  return /\/orchestrator_$/i.test(trimmed) ? trimmed : `${trimmed}/orchestrator_`;
+}
+async function describeResponseError(error) {
+  const response = error?.response;
+  if (response) {
+    let body = "";
+    try {
+      body = (await response.text()).slice(0, 500);
+    } catch {
+      body = "";
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      body: body ? ` - ${body}` : ""
+    };
+  }
+  const cause = error?.cause;
+  const message = cause instanceof Error ? cause.message : error instanceof Error ? error.message : String(error);
+  return { status: "?", statusText: message, body: "" };
+}
+
+// src/publish/services/orchestrator-publisher.ts
+var HEADER_FOLDER_ID = "X-UIPATH-OrganizationUnitId";
+var HEADER_TENANT_ID2 = "X-UIPATH-TenantId";
+var HEADER_NUGET_API_KEY = "X-NuGet-ApiKey";
+var ORCHESTRATOR_RELATIVE_URL = "/orchestrator_";
+var PROCESSES_UPLOAD_PATH = "/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage";
+var LIBRARIES_UPLOAD_PATH = "/odata/Libraries/UiPath.Server.Configuration.OData.UploadPackage";
+
+class OrchestratorPublisher {
+  fileSystem;
+  logger;
+  feedsService;
+  constructor(fileSystem, feedsService) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "Orchestrator");
+    this.feedsService = feedsService ?? new OrchestratorFeedsService;
+  }
+  async publishAsync(packagePaths, destination) {
+    if (packagePaths.length === 0) {
+      return ToolResult3.error(ToolErrorCodes3.InternalError, translate4.t("solutionpackager.publish.errors.orchestratorNoPackages"));
+    }
+    if (destination.kind === "OrchestratorCustom" /* OrchestratorCustom */) {
+      if (!destination.publishUrl) {
+        return ToolResult3.error(ToolErrorCodes3.InternalError, translate4.t("solutionpackager.publish.errors.orchestratorCustomPublishUrlRequired"));
+      }
+      this.logger.info(`Publishing ${packagePaths.length} package(s) to ${destination.publishUrl} (custom)`);
+      return this.postPackages(packagePaths, destination.publishUrl, this.buildCustomHeaders(destination));
+    }
+    if (!destination.connectionInfo?.cloudUrl) {
+      return ToolResult3.error(ToolErrorCodes3.InternalError, translate4.t("solutionpackager.publish.errors.orchestratorCloudUrlRequired"));
+    }
+    const orchestratorUrl = this.deriveOrchestratorUrl(destination.connectionInfo);
+    let feed;
+    try {
+      feed = await this.resolveFeed(destination, orchestratorUrl);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return ToolResult3.error(ToolErrorCodes3.InternalError, translate4.t("solutionpackager.publish.errors.orchestratorFeedResolutionFailed", { message }));
+    }
+    const targetUrl = this.buildPublishUrl(orchestratorUrl, feed);
+    const headers = this.buildHeaders(destination, feed);
+    this.logger.info(`Publishing ${packagePaths.length} package(s) to ${targetUrl} (feed ${feed.name}, ${feed.purpose})`);
+    return this.postPackages(packagePaths, targetUrl, headers);
+  }
+  async postPackages(packagePaths, targetUrl, headers) {
+    const form = new FormData;
+    for (const packagePath of packagePaths) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        return ToolResult3.error(ToolErrorCodes3.InternalError, translate4.t("solutionpackager.publish.errors.failedToReadPackage", { path: packagePath }));
+      }
+      const fileName = this.fileSystem.path.basename(packagePath);
+      form.append("file", new Blob([data], {
+        type: "application/octet-stream"
+      }), fileName);
+    }
+    const response = await fetch(targetUrl, {
+      method: "POST",
+      headers,
+      body: form
+    });
+    if (!response.ok) {
+      const body = await this.safeReadBody(response);
+      return ToolResult3.error(ToolErrorCodes3.InternalError, translate4.t("solutionpackager.publish.errors.orchestratorPublishFailed", {
+        status: response.status,
+        statusText: response.statusText,
+        body: body ? ` - ${body}` : ""
+      }));
+    }
+    this.logger.info("Orchestrator publish completed.");
+    return new ToolResult3(ToolErrorCodes3.Success, undefined, packagePaths);
+  }
+  async resolveFeed(destination, orchestratorUrl) {
+    const connection = {
+      orchestratorUrl,
+      accessToken: destination.connectionInfo.accessToken,
+      tenantId: destination.connectionInfo.tenantId
+    };
+    const feeds = await this.feedsService.getAccessibleFeedsAsync(connection);
+    if (destination.kind === "OrchestratorPersonalWorkspace" /* OrchestratorPersonalWorkspace */) {
+      const folders = await this.feedsService.getFoldersForCurrentUserAsync(connection);
+      const personalFolder = folders.find((f) => f.feedType === ExtendedFolderDtoFeedTypeEnum.PersonalWorkspace);
+      if (!personalFolder) {
+        const foldersDebug = folders.length === 0 ? "<none>" : folders.map((f) => `${f.displayName} (id=${f.id}, feedType=${f.feedType})`).join(", ");
+        throw new Error(translate4.t("solutionpackager.publish.errors.orchestratorPersonalWorkspaceFolderNotFound", { folders: foldersDebug }));
+      }
+      if (personalFolder.id == null) {
+        throw new Error(`Personal-workspace folder "${personalFolder.displayName}" has no id; cannot resolve its feed.`);
+      }
+      const match2 = feeds.find((f) => f.folderId === personalFolder.id);
+      if (!match2) {
+        this.throwFeedNotFound(destination, feeds);
+      }
+      return match2;
+    }
+    const expectedPurpose = destination.kind === "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */ ? PackageFeedDtoPurposeEnum.Libraries : PackageFeedDtoPurposeEnum.Processes;
+    const match = feeds.find((f) => f.purpose === expectedPurpose && f.folderId == null);
+    if (!match) {
+      this.throwFeedNotFound(destination, feeds);
+    }
+    return match;
+  }
+  throwFeedNotFound(destination, feeds) {
+    const available = feeds.length === 0 ? "<none>" : feeds.map((f) => `${f.name} (purpose=${f.purpose}, folderId=${f.folderId ?? "null"})`).join(", ");
+    throw new Error(translate4.t("solutionpackager.publish.errors.orchestratorFeedNotFound", {
+      kind: destination.kind,
+      available
+    }));
+  }
+  buildPublishUrl(orchestratorUrl, feed) {
+    const baseUrl = feed.publishUrl ? feed.publishUrl : `${orchestratorUrl}${feed.purpose === PackageFeedDtoPurposeEnum.Libraries ? LIBRARIES_UPLOAD_PATH : PROCESSES_UPLOAD_PATH}`;
+    const parsed = new URL(baseUrl);
+    if (feed.id) {
+      parsed.searchParams.set("feedId", feed.id);
+    }
+    return parsed.toString();
+  }
+  deriveOrchestratorUrl(connectionInfo) {
+    const raw = connectionInfo.cloudUrl ?? "";
+    let end = raw.length;
+    while (end > 0 && raw.charCodeAt(end - 1) === 47)
+      end--;
+    return `${raw.slice(0, end)}${ORCHESTRATOR_RELATIVE_URL}`;
+  }
+  buildHeaders(destination, feed) {
+    const headers = this.buildAuthHeaders(destination.connectionInfo);
+    const folderHeader = destination.kind === "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */ ? destination.folderId : feed.folderId;
+    if (folderHeader != null) {
+      headers[HEADER_FOLDER_ID] = String(folderHeader);
+    }
+    if (feed.authenticationType === PackageFeedDtoAuthenticationTypeEnum.ApiKey && feed.apiKey) {
+      headers[HEADER_NUGET_API_KEY] = feed.apiKey;
+    }
+    return headers;
+  }
+  buildCustomHeaders(destination) {
+    const headers = this.buildAuthHeaders(destination.connectionInfo);
+    if (destination.folderId != null) {
+      headers[HEADER_FOLDER_ID] = String(destination.folderId);
+    }
+    if (destination.apiKey) {
+      headers[HEADER_NUGET_API_KEY] = destination.apiKey;
+    }
+    return headers;
+  }
+  buildAuthHeaders(connectionInfo) {
+    const headers = {};
+    if (connectionInfo.accessToken) {
+      headers.Authorization = `Bearer ${connectionInfo.accessToken}`;
+    }
+    if (connectionInfo.tenantId) {
+      headers[HEADER_TENANT_ID2] = connectionInfo.tenantId;
+    }
+    return headers;
+  }
+  async safeReadBody(response) {
+    try {
+      const text = await response.text();
+      return text.slice(0, 500);
+    } catch {
+      return "";
+    }
+  }
+}
+
+// src/publish/services/project-publisher.ts
+class ProjectPublisher {
+  fileSystem;
+  logger;
+  localFolderPublisher;
+  nugetFeedPublisher;
+  orchestratorPublisher;
+  constructor(fileSystem, publishers) {
+    this.fileSystem = fileSystem;
+    this.logger = new ToolLogger("ProjectPublisher", "Publish");
+    this.localFolderPublisher = publishers?.localFolder ?? new LocalFolderPublisher(fileSystem);
+    this.nugetFeedPublisher = publishers?.nugetFeed ?? new NugetFeedPublisher(fileSystem);
+    this.orchestratorPublisher = publishers?.orchestrator ?? new OrchestratorPublisher(fileSystem);
+  }
+  async publishAsync(options) {
+    if (!options.packagePaths || options.packagePaths.length === 0) {
+      return ToolResult4.error(ToolErrorCodes4.InternalError, translate5.t("solutionpackager.publish.errors.atLeastOnePackage"));
+    }
+    for (const path of options.packagePaths) {
+      if (!await this.fileSystem.exists(path)) {
+        return ToolResult4.error(ToolErrorCodes4.InternalError, translate5.t("solutionpackager.publish.errors.packageNotFound", { path }));
+      }
+    }
+    try {
+      const destination = options.destination;
+      switch (destination.kind) {
+        case "LocalFolder" /* LocalFolder */:
+          return await this.localFolderPublisher.publishAsync(options.packagePaths, destination);
+        case "NugetFeed" /* NugetFeed */:
+          return await this.nugetFeedPublisher.publishAsync(options.packagePaths, destination);
+        case "OrchestratorPersonalWorkspace" /* OrchestratorPersonalWorkspace */:
+        case "OrchestratorTenantProcesses" /* OrchestratorTenantProcesses */:
+        case "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */:
+        case "OrchestratorCustom" /* OrchestratorCustom */:
+          return await this.orchestratorPublisher.publishAsync(options.packagePaths, destination);
+        default: {
+          const exhaustive = destination;
+          return ToolResult4.error(ToolErrorCodes4.InternalError, translate5.t("solutionpackager.publish.errors.unknownDestination", { destination: JSON.stringify(exhaustive) }));
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const localized = translate5.t("solutionpackager.publish.errors.publishFailed", { message });
+      this.logger.error(localized);
+      return ToolResult4.error(ToolErrorCodes4.InternalError, localized);
+    }
+  }
+}
 // src/services/governance-policy-service.ts
+import {
+  Path,
+  translate as translate6
+} from "@uipath/solutionpackager-tool-core";
 var LICENSE_TYPES = {
   NoLicense: "NoLicense",
   Development: "Development",
@@ -1092,7 +2259,7 @@ 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) => translate.t(`solutionpackager.governance.${key}`, params);
+var t = (key, params) => translate6.t(`solutionpackager.governance.${key}`, params);
 
 class GovernancePolicyService {
   fileSystem;
@@ -1112,7 +2279,7 @@ class GovernancePolicyService {
       this.logger.info(t("info.alreadyProvided"));
       return;
     }
-    const cloudUrl = connectionInfo?.cloudUrl;
+    let cloudUrl = connectionInfo?.cloudUrl;
     const organizationId = connectionInfo?.organizationId;
     const tenantId = connectionInfo?.tenantId;
     const accessToken = connectionInfo?.accessToken;
@@ -1122,9 +2289,17 @@ class GovernancePolicyService {
       return;
     }
     const profileKey = validateOptions.profileKey ?? DEFAULT_PROFILE_KEY;
-    const orchestratorUrl = toRelativeUrl(cloudUrl);
-    const licenseType = await this.resolveLicenseTypeAsync(profileKey, orchestratorUrl, accessToken, cancellationToken);
-    const policy = await this.downloadPolicyAsync(organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken);
+    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;
@@ -1142,8 +2317,8 @@ class GovernancePolicyService {
       validateOptions.governanceFileType = "Default" /* Default */;
     }
   }
-  async downloadPolicyAsync(organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken) {
-    const policyUrl = `/${organizationId}/roboticsops_` + `/api/Policy/license/${licenseType}/product/${profileKey}/tenant/${tenantId}`;
+  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, {
@@ -1175,11 +2350,11 @@ class GovernancePolicyService {
       return null;
     }
   }
-  async resolveLicenseTypeAsync(profileKey, orchestratorUrl, accessToken, cancellationToken) {
+  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(`${orchestratorUrl}${ACQUIRE_LICENSE_PATH}`, {
+      const response = await this.fetchFn(`${cloudUrl}${ACQUIRE_LICENSE_PATH}`, {
         method: "POST",
         headers: { Authorization: `Bearer ${accessToken}` },
         signal: cancellationToken
@@ -1214,7 +2389,7 @@ class GovernancePolicyService {
 }
 // src/services/pack-service.ts
 class PackService {
-  disallowedCharsRegex = /[^\w.-]/g;
+  disallowedCharsRegex = /[^\p{L}\p{N}_.-]/gu;
   spacesDotRegex = /[\s.]+/g;
   dotDashRegex = /\.{0,10}[-:]\.{0,10}/g;
   MaxPackageIdLength = 100;
@@ -1231,9 +2406,9 @@ class PackService {
 }
 // src/services/packager-parameters-validator.ts
 import {
-  ToolErrorCodes,
-  ToolResult,
-  translate as translate2
+  ToolErrorCodes as ToolErrorCodes5,
+  ToolResult as ToolResult5,
+  translate as translate7
 } from "@uipath/solutionpackager-tool-core";
 class PackagerParametersValidator {
   logger;
@@ -1243,52 +2418,52 @@ class PackagerParametersValidator {
     this.fileSystem = fileSystem;
   }
   async validateAsync(_options, _cancellationToken) {
-    return ToolResult.success();
+    return ToolResult5.success();
   }
   validateDestinationPath(destinationPath) {
     if (!destinationPath) {
-      const error = translate2.t("solutionpackager.validator.errors.destinationNotDefined");
+      const error = translate7.t("solutionpackager.validator.errors.destinationNotDefined");
       this.logger.error(error);
-      return ToolResult.error(ToolErrorCodes.InternalError, error);
+      return ToolResult5.error(ToolErrorCodes5.InternalError, error);
     }
-    return ToolResult.success();
+    return ToolResult5.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();
+      return ToolResult5.success();
     }
     if (!validateOptions.governanceFilePath) {
-      const error = translate2.t("solutionpackager.validator.errors.governanceRequired");
+      const error = translate7.t("solutionpackager.validator.errors.governanceRequired");
       this.logger.error(error);
-      return ToolResult.error(ToolErrorCodes.InternalError, error);
+      return ToolResult5.error(ToolErrorCodes5.InternalError, error);
     }
     try {
       const stat = await this.fileSystem.stat(validateOptions.governanceFilePath);
       if (!stat) {
-        const error = translate2.t("solutionpackager.validator.errors.governanceFileInfo", {
+        const error = translate7.t("solutionpackager.validator.errors.governanceFileInfo", {
           path: validateOptions.governanceFilePath
         });
         this.logger.error(error);
-        return ToolResult.error(ToolErrorCodes.InternalError, error);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, error);
       }
       if (stat.isDirectory()) {
-        const error = translate2.t("solutionpackager.validator.errors.governanceInvalidFile", {
+        const error = translate7.t("solutionpackager.validator.errors.governanceInvalidFile", {
           path: validateOptions.governanceFilePath
         });
         this.logger.error(error);
-        return ToolResult.error(ToolErrorCodes.InternalError, error);
+        return ToolResult5.error(ToolErrorCodes5.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);
+      return ToolResult5.error(ToolErrorCodes5.InternalError, errorLog);
     }
     this.logger.info(`Using Studio governance file: ${validateOptions.governanceFilePath}`);
-    return ToolResult.success();
+    return ToolResult5.success();
   }
 }
 // src/services/project-build-options-validator.ts
@@ -1300,22 +2475,22 @@ class ProjectBuildOptionsValidator extends PackagerParametersValidator {
 // src/services/project-loader.ts
 import {
   Path as Path2,
+  ProjectTool,
   ProjectTypes,
-  translate as translate3
+  translate as translate8
 } from "@uipath/solutionpackager-tool-core";
 
 class ProjectLoader {
   fileSystem;
-  static ProjectFileName = "project.uiproj";
   static WebAppManifestFileName = "webAppManifest.json";
   constructor(fileSystem) {
     this.fileSystem = fileSystem;
   }
   async loadProject(projectPath) {
     if (!projectPath) {
-      throw new Error(translate3.t("solutionpackager.projectLoader.errors.pathRequired"));
+      throw new Error(translate8.t("solutionpackager.projectLoader.errors.pathRequired"));
     }
-    const projectFilePath = Path2.join(projectPath, ProjectLoader.ProjectFileName);
+    const projectFilePath = Path2.join(projectPath, ProjectTool.ProjectFileName);
     const projectFileExists = await this.fileSystem.exists(projectFilePath);
     if (projectFileExists) {
       return await this.loadFromProjectFile(projectPath, projectFilePath);
@@ -1325,8 +2500,8 @@ class ProjectLoader {
     if (webAppManifestExists) {
       return this.loadFromWebAppManifest(projectPath, webAppManifestPath);
     }
-    throw new Error(translate3.t("solutionpackager.projectLoader.errors.noProjectFile", {
-      projectFile: ProjectLoader.ProjectFileName,
+    throw new Error(translate8.t("solutionpackager.projectLoader.errors.noProjectFile", {
+      projectFile: ProjectTool.ProjectFileName,
       manifestFile: ProjectLoader.WebAppManifestFileName,
       path: projectPath
     }));
@@ -1334,7 +2509,7 @@ class ProjectLoader {
   async loadFromProjectFile(projectPath, projectFilePath) {
     const fileContent = await this.fileSystem.readFile(projectFilePath);
     if (!fileContent) {
-      throw new Error(translate3.t("solutionpackager.projectLoader.errors.readFailed", {
+      throw new Error(translate8.t("solutionpackager.projectLoader.errors.readFailed", {
         path: projectFilePath
       }));
     }
@@ -1342,7 +2517,7 @@ class ProjectLoader {
     const projectData = JSON.parse(json);
     const projectType = projectData?.ProjectType || projectData?.type;
     if (!projectData || !projectType) {
-      throw new Error(translate3.t("solutionpackager.projectLoader.errors.invalidProject", {
+      throw new Error(translate8.t("solutionpackager.projectLoader.errors.invalidProject", {
         path: projectFilePath
       }));
     }
@@ -1368,10 +2543,11 @@ import {
   toolsFactoryRepository as defaultToolsFactoryRepository,
   NugetPackager,
   Path as Path3,
+  TargetFramework,
   TemporaryStorageService,
-  ToolErrorCodes as ToolErrorCodes3,
-  ToolResult as ToolResult3,
-  translate as translate4,
+  ToolErrorCodes as ToolErrorCodes7,
+  ToolResult as ToolResult7,
+  translate as translate9,
   ZipService
 } from "@uipath/solutionpackager-tool-core";
 
@@ -1413,12 +2589,12 @@ class ProjectPackOptionsBuilder {
       nuGetSourcesConfigPath: parameters.nuGetSourcesConfigPath,
       logLevel: parameters.logLevel,
       skipAnalyze: parameters.validateOptions.skipAnalyze,
-      skipValidate: false,
+      skipValidate: parameters.validateOptions.skipValidate,
       detailedLogPath: parameters.detailedLogPath,
       policyFilePath: parameters.validateOptions.governanceFilePath,
       policyFileType: parameters.validateOptions.governanceFileType,
       outputPath: parameters.outputPath,
-      outputType: undefined,
+      outputType: parameters.outputType,
       projectType: project.type,
       package: packageInfo,
       skipDependencyOptimization: parameters.packOptions?.skipDependencyOptimization ?? false,
@@ -1441,8 +2617,8 @@ class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator {
 
 // src/services/project-tool-executor.ts
 import {
-  ToolErrorCodes as ToolErrorCodes2,
-  ToolResult as ToolResult2
+  ToolErrorCodes as ToolErrorCodes6,
+  ToolResult as ToolResult6
 } from "@uipath/solutionpackager-tool-core";
 class ProjectToolExecutor {
   toolsFactory;
@@ -1500,12 +2676,12 @@ class ProjectToolExecutor {
         }
       }
     } catch (error) {
-      return ToolResult2.error(ToolErrorCodes2.InternalError, error instanceof Error ? error.message : String(error));
+      return ToolResult6.error(ToolErrorCodes6.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.");
+      return ToolResult6.error(ToolErrorCodes6.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)));
@@ -1513,7 +2689,7 @@ class ProjectToolExecutor {
     if (failedResult) {
       return failedResult;
     }
-    return ToolResult2.success();
+    return ToolResult6.success();
   }
 }
 
@@ -1592,10 +2768,6 @@ class ProjectPackager {
     this.projectLoader = new ProjectLoader(this.fileSystem);
     this.governancePolicyService = new GovernancePolicyService(this.fileSystem, this.temporaryStorage);
   }
-  async canPackProjectAsync(projectPath) {
-    const project = await this.projectLoader.loadProject(projectPath);
-    return this.repository.canHandleProject(project.type);
-  }
   async setupAsync(input, operationId) {
     this.telemetryService.setOperationId(operationId);
     await this.temporaryStorage.cleanup();
@@ -1639,12 +2811,14 @@ class ProjectPackager {
         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
       };
-      return await this.projectExecutor.validateAsync(validateOptions, uiPathProject, undefined, cancellationToken);
+      const context = this.createOperationContext(options, uiPathProject);
+      return await this.projectExecutor.validateAsync(validateOptions, uiPathProject, context, cancellationToken);
     }, cancellationToken);
   }
   async buildProjectAsync(options, cancellationToken) {
@@ -1663,12 +2837,12 @@ class ProjectPackager {
         nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
         logLevel: options.logLevel,
         skipAnalyze: options.validateOptions.skipAnalyze,
-        skipValidate: false,
+        skipValidate: options.validateOptions.skipValidate,
         detailedLogPath: options.detailedLogPath,
         policyFilePath: options.validateOptions.governanceFilePath,
         policyFileType: options.validateOptions.governanceFileType,
         outputPath: options.outputPath,
-        outputType: undefined,
+        outputType: options.outputType,
         projectType: uiPathProject.Type
       };
       return await this.projectExecutor.buildAsync(buildOptions, uiPathProject, undefined, cancellationToken);
@@ -1694,10 +2868,11 @@ class ProjectPackager {
           ProjectPath: loadedProject.projectPath,
           Id: loadedProject.name
         };
-        result = await this.projectExecutor.packAsync(projectPackOptions, uiPathProject, undefined, options.signingInfo, cancellationToken);
+        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);
+          result = new ToolResult7(ToolErrorCodes7.Success, undefined, destinationPackages);
         }
         if (result.isSuccess) {
           this.logger.info(`Project pack completed successfully. Packages: ${result.packages.join(", ")}`);
@@ -1708,7 +2883,7 @@ class ProjectPackager {
       } 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}`);
+        return ToolResult7.error(ToolErrorCodes7.InternalError, `Project pack failed: ${errorMessage2}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1716,7 +2891,7 @@ class ProjectPackager {
   }
   async getPackageStreamsAsync(result) {
     if (!result.isSuccess) {
-      throw new Error(translate4.t("solutionpackager.packager.errors.failedToGetStreams", {
+      throw new Error(translate9.t("solutionpackager.packager.errors.failedToGetStreams", {
         errorCode: result.errorCode,
         message: result.message ?? ""
       }));
@@ -1728,7 +2903,7 @@ class ProjectPackager {
     for (const packagePath of result.packages) {
       const data = await this.fileSystem.readFile(packagePath);
       if (!data) {
-        throw new Error(translate4.t("solutionpackager.packager.errors.failedToReadPackage", {
+        throw new Error(translate9.t("solutionpackager.packager.errors.failedToReadPackage", {
           path: packagePath
         }));
       }
@@ -1757,12 +2932,40 @@ class ProjectPackager {
       } 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}`);
+        return ToolResult7.error(ToolErrorCodes7.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(translate9.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 = [];
@@ -1774,33 +2977,27 @@ class ProjectPackager {
         if (nupkgFiles.length > 0) {
           for (const nupkgFile of nupkgFiles) {
             const filePath = Path3.join(packagePath, nupkgFile);
-            const destPath = Path3.join(destinationPath, nupkgFile);
-            const data = await this.fileSystem.readFile(filePath);
-            if (!data) {
-              throw new Error(translate4.t("solutionpackager.packager.errors.failedToReadPackage", {
-                path: filePath
-              }));
-            }
-            await this.fileSystem.writeFile(destPath, data);
-            destinationPackages.push(destPath);
+            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);
+          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 fileName = packagePath.split(/[\\/]/).pop() || packagePath;
-        const destPath = Path3.join(destinationPath, fileName);
-        const data = await this.fileSystem.readFile(packagePath);
-        if (!data) {
-          throw new Error(translate4.t("solutionpackager.packager.errors.failedToReadPackage", {
-            path: packagePath
-          }));
-        }
-        await this.fileSystem.writeFile(destPath, data);
-        destinationPackages.push(destPath);
+        const dest = await this.copyFileToDestination(packagePath, destinationPath);
+        destinationPackages.push(dest);
       }
     }
     return destinationPackages;
@@ -1813,10 +3010,13 @@ export {
   TelemetryService,
   TelemetryNames,
   RulesConfigFileType,
+  PublishDestinationKind,
   ProjectValidateOptionsValidator,
   ProjectValidateOptions,
   ProjectToolExecutor,
   ProjectRestoreOptions,
+  ProjectPublisher,
+  ProjectPublishOptions,
   ProjectPackager,
   ProjectPackOptions,
   ProjectLoader,