@uipath/project-packager 1.1.10 → 1.196.0

package/dist/node.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}"
       }
     }
   }
@@ -816,20 +1251,20 @@ I18nManager.registerTranslations("zu", zu_default);
 
 // src/node.ts
 import {
-  ConsoleTelemetryProvider as ConsoleTelemetryProvider2,
+  DebugTelemetryProvider as DebugTelemetryProvider2,
   NodeContextStorage as NodeContextStorage2,
   TelemetryService as TelemetryService2
-} from "@uipath/telemetry/node";
+} from "@uipath/common";
+import { ConsoleTelemetryProvider } from "@uipath/common/telemetry";
 
 // src/base-node-packager-factory.ts
-import { execSync } from "node:child_process";
-import { NodeFileSystem } from "@uipath/filesystem";
-import { translate } from "@uipath/solutionpackager-tool-core";
 import {
-  ConsoleTelemetryProvider,
+  DebugTelemetryProvider,
   NodeContextStorage,
   TelemetryService
-} from "@uipath/telemetry/node";
+} from "@uipath/common";
+import { NodeFileSystem } from "@uipath/filesystem";
+import { translate } from "@uipath/solutionpackager-tool-core";
 
 // src/services/tool-logger.ts
 import {
@@ -919,6 +1354,7 @@ class ToolLogger {
 
 // src/base-node-packager-factory.ts
 class BaseNodePackagerFactory {
+  dotnetDiscovery;
   getOrCreateFileSystem(config) {
     return config?.fileSystem ?? new NodeFileSystem;
   }
@@ -926,19 +1362,21 @@ class BaseNodePackagerFactory {
     if (config?.telemetryService) {
       return config.telemetryService;
     }
-    const provider = new ConsoleTelemetryProvider;
+    const provider = new DebugTelemetryProvider;
     const contextStorage = new NodeContextStorage;
     return new TelemetryService(provider, contextStorage);
   }
   checkDotnetAvailability(logger) {
-    logger.info("Checking for dotnet CLI availability...");
-    try {
-      execSync("dotnet --version", {
-        stdio: ["ignore", "pipe", "ignore"]
-      });
-      logger.info("dotnet CLI is available.");
-    } catch {
-      logger.error("dotnet CLI is not available. Workflow compiler functionality and package signing will not be available.");
+    if (!this.dotnetDiscovery) {
+      return;
+    }
+    const version = this.dotnetDiscovery.getDotnetVersion();
+    if (version) {
+      logger.info(translate.t("solutionpackager.dotnet.info.available", {
+        version
+      }));
+    } else {
+      logger.warn(translate.t("solutionpackager.dotnet.warnings.notAvailable"));
     }
   }
   configureLogHandler(config) {
@@ -964,6 +1402,7 @@ var RulesConfigFileType;
 
 class PackagerParameters {
   inputPath;
+  downloadUrl;
   logLevel = LogLevel2.Warn;
   outputPath;
   targetFramework;
@@ -981,12 +1420,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 {
@@ -995,8 +1436,33 @@ class ProjectPackOptions extends ProjectBuildOptions {
   signingInfo;
   packOptions;
 }
+// src/services/dotnet-discovery-service.ts
+import { execSync } from "node:child_process";
+
+class DotnetDiscoveryService {
+  cachedVersion;
+  isDotnetAvailable() {
+    return this.getDotnetVersion() !== undefined;
+  }
+  getDotnetVersion() {
+    if (this.cachedVersion !== undefined) {
+      return this.cachedVersion;
+    }
+    try {
+      const output = execSync("dotnet --version", {
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf-8"
+      });
+      this.cachedVersion = output.trim();
+      return this.cachedVersion;
+    } catch {
+      return;
+    }
+  }
+}
+
 // src/services/package-sign-service.ts
-import { execSync as execSync2, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import {
   ToolErrorCodes,
   ToolResult,
@@ -1004,13 +1470,14 @@ import {
 } from "@uipath/solutionpackager-tool-core";
 
 class NodePackageSignService {
+  dotnetDiscovery;
   logger;
-  constructor(logger) {
+  constructor(dotnetDiscovery, logger) {
+    this.dotnetDiscovery = dotnetDiscovery;
     this.logger = logger;
   }
   async signPackageAsync(packagePath, certificatePath, certificatePassword, timestampServer) {
-    if (!this.checkAvailable()) {
-      this.logger.error(translate2.t("solutionpackager.signing.info.dotnetNotAvailable"));
+    if (!this.dotnetDiscovery.isDotnetAvailable()) {
       return ToolResult.error(ToolErrorCodes.InternalError, translate2.t("solutionpackager.signing.errors.dotnetNotAvailable"));
     }
     const args = [
@@ -1056,18 +1523,6 @@ class NodePackageSignService {
       });
     });
   }
-  checkAvailable() {
-    try {
-      const output = execSync2("dotnet nuget --version", {
-        stdio: ["ignore", "pipe", "ignore"],
-        encoding: "utf-8"
-      });
-      this.logger.info(`dotnet CLI found, version ${output.trim()}`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
 }
 
 // src/services/project-packager.ts
@@ -1075,6 +1530,7 @@ import {
   toolsFactoryRepository as defaultToolsFactoryRepository,
   NugetPackager,
   Path as Path3,
+  TargetFramework,
   TemporaryStorageService,
   ToolErrorCodes as ToolErrorCodes4,
   ToolResult as ToolResult4,
@@ -1099,7 +1555,6 @@ var TelemetryNames;
 // src/services/governance-policy-service.ts
 import {
   Path,
-  toRelativeUrl,
   translate as translate3
 } from "@uipath/solutionpackager-tool-core";
 var LICENSE_TYPES = {
@@ -1136,7 +1591,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;
@@ -1146,9 +1601,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;
@@ -1166,8 +1629,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, {
@@ -1199,11 +1662,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
@@ -1239,7 +1702,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;
@@ -1328,13 +1791,13 @@ class ProjectBuildOptionsValidator extends PackagerParametersValidator {
 // src/services/project-loader.ts
 import {
   Path as Path2,
+  ProjectTool,
   ProjectTypes,
   translate as translate5
 } from "@uipath/solutionpackager-tool-core";
 
 class ProjectLoader {
   fileSystem;
-  static ProjectFileName = "project.uiproj";
   static WebAppManifestFileName = "webAppManifest.json";
   constructor(fileSystem) {
     this.fileSystem = fileSystem;
@@ -1343,7 +1806,7 @@ class ProjectLoader {
     if (!projectPath) {
       throw new Error(translate5.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);
@@ -1354,7 +1817,7 @@ class ProjectLoader {
       return this.loadFromWebAppManifest(projectPath, webAppManifestPath);
     }
     throw new Error(translate5.t("solutionpackager.projectLoader.errors.noProjectFile", {
-      projectFile: ProjectLoader.ProjectFileName,
+      projectFile: ProjectTool.ProjectFileName,
       manifestFile: ProjectLoader.WebAppManifestFileName,
       path: projectPath
     }));
@@ -1416,12 +1879,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,
@@ -1595,10 +2058,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();
@@ -1642,12 +2101,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) {
@@ -1666,12 +2127,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);
@@ -1697,7 +2158,8 @@ 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 ToolResult4(ToolErrorCodes4.Success, undefined, destinationPackages);
@@ -1766,6 +2228,34 @@ class ProjectPackager {
       }
     });
   }
+  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(translate6.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 = [];
@@ -1777,33 +2267,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(translate6.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(translate6.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;
@@ -1819,7 +2303,8 @@ class NodeProjectPackagerFactory extends BaseNodePackagerFactory {
     logger.info("Creating ProjectPackager instance...");
     const fileSystem = this.getOrCreateFileSystem(config);
     const telemetryService = this.getOrCreateTelemetryService(config);
-    const packageSignService = new NodePackageSignService(logger);
+    this.dotnetDiscovery = new DotnetDiscoveryService;
+    const packageSignService = new NodePackageSignService(this.dotnetDiscovery, logger);
     const projectPackager = new ProjectPackager(fileSystem, telemetryService, packageSignService);
     this.checkDotnetAvailability(logger);
     logger.info("ProjectPackager created successfully.");
@@ -1830,18 +2315,645 @@ async function createNodeProjectPackager(options) {
   const factory = new NodeProjectPackagerFactory;
   return factory.createAsync(options);
 }
+// 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 {
+  ToolErrorCodes as ToolErrorCodes8,
+  ToolResult as ToolResult8,
+  translate as translate11
+} from "@uipath/solutionpackager-tool-core";
+
+// src/publish/services/local-folder-publisher.ts
+import {
+  ToolErrorCodes as ToolErrorCodes5,
+  ToolResult as ToolResult5,
+  translate as translate7
+} 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 ToolResult5.error(ToolErrorCodes5.InternalError, translate7.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 ToolResult5.error(ToolErrorCodes5.InternalError, translate7.t("solutionpackager.publish.errors.localFolderFileExists", { path: destPath }));
+      }
+      const data = await this.fileSystem.readFile(sourcePath);
+      if (!data) {
+        return ToolResult5.error(ToolErrorCodes5.InternalError, translate7.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 ToolResult5(ToolErrorCodes5.Success, undefined, written);
+  }
+}
+
+// src/publish/services/nuget-feed-publisher.ts
+import {
+  ToolErrorCodes as ToolErrorCodes6,
+  ToolResult as ToolResult6,
+  translate as translate8
+} 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 ToolResult6.error(ToolErrorCodes6.InternalError, translate8.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 ToolResult6.error(ToolErrorCodes6.InternalError, translate8.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 ToolResult6.error(ToolErrorCodes6.InternalError, translate8.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 ToolResult6.error(ToolErrorCodes6.InternalError, translate8.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 ToolResult6(ToolErrorCodes6.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 ToolErrorCodes7,
+  ToolResult as ToolResult7,
+  translate as translate10
+} 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"
+};
+
+// src/publish/services/orchestrator-feeds-service.ts
+import { addSdkUserAgentHeader } from "@uipath/common/sdk-user-agent";
+import { translate as translate9 } 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(translate9.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(translate9.t("solutionpackager.publish.errors.getFoldersForCurrentUserFailed", { status, statusText, body }));
+    }
+  }
+  ensureOrchestratorUrl(connection) {
+    if (!connection.orchestratorUrl) {
+      throw new Error(translate9.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 ToolResult7.error(ToolErrorCodes7.InternalError, translate10.t("solutionpackager.publish.errors.orchestratorNoPackages"));
+    }
+    if (destination.kind === "OrchestratorCustom" /* OrchestratorCustom */) {
+      if (!destination.publishUrl) {
+        return ToolResult7.error(ToolErrorCodes7.InternalError, translate10.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 ToolResult7.error(ToolErrorCodes7.InternalError, translate10.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 ToolResult7.error(ToolErrorCodes7.InternalError, translate10.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 ToolResult7.error(ToolErrorCodes7.InternalError, translate10.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 ToolResult7.error(ToolErrorCodes7.InternalError, translate10.t("solutionpackager.publish.errors.orchestratorPublishFailed", {
+        status: response.status,
+        statusText: response.statusText,
+        body: body ? ` - ${body}` : ""
+      }));
+    }
+    this.logger.info("Orchestrator publish completed.");
+    return new ToolResult7(ToolErrorCodes7.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(translate10.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(translate10.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 ToolResult8.error(ToolErrorCodes8.InternalError, translate11.t("solutionpackager.publish.errors.atLeastOnePackage"));
+    }
+    for (const path of options.packagePaths) {
+      if (!await this.fileSystem.exists(path)) {
+        return ToolResult8.error(ToolErrorCodes8.InternalError, translate11.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 ToolResult8.error(ToolErrorCodes8.InternalError, translate11.t("solutionpackager.publish.errors.unknownDestination", { destination: JSON.stringify(exhaustive) }));
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const localized = translate11.t("solutionpackager.publish.errors.publishFailed", { message });
+      this.logger.error(localized);
+      return ToolResult8.error(ToolErrorCodes8.InternalError, localized);
+    }
+  }
+}
+
+// src/publish/node-project-publisher-factory.ts
+class NodeProjectPublisherFactory extends BaseNodePackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("ProjectPublisherFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating ProjectPublisher instance...");
+    const fileSystem = this.getOrCreateFileSystem(config);
+    this.getOrCreateTelemetryService(config);
+    const projectPublisher = new ProjectPublisher(fileSystem);
+    logger.info("ProjectPublisher created successfully.");
+    return projectPublisher;
+  }
+}
+async function createNodeProjectPublisher(options) {
+  const factory = new NodeProjectPublisherFactory;
+  return factory.createAsync(options);
+}
 export {
   setGlobalLogHandler,
+  createNodeProjectPublisher,
   createNodeProjectPackager,
   ToolsFactory,
   ToolLogger,
   TelemetryService2 as TelemetryService,
   TelemetryNames,
   RulesConfigFileType,
+  PublishDestinationKind,
   ProjectValidateOptionsValidator,
   ProjectValidateOptions,
   ProjectToolExecutor,
   ProjectRestoreOptions,
+  ProjectPublisher,
+  ProjectPublishOptions,
   ProjectPackager,
   ProjectPackOptions,
   ProjectLoader,
@@ -1852,6 +2964,9 @@ export {
   PackService,
   NodePackageSignService,
   NodeContextStorage2 as NodeContextStorage,
-  ConsoleTelemetryProvider2 as ConsoleTelemetryProvider,
+  GovernancePolicyService,
+  DotnetDiscoveryService,
+  DebugTelemetryProvider2 as DebugTelemetryProvider,
+  ConsoleTelemetryProvider,
   BaseNodePackagerFactory
 };