@uipath/packager-tool-workflowcompiler-browser 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/index.js

@@ -1,1247 +1,16 @@
-// src/i18n/index.ts
-import { I18nManager } from "@uipath/solutionpackager-tool-core";
-// src/i18n/locales/de.json
-var de_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Eingabeargumente sind zu groß ({length} Zeichen), um sie inline zu senden; sie werden als Dateianhang hochgeladen"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Anhang für Eingabeargumente konnte nicht erstellt werden ({status}): {errorText}",
-      attachmentResponseMalformed: "Die Antwort auf die Anhangerstellung enthielt keine ID und keine Blob-URI",
-      uploadInputArgumentsFailed: "Datei mit Eingabeargumenten konnte nicht hochgeladen werden ({status}): {statusText}"
-    }
-  }
-};
-
-// src/i18n/locales/en.ts
-var en = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      startingRemoteAgent: "Starting remote {operation} 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)",
-      skippingRemoteCompilation: "No connection info available — skipping remote compilation for workflow compiler projects",
-      cleaningUpTempDir: "Cleaning up temporary directory {path}",
-      deletingBucket: "Deleting temporary storage bucket {bucketId}",
-      copyingFiles: "Copying {count} file(s) for project {designId} to {path}",
-      offloadingInputArguments: "Input arguments are too large ({length} chars) to send inline; uploading them as a file attachment"
-    },
-    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",
-      agentFailed: "{operation} 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",
-      bundleOperationMismatch: "Cannot mix {sessionOperation} and {entryOperation} in the same context",
-      createAttachmentFailed: "Failed to create input arguments attachment ({status}): {errorText}",
-      attachmentResponseMalformed: "Attachment creation response did not include an id and blob URI",
-      uploadInputArgumentsFailed: "Failed to upload input arguments file ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/es.json
-var es_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Los argumentos de entrada son demasiado grandes ({length} caracteres) para enviarlos en línea; se cargarán como un archivo adjunto"
-    },
-    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",
-      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",
-      createAttachmentFailed: "No se pudo crear el archivo adjunto de argumentos de entrada ({status}): {errorText}",
-      attachmentResponseMalformed: "La respuesta de creación del archivo adjunto no incluía un id ni un URI de blob",
-      uploadInputArgumentsFailed: "No se pudo cargar el archivo de argumentos de entrada ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/es-MX.json
-var es_MX_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Los argumentos de entrada son demasiado grandes ({length} caracteres) para enviarlos en línea; se cargarán como un archivo adjunto"
-    },
-    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",
-      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",
-      createAttachmentFailed: "No se pudo crear el archivo adjunto de argumentos de entrada ({status}): {errorText}",
-      attachmentResponseMalformed: "La respuesta de creación del archivo adjunto no incluía un id ni un URI de blob",
-      uploadInputArgumentsFailed: "No se pudo cargar el archivo de argumentos de entrada ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/fr.json
-var fr_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Les arguments d'entrée sont trop volumineux ({length} caractères) pour être envoyés en ligne ; ils seront chargés en tant que pièce jointe"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Échec de la création de la pièce jointe des arguments d'entrée ({status}) : {errorText}",
-      attachmentResponseMalformed: "La réponse de création de la pièce jointe ne contenait pas d'id ni d'URI de blob",
-      uploadInputArgumentsFailed: "Échec du chargement du fichier des arguments d'entrée ({status}) : {statusText}"
-    }
-  }
-};
-// src/i18n/locales/ja.json
-var ja_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "入力引数が大きすぎるため ({length} 文字)、インラインで送信できません。ファイル添付としてアップロードします"
-    },
-    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",
-      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",
-      createAttachmentFailed: "入力引数の添付ファイルの作成に失敗しました ({status})：{errorText}",
-      attachmentResponseMalformed: "添付ファイルの作成応答に id と blob URI が含まれていませんでした",
-      uploadInputArgumentsFailed: "入力引数ファイルのアップロードに失敗しました ({status})：{statusText}"
-    }
-  }
-};
-// src/i18n/locales/ko.json
-var ko_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "입력 인수가 너무 커서({length}자) 인라인으로 보낼 수 없습니다. 파일 첨부로 업로드합니다"
-    },
-    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",
-      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",
-      createAttachmentFailed: "입력 인수 첨부 파일을 만들지 못했습니다({status}): {errorText}",
-      attachmentResponseMalformed: "첨부 파일 생성 응답에 id와 blob URI가 포함되어 있지 않습니다",
-      uploadInputArgumentsFailed: "입력 인수 파일을 업로드하지 못했습니다({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/pt.json
-var pt_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Os argumentos de entrada são demasiado grandes ({length} carateres) para serem enviados inline; serão carregados como um anexo de ficheiro"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Falha ao criar o anexo dos argumentos de entrada ({status}): {errorText}",
-      attachmentResponseMalformed: "A resposta de criação do anexo não incluía um id nem um URI de blob",
-      uploadInputArgumentsFailed: "Falha ao carregar o ficheiro de argumentos de entrada ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/pt-BR.json
-var pt_BR_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Os argumentos de entrada são muito grandes ({length} caracteres) para serem enviados inline; eles serão carregados como um anexo de arquivo"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Falha ao criar o anexo dos argumentos de entrada ({status}): {errorText}",
-      attachmentResponseMalformed: "A resposta de criação do anexo não incluiu um id nem uma URI de blob",
-      uploadInputArgumentsFailed: "Falha ao fazer upload do arquivo de argumentos de entrada ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/ro.json
-var ro_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Argumentele de intrare sunt prea mari ({length} caractere) pentru a fi trimise inline; vor fi încărcate ca atașament de fișier"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Crearea atașamentului cu argumentele de intrare a eșuat ({status}): {errorText}",
-      attachmentResponseMalformed: "Răspunsul de creare a atașamentului nu a inclus un id și un URI de blob",
-      uploadInputArgumentsFailed: "Încărcarea fișierului cu argumentele de intrare a eșuat ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/ru.json
-var ru_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Входные аргументы слишком велики ({length} символов) для встроенной отправки; они будут загружены как вложение файла"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Не удалось создать вложение с входными аргументами ({status}): {errorText}",
-      attachmentResponseMalformed: "Ответ на создание вложения не содержал id и blob-URI",
-      uploadInputArgumentsFailed: "Не удалось загрузить файл входных аргументов ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/tr.json
-var tr_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Giriş bağımsız değişkenleri satır içi gönderilemeyecek kadar büyük ({length} karakter); dosya eki olarak yüklenecek"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Giriş bağımsız değişkenleri eki oluşturulamadı ({status}): {errorText}",
-      attachmentResponseMalformed: "Ek oluşturma yanıtı bir kimlik ve blob URI'si içermiyordu",
-      uploadInputArgumentsFailed: "Giriş bağımsız değişkenleri dosyası yüklenemedi ({status}): {statusText}"
-    }
-  }
-};
-// src/i18n/locales/zh-CN.json
-var zh_CN_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "输入参数过大（{length} 个字符），无法内联发送；将作为文件附件上传"
-    },
-    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",
-      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",
-      createAttachmentFailed: "无法创建输入参数附件 ({status})：{errorText}",
-      attachmentResponseMalformed: "附件创建响应未包含 id 和 blob URI",
-      uploadInputArgumentsFailed: "无法上传输入参数文件 ({status})：{statusText}"
-    }
-  }
-};
-// src/i18n/locales/zh-TW.json
-var zh_TW_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "輸入引數過大（{length} 個字元），無法內嵌傳送；將以檔案附件形式上傳"
-    },
-    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",
-      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",
-      createAttachmentFailed: "無法建立輸入引數附件 ({status})：{errorText}",
-      attachmentResponseMalformed: "附件建立回應未包含 id 和 blob URI",
-      uploadInputArgumentsFailed: "無法上傳輸入引數檔案 ({status})：{statusText}"
-    }
-  }
-};
-// src/i18n/locales/zu.json
-var zu_default = {
-  toolWorkflowCompilerBrowser: {
-    info: {
-      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}",
-      offloadingInputArguments: "Izimpikiswano zokufaka zinkulu kakhulu ({length} izinhlamvu) ukuze zithunyelwe ngaphakathi; zizolayishwa njengesinamathiselo sefayela"
-    },
-    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",
-      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",
-      createAttachmentFailed: "Yehlulekile ukudala isinamathiselo sezimpikiswano zokufaka ({status}): {errorText}",
-      attachmentResponseMalformed: "Impendulo yokudala isinamathiselo ayifakanga i-id ne-blob URI",
-      uploadInputArgumentsFailed: "Yehlulekile ukulayisha ifayela lezimpikiswano zokufaka ({status}): {statusText}"
-    }
-  }
-};
-
-// 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
+  getSharedRemoteAgentBundleExecutor
+} from "@uipath/packager-remote-agent-browser";
 import {
-  normalizeIgnoredRules,
-  PackJobTargetKind,
-  ToolErrorCodes as ToolErrorCodes2,
-  ToolResult as ToolResult2,
-  toRelativeUrl as toRelativeUrl2,
-  translate as translate3
-} from "@uipath/solutionpackager-tool-core";
-
-// src/cleanup-result.ts
-import { toProjectCleanupInfoFromRemote } 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, zipService = new ZipService(fileSystem)) {
-    this.fileSystem = fileSystem;
-    this.logger = logger;
-    this.zipService = zipService;
-  }
-  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.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 {
-  LogMessage,
-  translate as translate2
+  ProjectTypes
 } from "@uipath/solutionpackager-tool-core";
