@uipath/packager-tool-workflowcompiler-browser 0.0.29

package/dist/index.js

@@ -0,0 +1,1104 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/i18n/index.ts
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+// src/i18n/locales/de.json
+var de_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/es.json
+var es_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/es-MX.json
+var es_MX_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/fr.json
+var fr_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/ja.json
+var ja_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/ko.json
+var ko_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/pt.json
+var pt_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/ro.json
+var ro_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/ru.json
+var ru_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/tr.json
+var tr_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+// src/i18n/locales/zu.json
+var zu_default = {
+  toolWorkflowCompilerBrowser: {
+    info: {
+      startingRemotePackAgent: "Starting remote pack agent for {count} project(s): {paths}",
+      connectingToHub: "Connecting to SignalR hub: {url}",
+      remoteAgentStartedExecution: "Remote agent started execution",
+      downloadingArchive: "Downloading pack result archive from bucket {bucketId}",
+      extractingArchive: "Extracting archive ({size} bytes) to {path}",
+      distributingPackages: "Distributing packages for {count} project(s)",
+      cleaningUpTempDir: "Cleaning up temporary directory {path}",
+      deletingBucket: "Deleting temporary storage bucket {bucketId}",
+      copyingFiles: "Copying {count} file(s) for project {designId} to {path}"
+    },
+    errors: {
+      missingConnectionInfo: "Missing connection info (cloudUrl, accessToken, or folderId)",
+      signalRConnectionFailed: "Failed to connect to SignalR hub",
+      hubConnectionFailed: "Failed to connect to SignalR hub at {url}: {message}",
+      packSucceededNoBucket: "Pack succeeded but no BucketId was returned",
+      packAgentFailed: "Pack agent failed with status {status} (code {errorCode})",
+      noResultForProject: "No result for project",
+      beginSessionFailed: "BeginSession failed ({status}): {errorText}",
+      hubConnectionClosed: "Hub connection closed unexpectedly",
+      packAgentDisconnected: "Pack agent disconnected unexpectedly",
+      deleteBucketFailed: "Unable to delete temporary storage bucket on Orchestrator: {statusText}",
+      cleanupBucketFailed: "Unable to cleanup remote bucket {bucketId}: {message}",
+      getBucketUriFailed: "Failed to get bucket read URI ({status}): {errorText}",
+      downloadArchiveFailed: "Failed to download archive from bucket ({status}): {statusText}",
+      noMatchingProject: "No matching project found for path: {projectPath}",
+      noOutputForProject: "No output found for project {designId}",
+      distributePackagesFailed: "Failed to distribute packages for {designId}: {message}",
+      sessionTimeout: "Session timed out waiting for projects: received {received} of {expected} expected projects"
+    }
+  }
+};
+
+// src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+
+// src/workflow-compiler-tool-factory.ts
+import {
+  ProjectTypes
+} from "@uipath/solutionpackager-tool-core";
+
+// src/project-bundle-executor.ts
+import {
+  ToolResult as ToolResult2,
+  toRelativeUrl as toRelativeUrl2,
+  translate as translate3
+} from "@uipath/solutionpackager-tool-core";
+
+// src/pack-result-processor.ts
+import {
+  ToolErrorCodes,
+  ToolResult,
+  toRelativeUrl,
+  translate,
+  ZipService
+} from "@uipath/solutionpackager-tool-core";
+
+class PackResultProcessor {
+  fileSystem;
+  logger;
+  zipService;
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+    this.zipService = new ZipService(fileSystem);
+  }
+  async processAsync(bucketId, projects, context) {
+    const connection = context.connection;
+    const results = new Map;
+    const tempDir = await this.fileSystem.getTempDir();
+    const extractPath = `${tempDir}/pack-result-${context.id}`;
+    try {
+      this.logger?.info(translate.t("toolWorkflowCompilerBrowser.info.downloadingArchive", { bucketId }));
+      const zipData = await this.downloadArchiveAsync(bucketId, connection);
+      this.logger?.info(translate.t("toolWorkflowCompilerBrowser.info.extractingArchive", { size: zipData.length, path: extractPath }));
+      await this.zipService.extractAsync(zipData, extractPath);
+      this.logger?.info(translate.t("toolWorkflowCompilerBrowser.info.distributingPackages", { count: projects.size }));
+      await this.distributePackages(extractPath, projects, context, results);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      for (const [projectPath] of projects) {
+        if (!results.has(projectPath)) {
+          results.set(projectPath, ToolResult.error("PackResultError", message));
+        }
+      }
+    } finally {
+      this.logger?.info(translate.t("toolWorkflowCompilerBrowser.info.cleaningUpTempDir", { path: extractPath }));
+      await this.fileSystem.rm(extractPath).catch(() => {});
+      await this.deleteBucketAsync(bucketId, connection);
+    }
+    return results;
+  }
+  async downloadArchiveAsync(bucketId, connection) {
+    const blobAccess = await this.getReadUriAsync(bucketId, connection);
+    return await this.downloadBlobAsync(blobAccess);
+  }
+  async deleteBucketAsync(bucketId, connection) {
+    try {
+      if (!bucketId) {
+        return;
+      }
+      const baseUrl = toRelativeUrl(connection.cloudUrl);
+      const url = `${baseUrl}/orchestrator_/odata/Buckets(${bucketId})`;
+      this.logger?.info(translate.t("toolWorkflowCompilerBrowser.info.deletingBucket", {
+        bucketId
+      }));
+      const response = await fetch(url, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${connection.accessToken}`,
+          "X-UIPATH-OrganizationUnitId": connection.folderId ?? ""
+        }
+      });
+      if (!response.ok) {
+        throw new Error(translate.t("toolWorkflowCompilerBrowser.errors.deleteBucketFailed", { statusText: response.statusText }));
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger?.warn(translate.t("toolWorkflowCompilerBrowser.errors.cleanupBucketFailed", { bucketId, message }));
+    }
+  }
+  async getReadUriAsync(bucketId, connection) {
+    const baseUrl = toRelativeUrl(connection.cloudUrl);
+    const url = `${baseUrl}/orchestrator_/odata/Buckets(${bucketId})` + `/UiPath.Server.Configuration.OData.GetReadUri` + `?path=rpa-packages.zip&expiryInMinutes=0`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${connection.accessToken}`,
+        "X-UIPATH-OrganizationUnitId": connection.folderId ?? ""
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(translate.t("toolWorkflowCompilerBrowser.errors.getBucketUriFailed", { status: response.status, errorText }));
+    }
+    return await response.json();
+  }
+  async downloadBlobAsync(blobAccess) {
+    const headers = {};
+    if (blobAccess.Headers) {
+      for (const [key, value] of Object.entries(blobAccess.Headers)) {
+        headers[key] = value;
+      }
+    }
+    const response = await fetch(blobAccess.Uri, {
+      method: blobAccess.Verb || "GET",
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(translate.t("toolWorkflowCompilerBrowser.errors.downloadArchiveFailed", {
+        status: response.status,
+        statusText: response.statusText
+      }));
+    }
+    const buffer = await response.arrayBuffer();
+    return new Uint8Array(buffer);
+  }
+  async distributePackages(extractPath, projects, context, results) {
+    for (const [projectPath, entry] of projects) {
+      const project = context.solution.Projects.find((p) => p.ProjectPath === projectPath);
+      if (!project) {
+        results.set(projectPath, ToolResult.error("PackResultError", translate.t("toolWorkflowCompilerBrowser.errors.noMatchingProject", { projectPath })));
+        continue;
+      }
+      const designId = project.Id;
+      const projectFilesDir = `${extractPath}/${designId}`;
+      const outputPath = entry.options.outputPath;
+      try {
+        const exists = await this.fileSystem.exists(projectFilesDir);
+        if (!exists) {
+          results.set(projectPath, ToolResult.error("PackResultError", translate.t("toolWorkflowCompilerBrowser.errors.noOutputForProject", { designId })));
+          continue;
+        }
+        const files = await this.fileSystem.readdir(projectFilesDir);
+        const outputFiles = [];
+        await this.fileSystem.mkdir(outputPath);
+        this.logger?.info(translate.t("toolWorkflowCompilerBrowser.info.copyingFiles", {
+          count: files.length,
+          designId,
+          path: outputPath
+        }));
+        for (const fileName of files) {
+          const srcFile = `${projectFilesDir}/${fileName}`;
+          const destFile = `${outputPath}/${fileName}`;
+          const data = await this.fileSystem.readFile(srcFile);
+          if (data) {
+            await this.fileSystem.writeFile(destFile, data);
+            outputFiles.push(destFile);
+          }
+        }
+        results.set(projectPath, new ToolResult(ToolErrorCodes.Success, undefined, outputFiles));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        results.set(projectPath, ToolResult.error("PackResultError", translate.t("toolWorkflowCompilerBrowser.errors.distributePackagesFailed", { designId, message })));
+      }
+    }
+  }
+}
+
+// src/packager-hub-connection.ts
+import {
+  HttpTransportType,
+  HubConnectionBuilder,
+  HubConnectionState
+} from "@microsoft/signalr";
+import {
+  LogLevel,
+  LogMessage,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+function toLogLevel(level) {
+  switch (level) {
+    case "Debug":
+      return LogLevel.Debug;
+    case "Information":
+      return LogLevel.Info;
+    case "Warning":
+      return LogLevel.Warn;
+    case "Error":
+      return LogLevel.Error;
+    default:
+      return LogLevel.Info;
+  }
+}
+class PackagerHubConnection {
+  logger;
+  hubConnection = null;
+  completionResolve = null;
+  completionReject = null;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async connectAsync(hubUrl, accessToken) {
+    try {
+      this.hubConnection = this.buildConnection(hubUrl, accessToken);
+      this.registerHandlers();
+      this.registerOnClose();
+      await this.hubConnection.start();
+    } catch (error) {
+      if (error instanceof Error && error.message.toLowerCase().includes("websocket")) {
+        this.hubConnection = this.buildConnection(hubUrl, accessToken, true);
+        this.registerHandlers();
+        this.registerOnClose();
+        await this.hubConnection.start();
+      } else {
+        throw error;
+      }
+    }
+  }
+  buildConnection(hubUrl, accessToken, disableWs = false) {
+    return new HubConnectionBuilder().withUrl(hubUrl, {
+      accessTokenFactory: () => accessToken,
+      transport: disableWs ? HttpTransportType.ServerSentEvents | HttpTransportType.LongPolling : undefined
+    }).withAutomaticReconnect().build();
+  }
+  registerOnClose() {
+    this.hubConnection?.onclose((error) => {
+      this.logger?.info(`[PackagerHub] onclose fired. error=${error?.message ?? "none"}, hasReject=${!!this.completionReject}, hasResolve=${!!this.completionResolve}`);
+      if (this.completionReject) {
+        this.completionReject(error ?? new Error(translate2.t("toolWorkflowCompilerBrowser.errors.hubConnectionClosed")));
+        this.completionResolve = null;
+        this.completionReject = null;
+      }
+    });
+  }
+  waitForCompletionAsync() {
+    return new Promise((resolve, reject) => {
+      this.completionResolve = resolve;
+      this.completionReject = reject;
+    });
+  }
+  async disconnectAsync() {
+    if (this.hubConnection && this.hubConnection.state !== HubConnectionState.Disconnected) {
+      await this.hubConnection.stop();
+    }
+    this.hubConnection = null;
+  }
+  registerHandlers() {
+    if (!this.hubConnection)
+      return;
+    this.hubConnection.on("SetExecutionCompleted" /* SetExecutionCompleted */, (jsonCommand) => {
+      this.onExecutionCompleted(jsonCommand);
+    });
+    this.hubConnection.on("SetLogMessage" /* SetLogMessage */, (jsonCommand) => {
+      this.onLogMessage(jsonCommand);
+    });
+    this.hubConnection.on("SetExecutionStarted" /* SetExecutionStarted */, (_jsonCommand) => {
+      this.logger?.info(translate2.t("toolWorkflowCompilerBrowser.info.remoteAgentStartedExecution"));
+    });
+    this.hubConnection.on("PeerDisconnected" /* PeerDisconnected */, () => {
+      this.logger?.info(`[PackagerHub] PeerDisconnected received. hasReject=${!!this.completionReject}`);
+      if (this.completionReject) {
+        this.completionReject(new Error(translate2.t("toolWorkflowCompilerBrowser.errors.packAgentDisconnected")));
+        this.completionResolve = null;
+        this.completionReject = null;
+      }
+    });
+  }
+  onLogMessage(jsonCommand) {
+    if (!this.logger)
+      return;
+    const command = JSON.parse(jsonCommand);
+    const agentLog = command.Argument1;
+    const logLevel = toLogLevel(agentLog.LogLevel);
+    const logMessage = new LogMessage(agentLog.Message, logLevel, {
+      source: agentLog.Source,
+      sourceTarget: agentLog.SourceTarget,
+      progress: agentLog.Progress,
+      code: agentLog.Code,
+      filePath: agentLog.FilePath,
+      line: agentLog.Line,
+      id: agentLog.Id
+    });
+    this.logger.logMessage(logMessage);
+  }
+  onExecutionCompleted(jsonCommand) {
+    this.logger?.info(`[PackagerHub] onExecutionCompleted called. hasResolve=${!!this.completionResolve}, raw=${jsonCommand}`);
+    if (!this.completionResolve) {
+      this.logger?.warn(`[PackagerHub] onExecutionCompleted: completionResolve is null, ignoring result`);
+      return;
+    }
+    const command = JSON.parse(jsonCommand);
+    const jobResult = command.Argument1;
+    this.logger?.info(`[PackagerHub] onExecutionCompleted parsed: errorCode=${jobResult.ErrorCode}, status=${jobResult.Status}, message=${jobResult.Message}, bucketId=${jobResult.BucketId}`);
+    this.completionResolve({
+      errorCode: jobResult.ErrorCode,
+      status: jobResult.Status,
+      message: jobResult.Message,
+      bucketId: jobResult.BucketId
+    });
+    this.completionResolve = null;
+    this.completionReject = null;
+  }
+}
+
+// src/project-bundle-executor.ts
+class ProjectBundleExecutor {
+  toolFactory;
+  fileSystem;
+  static SESSION_TIMEOUT_MS = 1800000;
+  sessions = new Map;
+  pendingSessionCreations = new Map;
+  constructor(toolFactory, fileSystem) {
+    this.toolFactory = toolFactory;
+    this.fileSystem = fileSystem;
+  }
+  async packAsync(options, context) {
+    const projectPath = options.projectPath;
+    context.logger?.info(`[BundleExecutor] packAsync called for project: ${projectPath}`);
+    const session = await this.getSessionAsync(context);
+    let resolve;
+    const promise = new Promise((r) => {
+      resolve = r;
+    });
+    session.projects.set(projectPath, { options, resolve });
+    const allReceived = session.projects.size === session.expectedCount;
+    context.logger?.info(`[BundleExecutor] session: ${session.projects.size}/${session.expectedCount} projects received. allReceived=${allReceived}`);
+    if (allReceived) {
+      clearTimeout(session.timeout);
+      await this.packOnAgentAsync(session, context);
+      this.sessions.delete(context.id);
+    }
+    return promise;
+  }
+  getSessionAsync(context) {
+    const existing = this.sessions.get(context.id);
+    if (existing) {
+      return Promise.resolve(existing);
+    }
+    let pending = this.pendingSessionCreations.get(context.id);
+    if (!pending) {
+      pending = this.createSessionAsync(context);
+      this.pendingSessionCreations.set(context.id, pending);
+    }
+    return pending;
+  }
+  async createSessionAsync(context) {
+    const expectedCount = this.countCompatibleProjects(context);
+    const session = {
+      expectedCount,
+      projects: new Map
+    };
+    session.timeout = setTimeout(() => {
+      if (session.projects.size < session.expectedCount) {
+        context.logger?.error(`[BundleExecutor] Session timed out after ${ProjectBundleExecutor.SESSION_TIMEOUT_MS}ms: ` + `received ${session.projects.size}/${session.expectedCount} projects`);
+        this.resolveAll(session, ToolResult2.error("SessionTimeoutError", translate3.t("toolWorkflowCompilerBrowser.errors.sessionTimeout", {
+          received: session.projects.size,
+          expected: session.expectedCount
+        })));
+        this.sessions.delete(context.id);
+      }
+    }, ProjectBundleExecutor.SESSION_TIMEOUT_MS);
+    this.sessions.set(context.id, session);
+    this.pendingSessionCreations.delete(context.id);
+    return session;
+  }
+  async packOnAgentAsync(session, context) {
+    const projectPaths = [...session.projects.keys()];
+    context.logger?.info(translate3.t("toolWorkflowCompilerBrowser.info.startingRemotePackAgent", {
+      count: session.expectedCount,
+      paths: projectPaths.join(", ")
+    }));
+    const connection = context.connection;
+    context.logger?.info(`[BundleExecutor] connection info: cloudUrl=${connection?.cloudUrl ?? "MISSING"}, hasToken=${!!connection?.accessToken}, folderId=${connection?.folderId ?? "MISSING"}`);
+    if (!connection?.cloudUrl || !connection.accessToken || !connection.folderId) {
+      this.resolveAll(session, ToolResult2.error("ConnectionError", translate3.t("toolWorkflowCompilerBrowser.errors.missingConnectionInfo")));
+      return;
+    }
+    const sessionId = crypto.randomUUID();
+    const hubConnection = await this.connectToHubAsync(connection, sessionId, context.logger);
+    if (!hubConnection) {
+      this.resolveAll(session, ToolResult2.error("SignalRConnectionError", translate3.t("toolWorkflowCompilerBrowser.errors.signalRConnectionFailed")));
+      return;
+    }
+    try {
+      context.logger?.info(`[BundleExecutor] Sending BeginSession...`);
+      await this.sendBeginSessionAsync(session, context, connection, sessionId);
+      context.logger?.info(`[BundleExecutor] BeginSession succeeded. Waiting for completion...`);
+      const result = await hubConnection.waitForCompletionAsync();
+      context.logger?.info(`[BundleExecutor] Got result: errorCode=${result.errorCode}, status=${result.status}, message=${result.message}, bucketId=${result.bucketId}`);
+      await this.handlePackResultAsync(result, session, context);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      context.logger?.error(`[BundleExecutor] packOnAgentAsync caught error: ${message}`);
+      this.resolveAll(session, ToolResult2.error("PackAgentError", message));
+    } finally {
+      await hubConnection.disconnectAsync();
+    }
+  }
+  async connectToHubAsync(connection, sessionId, logger) {
+    const relativeBase = toRelativeUrl2(connection.cloudUrl);
+    const hubUrl = `${relativeBase}/orchestrator_/signalr/robotdebug?sessionId=${sessionId}`;
+    logger?.info(translate3.t("toolWorkflowCompilerBrowser.info.connectingToHub", {
+      url: hubUrl
+    }));
+    const hubConnection = new PackagerHubConnection(logger);
+    try {
+      await hubConnection.connectAsync(hubUrl, connection.accessToken);
+      return hubConnection;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger?.error(translate3.t("toolWorkflowCompilerBrowser.errors.hubConnectionFailed", { url: hubUrl, message }));
+      return null;
+    }
+  }
+  async handlePackResultAsync(result, session, context) {
+    if (result.errorCode !== 0 || result.status !== 0 /* Succeeded */) {
+      this.resolveAll(session, ToolResult2.error("PackAgentError", result.message ?? translate3.t("toolWorkflowCompilerBrowser.errors.packAgentFailed", {
+        status: result.status,
+        errorCode: result.errorCode
+      })));
+      return;
+    }
+    if (result.bucketId == null) {
+      this.resolveAll(session, ToolResult2.error("PackAgentError", translate3.t("toolWorkflowCompilerBrowser.errors.packSucceededNoBucket")));
+      return;
+    }
+    const resultProcessor = new PackResultProcessor(this.fileSystem, context.logger);
+    const perProjectResults = await resultProcessor.processAsync(result.bucketId, session.projects, context);
+    for (const [projectPath, entry] of session.projects) {
+      const projectResult = perProjectResults.get(projectPath);
+      entry.resolve(projectResult ?? ToolResult2.error("PackResultError", translate3.t("toolWorkflowCompilerBrowser.errors.noResultForProject")));
+    }
+  }
+  async sendBeginSessionAsync(session, context, connection, sessionId) {
+    const relativeBase = toRelativeUrl2(connection.cloudUrl);
+    const url = `${relativeBase}/orchestrator_/api/serverless/jobs`;
+    context.logger?.info(`[BundleExecutor] BeginSession URL: ${url}`);
+    const firstEntry = session.projects.values().next().value;
+    const pkg = firstEntry.options.package;
+    const opts = firstEntry.options;
+    const rpaProjects = [...session.projects.entries()].map(([projectPath, entry]) => {
+      const project = context.solution.Projects.find((p) => p.ProjectPath === projectPath);
+      return {
+        RelativePath: project?.ProjectRelativePath ?? "",
+        DesignId: project?.Id ?? "",
+        PackageId: entry.options.package.id
+      };
+    });
+    const executorInfo = JSON.stringify({
+      Command: "Pack",
+      SupportedProtocolVersions: ["2.0"],
+      ProjectId: "",
+      DownloadUrl: context.downloadUrl ?? "",
+      SessionId: sessionId,
+      ProfileKey: "StudioWeb",
+      LicenseType: "Development",
+      LogLevel: opts.logLevel ?? "Warning",
+      Name: pkg.id,
+      Configuration: context.configuration,
+      Culture: "en-US",
+      Version: pkg.version,
+      Author: pkg.author ?? "",
+      Description: pkg.description ?? "",
+      SkipAnalyze: String(opts.skipAnalyze),
+      SkipValidate: String(opts.skipValidate),
+      TargetFramework: context.targetFramework,
+      RpaProjects: rpaProjects,
+      WorkflowCompilerVersion: context.workflowCompilerVersion ?? ""
+    });
+    const body = {
+      source: "StudioWeb",
+      targetFramework: context.targetFramework,
+      jobType: "PublishStudioProject",
+      inputArguments: executorInfo
+    };
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${connection.accessToken}`,
+      "X-UIPATH-OrganizationUnitId": connection.folderId ?? ""
+    };
+    if (connection.tenantId) {
+      headers["x-uipath-tenantid"] = connection.tenantId;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(translate3.t("toolWorkflowCompilerBrowser.errors.beginSessionFailed", { status: response.status, errorText }));
+    }
+  }
+  resolveAll(session, result) {
+    for (const [, entry] of session.projects) {
+      entry.resolve(result);
+    }
+  }
+  countCompatibleProjects(context) {
+    return context.solution.Projects.filter((p) => p.ProjectPath != null && this.toolFactory.supportedTypes.includes(p.Type)).length;
+  }
+}
+
+// src/workflow-compiler-tool.ts
+import {
+  ProjectTool,
+  ToolResult as ToolResult3
+} from "@uipath/solutionpackager-tool-core";
+
+class WorkflowCompilerTool extends ProjectTool {
+  bundleExecutor;
+  context;
+  constructor(fileSystem, logger, bundleExecutor, context) {
+    super(fileSystem, logger);
+    this.bundleExecutor = bundleExecutor;
+    this.context = context;
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.warn("Restore operation is not supported in browser environment");
+    return ToolResult3.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.warn("Validate operation is not supported in browser environment");
+    return ToolResult3.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.warn("Build operation is not supported in browser environment");
+    return ToolResult3.success();
+  }
+  async packAsync(options, _cancellationToken) {
+    if (!this.context) {
+      this.logger.warn("Pack operation requires a project operation context");
+      return ToolResult3.success();
+    }
+    return this.bundleExecutor.packAsync(options, this.context);
+  }
+}
+
+// src/workflow-compiler-tool-factory.ts
+class WorkflowCompilerToolFactory {
+  bundleExecutor;
+  supportedTypes = [
+    ProjectTypes.Process,
+    ProjectTypes.Library,
+    ProjectTypes.Tests,
+    ProjectTypes.WebApp
+  ];
+  async createAsync(logger, fileSystem, context) {
+    return new WorkflowCompilerTool(fileSystem, logger, this.getBundleExecutor(fileSystem), context);
+  }
+  getBundleExecutor(fileSystem) {
+    if (!this.bundleExecutor) {
+      this.bundleExecutor = new ProjectBundleExecutor(this, fileSystem);
+    }
+    return this.bundleExecutor;
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new WorkflowCompilerToolFactory);