@uipath/flow-tool 1.205.0-preview.277 → 1.206.0-preview.279

package/dist/{node-5ay0ddfj.js → node-0jy3qx5b.js}

@@ -1,33 +1,34 @@
 import {
-  I18nManager,
-  LogMessage,
-  NugetPackager,
   Path,
-  ProjectTool,
   TemporaryStorageService,
-  ToolResult,
   ZipService,
+  I18nManager,
+  translate,
   normalizeIgnoredRules,
-  toolsFactoryRepository,
-  translate
-} from "./packager-tool-pacrqxv2.js";
-import"./packager-tool-nkrmjr3a.js";
+  LogMessage,
+  ToolResult,
+  NugetPackager,
+  ProjectTool,
+  toolsFactoryRepository
+} from "./packager-tool-ze3fnf3s.js";
+import {
+  NodeFileSystem
+} from "./packager-tool-vgrswa8p.js";
+import {
+  ProjectDimensions,
+  PackagerDimensions,
+  projectKey,
+  PROJECT_IDENTITY_LOOKUP_BUDGET_MS,
+  withinProjectIdentityBudget,
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
-  ConsoleTelemetryProvider,
+  carriedInstructions,
   DebugTelemetryProvider,
   NodeContextStorage,
-  PackagerDimensions,
   TelemetryService,
-  addSdkUserAgentHeader,
-  carriedInstructions
-} from "./packager-tool-apawc11t.js";
-import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
-import {
-  NodeFileSystem
-} from "./packager-tool-myhbp761.js";
-import"./packager-tool-1yh8g550.js";
+  isProjectTelemetryDisabled
+} from "./packager-tool-8ed52y5r.js";
 // ../packager/project-packager/src/i18n/locales/de.json
 var de_default = {
   solutionpackager: {
@@ -1416,7 +1417,9 @@ var globalLogHandler = (logMessage) => {
   }
 };
 function setGlobalLogHandler(handler) {
+  const previous = globalLogHandler;
   globalLogHandler = handler;
+  return previous;
 }
 
 class ToolLogger {
@@ -1517,13 +1520,6 @@ class BaseNodePackagerFactory {
   }
 }
 // ../packager/project-packager/src/models/packager-parameters.ts
-var RulesConfigFileType;
-((RulesConfigFileType2) => {
-  RulesConfigFileType2["Default"] = "Default";
-  RulesConfigFileType2["AutomationOps"] = "AutomationOps";
-  RulesConfigFileType2["Studio"] = "Studio";
-})(RulesConfigFileType ||= {});
-
 class PackagerParameters {
   inputPath;
   downloadUrl;
@@ -1557,12 +1553,7 @@ class ProjectValidateOptions extends ProjectRestoreOptions {
 // ../packager/project-packager/src/models/project-build-options.ts
 class ProjectBuildOptions extends ProjectValidateOptions {
   outputType;
-}
-// ../packager/project-packager/src/models/project-cleanup-options.ts
-class ProjectCleanupOptions extends PackagerParameters {
-  dryRun = false;
-  skipImports = false;
-  lockKey;
+  activitiesRootCategory;
 }
 // ../packager/project-packager/src/models/project-pack-options.ts
 class ProjectPackOptions extends ProjectBuildOptions {
@@ -1659,22 +1650,6 @@ class NodePackageSignService {
     });
   }
 }
-// ../packager/project-packager/src/telemetry-names.ts
-var TelemetryNames;
-((TelemetryNames2) => {
-  TelemetryNames2["ProjectToolPack"] = "ProjectPackager.Tool.Pack";
-  TelemetryNames2["ProjectToolRestore"] = "ProjectPackager.Tool.Restore";
-  TelemetryNames2["ProjectToolValidate"] = "ProjectPackager.Tool.Validate";
-  TelemetryNames2["ProjectToolBuild"] = "ProjectPackager.Tool.Build";
-  TelemetryNames2["ProjectToolCleanup"] = "ProjectPackager.Tool.Cleanup";
-  TelemetryNames2["ProjectPackagerPack"] = "ProjectPackager.Pack";
-  TelemetryNames2["ProjectPackagerRestore"] = "ProjectPackager.Restore";
-  TelemetryNames2["ProjectPackagerValidate"] = "ProjectPackager.Validate";
-  TelemetryNames2["ProjectPackagerBuild"] = "ProjectPackager.Build";
-  TelemetryNames2["ProjectPackagerCleanup"] = "ProjectPackager.Cleanup";
-  TelemetryNames2["ProjectPackagerProjectLoaded"] = "ProjectPackager.ProjectLoaded";
-})(TelemetryNames ||= {});
-
 // ../gov/aops-policy-sdk/generated/src/runtime.ts
 var BASE_PATH = "http://localhost".replace(/\/+$/, "");
 
@@ -3294,7 +3269,7 @@ var package_default = {
   name: "@uipath/project-packager",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.205.0-preview.277",
+  version: "1.206.0-preview.279",
   description: "UiPath Project Packager - core library for packing individual UiPath projects",
   type: "module",
   main: "./dist/index.js",
@@ -3588,10 +3563,6 @@ async function resolveProducedNupkgsAsync(fileSystem, packagePath) {
 
 // ../packager/project-packager/src/services/pack-service.ts
 var PACKAGE_ID_TOO_LONG = "PACKAGE_ID_TOO_LONG";
-function isPackageIdTooLongError(error) {
-  return error instanceof Error && error.code === PACKAGE_ID_TOO_LONG;
-}
-
 class PackService {
   disallowedCharsRegex = /[^\p{L}\p{N}_.-]/gu;
   spacesDotRegex = /[\s.]+/g;
@@ -3724,8 +3695,8 @@ class PackagerParametersValidator {
         return ToolResult.error("INTERNAL_ERROR" /* InternalError */, error);
       }
     } catch (error) {
-      const errorMessage2 = error instanceof Error ? error.message : String(error);
-      const errorLog = `Governance file not found or inaccessible: ${validateOptions.governanceFilePath}. Error: ${errorMessage2}`;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorLog = `Governance file not found or inaccessible: ${validateOptions.governanceFilePath}. Error: ${errorMessage}`;
       this.logger.error(errorLog);
       return ToolResult.error("INTERNAL_ERROR" /* InternalError */, errorLog);
     }
@@ -3848,6 +3819,7 @@ class ProjectPackOptionsBuilder {
       policyFileType: parameters.validateOptions.governanceFileType,
       outputPath: parameters.outputPath,
       outputType: parameters.outputType,
+      activitiesRootCategory: parameters.activitiesRootCategory,
       projectType: project.type,
       package: packageInfo,
       skipDependencyOptimization: parameters.packOptions?.skipDependencyOptimization ?? false,
@@ -3873,6 +3845,8 @@ class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator {
 }
 
 // ../packager/project-packager/src/services/project-tool-executor.ts
+var observerTimedOut = (phase) => () => new ToolLogger("ProjectToolExecutor", "ProjectActivity").debug(`project activity (${phase}) skipped: no answer within ${PROJECT_IDENTITY_LOOKUP_BUDGET_MS} ms`);
+
 class ProjectToolExecutor {
   toolsFactory;
   telemetry;
@@ -3881,36 +3855,44 @@ class ProjectToolExecutor {
     this.telemetry = telemetry;
   }
   async restoreAsync(options, project, context, cancellationToken) {
-    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Restore" /* ProjectToolRestore */, project.Type, async () => tool.restoreAsync(options, cancellationToken), {
-      [PackagerDimensions.ProjectId]: project.Id,
-      [PackagerDimensions.ProjectType]: project.Type
-    }));
+    return await this.executeToolOperationAsync(project, context, (tool, properties) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Restore" /* ProjectToolRestore */, project.Type, async () => tool.restoreAsync(options, cancellationToken), properties));
   }
   async validateAsync(options, project, context, cancellationToken) {
-    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Validate" /* ProjectToolValidate */, project.Type, async () => tool.validateAsync(options, cancellationToken), {
-      [PackagerDimensions.ProjectId]: project.Id,
-      [PackagerDimensions.ProjectType]: project.Type
-    }));
+    return await this.executeToolOperationAsync(project, context, (tool, properties) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Validate" /* ProjectToolValidate */, project.Type, async () => tool.validateAsync(options, cancellationToken), properties));
   }
   async buildAsync(options, project, context, cancellationToken) {
-    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Build" /* ProjectToolBuild */, project.Type, async () => tool.buildAsync(options, cancellationToken), {
-      [PackagerDimensions.ProjectId]: project.Id,
-      [PackagerDimensions.ProjectType]: project.Type
-    }));
+    return await this.executeToolOperationAsync(project, context, (tool, properties) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Build" /* ProjectToolBuild */, project.Type, async () => tool.buildAsync(options, cancellationToken), properties));
   }
   async packAsync(options, project, context, cancellationToken) {
-    return await this.executeToolOperationAsync(project, context, async (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Pack" /* ProjectToolPack */, project.Type, async () => tool.packAsync(options, cancellationToken), {
-      [PackagerDimensions.ProjectId]: project.Id,
-      [PackagerDimensions.ProjectType]: project.Type
-    }));
+    return await this.executeToolOperationAsync(project, context, async (tool, properties) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Pack" /* ProjectToolPack */, project.Type, async () => tool.packAsync(options, cancellationToken), properties));
   }
   async cleanupAsync(options, project, context, cancellationToken) {
-    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Cleanup" /* ProjectToolCleanup */, project.Type, async () => tool.cleanupAsync(options, cancellationToken), {
-      [PackagerDimensions.ProjectId]: project.Id,
-      [PackagerDimensions.ProjectType]: project.Type
-    }));
+    return await this.executeToolOperationAsync(project, context, (tool, properties) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Cleanup" /* ProjectToolCleanup */, project.Type, async () => tool.cleanupAsync(options, cancellationToken), properties));
   }
   async executeToolOperationAsync(project, context, operation) {
+    const solutionKey = context?.solutionId ? projectKey(context.solutionId) : undefined;
+    const identity = solutionKey && !isProjectTelemetryDisabled() ? {
+      [ProjectDimensions.SolutionKey]: solutionKey,
+      [ProjectDimensions.SolutionProjectKey]: projectKey(project.Id)
+    } : {};
+    const properties = {
+      [PackagerDimensions.ProjectId]: project.Id,
+      [PackagerDimensions.ProjectType]: project.Type,
+      ...identity
+    };
+    return this.observeToolOperationAsync(project, context, (tool) => operation(tool, properties));
+  }
+  async observeToolOperationAsync(project, context, operation) {
+    if (!context?.projectActivity) {
+      return this.runToolOperationAsync(project, context, operation);
+    }
+    const observe = context.projectActivity;
+    await withinProjectIdentityBudget(Promise.resolve().then(() => observe(project, "before", undefined, context.solutionId)).catch(() => {}), observerTimedOut("before"));
+    const result = await this.runToolOperationAsync(project, context, operation);
+    await withinProjectIdentityBudget(Promise.resolve().then(() => observe(project, "after", result.isSuccess, context.solutionId)).catch(() => {}), observerTimedOut("after"));
+    return result;
+  }
+  async runToolOperationAsync(project, context, operation) {
     try {
       const tool = await this.toolsFactory.createProjectToolAsync(project, context);
       try {
@@ -4060,7 +4042,7 @@ class ProjectPackager {
     }, cancellationToken);
   }
   async buildProjectAsync(options, cancellationToken) {
-    const [governanceError] = await catchError(this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken));
+    const [governanceError] = await catchError2(this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken));
     if (governanceError) {
       return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project build failed: ${governanceError.message}`, carriedInstructions(governanceError));
     }
@@ -4086,6 +4068,7 @@ class ProjectPackager {
         policyFileType: options.validateOptions.governanceFileType,
         outputPath: options.outputPath,
         outputType: options.outputType,
+        activitiesRootCategory: options.activitiesRootCategory,
         projectType: uiPathProject.Type
       };
       const context = this.createOperationContext(options, uiPathProject);
@@ -4129,9 +4112,9 @@ class ProjectPackager {
         }
         return result;
       } catch (error) {
-        const errorMessage2 = error instanceof Error ? error.message : String(error);
-        this.logger.error(`Processing error: ${errorMessage2}`);
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project pack failed: ${errorMessage2}`, carriedInstructions(error));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project pack failed: ${errorMessage}`, carriedInstructions(error));
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -4196,9 +4179,9 @@ class ProjectPackager {
         }
         return operationResult;
       } catch (error) {
-        const errorMessage2 = error instanceof Error ? error.message : String(error);
-        this.logger.error(`Processing error: ${errorMessage2}`);
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project ${operationName.toLowerCase()} failed: ${errorMessage2}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project ${operationName.toLowerCase()} failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -4275,563 +4258,11 @@ async function createNodeProjectPackager(options) {
   const factory = new NodeProjectPackagerFactory;
   return factory.createAsync(options);
 }
-// ../packager/project-packager/src/publish/models/publish-options.ts
-var PublishDestinationKind;
-((PublishDestinationKind2) => {
-  PublishDestinationKind2["LocalFolder"] = "LocalFolder";
-  PublishDestinationKind2["NugetFeed"] = "NugetFeed";
-  PublishDestinationKind2["OrchestratorPersonalWorkspace"] = "OrchestratorPersonalWorkspace";
-  PublishDestinationKind2["OrchestratorTenantProcesses"] = "OrchestratorTenantProcesses";
-  PublishDestinationKind2["OrchestratorSharedLibraries"] = "OrchestratorSharedLibraries";
-  PublishDestinationKind2["OrchestratorCustom"] = "OrchestratorCustom";
-})(PublishDestinationKind ||= {});
-
-class ProjectPublishOptions {
-  packagePaths;
-  destination;
-  constructor(packagePaths, destination) {
-    this.packagePaths = packagePaths;
-    this.destination = destination;
-  }
-}
-// ../packager/project-packager/src/publish/services/local-folder-publisher.ts
-class LocalFolderPublisher {
-  fileSystem;
-  logger;
-  constructor(fileSystem) {
-    this.fileSystem = fileSystem;
-    this.logger = new ToolLogger("ProjectPublisher", "LocalFolder");
-  }
-  async publishAsync(packagePaths, destination) {
-    const overwrite = destination.overwrite ?? true;
-    if (!destination.folderPath) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.localFolderRequired"));
-    }
-    if (!await this.fileSystem.exists(destination.folderPath)) {
-      await this.fileSystem.mkdir(destination.folderPath);
-    }
-    const written = [];
-    for (const sourcePath of packagePaths) {
-      const fileName = this.fileSystem.path.basename(sourcePath);
-      const destPath = this.fileSystem.path.join(destination.folderPath, fileName);
-      if (!overwrite && await this.fileSystem.exists(destPath)) {
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.localFolderFileExists", { path: destPath }));
-      }
-      const data = await this.fileSystem.readFile(sourcePath);
-      if (!data) {
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: sourcePath }));
-      }
-      await this.fileSystem.writeFile(destPath, data);
-      written.push(destPath);
-      this.logger.info(`Copied package to ${destPath}`);
-    }
-    return new ToolResult("SUCCESS" /* Success */, undefined, written);
-  }
-}
-
-// ../packager/project-packager/src/publish/services/nuget-feed-publisher.ts
-var NUGET_V3_PACKAGE_PUBLISH_TYPE = "PackagePublish/2.0.0";
-
-class NugetFeedPublisher {
-  fileSystem;
-  logger;
-  constructor(fileSystem) {
-    this.fileSystem = fileSystem;
-    this.logger = new ToolLogger("ProjectPublisher", "NugetFeed");
-  }
-  async publishAsync(packagePaths, destination) {
-    if (!destination.feedUrl) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.nugetFeedUrlRequired"));
-    }
-    let pushUrl;
-    try {
-      pushUrl = await this.resolvePushUrl(destination.feedUrl, destination.apiKey);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.nugetPushUrlResolutionFailed", { feedUrl: destination.feedUrl, message }));
-    }
-    const published = [];
-    for (const packagePath of packagePaths) {
-      const data = await this.fileSystem.readFile(packagePath);
-      if (!data) {
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: packagePath }));
-      }
-      const fileName = this.fileSystem.path.basename(packagePath);
-      const form = new FormData;
-      form.append("package", new Blob([data], {
-        type: "application/octet-stream"
-      }), fileName);
-      const headers = {};
-      if (destination.apiKey) {
-        headers["X-NuGet-ApiKey"] = destination.apiKey;
-      }
-      this.logger.info(`Pushing ${fileName} to ${pushUrl}`);
-      const response = await fetch(pushUrl, {
-        method: "PUT",
-        headers,
-        body: form
-      });
-      if (!response.ok) {
-        const body = await this.safeReadBody(response);
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.nugetPushFailed", {
-          fileName,
-          status: response.status,
-          statusText: response.statusText,
-          body: body ? ` - ${body}` : ""
-        }));
-      }
-      published.push(packagePath);
-      this.logger.info(`Pushed ${fileName} successfully.`);
-    }
-    return new ToolResult("SUCCESS" /* Success */, undefined, published);
-  }
-  async resolvePushUrl(feedUrl, apiKey) {
-    let end = feedUrl.length;
-    while (end > 0 && feedUrl.charCodeAt(end - 1) === 47)
-      end--;
-    const trimmed = feedUrl.slice(0, end);
-    if (/\/api\/v2\/package\/?$/i.test(trimmed)) {
-      return trimmed;
-    }
-    if (/\.json$/i.test(trimmed)) {
-      return this.resolveFromServiceIndex(trimmed, apiKey);
-    }
-    return `${trimmed}/api/v2/package`;
-  }
-  async resolveFromServiceIndex(serviceIndexUrl, apiKey) {
-    const headers = { Accept: "application/json" };
-    if (apiKey) {
-      headers["X-NuGet-ApiKey"] = apiKey;
-    }
-    const response = await fetch(serviceIndexUrl, { headers });
-    if (!response.ok) {
-      throw new Error(`service index returned ${response.status} ${response.statusText}`);
-    }
-    const index = await response.json();
-    const resource = index.resources?.find((r) => r["@type"] === NUGET_V3_PACKAGE_PUBLISH_TYPE);
-    if (!resource?.["@id"]) {
-      throw new Error(`service index has no ${NUGET_V3_PACKAGE_PUBLISH_TYPE} resource`);
-    }
-    return resource["@id"];
-  }
-  async safeReadBody(response) {
-    try {
-      const text = await response.text();
-      return text.slice(0, 500);
-    } catch {
-      return "";
-    }
-  }
-}
-
-// ../packager/project-packager/src/publish/services/orchestrator-feed-types.ts
-var PackageFeedDtoPurposeEnum = {
-  Undefined: "Undefined",
-  Processes: "Processes",
-  Libraries: "Libraries",
-  PersonalWorkspace: "PersonalWorkspace",
-  FolderHierarchy: "FolderHierarchy"
-};
-var PackageFeedDtoAuthenticationTypeEnum = {
-  Secure: "Secure",
-  ApiKey: "ApiKey",
-  Basic: "Basic"
-};
-var ExtendedFolderDtoFeedTypeEnum = {
-  Undefined: "Undefined",
-  Processes: "Processes",
-  Libraries: "Libraries",
-  PersonalWorkspace: "PersonalWorkspace",
-  FolderHierarchy: "FolderHierarchy"
-};
-
 // ../packager/project-packager/src/publish/services/orchestrator-feeds-service.ts
-var HEADER_TENANT_ID = "X-UIPATH-TenantId";
-var FEEDS_PATH = "/api/PackageFeeds/GetFeeds";
-var FOLDERS_PATH = "/api/FoldersNavigation/GetAllFoldersForCurrentUser";
 var SDK_USER_AGENT = `${package_default.name.replace(/^@uipath\//, "")}/${package_default.version}`;
-
-class OrchestratorFeedsService {
-  logger;
-  constructor() {
-    this.logger = new ToolLogger("OrchestratorFeedsService", "Feeds");
-  }
-  async getAccessibleFeedsAsync(connection) {
-    this.ensureOrchestratorUrl(connection);
-    this.logger.info(`Fetching accessible feeds from ${connection.orchestratorUrl}`);
-    try {
-      const json = await orchestratorGet(connection, FEEDS_PATH);
-      return Array.isArray(json) ? json : [];
-    } catch (error) {
-      const { status, statusText, body } = await describeResponseError(error);
-      throw new Error(translate.t("solutionpackager.publish.errors.getAccessibleFeedsFailed", { status, statusText, body }));
-    }
-  }
-  async getFoldersForCurrentUserAsync(connection) {
-    this.ensureOrchestratorUrl(connection);
-    this.logger.info(`Fetching folders from ${connection.orchestratorUrl}`);
-    try {
-      const json = await orchestratorGet(connection, FOLDERS_PATH);
-      return Array.isArray(json) ? json.map(mapExtendedFolder) : [];
-    } catch (error) {
-      const { status, statusText, body } = await describeResponseError(error);
-      throw new Error(translate.t("solutionpackager.publish.errors.getFoldersForCurrentUserFailed", { status, statusText, body }));
-    }
-  }
-  ensureOrchestratorUrl(connection) {
-    if (!connection.orchestratorUrl) {
-      throw new Error(translate.t("solutionpackager.publish.errors.orchestratorUrlRequired"));
-    }
-  }
-}
-function mapExtendedFolder(json) {
-  return {
-    isSelectable: json.IsSelectable,
-    hasChildren: json.HasChildren,
-    level: json.Level,
-    key: json.Key,
-    displayName: json.DisplayName,
-    fullyQualifiedName: json.FullyQualifiedName,
-    description: json.Description,
-    folderType: json.FolderType,
-    isPersonal: json.IsPersonal,
-    provisionType: json.ProvisionType,
-    permissionModel: json.PermissionModel,
-    parentId: json.ParentId,
-    parentKey: json.ParentKey,
-    feedType: json.FeedType,
-    id: json.Id
-  };
-}
-
-class OrchestratorResponseError extends Error {
-  response;
-  constructor(response) {
-    super(`Orchestrator request failed with status ${response.status}.`);
-    this.response = response;
-    this.name = "OrchestratorResponseError";
-  }
-}
-async function orchestratorGet(connection, relativePath) {
-  const url = `${normalizeOrchestratorBasePath(connection.orchestratorUrl)}${relativePath}`;
-  const response = await fetch(url, {
-    method: "GET",
-    headers: buildHeaders(connection)
-  });
-  if (!response.ok) {
-    throw new OrchestratorResponseError(response);
-  }
-  const text = await response.text();
-  if (text === "" || text === "null") {
-    return null;
-  }
-  return JSON.parse(text);
-}
-function buildHeaders(connection) {
-  const headers = {};
-  if (connection.accessToken) {
-    headers.Authorization = `Bearer ${connection.accessToken}`;
-  }
-  if (connection.tenantId) {
-    headers[HEADER_TENANT_ID] = connection.tenantId;
-  }
-  return addSdkUserAgentHeader(headers, SDK_USER_AGENT);
-}
-function normalizeOrchestratorBasePath(orchestratorUrl) {
-  let end = orchestratorUrl.length;
-  while (end > 0 && orchestratorUrl.charCodeAt(end - 1) === 47)
-    end--;
-  const trimmed = orchestratorUrl.slice(0, end);
-  return /\/orchestrator_$/i.test(trimmed) ? trimmed : `${trimmed}/orchestrator_`;
-}
-async function describeResponseError(error) {
-  const response = error?.response;
-  if (response) {
-    let body = "";
-    try {
-      body = (await response.text()).slice(0, 500);
-    } catch {
-      body = "";
-    }
-    return {
-      status: response.status,
-      statusText: response.statusText,
-      body: body ? ` - ${body}` : ""
-    };
-  }
-  const cause = error?.cause;
-  const message = cause instanceof Error ? cause.message : error instanceof Error ? error.message : String(error);
-  return { status: "?", statusText: message, body: "" };
-}
-
-// ../packager/project-packager/src/publish/services/orchestrator-publisher.ts
-var HEADER_FOLDER_ID = "X-UIPATH-OrganizationUnitId";
-var HEADER_TENANT_ID2 = "X-UIPATH-TenantId";
-var HEADER_NUGET_API_KEY = "X-NuGet-ApiKey";
-var ORCHESTRATOR_RELATIVE_URL = "/orchestrator_";
-var PROCESSES_UPLOAD_PATH = "/odata/Processes/UiPath.Server.Configuration.OData.UploadPackage";
-var LIBRARIES_UPLOAD_PATH = "/odata/Libraries/UiPath.Server.Configuration.OData.UploadPackage";
-
-class OrchestratorPublisher {
-  fileSystem;
-  logger;
-  feedsService;
-  constructor(fileSystem, feedsService) {
-    this.fileSystem = fileSystem;
-    this.logger = new ToolLogger("ProjectPublisher", "Orchestrator");
-    this.feedsService = feedsService ?? new OrchestratorFeedsService;
-  }
-  async publishAsync(packagePaths, destination) {
-    if (packagePaths.length === 0) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorNoPackages"));
-    }
-    if (destination.kind === "OrchestratorCustom" /* OrchestratorCustom */) {
-      if (!destination.publishUrl) {
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorCustomPublishUrlRequired"));
-      }
-      this.logger.info(`Publishing ${packagePaths.length} package(s) to ${destination.publishUrl} (custom)`);
-      return this.postPackages(packagePaths, destination.publishUrl, this.buildCustomHeaders(destination));
-    }
-    if (!destination.connectionInfo?.cloudUrl) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorCloudUrlRequired"));
-    }
-    const orchestratorUrl = this.deriveOrchestratorUrl(destination.connectionInfo);
-    let feed;
-    try {
-      feed = await this.resolveFeed(destination, orchestratorUrl);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorFeedResolutionFailed", { message }));
-    }
-    const targetUrl = this.buildPublishUrl(orchestratorUrl, feed);
-    const headers = this.buildHeaders(destination, feed);
-    this.logger.info(`Publishing ${packagePaths.length} package(s) to ${targetUrl} (feed ${feed.name}, ${feed.purpose})`);
-    return this.postPackages(packagePaths, targetUrl, headers);
-  }
-  async postPackages(packagePaths, targetUrl, headers) {
-    const form = new FormData;
-    for (const packagePath of packagePaths) {
-      const data = await this.fileSystem.readFile(packagePath);
-      if (!data) {
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.failedToReadPackage", { path: packagePath }));
-      }
-      const fileName = this.fileSystem.path.basename(packagePath);
-      form.append("file", new Blob([data], {
-        type: "application/octet-stream"
-      }), fileName);
-    }
-    const response = await fetch(targetUrl, {
-      method: "POST",
-      headers,
-      body: form
-    });
-    if (!response.ok) {
-      const body = await this.safeReadBody(response);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.orchestratorPublishFailed", {
-        status: response.status,
-        statusText: response.statusText,
-        body: body ? ` - ${body}` : ""
-      }));
-    }
-    this.logger.info("Orchestrator publish completed.");
-    return new ToolResult("SUCCESS" /* Success */, undefined, packagePaths);
-  }
-  async resolveFeed(destination, orchestratorUrl) {
-    const connection = {
-      orchestratorUrl,
-      accessToken: destination.connectionInfo.accessToken,
-      tenantId: destination.connectionInfo.tenantId
-    };
-    const feeds = await this.feedsService.getAccessibleFeedsAsync(connection);
-    if (destination.kind === "OrchestratorPersonalWorkspace" /* OrchestratorPersonalWorkspace */) {
-      const folders = await this.feedsService.getFoldersForCurrentUserAsync(connection);
-      const personalFolder = folders.find((f) => f.feedType === ExtendedFolderDtoFeedTypeEnum.PersonalWorkspace);
-      if (!personalFolder) {
-        const foldersDebug = folders.length === 0 ? "<none>" : folders.map((f) => `${f.displayName} (id=${f.id}, feedType=${f.feedType})`).join(", ");
-        throw new Error(translate.t("solutionpackager.publish.errors.orchestratorPersonalWorkspaceFolderNotFound", { folders: foldersDebug }));
-      }
-      if (personalFolder.id == null) {
-        throw new Error(`Personal-workspace folder "${personalFolder.displayName}" has no id; cannot resolve its feed.`);
-      }
-      const match2 = feeds.find((f) => f.folderId === personalFolder.id);
-      if (!match2) {
-        this.throwFeedNotFound(destination, feeds);
-      }
-      return match2;
-    }
-    const expectedPurpose = destination.kind === "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */ ? PackageFeedDtoPurposeEnum.Libraries : PackageFeedDtoPurposeEnum.Processes;
-    const match = feeds.find((f) => f.purpose === expectedPurpose && f.folderId == null);
-    if (!match) {
-      this.throwFeedNotFound(destination, feeds);
-    }
-    return match;
-  }
-  throwFeedNotFound(destination, feeds) {
-    const available = feeds.length === 0 ? "<none>" : feeds.map((f) => `${f.name} (purpose=${f.purpose}, folderId=${f.folderId ?? "null"})`).join(", ");
-    throw new Error(translate.t("solutionpackager.publish.errors.orchestratorFeedNotFound", {
-      kind: destination.kind,
-      available
-    }));
-  }
-  buildPublishUrl(orchestratorUrl, feed) {
-    const baseUrl = feed.publishUrl ? feed.publishUrl : `${orchestratorUrl}${feed.purpose === PackageFeedDtoPurposeEnum.Libraries ? LIBRARIES_UPLOAD_PATH : PROCESSES_UPLOAD_PATH}`;
-    const parsed = new URL(baseUrl);
-    if (feed.id) {
-      parsed.searchParams.set("feedId", feed.id);
-    }
-    return parsed.toString();
-  }
-  deriveOrchestratorUrl(connectionInfo) {
-    const raw = connectionInfo.cloudUrl ?? "";
-    let end = raw.length;
-    while (end > 0 && raw.charCodeAt(end - 1) === 47)
-      end--;
-    return `${raw.slice(0, end)}${ORCHESTRATOR_RELATIVE_URL}`;
-  }
-  buildHeaders(destination, feed) {
-    const headers = this.buildAuthHeaders(destination.connectionInfo);
-    const folderHeader = destination.kind === "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */ ? destination.folderId : feed.folderId;
-    if (folderHeader != null) {
-      headers[HEADER_FOLDER_ID] = String(folderHeader);
-    }
-    if (feed.authenticationType === PackageFeedDtoAuthenticationTypeEnum.ApiKey && feed.apiKey) {
-      headers[HEADER_NUGET_API_KEY] = feed.apiKey;
-    }
-    return headers;
-  }
-  buildCustomHeaders(destination) {
-    const headers = this.buildAuthHeaders(destination.connectionInfo);
-    if (destination.folderId != null) {
-      headers[HEADER_FOLDER_ID] = String(destination.folderId);
-    }
-    if (destination.apiKey) {
-      headers[HEADER_NUGET_API_KEY] = destination.apiKey;
-    }
-    return headers;
-  }
-  buildAuthHeaders(connectionInfo) {
-    const headers = {};
-    if (connectionInfo.accessToken) {
-      headers.Authorization = `Bearer ${connectionInfo.accessToken}`;
-    }
-    if (connectionInfo.tenantId) {
-      headers[HEADER_TENANT_ID2] = connectionInfo.tenantId;
-    }
-    return headers;
-  }
-  async safeReadBody(response) {
-    try {
-      const text = await response.text();
-      return text.slice(0, 500);
-    } catch {
-      return "";
-    }
-  }
-}
-
-// ../packager/project-packager/src/publish/services/project-publisher.ts
-class ProjectPublisher {
-  fileSystem;
-  logger;
-  localFolderPublisher;
-  nugetFeedPublisher;
-  orchestratorPublisher;
-  constructor(fileSystem, publishers) {
-    this.fileSystem = fileSystem;
-    this.logger = new ToolLogger("ProjectPublisher", "Publish");
-    this.localFolderPublisher = publishers?.localFolder ?? new LocalFolderPublisher(fileSystem);
-    this.nugetFeedPublisher = publishers?.nugetFeed ?? new NugetFeedPublisher(fileSystem);
-    this.orchestratorPublisher = publishers?.orchestrator ?? new OrchestratorPublisher(fileSystem);
-  }
-  async publishAsync(options) {
-    if (!options.packagePaths || options.packagePaths.length === 0) {
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.atLeastOnePackage"));
-    }
-    for (const path of options.packagePaths) {
-      if (!await this.fileSystem.exists(path)) {
-        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.packageNotFound", { path }));
-      }
-    }
-    try {
-      const destination = options.destination;
-      switch (destination.kind) {
-        case "LocalFolder" /* LocalFolder */:
-          return await this.localFolderPublisher.publishAsync(options.packagePaths, destination);
-        case "NugetFeed" /* NugetFeed */:
-          return await this.nugetFeedPublisher.publishAsync(options.packagePaths, destination);
-        case "OrchestratorPersonalWorkspace" /* OrchestratorPersonalWorkspace */:
-        case "OrchestratorTenantProcesses" /* OrchestratorTenantProcesses */:
-        case "OrchestratorSharedLibraries" /* OrchestratorSharedLibraries */:
-        case "OrchestratorCustom" /* OrchestratorCustom */:
-          return await this.orchestratorPublisher.publishAsync(options.packagePaths, destination);
-        default: {
-          const exhaustive = destination;
-          return ToolResult.error("INTERNAL_ERROR" /* InternalError */, translate.t("solutionpackager.publish.errors.unknownDestination", { destination: JSON.stringify(exhaustive) }));
-        }
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      const localized = translate.t("solutionpackager.publish.errors.publishFailed", { message });
-      this.logger.error(localized);
-      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, localized);
-    }
-  }
-}
-
-// ../packager/project-packager/src/publish/node-project-publisher-factory.ts
-class NodeProjectPublisherFactory extends BaseNodePackagerFactory {
-  async createAsync(config) {
-    const logger = new ToolLogger("ProjectPublisherFactory", "Create");
-    this.configureLanguage(config);
-    this.configureLogHandler(config);
-    logger.info("Creating ProjectPublisher instance...");
-    const fileSystem = this.getOrCreateFileSystem(config);
-    this.getOrCreateTelemetryService(config);
-    const projectPublisher = new ProjectPublisher(fileSystem);
-    logger.info("ProjectPublisher created successfully.");
-    return projectPublisher;
-  }
-}
-async function createNodeProjectPublisher(options) {
-  const factory = new NodeProjectPublisherFactory;
-  return factory.createAsync(options);
-}
 export {
-  BaseNodePackagerFactory,
-  ConsoleTelemetryProvider,
-  DebugTelemetryProvider,
-  DotnetDiscoveryService,
-  GovernancePolicyService,
-  NodeContextStorage,
-  NodePackageSignService,
-  PACKAGE_ID_TOO_LONG,
-  PackService,
-  PackagerParameters,
-  PackagerParametersValidator,
-  ProjectBuildOptions,
-  ProjectBuildOptionsValidator,
-  ProjectCleanupOptions,
-  ProjectLoader,
   ProjectPackOptions,
-  ProjectPackager,
-  ProjectPublishOptions,
-  ProjectPublisher,
-  ProjectRestoreOptions,
-  ProjectToolExecutor,
-  ProjectValidateOptions,
-  ProjectValidateOptionsValidator,
-  PublishDestinationKind,
-  RulesConfigFileType,
-  TelemetryNames,
-  TelemetryService,
-  ToolLogger,
-  ToolsFactory,
-  createNodeProjectPackager,
-  createNodeProjectPublisher,
-  isPackageIdTooLongError,
-  resolveProducedNupkgsAsync,
-  setGlobalLogHandler,
-  signNupkgsAsync
+  createNodeProjectPackager
 };
 
-//# debugId=F9B59A3BE865440B64756E2164756E21
+//# debugId=7B8E24C5C2B351AE64756E2164756E21