-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 logMessage = new LogMessage(agentLog.message, agentLog.logLevel, {
-      source: agentLog.source,
-      sourceTarget: agentLog.sourceTarget,
-      progress: agentLog.progress,
-      code: agentLog.code,
-      filePath: agentLog.filePath,
-      line: agentLog.line,
-      id: agentLog.id
-    }, agentLog.timestamp);
-    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,
-      changedFilesByProject: jobResult.ChangedFilesByProject,
-      unusedDependenciesByProject: jobResult.UnusedDependenciesByProject
-    });
-    this.completionResolve = null;
-    this.completionReject = null;
-  }
-}
-
-// src/project-bundle-executor.ts
-class ProjectBundleExecutor {
-  toolFactory;
-  fileSystem;
-  static SESSION_TIMEOUT_MS = 1800000;
-  static MAX_INLINE_INPUT_ARGUMENTS_LENGTH = 1e4;
-  sessions = new Map;
-  pendingSessionCreations = new Map;
-  constructor(toolFactory, fileSystem) {
-    this.toolFactory = toolFactory;
-    this.fileSystem = fileSystem;
-  }
-  async packAsync(options, context) {
-    return this.enqueueAsync(context, {
-      operation: "Pack" /* Pack */,
-      options,
-      resolve: () => {}
-    });
-  }
-  async validateAsync(options, context) {
-    return this.enqueueAsync(context, {
-      operation: "Validate" /* Validate */,
-      options,
-      resolve: () => {}
-    });
-  }
-  async cleanupAsync(options, context) {
-    if (context.downloadUrl && !options.dryRun && !context.solutionId && !context.projectId) {
-      return ToolResult2.error(ToolErrorCodes2.InternalError, "Cleanup save-back requires a solutionId or projectId for downloaded workspaces.");
-    }
-    return this.enqueueAsync(context, {
-      operation: "Cleanup" /* Cleanup */,
-      options,
-      resolve: () => {}
-    });
-  }
-  async enqueueAsync(context, entry) {
-    const projectPath = entry.options.projectPath;
-    context.logger?.info(`[BundleExecutor] ${entry.operation}Async called for project: ${projectPath}`);
-    const session = await this.getSessionAsync(context, entry.operation);
-    if (session.operation !== entry.operation) {
-      return ToolResult2.error("BundleOperationMismatch", translate3.t("toolWorkflowCompilerBrowser.errors.bundleOperationMismatch", {
-        sessionOperation: session.operation,
-        entryOperation: entry.operation
-      }));
-    }
-    const promise = new Promise((resolve) => {
-      entry.resolve = resolve;
-    });
-    session.projects.set(projectPath, entry);
-    const allReceived = session.projects.size === session.expectedCount;
-    context.logger?.info(`[BundleExecutor] session (${session.operation}): ${session.projects.size}/${session.expectedCount} projects received. allReceived=${allReceived}`);
-    if (allReceived) {
-      clearTimeout(session.timeout);
-      await this.runAgentAsync(session, context);
-      this.sessions.delete(context.id);
-    }
-    return promise;
-  }
-  getSessionAsync(context, operation) {
-    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, operation);
-      this.pendingSessionCreations.set(context.id, pending);
-    }
-    return pending;
-  }
-  async createSessionAsync(context, operation) {
-    const expectedCount = this.countCompatibleProjects(context);
-    const session = {
-      operation,
-      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 runAgentAsync(session, context) {
-    const projectPaths = [...session.projects.keys()];
-    context.logger?.info(translate3.t("toolWorkflowCompilerBrowser.info.startingRemoteAgent", {
-      operation: session.operation,
-      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.handleAgentResultAsync(result, session, context);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      context.logger?.error(`[BundleExecutor] runAgentAsync caught error: ${message}`);
-      this.resolveAll(session, ToolResult2.error(`${session.operation}AgentError`, 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 handleAgentResultAsync(result, session, context) {
-    if (result.errorCode !== 0 || result.status !== 0 /* Succeeded */) {
-      this.resolveAll(session, ToolResult2.error(`${session.operation}AgentError`, result.message ?? translate3.t("toolWorkflowCompilerBrowser.errors.agentFailed", {
-        operation: session.operation,
-        status: result.status,
-        errorCode: result.errorCode
-      })));
-      return;
-    }
-    if (session.operation === "Pack" /* Pack */) {
-      await this.handlePackBucketAsync(result, session, context);
-      return;
-    }
-    if (session.operation === "Cleanup" /* Cleanup */) {
-      this.resolveCleanup(result, session, context);
-      return;
-    }
-    this.resolveAll(session, ToolResult2.success());
-  }
-  resolveCleanup(result, session, context) {
-    for (const [projectPath, entry] of session.projects) {
-      const details = {};
-      if (result.changedFilesByProject) {
-        details.changedFilesByProject = result.changedFilesByProject;
-      }
-      const designId = context.projects.find((p) => p.ProjectPath === projectPath)?.Id;
-      const raw = designId ? result.unusedDependenciesByProject?.[designId] : undefined;
-      if (raw) {
-        details.projectCleanup = toProjectCleanupInfoFromRemote(raw);
-      }
-      const projectResult = ToolResult2.success();
-      if (Object.keys(details).length > 0) {
-        projectResult.details = details;
-      }
-      entry.resolve(projectResult);
-    }
-  }
-  async handlePackBucketAsync(result, session, context) {
-    if (result.bucketId == null) {
-      this.resolveAll(session, ToolResult2.error("PackAgentError", translate3.t("toolWorkflowCompilerBrowser.errors.packSucceededNoBucket")));
-      return;
-    }
-    const packEntries = new Map;
-    for (const [projectPath, entry] of session.projects) {
-      if (entry.operation === "Pack" /* Pack */) {
-        packEntries.set(projectPath, { options: entry.options });
-      }
-    }
-    const resultProcessor = new PackResultProcessor(this.fileSystem, context.logger);
-    const perProjectResults = await resultProcessor.processAsync(result.bucketId, packEntries, 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 onLocalRobot = context.jobTarget?.kind === PackJobTargetKind.LocalRobot;
-    const url = onLocalRobot ? `${relativeBase}/orchestrator_/api/RobotDebug/BeginSession` : `${relativeBase}/orchestrator_/api/serverless/jobs`;
-    context.logger?.info(`[BundleExecutor] BeginSession URL: ${url} (target=${context.jobTarget?.kind ?? PackJobTargetKind.Serverless})`);
-    const firstEntry = session.projects.values().next().value;
-    const opts = firstEntry.options;
-    const skipAnalyze = "skipAnalyze" in opts ? opts.skipAnalyze : false;
-    const skipValidate = "skipValidate" in opts ? opts.skipValidate : false;
-    const ignoredRules = normalizeIgnoredRules("ignoredRules" in opts ? opts.ignoredRules : undefined);
-    const rpaProjects = [...session.projects.entries()].map(([projectPath, entry]) => {
-      const project = context.projects.find((p) => p.ProjectPath === projectPath);
-      return {
-        RelativePath: project?.ProjectRelativePath ?? "",
-        DesignId: project?.Id ?? "",
-        ProjectStorageId: entry.operation === "Pack" /* Pack */ ? entry.options.projectStorageId ?? "" : "",
-        PackageId: entry.operation === "Pack" /* Pack */ ? entry.options.package.id : ""
-      };
-    });
-    const executorInfo = {
-      Command: session.operation,
-      SupportedProtocolVersions: ["2.0"],
-      DownloadUrl: context.downloadUrl ?? "",
-      SolutionId: context.solutionId ?? "",
-      ProjectId: context.projectId ?? "",
-      SessionId: sessionId,
-      ProfileKey: "StudioWeb",
-      LicenseType: "Development",
-      LogLevel: opts.logLevel ?? "Warning",
-      Culture: "en-US",
-      DownloadTimeoutInSeconds: 300,
-      SkipAnalyze: String(skipAnalyze),
-      SkipValidate: String(skipValidate),
-      TargetFramework: context.targetFramework,
-      RpaProjects: rpaProjects,
-      WorkflowCompilerVersion: context.workflowCompilerVersion ?? ""
-    };
-    if (ignoredRules.length > 0) {
-      executorInfo.IgnoredRules = ignoredRules;
-    }
-    if (firstEntry.operation === "Pack" /* Pack */) {
-      executorInfo.Configuration = context.configuration;
-      const pkg = firstEntry.options.package;
-      executorInfo.Package = {
-        Name: pkg.id,
-        Version: pkg.version,
-        Author: pkg.author ?? "",
-        Description: pkg.description ?? "",
-        ReleaseNotes: pkg.releaseNotes ?? "",
-        Tags: pkg.tags ?? "",
-        IconUrl: pkg.iconUrl ?? "",
-        ProjectUrl: pkg.projectUrl ?? "",
-        RepositoryType: pkg.repositoryType ?? "",
-        RepositoryUrl: pkg.repositoryUrl ?? "",
-        RepositoryBranch: pkg.repositoryBranch ?? "",
-        RepositoryCommit: pkg.repositoryCommit ?? ""
-      };
-      executorInfo.Name = pkg.id;
-      executorInfo.Version = pkg.version;
-      executorInfo.Author = pkg.author ?? "";
-      executorInfo.Description = pkg.description ?? "";
-      executorInfo.ReleaseNotes = pkg.releaseNotes ?? "";
-      if (context.localSourcePath) {
-        if (onLocalRobot && context.jobTarget?.machineSessionIds?.length) {
-          executorInfo.LocalSourcePath = context.localSourcePath;
-        } else {
-          context.logger?.warn("[BundleExecutor] Dropping localSourcePath: the pack job is not pinned to a local robot machine session.");
-        }
-      }
-    }
-    if (firstEntry.operation === "Cleanup" /* Cleanup */) {
-      executorInfo.DryRun = firstEntry.options.dryRun;
-      executorInfo.SkipImports = firstEntry.options.skipImports;
-      if (context.lockKey) {
-        executorInfo.LockKey = context.lockKey;
-      }
-    }
-    const inputArguments = JSON.stringify(executorInfo);
-    const body = onLocalRobot ? {
-      source: "StudioWeb",
-      targetFramework: context.targetFramework,
-      runtimeType: "Development",
-      runAsMe: true,
-      jobsCount: 1,
-      strategy: "ModernJobsCount",
-      requiresUserInteraction: false,
-      ...context.jobTarget?.machineSessionIds?.length ? {
-        machineSessionIds: context.jobTarget.machineSessionIds
-      } : {}
-    } : {
-      source: "StudioWeb",
-      targetFramework: context.targetFramework,
-      jobType: "PublishStudioProject"
-    };
-    if (inputArguments.length > ProjectBundleExecutor.MAX_INLINE_INPUT_ARGUMENTS_LENGTH) {
-      context.logger?.info(translate3.t("toolWorkflowCompilerBrowser.info.offloadingInputArguments", { length: inputArguments.length }));
-      body.inputFile = await this.uploadInputArgumentsFileAsync(inputArguments, connection, context.logger);
-    } else {
-      body.inputArguments = inputArguments;
-    }
-    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 }));
-    }
-  }
-  async uploadInputArgumentsFileAsync(inputArguments, connection, logger) {
-    const baseUrl = toRelativeUrl2(connection.cloudUrl);
-    const attachmentsUrl = `${baseUrl}/orchestrator_/odata/Attachments`;
-    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 createResponse = await fetch(attachmentsUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({ name: "input.json" })
-    });
-    if (!createResponse.ok) {
-      const errorText = await createResponse.text();
-      throw new Error(translate3.t("toolWorkflowCompilerBrowser.errors.createAttachmentFailed", { status: createResponse.status, errorText }));
-    }
-    const attachment = await createResponse.json();
-    const attachmentId = attachment.Id ?? attachment.id ?? "";
-    const writeUri = attachment.BlobFileAccess?.Uri ?? attachment.blobFileAccess?.Uri;
-    if (!attachmentId || !writeUri) {
-      throw new Error(translate3.t("toolWorkflowCompilerBrowser.errors.attachmentResponseMalformed"));
-    }
-    const uploadResponse = await fetch(writeUri, {
-      method: "PUT",
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "x-ms-blob-type": "BlockBlob"
-      },
-      body: inputArguments
-    });
-    if (!uploadResponse.ok) {
-      throw new Error(translate3.t("toolWorkflowCompilerBrowser.errors.uploadInputArgumentsFailed", {
-        status: uploadResponse.status,
-        statusText: uploadResponse.statusText
-      }));
-    }
-    logger?.info(`[BundleExecutor] Uploaded input arguments as attachment ${attachmentId}`);
-    return attachmentId;
-  }
-  resolveAll(session, result) {
-    for (const [, entry] of session.projects) {
-      entry.resolve(result);
-    }
-  }
-  countCompatibleProjects(context) {
-    return context.projects.filter((p) => p.ProjectPath != null && this.toolFactory.supportedTypes.includes(p.Type)).length;
-  }
-}
 
 // src/workflow-compiler-tool.ts
 import {
   ProjectTool,
-  ToolErrorCodes as ToolErrorCodes3,
-  ToolResult as ToolResult3
+  ToolErrorCodes,
+  ToolResult
 } from "@uipath/solutionpackager-tool-core";
 
 class WorkflowCompilerTool extends ProjectTool {
@@ -1254,27 +23,27 @@ class WorkflowCompilerTool extends ProjectTool {
   }
   async restoreAsync(_options, _cancellationToken) {
     this.logger.warn("Restore operation is not supported in browser environment");
-    return ToolResult3.success();
+    return ToolResult.success();
   }
   async validateAsync(options, _cancellationToken) {
     if (!this.context) {
-      return ToolResult3.error(ToolErrorCodes3.InternalError, "Validate operation requires a project operation context");
+      return ToolResult.error(ToolErrorCodes.InternalError, "Validate operation requires a project operation context");
     }
     return this.bundleExecutor.validateAsync(options, this.context);
   }
   async buildAsync(_options, _cancellationToken) {
     this.logger.warn("Build operation is not supported in browser environment");
-    return ToolResult3.success();
+    return ToolResult.success();
   }
   async packAsync(options, _cancellationToken) {
     if (!this.context) {
-      return ToolResult3.error(ToolErrorCodes3.InternalError, "Pack operation requires a project operation context");
+      return ToolResult.error(ToolErrorCodes.InternalError, "Pack operation requires a project operation context");
     }
     return this.bundleExecutor.packAsync(options, this.context);
   }
   async cleanupAsync(options, _cancellationToken) {
     if (!this.context) {
-      return ToolResult3.error(ToolErrorCodes3.InternalError, "Cleanup operation requires a project operation context");
+      return ToolResult.error(ToolErrorCodes.InternalError, "Cleanup operation requires a project operation context");
     }
     return this.bundleExecutor.cleanupAsync(options, this.context);
   }
@@ -1283,24 +52,22 @@ class WorkflowCompilerTool extends ProjectTool {
 // src/workflow-compiler-tool-factory.ts
 class WorkflowCompilerToolFactory {
   bundleExecutor;
+  delegatesToRemoteAgent = true;
   supportedTypes = [
     ProjectTypes.Process,
     ProjectTypes.Library,
     ProjectTypes.Tests,
     ProjectTypes.WebApp
   ];
-  async createAsync(logger, fileSystem, context) {
-    return new WorkflowCompilerTool(fileSystem, logger, this.getBundleExecutor(fileSystem), context);
+  constructor(bundleExecutor) {
+    this.bundleExecutor = bundleExecutor;
   }
-  getBundleExecutor(fileSystem) {
-    if (!this.bundleExecutor) {
-      this.bundleExecutor = new ProjectBundleExecutor(this, fileSystem);
-    }
-    return this.bundleExecutor;
+  async createAsync(logger, fileSystem, context) {
+    return new WorkflowCompilerTool(fileSystem, logger, this.bundleExecutor ?? getSharedRemoteAgentBundleExecutor(fileSystem), context);
   }
 }
 export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=587F7D204E593C1564756E2164756E21
+//# debugId=7A45F6FA7ACAA00E64756E2164756E21