@uipath/api-workflow-tool 0.1.12 → 0.1.14

package/dist/tool.js

@@ -30,8 +30,1929 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// ../telemetry/dist/node.js
+import { AsyncLocalStorage } from "node:async_hooks";
+
+class ConsoleTelemetryProvider {
+  async trackEvent(eventName, _properties) {
+    console.log(`[Telemetry] Event: ${eventName}`);
+  }
+  async trackException(error, _properties) {
+    console.log(`[Telemetry] Exception: ${error.message}`);
+  }
+  async trackRequest(name, duration, success, _properties) {
+    console.log(`[Telemetry] Request: ${name} (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+  async trackDependency(name, type, duration, success, _properties) {
+    console.log(`[Telemetry] Dependency: ${name} [${type}] (${duration}ms, ${success ? "ok" : "fail"})`);
+  }
+}
+
+class NodeContextStorage {
+  storage = new AsyncLocalStorage;
+  run(context, fn) {
+    return this.storage.run(context, fn);
+  }
+  getContext() {
+    return this.storage.getStore();
+  }
+}
+
+class TelemetryService {
+  telemetryProvider;
+  contextStorage;
+  operationId;
+  defaultProperties;
+  constructor(telemetryProvider, contextStorage) {
+    this.telemetryProvider = telemetryProvider;
+    this.contextStorage = contextStorage;
+  }
+  setOperationId(operationId) {
+    this.operationId = operationId;
+  }
+  setProvider(provider) {
+    this.telemetryProvider = provider;
+  }
+  setDefaultProperties(properties) {
+    this.defaultProperties = properties;
+  }
+  trackEvent(name, properties) {
+    const context = this.getCurrentContext();
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackEvent(name, enrichedProperties);
+  }
+  trackException(error, properties) {
+    const context = this.getCurrentContext();
+    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+    this.telemetryProvider.trackException(error, enrichedProperties);
+  }
+  async trackRequest(name, fn, properties) {
+    const context = {
+      operationId: this.operationId ?? this.generateId(),
+      id: this.generateId()
+    };
+    const startTime = performance.now();
+    try {
+      const result = await this.contextStorage.run(context, fn);
+      const durationMs = performance.now() - startTime;
+      const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
+      await this.telemetryProvider.trackRequest(name, durationMs, true, enrichedProperties);
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error));
+      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, context);
+      await this.telemetryProvider.trackRequest(name, durationMs, false, enrichedProperties);
+      throw error;
+    }
+  }
+  async trackDependencyOperation(name, type, fn, properties) {
+    const parentContext = this.getCurrentContext();
+    if (!parentContext) {
+      throw new Error("trackDependencyOperation must be called within a trackRequest block.");
+    }
+    const childContext = {
+      operationId: parentContext.operationId,
+      parentId: parentContext.id,
+      id: this.generateId()
+    };
+    const startTime = performance.now();
+    try {
+      const result = await this.contextStorage.run(childContext, fn);
+      const durationMs = performance.now() - startTime;
+      const enrichedProperties = this.enrichPropertiesWithContext(properties, childContext);
+      await this.telemetryProvider.trackDependency(name, type, durationMs, true, enrichedProperties);
+      return result;
+    } catch (error) {
+      const durationMs = performance.now() - startTime;
+      const err = error instanceof Error ? error : new Error(String(error));
+      const enrichedProperties = this.enrichPropertiesWithContext({ ...properties, errorMessage: err.message }, childContext);
+      await this.telemetryProvider.trackDependency(name, type, durationMs, false, enrichedProperties);
+      throw error;
+    }
+  }
+  getCurrentContext() {
+    return this.contextStorage.getContext();
+  }
+  enrichPropertiesWithContext(properties, context) {
+    return {
+      ...this.defaultProperties,
+      ...properties,
+      ...context
+    };
+  }
+  generateId() {
+    return crypto.randomUUID().replaceAll("-", "");
+  }
+}
+var init_node = () => {};
+
+// ../packager/project-packager/dist/node.js
+var exports_node = {};
+__export(exports_node, {
+  setGlobalLogHandler: () => setGlobalLogHandler,
+  createNodeProjectPackager: () => createNodeProjectPackager,
+  ToolsFactory: () => ToolsFactory,
+  ToolLogger: () => ToolLogger,
+  TelemetryService: () => TelemetryService,
+  TelemetryNames: () => TelemetryNames,
+  RulesConfigFileType: () => RulesConfigFileType,
+  ProjectValidateOptionsValidator: () => ProjectValidateOptionsValidator,
+  ProjectValidateOptions: () => ProjectValidateOptions,
+  ProjectToolExecutor: () => ProjectToolExecutor,
+  ProjectRestoreOptions: () => ProjectRestoreOptions,
+  ProjectPackager: () => ProjectPackager,
+  ProjectPackOptions: () => ProjectPackOptions,
+  ProjectLoader: () => ProjectLoader,
+  ProjectBuildOptionsValidator: () => ProjectBuildOptionsValidator,
+  ProjectBuildOptions: () => ProjectBuildOptions,
+  PackagerParametersValidator: () => PackagerParametersValidator,
+  PackagerParameters: () => PackagerParameters,
+  PackService: () => PackService,
+  NodePackageSignService: () => NodePackageSignService,
+  NodeContextStorage: () => NodeContextStorage,
+  ConsoleTelemetryProvider: () => ConsoleTelemetryProvider,
+  BaseNodePackagerFactory: () => BaseNodePackagerFactory
+});
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+import { execSync } from "node:child_process";
+import { NodeFileSystem } from "@uipath/filesystem";
+import { translate } from "@uipath/solutionpackager-tool-core";
+import {
+  LogLevel,
+  LogMessage
+} from "@uipath/solutionpackager-tool-core";
+import {
+  LogLevel as LogLevel2
+} from "@uipath/solutionpackager-tool-core";
+import { execSync as execSync2, spawn } from "node:child_process";
+import {
+  ToolErrorCodes,
+  ToolResult,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+import {
+  toolsFactoryRepository as defaultToolsFactoryRepository,
+  NugetPackager,
+  Path as Path3,
+  TemporaryStorageService,
+  ToolErrorCodes as ToolErrorCodes4,
+  ToolResult as ToolResult4,
+  translate as translate6,
+  ZipService
+} from "@uipath/solutionpackager-tool-core";
+import {
+  Path,
+  toRelativeUrl,
+  translate as translate3
+} from "@uipath/solutionpackager-tool-core";
+import {
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2,
+  translate as translate4
+} from "@uipath/solutionpackager-tool-core";
+import {
+  Path as Path2,
+  ProjectTypes,
+  translate as translate5
+} from "@uipath/solutionpackager-tool-core";
+import {
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3
+} from "@uipath/solutionpackager-tool-core";
+function setGlobalLogHandler(handler) {
+  globalLogHandler = handler;
+}
+
+class ToolLogger {
+  source;
+  sourceTarget;
+  constructor(source, sourceTarget) {
+    this.source = source;
+    this.sourceTarget = sourceTarget;
+  }
+  debug(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Debug, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  info(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Info, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  warn(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Warn, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  error(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Error, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  progress(message, options) {
+    const logMessage = new LogMessage(message, LogLevel.Info, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  log(message, logLevel, options) {
+    const logMessage = new LogMessage(message, logLevel, {
+      source: this.source,
+      sourceTarget: this.sourceTarget,
+      ...options
+    });
+    globalLogHandler(logMessage);
+  }
+  logMessage(message) {
+    globalLogHandler(message);
+  }
+}
+
+class BaseNodePackagerFactory {
+  getOrCreateFileSystem(config) {
+    return config?.fileSystem ?? new NodeFileSystem;
+  }
+  getOrCreateTelemetryService(config) {
+    if (config?.telemetryService) {
+      return config.telemetryService;
+    }
+    const provider = new ConsoleTelemetryProvider;
+    const contextStorage = new NodeContextStorage;
+    return new TelemetryService(provider, contextStorage);
+  }
+  checkDotnetAvailability(logger) {
+    logger.info("Checking for dotnet CLI availability...");
+    try {
+      execSync("dotnet --version", {
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      logger.info("dotnet CLI is available.");
+    } catch {
+      logger.error("dotnet CLI is not available. Workflow compiler functionality and package signing will not be available.");
+    }
+  }
+  configureLogHandler(config) {
+    if (config?.logHandler) {
+      setGlobalLogHandler(config.logHandler);
+    }
+  }
+  configureLanguage(config) {
+    const language = config?.language ?? "en";
+    translate.setLocale(language);
+  }
+}
+
+class PackagerParameters {
+  inputPath;
+  logLevel = LogLevel2.Warn;
+  outputPath;
+  targetFramework;
+  excludeConfiguredSources = false;
+  nuGetSourcesConfigPath;
+  detailedLogPath;
+  connection;
+  workflowCompilerVersion;
+}
+
+class NodePackageSignService {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async signPackageAsync(packagePath, certificatePath, certificatePassword, timestampServer) {
+    if (!this.checkAvailable()) {
+      this.logger.error(translate2.t("solutionpackager.signing.info.dotnetNotAvailable"));
+      return ToolResult.error(ToolErrorCodes.InternalError, translate2.t("solutionpackager.signing.errors.dotnetNotAvailable"));
+    }
+    const args = [
+      "nuget",
+      "sign",
+      packagePath,
+      "--certificate-path",
+      certificatePath,
+      "--overwrite"
+    ];
+    if (certificatePassword) {
+      args.push("--certificate-password", certificatePassword);
+    }
+    if (timestampServer) {
+      args.push("--timestamper", timestampServer);
+    }
+    return new Promise((resolve) => {
+      const childProcess = spawn("dotnet", args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        windowsHide: true
+      });
+      let stderr = "";
+      childProcess.stdout?.on("data", (data) => {
+        this.logger.info(data.toString().trim());
+      });
+      childProcess.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      childProcess.on("error", (error) => {
+        this.logger.error(`Failed to start dotnet process: ${error.message}`);
+        resolve(ToolResult.error(ToolErrorCodes.InternalError, `Failed to start dotnet process: ${error.message}`));
+      });
+      childProcess.on("exit", (code) => {
+        if (code === 0) {
+          this.logger.info(`Successfully signed package: ${packagePath}`);
+          resolve(ToolResult.success());
+        } else {
+          const errorMessage = stderr.trim() || `dotnet nuget sign exited with code ${code}`;
+          this.logger.error(`Package signing failed: ${errorMessage}`);
+          resolve(ToolResult.error(ToolErrorCodes.InternalError, `Package signing failed: ${errorMessage}`));
+        }
+      });
+    });
+  }
+  checkAvailable() {
+    try {
+      const output = execSync2("dotnet nuget --version", {
+        stdio: ["ignore", "pipe", "ignore"],
+        encoding: "utf-8"
+      });
+      this.logger.info(`dotnet CLI found, version ${output.trim()}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+class GovernancePolicyService {
+  fileSystem;
+  temporaryStorage;
+  fetchFn;
+  logger = new ToolLogger("GovernancePolicyService", "ResolvePolicy");
+  constructor(fileSystem, temporaryStorage, fetchFn = fetch.bind(globalThis)) {
+    this.fileSystem = fileSystem;
+    this.temporaryStorage = temporaryStorage;
+    this.fetchFn = fetchFn;
+  }
+  async resolveGovernancePolicyAsync(validateOptions, connectionInfo, cancellationToken) {
+    if (validateOptions.governanceFileType !== "AutomationOps") {
+      return;
+    }
+    if (validateOptions.governanceFilePath) {
+      this.logger.info(t("info.alreadyProvided"));
+      return;
+    }
+    const cloudUrl = connectionInfo?.cloudUrl;
+    const organizationId = connectionInfo?.organizationId;
+    const tenantId = connectionInfo?.tenantId;
+    const accessToken = connectionInfo?.accessToken;
+    if (!cloudUrl || !organizationId || !tenantId || !accessToken) {
+      this.logger.warn(t("errors.connectionIncomplete"));
+      validateOptions.governanceFileType = "Default";
+      return;
+    }
+    const profileKey = validateOptions.profileKey ?? DEFAULT_PROFILE_KEY;
+    const orchestratorUrl = toRelativeUrl(cloudUrl);
+    const licenseType = await this.resolveLicenseTypeAsync(profileKey, orchestratorUrl, accessToken, cancellationToken);
+    const policy = await this.downloadPolicyAsync(organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken);
+    if (!policy) {
+      validateOptions.governanceFileType = "Default";
+      return;
+    }
+    try {
+      const dir = await this.temporaryStorage.getTempSubfolderPathAsync(GOVERNANCE_SUBFOLDER);
+      const filePath = Path.join(dir, GOVERNANCE_FILE_NAME);
+      await this.fileSystem.writeFile(filePath, policy);
+      this.logger.info(t("info.saved", { path: filePath }));
+      validateOptions.governanceFilePath = filePath;
+    } catch (error) {
+      this.logger.warn(t("errors.failedToSave", {
+        error: errorMessage(error)
+      }));
+      validateOptions.governanceFileType = "Default";
+    }
+  }
+  async downloadPolicyAsync(organizationId, tenantId, accessToken, licenseType, profileKey, cancellationToken) {
+    const policyUrl = `/${organizationId}/roboticsops_` + `/api/Policy/license/${licenseType}/product/${profileKey}/tenant/${tenantId}`;
+    this.logger.info(t("info.downloading", { url: policyUrl }));
+    try {
+      const response = await this.fetchFn(policyUrl, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          AccountId: organizationId
+        },
+        signal: cancellationToken
+      });
+      if (response.status === 204 || response.status === 404) {
+        this.logger.info(t("info.noPolicyFound"));
+        return null;
+      }
+      if (!response.ok) {
+        const body = await response.text();
+        this.logger.warn(t("errors.failedToGetPolicy", { content: body }));
+        return null;
+      }
+      const content = await response.text();
+      if (!content?.trimStart().startsWith("{")) {
+        this.logger.info(t("info.responseNotJson"));
+        return null;
+      }
+      return content;
+    } catch (error) {
+      this.logger.warn(t("errors.failedToDownload", {
+        error: errorMessage(error)
+      }));
+      return null;
+    }
+  }
+  async resolveLicenseTypeAsync(profileKey, orchestratorUrl, accessToken, cancellationToken) {
+    const isStudioWeb = profileKey === DEFAULT_PROFILE_KEY;
+    const fallback = isStudioWeb ? LICENSE_TYPES.NoLicense : LICENSE_TYPES.Development;
+    try {
+      const response = await this.fetchFn(`${orchestratorUrl}${ACQUIRE_LICENSE_PATH}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${accessToken}` },
+        signal: cancellationToken
+      });
+      if (!response.ok) {
+        this.logger.info(t("info.licenseStatus", {
+          status: response.status,
+          fallback
+        }));
+        return fallback;
+      }
+      const { isLicensed, robotType } = await response.json();
+      this.logger.info(t("info.licenseResponse", {
+        isLicensed: String(isLicensed),
+        robotType: String(robotType)
+      }));
+      if (!isLicensed || !robotType) {
+        return fallback;
+      }
+      if (isStudioWeb) {
+        return robotType === LICENSE_TYPES.AutomationKit ? LICENSE_TYPES.AutomationKit : LICENSE_TYPES.NoLicense;
+      }
+      return robotType;
+    } catch (error) {
+      this.logger.info(t("info.licenseFailed", {
+        error: errorMessage(error),
+        fallback
+      }));
+      return fallback;
+    }
+  }
+}
+
+class PackService {
+  disallowedCharsRegex = /[^\w.-]/g;
+  spacesDotRegex = /[\s.]+/g;
+  dotDashRegex = /\.{0,10}[-:]\.{0,10}/g;
+  MaxPackageIdLength = 100;
+  sanitizePackageId(packageId) {
+    packageId = packageId.trim();
+    packageId = packageId.replace(this.spacesDotRegex, ".");
+    packageId = packageId.replace(this.dotDashRegex, "-");
+    packageId = packageId.replace(this.disallowedCharsRegex, "_");
+    if (packageId.length > this.MaxPackageIdLength) {
+      throw new Error(`Package id ${packageId} exceeds the characters limit of ${this.MaxPackageIdLength}`);
+    }
+    return packageId;
+  }
+}
+
+class PackagerParametersValidator {
+  logger;
+  fileSystem;
+  constructor(logger, fileSystem) {
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(_options, _cancellationToken) {
+    return ToolResult2.success();
+  }
+  validateDestinationPath(destinationPath) {
+    if (!destinationPath) {
+      const error = translate4.t("solutionpackager.validator.errors.destinationNotDefined");
+      this.logger.error(error);
+      return ToolResult2.error(ToolErrorCodes2.InternalError, error);
+    }
+    return ToolResult2.success();
+  }
+  async validateGovernanceOptions(validateOptions) {
+    if (validateOptions.governanceFileType === "Default") {
+      if (validateOptions.governanceFilePath) {
+        this.logger.warn(`Governance file path '${validateOptions.governanceFilePath}' will be ignored when governance file type is Default`);
+      }
+      return ToolResult2.success();
+    }
+    if (!validateOptions.governanceFilePath) {
+      const error = translate4.t("solutionpackager.validator.errors.governanceRequired");
+      this.logger.error(error);
+      return ToolResult2.error(ToolErrorCodes2.InternalError, error);
+    }
+    try {
+      const stat = await this.fileSystem.stat(validateOptions.governanceFilePath);
+      if (!stat) {
+        const error = translate4.t("solutionpackager.validator.errors.governanceFileInfo", {
+          path: validateOptions.governanceFilePath
+        });
+        this.logger.error(error);
+        return ToolResult2.error(ToolErrorCodes2.InternalError, error);
+      }
+      if (stat.isDirectory()) {
+        const error = translate4.t("solutionpackager.validator.errors.governanceInvalidFile", {
+          path: validateOptions.governanceFilePath
+        });
+        this.logger.error(error);
+        return ToolResult2.error(ToolErrorCodes2.InternalError, error);
+      }
+    } catch (error) {
+      const errorMessage2 = error instanceof Error ? error.message : String(error);
+      const errorLog = `Governance file not found or inaccessible: ${validateOptions.governanceFilePath}. Error: ${errorMessage2}`;
+      this.logger.error(errorLog);
+      return ToolResult2.error(ToolErrorCodes2.InternalError, errorLog);
+    }
+    this.logger.info(`Using Studio governance file: ${validateOptions.governanceFilePath}`);
+    return ToolResult2.success();
+  }
+}
+
+class ProjectLoader {
+  fileSystem;
+  static ProjectFileName = "project.uiproj";
+  static WebAppManifestFileName = "webAppManifest.json";
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async loadProject(projectPath) {
+    if (!projectPath) {
+      throw new Error(translate5.t("solutionpackager.projectLoader.errors.pathRequired"));
+    }
+    const projectFilePath = Path2.join(projectPath, ProjectLoader.ProjectFileName);
+    const projectFileExists = await this.fileSystem.exists(projectFilePath);
+    if (projectFileExists) {
+      return await this.loadFromProjectFile(projectPath, projectFilePath);
+    }
+    const webAppManifestPath = Path2.join(projectPath, ProjectLoader.WebAppManifestFileName);
+    const webAppManifestExists = await this.fileSystem.exists(webAppManifestPath);
+    if (webAppManifestExists) {
+      return this.loadFromWebAppManifest(projectPath, webAppManifestPath);
+    }
+    throw new Error(translate5.t("solutionpackager.projectLoader.errors.noProjectFile", {
+      projectFile: ProjectLoader.ProjectFileName,
+      manifestFile: ProjectLoader.WebAppManifestFileName,
+      path: projectPath
+    }));
+  }
+  async loadFromProjectFile(projectPath, projectFilePath) {
+    const fileContent = await this.fileSystem.readFile(projectFilePath);
+    if (!fileContent) {
+      throw new Error(translate5.t("solutionpackager.projectLoader.errors.readFailed", {
+        path: projectFilePath
+      }));
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const projectData = JSON.parse(json);
+    const projectType = projectData?.ProjectType || projectData?.type;
+    if (!projectData || !projectType) {
+      throw new Error(translate5.t("solutionpackager.projectLoader.errors.invalidProject", {
+        path: projectFilePath
+      }));
+    }
+    return {
+      type: projectType,
+      name: projectData.Name || Path2.basename(projectPath),
+      projectPath,
+      projectFilePath
+    };
+  }
+  loadFromWebAppManifest(projectPath, webAppManifestPath) {
+    const folderName = Path2.basename(projectPath);
+    return {
+      type: ProjectTypes.AppV2,
+      name: folderName,
+      projectPath,
+      projectFilePath: webAppManifestPath
+    };
+  }
+}
+
+class ProjectPackOptionsBuilder {
+  packService;
+  fileSystem;
+  constructor(packService, fileSystem) {
+    this.packService = packService;
+    this.fileSystem = fileSystem;
+  }
+  async buildProjectPackOptions(parameters, project) {
+    if (!parameters.outputPath) {
+      throw new Error("Output path is required for Pack command");
+    }
+    await this.fileSystem.mkdir(parameters.outputPath);
+    const packageId = !parameters.package.id || parameters.package.id.trim() === "" ? project.name : parameters.package.id;
+    const packageInfo = {
+      ...parameters.package,
+      id: this.packService.sanitizePackageId(packageId)
+    };
+    return {
+      projectPath: project.projectPath,
+      excludeConfiguredSources: parameters.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: parameters.nuGetSourcesConfigPath,
+      logLevel: parameters.logLevel,
+      skipAnalyze: parameters.validateOptions.skipAnalyze,
+      skipValidate: false,
+      detailedLogPath: parameters.detailedLogPath,
+      policyFilePath: parameters.validateOptions.governanceFilePath,
+      policyFileType: parameters.validateOptions.governanceFileType,
+      outputPath: parameters.outputPath,
+      outputType: undefined,
+      projectType: project.type,
+      package: packageInfo,
+      skipDependencyOptimization: parameters.packOptions?.skipDependencyOptimization ?? false,
+      includeSources: parameters.packOptions?.includeSources ?? false,
+      splitPackages: parameters.packOptions?.splitPackages ?? false
+    };
+  }
+}
+
+class ProjectToolExecutor {
+  toolsFactory;
+  telemetry;
+  packageSignService;
+  constructor(toolsFactory, telemetry, packageSignService) {
+    this.toolsFactory = toolsFactory;
+    this.telemetry = telemetry;
+    this.packageSignService = packageSignService;
+  }
+  async restoreAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Restore", project.Type, async () => tool.restoreAsync(options, cancellationToken), {
+      projectId: project.Id,
+      projectType: project.Type
+    }));
+  }
+  async validateAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Validate", project.Type, async () => tool.validateAsync(options, cancellationToken), {
+      projectId: project.Id,
+      projectType: project.Type
+    }));
+  }
+  async buildAsync(options, project, context, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, (tool) => this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Build", project.Type, async () => tool.buildAsync(options, cancellationToken), {
+      projectId: project.Id,
+      projectType: project.Type
+    }));
+  }
+  async packAsync(options, project, context, signingInfo, cancellationToken) {
+    return await this.executeToolOperationAsync(project, context, async (tool) => {
+      const result = await this.telemetry.trackDependencyOperation("ProjectPackager.Tool.Pack", project.Type, async () => {
+        return await tool.packAsync(options, cancellationToken);
+      }, {
+        projectId: project.Id,
+        projectType: project.Type
+      });
+      if (result.isSuccess && signingInfo?.certificatePath && result.packages.length > 0) {
+        const signResult = await this.signPackagesAsync(result.packages, signingInfo);
+        if (!signResult.isSuccess) {
+          return signResult;
+        }
+      }
+      return result;
+    });
+  }
+  async executeToolOperationAsync(project, context, operation) {
+    try {
+      const tool = await this.toolsFactory.createProjectToolAsync(project, context);
+      try {
+        return await operation(tool);
+      } finally {
+        const disposeResult = tool.dispose();
+        if (disposeResult instanceof Promise) {
+          await disposeResult;
+        }
+      }
+    } catch (error) {
+      return ToolResult3.error(ToolErrorCodes3.InternalError, error instanceof Error ? error.message : String(error));
+    }
+  }
+  async signPackagesAsync(packages, signingInfo) {
+    if (!this.packageSignService) {
+      return ToolResult3.error(ToolErrorCodes3.InternalError, "Package signing is required but signing service is not available. Package signing requires dotnet CLI to be installed in Node.js environment.");
+    }
+    const certificatePath = signingInfo.certificatePath;
+    const signResults = await Promise.all(packages.map((packagePath) => this.packageSignService?.signPackageAsync(packagePath, certificatePath, signingInfo.certificatePassword, signingInfo.timestampServer)));
+    const failedResult = signResults.find((result) => result && !result.isSuccess);
+    if (failedResult) {
+      return failedResult;
+    }
+    return ToolResult3.success();
+  }
+}
+
+class ToolsFactory {
+  repository;
+  fileSystem;
+  constructor(repository, fileSystem) {
+    this.repository = repository;
+    this.fileSystem = fileSystem;
+  }
+  async createSolutionToolAsync(solutionName) {
+    const logger = new ToolLogger("ResourceBuilder", solutionName);
+    const factory = this.repository.getSolutionToolFactory();
+    return await factory.createAsync(logger, this.fileSystem);
+  }
+  async createProjectToolAsync(project, context) {
+    const sourceTarget = getSourceTarget();
+    const logger = new ToolLogger(project.Type, sourceTarget);
+    if (!project.ProjectPath) {
+      throw new Error(`Project path not set for project: ${project.Id}`);
+    }
+    const factory = this.repository.getProjectToolFactory(project.Type);
+    return await factory.createAsync(logger, this.fileSystem, context);
+    function getSourceTarget() {
+      const segments = project.ProjectRelativePath.split(/[/\\]/);
+      if (segments.length > 1) {
+        return segments[0];
+      }
+      return project.Id;
+    }
+  }
+}
+
+class ProjectPackager {
+  fileSystem;
+  telemetryService;
+  packageSignService;
+  repository;
+  temporaryStorage;
+  zipService;
+  logger;
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  projectLoader;
+  validateOptionsValidator;
+  buildOptionsValidator;
+  packOptionsValidator;
+  nugetPackager;
+  governancePolicyService;
+  constructor(fileSystem, telemetryService, packageSignService) {
+    this.fileSystem = fileSystem;
+    this.telemetryService = telemetryService;
+    this.packageSignService = packageSignService;
+    this.repository = defaultToolsFactoryRepository;
+    this.temporaryStorage = new TemporaryStorageService(this.fileSystem);
+    this.zipService = new ZipService(this.fileSystem);
+    this.nugetPackager = new NugetPackager(this.fileSystem);
+    this.logger = new ToolLogger("ProjectPackager", "PackProject");
+    this.validateOptionsValidator = new ProjectValidateOptionsValidator(this.logger, this.fileSystem);
+    this.buildOptionsValidator = new ProjectBuildOptionsValidator(this.logger, this.fileSystem);
+    this.packOptionsValidator = new ProjectPackOptionsValidator(this.logger, this.fileSystem);
+    const packService = new PackService;
+    this.optionsBuilder = new ProjectPackOptionsBuilder(packService, this.fileSystem);
+    this.toolsFactory = new ToolsFactory(this.repository, this.fileSystem);
+    this.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService, this.packageSignService);
+    this.projectLoader = new ProjectLoader(this.fileSystem);
+    this.governancePolicyService = new GovernancePolicyService(this.fileSystem, this.temporaryStorage);
+  }
+  async canPackProjectAsync(projectPath) {
+    const project = await this.projectLoader.loadProject(projectPath);
+    return this.repository.canHandleProject(project.type);
+  }
+  async setupAsync(input, operationId) {
+    this.telemetryService.setOperationId(operationId);
+    await this.temporaryStorage.cleanup();
+    if (typeof input === "string") {
+      return input;
+    }
+    const inputPath = await this.temporaryStorage.getTempSubfolderPathAsync("input");
+    await this.zipService.extractAsync(input, inputPath);
+    const entries = await this.fileSystem.readdir(inputPath);
+    if (entries.length === 1) {
+      const innerPath = Path3.join(inputPath, entries[0]);
+      const stat = await this.fileSystem.stat(innerPath);
+      if (stat?.isDirectory()) {
+        return innerPath;
+      }
+    }
+    return inputPath;
+  }
+  async restoreProjectAsync(options, cancellationToken) {
+    return await this.executeProjectOperationAsync(options, "Restore", "ProjectPackager.Restore", async (uiPathProject, loadedProject) => {
+      const restoreOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        logLevel: options.logLevel,
+        outputPath: options.outputPath
+      };
+      return await this.projectExecutor.restoreAsync(restoreOptions, uiPathProject, undefined, cancellationToken);
+    }, cancellationToken);
+  }
+  async validateProjectAsync(options, cancellationToken) {
+    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+    const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
+    if (!validationResult.isSuccess) {
+      return validationResult;
+    }
+    return await this.executeProjectOperationAsync(options, "Validate", "ProjectPackager.Validate", async (uiPathProject, loadedProject) => {
+      const validateOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        logLevel: options.logLevel,
+        skipAnalyze: options.validateOptions.skipAnalyze,
+        defaultSeverity: options.validateOptions.defaultSeverity,
+        detailedLogPath: options.detailedLogPath,
+        policyFilePath: options.validateOptions.governanceFilePath,
+        policyFileType: options.validateOptions.governanceFileType
+      };
+      return await this.projectExecutor.validateAsync(validateOptions, uiPathProject, undefined, cancellationToken);
+    }, cancellationToken);
+  }
+  async buildProjectAsync(options, cancellationToken) {
+    await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+    const validationResult = await this.buildOptionsValidator.validateAsync(options, cancellationToken);
+    if (!validationResult.isSuccess) {
+      return validationResult;
+    }
+    return await this.executeProjectOperationAsync(options, "Build", "ProjectPackager.Build", async (uiPathProject, loadedProject) => {
+      if (!options.outputPath) {
+        options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+      }
+      const buildOptions = {
+        projectPath: loadedProject.projectPath,
+        excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+        nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+        logLevel: options.logLevel,
+        skipAnalyze: options.validateOptions.skipAnalyze,
+        skipValidate: false,
+        detailedLogPath: options.detailedLogPath,
+        policyFilePath: options.validateOptions.governanceFilePath,
+        policyFileType: options.validateOptions.governanceFileType,
+        outputPath: options.outputPath,
+        outputType: undefined,
+        projectType: uiPathProject.Type
+      };
+      return await this.projectExecutor.buildAsync(buildOptions, uiPathProject, undefined, cancellationToken);
+    }, cancellationToken);
+  }
+  async packProjectAsync(options, cancellationToken) {
+    return await this.telemetryService.trackRequest("ProjectPackager.Pack", async () => {
+      try {
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        let result = await this.packOptionsValidator.validateAsync(options, cancellationToken);
+        if (!result.isSuccess) {
+          return result;
+        }
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+        }
+        const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+        this.telemetryService.trackEvent("ProjectPackager.ProjectLoaded", { projectId: loadedProject.name });
+        const projectPackOptions = await this.optionsBuilder.buildProjectPackOptions(options, loadedProject);
+        const uiPathProject = {
+          Type: loadedProject.type,
+          ProjectRelativePath: Path3.basename(loadedProject.projectFilePath),
+          ProjectPath: loadedProject.projectPath,
+          Id: loadedProject.name
+        };
+        result = await this.projectExecutor.packAsync(projectPackOptions, uiPathProject, undefined, options.signingInfo, cancellationToken);
+        if (result.isSuccess && result.packages.length > 0) {
+          const destinationPackages = await this.copyPackagesToDestination(result.packages, options.destinationPath, projectPackOptions.package);
+          result = new ToolResult4(ToolErrorCodes4.Success, undefined, destinationPackages);
+        }
+        if (result.isSuccess) {
+          this.logger.info(`Project pack completed successfully. Packages: ${result.packages.join(", ")}`);
+        } else {
+          this.logger.error(`Project pack failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage2}`);
+        return ToolResult4.error(ToolErrorCodes4.InternalError, `Project pack failed: ${errorMessage2}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async getPackageStreamsAsync(result) {
+    if (!result.isSuccess) {
+      throw new Error(translate6.t("solutionpackager.packager.errors.failedToGetStreams", {
+        errorCode: result.errorCode,
+        message: result.message ?? ""
+      }));
+    }
+    if (!result.packages || result.packages.length === 0) {
+      return [];
+    }
+    const packageStreams = [];
+    for (const packagePath of result.packages) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        throw new Error(translate6.t("solutionpackager.packager.errors.failedToReadPackage", {
+          path: packagePath
+        }));
+      }
+      const name = packagePath.split(/[\\/]/).pop() || packagePath;
+      packageStreams.push({ name, data });
+    }
+    return packageStreams;
+  }
+  async executeProjectOperationAsync(options, operationName, telemetryName, operation, _cancellationToken) {
+    return await this.telemetryService.trackRequest(telemetryName, async () => {
+      try {
+        const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+        const uiPathProject = {
+          Type: loadedProject.type,
+          ProjectRelativePath: Path3.basename(loadedProject.projectFilePath),
+          ProjectPath: loadedProject.projectPath,
+          Id: loadedProject.name
+        };
+        const operationResult = await operation(uiPathProject, loadedProject);
+        if (operationResult.isSuccess) {
+          this.logger.info(`Project ${operationName.toLowerCase()} completed successfully.`);
+        } else {
+          this.logger.error(`Project ${operationName.toLowerCase()} failed with error code ${operationResult.errorCode}: ${operationResult.message}`);
+        }
+        return operationResult;
+      } catch (error) {
+        const errorMessage2 = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage2}`);
+        return ToolResult4.error(ToolErrorCodes4.InternalError, `Project ${operationName.toLowerCase()} failed: ${errorMessage2}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async copyPackagesToDestination(packagePaths, destinationPath, packageInfo) {
+    await this.fileSystem.mkdir(destinationPath);
+    const destinationPackages = [];
+    for (const packagePath of packagePaths) {
+      const stat = await this.fileSystem.stat(packagePath);
+      if (stat?.isDirectory()) {
+        const files = await this.fileSystem.readdir(packagePath);
+        const nupkgFiles = files.filter((f) => f.endsWith(".nupkg"));
+        if (nupkgFiles.length > 0) {
+          for (const nupkgFile of nupkgFiles) {
+            const filePath = Path3.join(packagePath, nupkgFile);
+            const destPath = Path3.join(destinationPath, nupkgFile);
+            const data = await this.fileSystem.readFile(filePath);
+            if (!data) {
+              throw new Error(translate6.t("solutionpackager.packager.errors.failedToReadPackage", {
+                path: filePath
+              }));
+            }
+            await this.fileSystem.writeFile(destPath, data);
+            destinationPackages.push(destPath);
+          }
+        } else {
+          const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+          const destPath = Path3.join(destinationPath, nupkgFileName);
+          const packResult = await this.nugetPackager.packAsync(packagePath, packageInfo, destPath);
+          destinationPackages.push(packResult.outputPath);
+        }
+      } else {
+        const fileName = packagePath.split(/[\\/]/).pop() || packagePath;
+        const destPath = Path3.join(destinationPath, fileName);
+        const data = await this.fileSystem.readFile(packagePath);
+        if (!data) {
+          throw new Error(translate6.t("solutionpackager.packager.errors.failedToReadPackage", {
+            path: packagePath
+          }));
+        }
+        await this.fileSystem.writeFile(destPath, data);
+        destinationPackages.push(destPath);
+      }
+    }
+    return destinationPackages;
+  }
+}
+async function createNodeProjectPackager(options) {
+  const factory = new NodeProjectPackagerFactory;
+  return factory.createAsync(options);
+}
+var de_default, en, es_default, es_MX_default, fr_default, ja_default, ko_default, pt_default, pt_BR_default, ro_default, ru_default, tr_default, zh_CN_default, zh_TW_default, zu_default, globalLogHandler = (logMessage) => {
+  const formattedMessage = logMessage.toFormattedString();
+  switch (logMessage.logLevel) {
+    case LogLevel.Debug:
+      console.debug(formattedMessage);
+      break;
+    case LogLevel.Info:
+      console.info(formattedMessage);
+      break;
+    case LogLevel.Warn:
+      console.warn(formattedMessage);
+      break;
+    case LogLevel.Error:
+      console.error(formattedMessage);
+      break;
+  }
+}, RulesConfigFileType, ProjectRestoreOptions, ProjectValidateOptions, ProjectBuildOptions, ProjectPackOptions, TelemetryNames, LICENSE_TYPES, DEFAULT_PROFILE_KEY = "StudioWeb", ACQUIRE_LICENSE_PATH = "/orchestrator_/api/StudioWeb/AcquireLicense", GOVERNANCE_SUBFOLDER = "governance", GOVERNANCE_FILE_NAME = "governance-policy.json", errorMessage = (error) => error instanceof Error ? error.message : String(error), t = (key, params) => translate3.t(`solutionpackager.governance.${key}`, params), ProjectBuildOptionsValidator, ProjectPackOptionsValidator, ProjectValidateOptionsValidator, NodeProjectPackagerFactory;
+var init_node2 = __esm(() => {
+  init_node();
+  init_node();
+  de_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  en = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  es_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  es_MX_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  fr_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  ja_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  ko_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  pt_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  pt_BR_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  ro_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  ru_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  tr_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  zh_CN_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  zh_TW_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  zu_default = {
+    solutionpackager: {
+      projectLoader: {
+        errors: {
+          pathRequired: "Project directory path is required",
+          noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+          readFailed: "Failed to read project file: {path}",
+          invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+        }
+      },
+      validator: {
+        errors: {
+          destinationNotDefined: "Destination path is not defined",
+          governanceRequired: "Governance file path is required when governance file type is not Default",
+          governanceFileInfo: "Unable to get file information: {path}",
+          governanceInvalidFile: "Governance file path is not a valid file: {path}"
+        }
+      },
+      packager: {
+        errors: {
+          failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+          failedToReadPackage: "Failed to read package file: {path}"
+        }
+      },
+      governance: {
+        info: {
+          alreadyProvided: "Governance policy file already provided, skipping download.",
+          saved: "Governance policy saved to {path}",
+          downloading: "Downloading governance policy from {url}",
+          noPolicyFound: "No governance policy found for this configuration.",
+          responseNotJson: "Policy response is not JSON, treating as no policy.",
+          licenseStatus: "AcquireLicense returned {status}, using {fallback}.",
+          licenseResponse: "AcquireLicense: isLicensed={isLicensed}, robotType={robotType}",
+          licenseFailed: "AcquireLicense failed: {error}. Using {fallback}."
+        },
+        errors: {
+          connectionIncomplete: "Connection info incomplete, falling back to Default governance.",
+          failedToGetPolicy: "Failed to download governance policy: {content}",
+          failedToSave: "Failed to save governance policy: {error}. Falling back to Default governance.",
+          failedToDownload: "Failed to download governance policy: {error}. Falling back to Default governance."
+        }
+      },
+      signing: {
+        errors: {
+          dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+        },
+        info: {
+          dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+        }
+      }
+    }
+  };
+  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);
+  ((RulesConfigFileType2) => {
+    RulesConfigFileType2["Default"] = "Default";
+    RulesConfigFileType2["AutomationOps"] = "AutomationOps";
+    RulesConfigFileType2["Studio"] = "Studio";
+  })(RulesConfigFileType ||= {});
+  ProjectRestoreOptions = class ProjectRestoreOptions extends PackagerParameters {
+  };
+  ProjectValidateOptions = class ProjectValidateOptions extends ProjectRestoreOptions {
+    validateOptions = {
+      skipAnalyze: false,
+      governanceFileType: "Default"
+    };
+  };
+  ProjectBuildOptions = class ProjectBuildOptions extends ProjectValidateOptions {
+  };
+  ProjectPackOptions = class ProjectPackOptions extends ProjectBuildOptions {
+    destinationPath;
+    package;
+    signingInfo;
+    packOptions;
+  };
+  ((TelemetryNames2) => {
+    TelemetryNames2["ProjectToolPack"] = "ProjectPackager.Tool.Pack";
+    TelemetryNames2["ProjectToolRestore"] = "ProjectPackager.Tool.Restore";
+    TelemetryNames2["ProjectToolValidate"] = "ProjectPackager.Tool.Validate";
+    TelemetryNames2["ProjectToolBuild"] = "ProjectPackager.Tool.Build";
+    TelemetryNames2["ProjectPackagerPack"] = "ProjectPackager.Pack";
+    TelemetryNames2["ProjectPackagerRestore"] = "ProjectPackager.Restore";
+    TelemetryNames2["ProjectPackagerValidate"] = "ProjectPackager.Validate";
+    TelemetryNames2["ProjectPackagerBuild"] = "ProjectPackager.Build";
+    TelemetryNames2["ProjectPackagerProjectLoaded"] = "ProjectPackager.ProjectLoaded";
+  })(TelemetryNames ||= {});
+  LICENSE_TYPES = {
+    NoLicense: "NoLicense",
+    Development: "Development",
+    Attended: "Attended",
+    Unattended: "Unattended",
+    StudioX: "StudioX",
+    StudioPro: "StudioPro",
+    AutomationKit: "AutomationKit"
+  };
+  ProjectBuildOptionsValidator = class ProjectBuildOptionsValidator extends PackagerParametersValidator {
+    async validateAsync(options, _cancellationToken) {
+      return await this.validateGovernanceOptions(options.validateOptions);
+    }
+  };
+  ProjectPackOptionsValidator = class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator {
+    async validateAsync(options, cancellationToken) {
+      const destinationResult = this.validateDestinationPath(options.destinationPath);
+      if (!destinationResult.isSuccess) {
+        return destinationResult;
+      }
+      return await super.validateAsync(options, cancellationToken);
+    }
+  };
+  ProjectValidateOptionsValidator = class ProjectValidateOptionsValidator extends PackagerParametersValidator {
+    async validateAsync(options, _cancellationToken) {
+      return await this.validateGovernanceOptions(options.validateOptions);
+    }
+  };
+  NodeProjectPackagerFactory = class NodeProjectPackagerFactory extends BaseNodePackagerFactory {
+    async createAsync(config) {
+      const logger = new ToolLogger("ProjectPackagerFactory", "Create");
+      this.configureLanguage(config);
+      this.configureLogHandler(config);
+      logger.info("Creating ProjectPackager instance...");
+      const fileSystem = this.getOrCreateFileSystem(config);
+      const telemetryService = this.getOrCreateTelemetryService(config);
+      const packageSignService = new NodePackageSignService(logger);
+      const projectPackager = new ProjectPackager(fileSystem, telemetryService, packageSignService);
+      this.checkDotnetAvailability(logger);
+      logger.info("ProjectPackager created successfully.");
+      return projectPackager;
+    }
+  };
+});
+
 // ../../node_modules/@uipath/api-workflow-executor/dist/contracts/expression-handler.js
 var require_expression_handler = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -1070,7 +2991,7 @@ var require_localization_service = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.LocalizationService = undefined;
   exports.initLocalization = initLocalization;
-  exports.t = t;
+  exports.t = t2;
   exports.isLanguageSupported = isLanguageSupported;
   var en_json_1 = __importDefault(require_en());
   var de_json_1 = __importDefault(require_de());
@@ -1177,7 +3098,7 @@ var require_localization_service = __commonJS((exports) => {
   async function initLocalization(language = DEFAULT_LANGUAGE) {
     globalInstance = await LocalizationService.create(language);
   }
-  function t(key, values) {
+  function t2(key, values) {
     if (!globalInstance) {
       globalInstance = LocalizationService.createDefault();
     }
@@ -1280,13 +3201,13 @@ var require_workflow_events = __commonJS((exports) => {
 var require_workflow_log_data = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.LogLevel = undefined;
-  var LogLevel;
-  (function(LogLevel2) {
-    LogLevel2["VERBOSE"] = "Verbose";
-    LogLevel2["INFO"] = "Information";
-    LogLevel2["WARN"] = "Warning";
-    LogLevel2["ERROR"] = "Error";
-  })(LogLevel || (exports.LogLevel = LogLevel = {}));
+  var LogLevel4;
+  (function(LogLevel5) {
+    LogLevel5["VERBOSE"] = "Verbose";
+    LogLevel5["INFO"] = "Information";
+    LogLevel5["WARN"] = "Warning";
+    LogLevel5["ERROR"] = "Error";
+  })(LogLevel4 || (exports.LogLevel = LogLevel4 = {}));
 });
 
 // ../../node_modules/@uipath/api-workflow-executor/dist/models/logging/index.js
@@ -1644,8 +3565,8 @@ var require_activity_base = __commonJS((exports) => {
   exports.ActivityBase = undefined;
 
   class ActivityBase {
-    constructor(logger) {
-      this.logger = logger;
+    constructor(logger2) {
+      this.logger = logger2;
     }
   }
   exports.ActivityBase = ActivityBase;
@@ -1663,8 +3584,8 @@ var require_generic_utils = __commonJS((exports) => {
   }
   function getErrorMessage(error) {
     try {
-      const errorMessage = isError(error) ? error.message : error ? typeof error === "object" ? JSON.stringify(error) : String(error) : "Unknown Error";
-      return errorMessage;
+      const errorMessage2 = isError(error) ? error.message : error ? typeof error === "object" ? JSON.stringify(error) : String(error) : "Unknown Error";
+      return errorMessage2;
     } catch (err) {
       console.error("Error getting error message - circular reference or stringify failed");
       return "Unknown Error";
@@ -2686,8 +4607,8 @@ var require_http_utils = __commonJS((exports) => {
       }
     } catch (error) {
       console.error("Error reading response content:", error);
-      const errorMessage = (0, generic_utils_1.getErrorMessage)(error);
-      throw new Error(`Error reading response content: [${mediaType}] - ${errorMessage}`);
+      const errorMessage2 = (0, generic_utils_1.getErrorMessage)(error);
+      throw new Error(`Error reading response content: [${mediaType}] - ${errorMessage2}`);
     }
   };
 });
@@ -2823,8 +4744,8 @@ var require_http_retry_policy = __commonJS((exports) => {
         "timeout",
         "aborted"
       ];
-      const errorMessage = error.message.toLowerCase();
-      return networkErrorPatterns.some((pattern) => errorMessage.includes(pattern.toLowerCase()));
+      const errorMessage2 = error.message.toLowerCase();
+      return networkErrorPatterns.some((pattern) => errorMessage2.includes(pattern.toLowerCase()));
     }
   }
   exports.HttpRetryPolicy = HttpRetryPolicy;
@@ -2836,11 +4757,11 @@ var require_http_retry_utils = __commonJS((exports) => {
   exports.makeHttpRequestWithRetry = undefined;
   var http_utils_1 = require_http_utils();
   var http_retry_policy_1 = require_http_retry_policy();
-  var makeHttpRequestWithRetry = async (url, method, headers, params, body, proxySettings, multipartFormData, timeoutMs, retryConfig, logger, verboseLoggingEnabled) => {
+  var makeHttpRequestWithRetry = async (url, method, headers, params, body, proxySettings, multipartFormData, timeoutMs, retryConfig, logger2, verboseLoggingEnabled) => {
     if (!retryConfig) {
       return (0, http_utils_1.makeHttpRequest)(url, method, headers, params, body, proxySettings, multipartFormData, timeoutMs, verboseLoggingEnabled);
     }
-    logger?.debug(`[Retry] Method: ${method}, RetryConfig provided: ${JSON.stringify(retryConfig)}`);
+    logger2?.debug(`[Retry] Method: ${method}, RetryConfig provided: ${JSON.stringify(retryConfig)}`);
     const config = http_retry_policy_1.HttpRetryPolicy.normalizeRetryConfig(retryConfig);
     let attemptNumber = 0;
     let totalDelayMs = 0;
@@ -2873,7 +4794,7 @@ var require_http_retry_utils = __commonJS((exports) => {
         };
         const decision = http_retry_policy_1.HttpRetryPolicy.shouldRetry(config, context);
         if (!decision.shouldRetry) {
-          logger?.debug(`[Retry] Not retrying: ${decision.reason}`);
+          logger2?.debug(`[Retry] Not retrying: ${decision.reason}`);
           if (attemptNumber > 1 && result.data) {
             const retryInfo = {
               retryCount: attemptNumber - 1,
@@ -2892,9 +4813,9 @@ var require_http_retry_utils = __commonJS((exports) => {
           await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
           totalDelayMs += decision.delayMs;
         }
-        logger?.debug(`[Retry] Retrying in ${decision.delayMs}ms: ${decision.reason}: attempt ${attemptNumber}`);
+        logger2?.debug(`[Retry] Retrying in ${decision.delayMs}ms: ${decision.reason}: attempt ${attemptNumber}`);
       } catch (error) {
-        logger?.error(`Error while making HTTP request attempt ${attemptNumber}: ${error}`);
+        logger2?.error(`Error while making HTTP request attempt ${attemptNumber}: ${error}`);
         const context = {
           attemptNumber,
           error,
@@ -2902,7 +4823,7 @@ var require_http_retry_utils = __commonJS((exports) => {
         };
         const decision = http_retry_policy_1.HttpRetryPolicy.shouldRetry(config, context);
         if (!decision.shouldRetry) {
-          logger?.debug(`[Retry] Not retrying after exception: ${decision.reason}`);
+          logger2?.debug(`[Retry] Not retrying after exception: ${decision.reason}`);
           return {
             success: false,
             error
@@ -2913,7 +4834,7 @@ var require_http_retry_utils = __commonJS((exports) => {
           await new Promise((resolve) => setTimeout(resolve, decision.delayMs));
           totalDelayMs += decision.delayMs;
         }
-        logger?.debug(`[Retry] Retrying in ${decision.delayMs}ms: ${decision.reason}: attempt ${attemptNumber}`);
+        logger2?.debug(`[Retry] Retrying in ${decision.delayMs}ms: ${decision.reason}: attempt ${attemptNumber}`);
       }
     }
   };
@@ -2931,8 +4852,8 @@ var require_http_request_activity = __commonJS((exports) => {
   var http_utils_1 = require_http_utils();
 
   class HttpRequestActivity extends activity_base_1.ActivityBase {
-    constructor(requestDefinition, logger, name) {
-      super(logger);
+    constructor(requestDefinition, logger2, name) {
+      super(logger2);
       this.type = models_1.ActivityType.HttpRequest;
       this.name = models_1.ActivityType.HttpRequest;
       this.properties = requestDefinition.properties;
@@ -3333,16 +5254,16 @@ var require_is_utils = __commonJS((exports) => {
       vendorProcessingTimeMs: isProxyAPIResponse.vendorProcessingTimeMs
     };
     const parsedContent = parsedResponse.content;
-    let errorMessage = "";
+    let errorMessage2 = "";
     if (typeof parsedContent === "string") {
-      errorMessage = parsedContent;
+      errorMessage2 = parsedContent;
     } else if (parsedContent && typeof parsedContent === "object" && "message" in parsedContent) {
-      errorMessage = parsedContent.message;
+      errorMessage2 = parsedContent.message;
     }
     return {
       success: isSuccess,
       data: parsedResponse,
-      error: isSuccess ? undefined : new Error(errorMessage ? `HTTP Status: ${code} - ${errorMessage}` : `HTTP Status: ${code}`)
+      error: isSuccess ? undefined : new Error(errorMessage2 ? `HTTP Status: ${code} - ${errorMessage2}` : `HTTP Status: ${code}`)
     };
   };
   exports.toStandardHttpResponse = toStandardHttpResponse;
@@ -3425,7 +5346,7 @@ var require_is_utils = __commonJS((exports) => {
     return true;
   };
   exports.isPaginationCallRequired = isPaginationCallRequired;
-  var fetchAllPaginatedData = async (requestUrl, initialPageData, maxRecords, queryParameters = {}, method = http_method_1.HttpMethod.GET, headers = {}, useProxyServer = false, proxySettings = undefined, timeoutMs = 30000, retryConfig = undefined, logger) => {
+  var fetchAllPaginatedData = async (requestUrl, initialPageData, maxRecords, queryParameters = {}, method = http_method_1.HttpMethod.GET, headers = {}, useProxyServer = false, proxySettings = undefined, timeoutMs = 30000, retryConfig = undefined, logger2) => {
     const pageDetails = (0, exports.extractPageDetailsIfPresent)(initialPageData);
     let hasMorePages = pageDetails?.hasMorePages || false;
     let nextPageToken = pageDetails?.nextPageToken;
@@ -3439,14 +5360,14 @@ var require_is_utils = __commonJS((exports) => {
         nextPageToken
       }
     };
-    logger.debug(`Starting paginated request with maxRecords: ${maxRecords}`);
+    logger2.debug(`Starting paginated request with maxRecords: ${maxRecords}`);
     while (hasMorePages && allRecords.length < maxRecords) {
       pageCount++;
-      logger.debug(`Fetching page ${pageCount}, current records: ${allRecords.length}, nextPageToken: ${nextPageToken ? "present" : "none"}`);
-      pageResult = await fetchPaginatedPage(requestUrl, nextPageToken, queryParameters, method, headers, useProxyServer, proxySettings, timeoutMs, retryConfig, logger);
+      logger2.debug(`Fetching page ${pageCount}, current records: ${allRecords.length}, nextPageToken: ${nextPageToken ? "present" : "none"}`);
+      pageResult = await fetchPaginatedPage(requestUrl, nextPageToken, queryParameters, method, headers, useProxyServer, proxySettings, timeoutMs, retryConfig, logger2);
       if (!pageResult.success || !pageResult.data) {
-        logger.error(`Pagination request failed on page ${pageCount}: ${pageResult.error?.message || "Unknown error"}`);
-        logger.warn(`Returning ${allRecords.length} already fetched records despite pagination error`);
+        logger2.error(`Pagination request failed on page ${pageCount}: ${pageResult.error?.message || "Unknown error"}`);
+        logger2.warn(`Returning ${allRecords.length} already fetched records despite pagination error`);
         return {
           success: false,
           data: initialPageData,
@@ -3456,19 +5377,19 @@ var require_is_utils = __commonJS((exports) => {
       const { responseData: pageData, hasMorePages: pageHasMore, nextPageToken: pageNextToken } = pageResult.data;
       const pageContent = Array.isArray(pageData.content) ? pageData.content : [];
       allRecords.push(...pageContent);
-      logger.info(`Page ${pageCount} returned ${pageContent.length} records, total so far: ${allRecords.length}, hasMorePages: ${pageHasMore}, nextPageToken: ${pageNextToken ? "present" : "none"}`);
+      logger2.info(`Page ${pageCount} returned ${pageContent.length} records, total so far: ${allRecords.length}, hasMorePages: ${pageHasMore}, nextPageToken: ${pageNextToken ? "present" : "none"}`);
       hasMorePages = pageHasMore && !!pageNextToken;
       nextPageToken = pageNextToken;
       if (allRecords.length >= maxRecords) {
-        logger.debug(`Reached maxRecords limit (${maxRecords}), stopping pagination after ${pageCount} pages`);
+        logger2.debug(`Reached maxRecords limit (${maxRecords}), stopping pagination after ${pageCount} pages`);
         break;
       }
       if (!hasMorePages) {
-        logger.debug(`No more pages available, stopping pagination after ${pageCount} pages`);
+        logger2.debug(`No more pages available, stopping pagination after ${pageCount} pages`);
         break;
       }
     }
-    logger.debug(`Pagination completed. Total pages: ${pageCount}, Total records: ${allRecords.length}`);
+    logger2.debug(`Pagination completed. Total pages: ${pageCount}, Total records: ${allRecords.length}`);
     let finalResponse = pageResult.data?.responseData;
     if (!finalResponse) {
       return {
@@ -3501,12 +5422,12 @@ var require_is_utils = __commonJS((exports) => {
     return cleanedHeaders;
   };
   exports.cleanPaginationHeaders = cleanPaginationHeaders;
-  var fetchPaginatedPage = async (requestUrl, nextPageToken, queryParameters = {}, method = http_method_1.HttpMethod.GET, headers = {}, useProxyServer = false, proxySettings = undefined, timeoutMs = 30000, retryConfig = undefined, logger) => {
+  var fetchPaginatedPage = async (requestUrl, nextPageToken, queryParameters = {}, method = http_method_1.HttpMethod.GET, headers = {}, useProxyServer = false, proxySettings = undefined, timeoutMs = 30000, retryConfig = undefined, logger2) => {
     const queryParams = {
       ...queryParameters,
       ...nextPageToken && { nextPage: nextPageToken }
     };
-    const response = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(requestUrl, method, headers, queryParams, undefined, useProxyServer ? proxySettings : undefined, undefined, timeoutMs, retryConfig, logger);
+    const response = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(requestUrl, method, headers, queryParams, undefined, useProxyServer ? proxySettings : undefined, undefined, timeoutMs, retryConfig, logger2);
     if (!response.success || !response.data) {
       return {
         success: false,
@@ -3723,7 +5644,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
         ...orchestratorHeaders
       };
     }
-    static async preProcessEndpointSpecific(context, orchestratorContext, baseUrl, logger, activityName) {
+    static async preProcessEndpointSpecific(context, orchestratorContext, baseUrl, logger2, activityName) {
       const endpoint = context.properties.endpoint;
       const method = context.properties.method;
       if (OrchestratorUtils.isAssetEndpoint(endpoint)) {
@@ -3733,7 +5654,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
       } else if (OrchestratorUtils.isQueueItemsEndpoint(endpoint)) {
         OrchestratorUtils.processQueueItemsEndpoint(context, orchestratorContext);
       } else if (OrchestratorUtils.isRunJobEndPoint(endpoint, method)) {
-        await OrchestratorUtils.processRunJobEndpoint(context, orchestratorContext, baseUrl, logger, activityName);
+        await OrchestratorUtils.processRunJobEndpoint(context, orchestratorContext, baseUrl, logger2, activityName);
       }
     }
     static processAssetEndpoint(context, orchestratorContext) {
@@ -3757,7 +5678,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
         };
       }
     }
-    static async processRunJobEndpoint(context, orchestratorContext, baseUrl, logger, activityName) {
+    static async processRunJobEndpoint(context, orchestratorContext, baseUrl, logger2, activityName) {
       if (!context.properties.body) {
         context.properties.body = {};
       }
@@ -3768,7 +5689,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
       if (orchestratorContext.source) {
         body.Source = orchestratorContext.source;
       }
-      await OrchestratorUtils.preProcessJobsEndPointRequest(context, baseUrl, logger, activityName);
+      await OrchestratorUtils.preProcessJobsEndPointRequest(context, baseUrl, logger2, activityName);
     }
     static isAssetEndpoint(endpoint) {
       return endpoint.includes(OrchestratorUtils.ASSETS_ENDPOINT);
@@ -3796,19 +5717,19 @@ var require_orchestrator_utils = __commonJS((exports) => {
       const regex = new RegExp(`${pathPrefix}[^\\/\\?#]+`, "g");
       return url.replace(regex, `${pathPrefix}${encodeURIComponent(resourceName)}`);
     }
-    static async postProcessEndPointSpecific(context, response, baseUrl, logger) {
+    static async postProcessEndPointSpecific(context, response, baseUrl, logger2) {
       if (OrchestratorUtils.isRunJobEndPoint(context?.properties?.endpoint, context?.properties?.method) || OrchestratorUtils.isGetJobResultEndPoint(context?.properties?.endpoint, context?.properties?.method)) {
-        return await OrchestratorUtils.postProcessJobsEndpoint(context, response, baseUrl, logger);
+        return await OrchestratorUtils.postProcessJobsEndpoint(context, response, baseUrl, logger2);
       }
       return response;
     }
-    static async postProcessJobsEndpoint(context, response, baseUrl, logger) {
+    static async postProcessJobsEndpoint(context, response, baseUrl, logger2) {
       if (!(0, generic_utils_1.hasProperty)(response?.data?.content, "OutputFile")) {
         return response;
       }
       if (!(0, generic_utils_1.hasProperty)(response?.data?.content, "OrganizationUnitId")) {
         const err = "No OrganizationUnitId found in the Orchestrator response";
-        logger.error(err);
+        logger2.error(err);
         return {
           success: false,
           error: new Error(err)
@@ -3816,7 +5737,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
       }
       const organizationUnitId = response?.data?.content.OrganizationUnitId;
       const outputFileName = response?.data?.content["OutputFile"];
-      let extractedResponse = await OrchestratorUtils.extractOutputFileAndFetchContents(baseUrl, outputFileName, organizationUnitId, context.properties, logger);
+      let extractedResponse = await OrchestratorUtils.extractOutputFileAndFetchContents(baseUrl, outputFileName, organizationUnitId, context.properties, logger2);
       if (!extractedResponse.success) {
         return {
           success: false,
@@ -3870,15 +5791,15 @@ var require_orchestrator_utils = __commonJS((exports) => {
       };
       return { requestUrl, headers };
     }
-    static async extractOutputFileAndFetchContents(baseUrl, outputFileName, organizationUnitId, properties, logger) {
+    static async extractOutputFileAndFetchContents(baseUrl, outputFileName, organizationUnitId, properties, logger2) {
       try {
         const { requestUrl, headers } = OrchestratorUtils.getAttachmentRequestConfig(baseUrl, outputFileName, properties.accessToken, organizationUnitId);
-        const orchestratorAttachmentResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(requestUrl, http_method_1.HttpMethod.GET, headers, undefined, undefined, undefined, undefined, properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger);
+        const orchestratorAttachmentResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(requestUrl, http_method_1.HttpMethod.GET, headers, undefined, undefined, undefined, undefined, properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger2);
         try {
           const uriValidationResult = OrchestratorUtils.validateAndExtractOutputFileUri(orchestratorAttachmentResponse);
           if (!uriValidationResult.success) {
             const err = `Error while validating and extracting URI from Orchestrator response: ${uriValidationResult.error}`;
-            logger.error(err);
+            logger2.error(err);
             return {
               success: false,
               error: new Error(err)
@@ -3887,7 +5808,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
           const uri = uriValidationResult.uri;
           const rawOutputFileResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(uri, http_method_1.HttpMethod.GET, {
             [constants_1.CONTENT_TYPE]: constants_1.APPLICATION_JSON
-          }, undefined, undefined, undefined, undefined, properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger);
+          }, undefined, undefined, undefined, undefined, properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger2);
           const contentValidationResponse = OrchestratorUtils.validateAndExtractContentFromOutputFileUriResponse(rawOutputFileResponse);
           if (contentValidationResponse.success) {
             const parsedContent = OrchestratorUtils.parseJsonOrReturnOriginalObject(contentValidationResponse.content);
@@ -3898,7 +5819,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
           }
         } catch (error) {
           const err = `Error requesting Orchestrator output file URI : ${(0, utils_1.getErrorMessage)(error)}`;
-          logger.error(err);
+          logger2.error(err);
           return {
             success: false,
             error: new Error(err)
@@ -3906,7 +5827,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
         }
       } catch (error) {
         const err = `Error while extracting content from Orchestrator output file: ${(0, utils_1.getErrorMessage)(error)}`;
-        logger.error(err);
+        logger2.error(err);
         return {
           success: false,
           error: new Error(err)
@@ -3917,10 +5838,10 @@ var require_orchestrator_utils = __commonJS((exports) => {
         error: new Error(`Error while extracting content from Orchestrator output file`)
       };
     }
-    static async preProcessJobsEndPointRequest(context, baseUrl, logger, activityName) {
-      await OrchestratorUtils.handleOversizedInputArguments(context, baseUrl, logger, activityName);
+    static async preProcessJobsEndPointRequest(context, baseUrl, logger2, activityName) {
+      await OrchestratorUtils.handleOversizedInputArguments(context, baseUrl, logger2, activityName);
     }
-    static async handleOversizedInputArguments(context, baseUrl, logger, activityName) {
+    static async handleOversizedInputArguments(context, baseUrl, logger2, activityName) {
       if (!context?.properties?.body) {
         return;
       }
@@ -3935,25 +5856,25 @@ var require_orchestrator_utils = __commonJS((exports) => {
       }
       const filename = (0, generic_utils_1.getNewGuid)();
       try {
-        const { attachmentId, blobStorageUrl, uploadHeaders } = await OrchestratorUtils.createOrchestratorAttachmentAndGetUploadMetadata(context, baseUrl, filename, logger, activityName);
-        logger.debug(`[${activityName}] Uploading content to Azure Blob Storage: ${blobStorageUrl}`);
+        const { attachmentId, blobStorageUrl, uploadHeaders } = await OrchestratorUtils.createOrchestratorAttachmentAndGetUploadMetadata(context, baseUrl, filename, logger2, activityName);
+        logger2.debug(`[${activityName}] Uploading content to Azure Blob Storage: ${blobStorageUrl}`);
         const encoder = new TextEncoder;
         const fileContent = encoder.encode(inputString);
-        logger.debug(`[${activityName}] Prepared content bytes for upload (${fileContent.length} bytes)`);
-        const attachmentUploadResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(blobStorageUrl, http_method_1.HttpMethod.PUT, uploadHeaders, undefined, fileContent, undefined, undefined, context.properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger);
+        logger2.debug(`[${activityName}] Prepared content bytes for upload (${fileContent.length} bytes)`);
+        const attachmentUploadResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(blobStorageUrl, http_method_1.HttpMethod.PUT, uploadHeaders, undefined, fileContent, undefined, undefined, context.properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger2);
         if (!attachmentUploadResponse.success) {
           const errorMsg = `Failed to upload content to Azure Blob Storage: ${attachmentUploadResponse.error?.message || "Unknown error"}`;
-          logger.error(`[${activityName}] ${errorMsg}`);
+          logger2.error(`[${activityName}] ${errorMsg}`);
           throw new Error(errorMsg);
         }
-        logger.debug(`[${activityName}] Successfully uploaded content to Azure Blob Storage`);
+        logger2.debug(`[${activityName}] Successfully uploaded content to Azure Blob Storage`);
         context.properties.body = {
           ...body,
           InputFile: attachmentId
         };
         delete context.properties.body.InputArguments;
       } catch (error) {
-        logger.error(`[${activityName}] Error processing large InputArguments: ${error}`);
+        logger2.error(`[${activityName}] Error processing large InputArguments: ${error}`);
         return;
       }
     }
@@ -3970,18 +5891,18 @@ var require_orchestrator_utils = __commonJS((exports) => {
       ].join("/");
       return `${baseUrl}/${path}`;
     }
-    static async createOrchestratorAttachmentAndGetUploadMetadata(context, baseUrl, filename, logger, activityName) {
+    static async createOrchestratorAttachmentAndGetUploadMetadata(context, baseUrl, filename, logger2, activityName) {
       try {
         const url = baseUrl + OrchestratorUtils.ATTACHMENTS_ENDPOINT;
         const attachmentCreationPayload = {
           Name: filename
         };
-        logger.debug(`[${activityName}] Creating attachment: ${filename}`);
+        logger2.debug(`[${activityName}] Creating attachment: ${filename}`);
         const attachmentCreationRequestHeaders = {
           ...context.properties.headers
         };
-        let attachmentCreationResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(url, http_method_1.HttpMethod.POST, attachmentCreationRequestHeaders, undefined, attachmentCreationPayload, context.properties.useProxyServer ? context.properties.proxySettings : undefined, undefined, context.properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger);
-        const attachmentMetadata = OrchestratorUtils.validateAndExtractAttachmentMetadata(attachmentCreationResponse, logger, activityName);
+        let attachmentCreationResponse = await (0, http_retry_utils_1.makeHttpRequestWithRetry)(url, http_method_1.HttpMethod.POST, attachmentCreationRequestHeaders, undefined, attachmentCreationPayload, context.properties.useProxyServer ? context.properties.proxySettings : undefined, undefined, context.properties.timeoutMs || 30000, OrchestratorUtils.DEFAULT_HTTP_RETRY_CONFIG, logger2);
+        const attachmentMetadata = OrchestratorUtils.validateAndExtractAttachmentMetadata(attachmentCreationResponse, logger2, activityName);
         if (!attachmentMetadata.success) {
           throw attachmentMetadata.error;
         }
@@ -3991,14 +5912,14 @@ var require_orchestrator_utils = __commonJS((exports) => {
           uploadHeaders: attachmentMetadata.data.uploadHeaders
         };
       } catch (error) {
-        logger.error(`[${activityName}] Error in createOrchestratorAttachmentAndGetUploadMetadata: ${error}`);
+        logger2.error(`[${activityName}] Error in createOrchestratorAttachmentAndGetUploadMetadata: ${error}`);
         throw error;
       }
     }
-    static validateAndExtractAttachmentMetadata(attachmentCreationResponse, logger, activityName) {
+    static validateAndExtractAttachmentMetadata(attachmentCreationResponse, logger2, activityName) {
       if (!attachmentCreationResponse.success || !attachmentCreationResponse.data) {
         const errorMsg = `Failed to create attachment: ${attachmentCreationResponse.error?.message || "Unknown error"}`;
-        logger.error(`[${activityName}] ${errorMsg}`);
+        logger2.error(`[${activityName}] ${errorMsg}`);
         return {
           success: false,
           data: undefined,
@@ -4007,7 +5928,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
       }
       if (!(0, generic_utils_1.hasProperty)(attachmentCreationResponse.data, "content")) {
         const errorMsg = "Invalid attachment response: missing content";
-        logger.error(`[${activityName}] ${errorMsg}`);
+        logger2.error(`[${activityName}] ${errorMsg}`);
         return {
           success: false,
           data: undefined,
@@ -4017,7 +5938,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
       const content = attachmentCreationResponse.data.content;
       if (!(0, generic_utils_1.hasProperty)(content, "Id") || !(0, generic_utils_1.hasProperty)(content, "BlobFileAccess") || !(0, generic_utils_1.hasProperty)(content.BlobFileAccess, "Uri")) {
         const errorMsg = `Invalid attachment response: missing Id or BlobFileAccess or Uri`;
-        logger.error(`[${activityName}] ${errorMsg}`);
+        logger2.error(`[${activityName}] ${errorMsg}`);
         return {
           success: false,
           data: undefined,
@@ -4035,7 +5956,7 @@ var require_orchestrator_utils = __commonJS((exports) => {
               uploadHeaders[headers.Keys[i]] = headers.Values[i];
             }
           }
-          logger.debug(`[${activityName}] Extracted upload headers from BlobFileAccess Keys/Values: ${JSON.stringify(Object.keys(uploadHeaders))}`);
+          logger2.debug(`[${activityName}] Extracted upload headers from BlobFileAccess Keys/Values: ${JSON.stringify(Object.keys(uploadHeaders))}`);
         }
       }
       return {
@@ -4078,20 +5999,20 @@ var require_orchestrator_request_processor = __commonJS((exports) => {
   var orchestrator_utils_1 = require_orchestrator_utils();
 
   class OrchestratorRequestProcessor extends base_request_processor_1.BaseRequestProcessor {
-    async preHook(context, baseUrl, logger, activityName) {
+    async preHook(context, baseUrl, logger2, activityName) {
       const orchestratorContext = context.properties.connectorContext?.orchestratorContext;
       if (!orchestratorContext) {
         return;
       }
       orchestrator_utils_1.OrchestratorUtils.applyFolderHeaders(context, orchestratorContext);
-      await orchestrator_utils_1.OrchestratorUtils.preProcessEndpointSpecific(context, orchestratorContext, baseUrl, logger, activityName);
+      await orchestrator_utils_1.OrchestratorUtils.preProcessEndpointSpecific(context, orchestratorContext, baseUrl, logger2, activityName);
     }
-    async postHook(context, response, baseUrl, logger) {
+    async postHook(context, response, baseUrl, logger2) {
       const orchestratorContext = context.properties.connectorContext?.orchestratorContext;
       if (!orchestratorContext) {
         return response;
       }
-      response = await orchestrator_utils_1.OrchestratorUtils.postProcessEndPointSpecific(context, response, baseUrl, logger);
+      response = await orchestrator_utils_1.OrchestratorUtils.postProcessEndPointSpecific(context, response, baseUrl, logger2);
       return response;
     }
   }
@@ -4166,8 +6087,8 @@ var require_int_svc_api_request_activity = __commonJS((exports) => {
   var processors_1 = require_processors();
 
   class IntSvcApiRequestActivity extends activity_base_1.ActivityBase {
-    constructor(requestDefinition, logger, name) {
-      super(logger);
+    constructor(requestDefinition, logger2, name) {
+      super(logger2);
       this.type = models_1.ActivityType.IntSvcApiRequest;
       this.name = models_1.ActivityType.IntSvcApiRequest;
       this.INTEGRATION_SERVICE_PATH_PREFIX = "elements_/v3/element/instances";
@@ -4311,7 +6232,7 @@ var require_int_svc_api_request_activity = __commonJS((exports) => {
         }
         await new Promise((resolve) => setTimeout(resolve, interval));
       } while (currentResponse.data.statusCode === 202);
-      function logPollingTimeDetails(logger, success) {
+      function logPollingTimeDetails(logger2, success) {
         const jobRequestToPollStartTime = timeMakingIsRequest - startTime;
         const totalPollingTime = Date.now() - startTime;
         const pollingRequestDurations = pollingRequestDurationsMs.map((duration, index) => {
@@ -4330,7 +6251,7 @@ var require_int_svc_api_request_activity = __commonJS((exports) => {
           pollingRequestDurations
         };
         const logMessage = `[IntSvcApiRequestActivity] Async process polling time details: ${JSON.stringify(asyncProcessPollingTimeDetails)}`;
-        logger.warn(logMessage);
+        logger2.warn(logMessage);
         console.warn(logMessage);
       }
       logPollingTimeDetails(this.logger, true);
@@ -4453,8 +6374,8 @@ var require_int_svc_event_api_request_activity = __commonJS((exports) => {
   };
 
   class IntSvcEventApiRequestActivity extends activity_base_1.ActivityBase {
-    constructor(requestDefinition, logger, name) {
-      super(logger);
+    constructor(requestDefinition, logger2, name) {
+      super(logger2);
       this.type = models_1.ActivityType.IntSvcEventRequest;
       this.name = models_1.ActivityType.IntSvcEventRequest;
       this.INTEGRATION_SERVICE_PATH_PREFIX = "elements_/v3/element/instances";
@@ -4683,8 +6604,8 @@ var require_execute_script_activity = __commonJS((exports) => {
   var local_script_executor_1 = require_local_script_executor();
 
   class ExecuteScriptActivity extends activity_base_1.ActivityBase {
-    constructor(definition, logger, name) {
-      super(logger);
+    constructor(definition, logger2, name) {
+      super(logger2);
       this.type = models_1.ActivityType.ScriptExecution;
       this.name = models_1.ActivityType.ScriptExecution;
       this.properties = definition.properties;
@@ -4982,8 +6903,8 @@ var require_log_message_activity = __commonJS((exports) => {
   var activity_base_1 = require_activity_base();
 
   class LogMessageActivity extends activity_base_1.ActivityBase {
-    constructor(definition, logger, name) {
-      super(logger);
+    constructor(definition, logger2, name) {
+      super(logger2);
       this.type = activities_1.ActivityType.LogMessage;
       this.name = activities_1.ActivityType.LogMessage;
       this.properties = definition.properties;
@@ -5009,14 +6930,14 @@ var require_activity_factory = __commonJS((exports) => {
   var log_message_activity_1 = require_log_message_activity();
   var execute_script_activity_1 = require_execute_script_activity();
   var models_1 = require_models();
-  function ActivityFactory(activityDefinition, logger, name) {
+  function ActivityFactory(activityDefinition, logger2, name) {
     switch (activityDefinition.type) {
       case models_1.ActivityType.HttpRequest:
-        return new http_request_activity_1.HttpRequestActivity(activityDefinition, logger, name);
+        return new http_request_activity_1.HttpRequestActivity(activityDefinition, logger2, name);
       case models_1.ActivityType.ScriptExecution:
-        return new execute_script_activity_1.ExecuteScriptActivity(activityDefinition, logger, name);
+        return new execute_script_activity_1.ExecuteScriptActivity(activityDefinition, logger2, name);
       case models_1.ActivityType.LogMessage:
-        return new log_message_activity_1.LogMessageActivity(activityDefinition, logger, name);
+        return new log_message_activity_1.LogMessageActivity(activityDefinition, logger2, name);
       default:
         throw new Error(`Unsupported step type: ${activityDefinition.type}`);
     }
@@ -5267,9 +7188,9 @@ var require_moment = __commonJS((exports, module) => {
       some = Array.prototype.some;
     } else {
       some = function(fun) {
-        var t = Object(this), len = t.length >>> 0, i;
+        var t2 = Object(this), len = t2.length >>> 0, i;
         for (i = 0;i < len; i++) {
-          if (i in t && fun.call(this, t[i], i, t)) {
+          if (i in t2 && fun.call(this, t2[i], i, t2)) {
             return true;
           }
         }
@@ -8941,7 +10862,7 @@ var require_date_format_utils = __commonJS((exports) => {
   var constants_1 = require_constants2();
 
   class DateFormatUtils {
-    static extractOffsetFromDateExpression(expression, logger) {
+    static extractOffsetFromDateExpression(expression, logger2) {
       if (!expression || typeof expression !== "string") {
         return null;
       }
@@ -8958,17 +10879,17 @@ var require_date_format_utils = __commonJS((exports) => {
         const offset = offsetMatch[0] === constants_1.UTC_TIMEZONE_INDICATOR ? constants_1.DEFAULT_TIMEZONE_OFFSET : offsetMatch[0];
         return offset;
       } catch (error) {
-        logger.error(`${this.LOG_PREFIX}Failed to extract offset from date expression "${expression}": ${error.message}.`);
+        logger2.error(`${this.LOG_PREFIX}Failed to extract offset from date expression "${expression}": ${error.message}.`);
         return null;
       }
     }
-    static formatDate(utcString, mask, offset, logger) {
+    static formatDate(utcString, mask, offset, logger2) {
       if (!utcString || typeof utcString !== "string") {
-        logger.warn(`${this.LOG_PREFIX}UTC string must be a non-empty string. Cannot format date.`);
+        logger2.warn(`${this.LOG_PREFIX}UTC string must be a non-empty string. Cannot format date.`);
         return utcString || "";
       }
       if (!mask || typeof mask !== "string") {
-        logger.warn(`${this.LOG_PREFIX}Mask must be a non-empty string. Returning original UTC string: ${utcString}`);
+        logger2.warn(`${this.LOG_PREFIX}Mask must be a non-empty string. Returning original UTC string: ${utcString}`);
         return utcString;
       }
       try {
@@ -8984,7 +10905,7 @@ var require_date_format_utils = __commonJS((exports) => {
         formatted = formatted.replace(/\[Z\]/g, "Z");
         return formatted;
       } catch (error) {
-        logger.error(`${this.LOG_PREFIX}Failed to format date "${utcString}" with mask "${mask}": ${error.message}. Returning original UTC string.`);
+        logger2.error(`${this.LOG_PREFIX}Failed to format date "${utcString}" with mask "${mask}": ${error.message}. Returning original UTC string.`);
         return utcString;
       }
     }
@@ -9042,20 +10963,20 @@ var require_error_utils = __commonJS((exports) => {
     return !!error && typeof error === "object" && "name" in error && "title" in error && "detail" in error && "type" in error && "status" in error;
   }
   function toErrorString(error) {
-    let errorMessage = "Unknown error";
+    let errorMessage2 = "Unknown error";
     if (isWorkflowError(error)) {
       const title = `${error.name}: ${error.title}`;
       const instance = "instance" in error && error.instance ? `. ${error.instance}` : "";
       const detail = "detail" in error && error.detail ? `. ${error.detail}` : "";
-      errorMessage = `${title}${instance}${detail}`;
+      errorMessage2 = `${title}${instance}${detail}`;
     } else if (!!error && typeof error === "object" && "name" in error && "message" in error) {
       const message = `${error.name}: ${error.message}`;
       const stack = "stack" in error && error.stack ? `. ${error.stack}` : "";
-      errorMessage = `${message}${stack}`;
+      errorMessage2 = `${message}${stack}`;
     } else {
-      errorMessage = (0, api_workflow_commons_1.getErrorMessage)(error);
+      errorMessage2 = (0, api_workflow_commons_1.getErrorMessage)(error);
     }
-    return errorMessage;
+    return errorMessage2;
   }
 });
 
@@ -9124,9 +11045,9 @@ var require_resource_override_resolver = __commonJS((exports) => {
   var constants_1 = require_constants2();
 
   class ResourceOverrideResolver {
-    static getOverriddenValue(workflowConfig, logger, resourceType, propertyName, defaultResourceKey, solutionResourceKey) {
+    static getOverriddenValue(workflowConfig, logger2, resourceType, propertyName, defaultResourceKey, solutionResourceKey) {
       if (!workflowConfig.resourceOverwrites || Object.keys(workflowConfig.resourceOverwrites).length === 0) {
-        logger.info(`Resource overwrites is empty, returning defaultResourceKey: ${defaultResourceKey}`);
+        logger2.info(`Resource overwrites is empty, returning defaultResourceKey: ${defaultResourceKey}`);
         return defaultResourceKey;
       }
       const getResourceOverride = (identifier) => {
@@ -9145,10 +11066,10 @@ var require_resource_override_resolver = __commonJS((exports) => {
       if (resourceOverride) {
         return resourceOverride;
       }
-      logger.info(`No resource overrides found, returning defaultResourceKey: ${defaultResourceKey}`);
+      logger2.info(`No resource overrides found, returning defaultResourceKey: ${defaultResourceKey}`);
       return defaultResourceKey;
     }
-    static getOrchestratorOverrides(workflowConfig, logger, endpoint, pathParameters, bodyParameters) {
+    static getOrchestratorOverrides(workflowConfig, logger2, endpoint, pathParameters, bodyParameters) {
       const resourcePrefix = this.getResourcePrefix(endpoint);
       if (!resourcePrefix) {
         return;
@@ -9157,13 +11078,13 @@ var require_resource_override_resolver = __commonJS((exports) => {
       if (endpoint.includes(constants_1.ORCHESTRATOR_JOBS_ENDPOINT)) {
         resourceParam = bodyParameters?.ReleaseName;
         if (!resourceParam) {
-          logger.info("No ReleaseName found in body parameters for Jobs endpoint orchestrator context resolution");
+          logger2.info("No ReleaseName found in body parameters for Jobs endpoint orchestrator context resolution");
           return;
         }
       } else {
         resourceParam = pathParameters.id;
         if (!resourceParam) {
-          logger.info("No resource path parameter found for orchestrator context resolution");
+          logger2.info("No resource path parameter found for orchestrator context resolution");
           return;
         }
       }
@@ -9180,16 +11101,16 @@ var require_resource_override_resolver = __commonJS((exports) => {
         orchestratorContext = {
           folderKey: workflowConfig.processConfig?.folderKey
         };
-        logger.info(`Fallback orchestrator context: ${JSON.stringify(orchestratorContext)}`);
+        logger2.info(`Fallback orchestrator context: ${JSON.stringify(orchestratorContext)}`);
       }
       if (endpoint.includes(constants_1.ORCHESTRATOR_JOBS_ENDPOINT)) {
         orchestratorContext.source = constants_1.API_WORKFLOW_SOURCE;
       }
       return orchestratorContext;
     }
-    static getPropertyBindings(workflowConfig, logger, eventType) {
+    static getPropertyBindings(workflowConfig, logger2, eventType) {
       if (!workflowConfig.resourceOverwrites || Object.keys(workflowConfig.resourceOverwrites).length === 0) {
-        logger.info(`Resource overwrites is empty, no property bindings for eventType: ${eventType}`);
+        logger2.info(`Resource overwrites is empty, no property bindings for eventType: ${eventType}`);
         return;
       }
       const propertyIdentifier = `Property.${eventType}`;
@@ -9197,7 +11118,7 @@ var require_resource_override_resolver = __commonJS((exports) => {
       if (propertyBindings && typeof propertyBindings === "object") {
         return propertyBindings;
       }
-      logger.info(`No property bindings found for eventType: ${eventType}`);
+      logger2.info(`No property bindings found for eventType: ${eventType}`);
       return;
     }
     static getResourcePrefix(endpoint) {
@@ -10173,8 +12094,8 @@ var require_js_expression_handler = __commonJS((exports) => {
         this.setupWorkerListeners();
         await new Promise((resolve) => setTimeout(resolve, 10));
       } catch (error) {
-        const errorMessage = "Failed to initialize Worker for expression evaluation";
-        console.error(`[JsExpressionHandler] ${errorMessage}:`, error);
+        const errorMessage2 = "Failed to initialize Worker for expression evaluation";
+        console.error(`[JsExpressionHandler] ${errorMessage2}:`, error);
         const workflowError = new utils_1.WorkflowErrorBuilder().fromError(error).setInstance(JsExpressionHandler.INSTANCE_NAME).setTitle((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR)).build();
         throw workflowError;
       }
@@ -10660,10 +12581,10 @@ var require_trace_view_data_formatter = __commonJS((exports) => {
         const workflowError = error;
         const instance = "instance" in error && error.instance ? `${error.instance}: ` : "";
         const detail = "detail" in error && error.detail ? error.detail : "";
-        const errorMessage = `${instance}${detail}`;
+        const errorMessage2 = `${instance}${detail}`;
         spanError = {
           message: workflowError.title,
-          details: errorMessage
+          details: errorMessage2
         };
       } else {
         spanError = {
@@ -10767,10 +12688,10 @@ var require_abstract_task_handler = __commonJS((exports) => {
   var utils_1 = require_utils3();
 
   class AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
       this.workflowConfig = taskHandlerArgs.workflowConfig;
       this.expressionHandler = expressionHandler;
-      this.logger = logger;
+      this.logger = logger2;
       this.taskHandlerArgs = taskHandlerArgs;
     }
     async handleTask(taskName, task, runtimeExpressionArgs) {
@@ -10850,8 +12771,8 @@ var require_script_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class BaseScriptTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, _input) {
       const scriptInput = {};
@@ -10861,11 +12782,11 @@ var require_script_task_handler = __commonJS((exports) => {
   exports.BaseScriptTaskHandler = BaseScriptTaskHandler;
 
   class DefaultScriptTaskHandler extends BaseScriptTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
-    static create(taskHandlerArgs, logger, expressionHandler) {
-      return new DefaultScriptTaskHandler(taskHandlerArgs, logger, expressionHandler);
+    static create(taskHandlerArgs, logger2, expressionHandler) {
+      return new DefaultScriptTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     async executeScript(taskName, task, _input) {
       const scriptConfig = task.run;
@@ -10956,18 +12877,18 @@ var require_debug_manager = __commonJS((exports) => {
     static validateBreakpoints(breakpoints) {
       for (const bp of breakpoints) {
         if (!bp.id?.trim()) {
-          const errorMessage = "Breakpoint ID cannot be empty";
-          console.error(`[DebugManager] ${errorMessage}`);
+          const errorMessage2 = "Breakpoint ID cannot be empty";
+          console.error(`[DebugManager] ${errorMessage2}`);
           throw new Error((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR));
         }
         if (!bp.taskId?.trim()) {
-          const errorMessage = "Task ID cannot be empty";
-          console.error(`[DebugManager] ${errorMessage}`);
+          const errorMessage2 = "Task ID cannot be empty";
+          console.error(`[DebugManager] ${errorMessage2}`);
           throw new Error((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR));
         }
         if (typeof bp.isEnabled !== "boolean") {
-          const errorMessage = "Breakpoint isEnabled must be a boolean";
-          console.error(`[DebugManager] ${errorMessage}`);
+          const errorMessage2 = "Breakpoint isEnabled must be a boolean";
+          console.error(`[DebugManager] ${errorMessage2}`);
           throw new Error((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR));
         }
       }
@@ -11094,13 +13015,13 @@ var require_logging_helper = __commonJS((exports) => {
   var executor_utils_1 = require_executor_utils();
 
   class LoggingHelper {
-    static async logWorkflowData(logger, params) {
+    static async logWorkflowData(logger2, params) {
       const logData = LoggingHelper.buildWorkflowLogData(params.event, params.runtimeExpressionArgs, params.input, params.output, params.details);
-      await logger.logWorkflowEvent(params.event, logData, params.error);
+      await logger2.logWorkflowEvent(params.event, logData, params.error);
     }
-    static async logTaskData(logger, params, expressionHandler) {
+    static async logTaskData(logger2, params, expressionHandler) {
       const logData = await LoggingHelper.buildTaskLogData(params.taskId, params.taskType, params.event, params.runtimeExpressionArgs, expressionHandler, params.input, params.output, params.properties, params.variables, params.displayName, params.shouldPause, params.breakpointId, params.vendorExecutionTimeMs, params.HttpCallMode, params.isUiPathInternalServiceCall);
-      await logger.logTaskEvent(params.event, logData, params.error);
+      await logger2.logTaskEvent(params.event, logData, params.error);
     }
     static buildWorkflowLogData(event, runtimeExpressionArgs, input, output, details) {
       let executionTimeMs = undefined;
@@ -13834,10 +15755,10 @@ var require_isIterable = __commonJS((exports) => {
 var require_isReadableStreamLike = __commonJS((exports) => {
   var __generator = exports && exports.__generator || function(thisArg, body) {
     var _ = { label: 0, sent: function() {
-      if (t[0] & 1)
-        throw t[1];
-      return t[1];
-    }, trys: [], ops: [] }, f, y, t, g;
+      if (t2[0] & 1)
+        throw t2[1];
+      return t2[1];
+    }, trys: [], ops: [] }, f, y, t2, g;
     return g = { next: verb(0), throw: verb(1), return: verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
       return this;
     }), g;
@@ -13851,14 +15772,14 @@ var require_isReadableStreamLike = __commonJS((exports) => {
         throw new TypeError("Generator is already executing.");
       while (_)
         try {
-          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-            return t;
-          if (y = 0, t)
-            op = [op[0] & 2, t.value];
+          if (f = 1, y && (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && !(t2 = t2.call(y, op[1])).done)
+            return t2;
+          if (y = 0, t2)
+            op = [op[0] & 2, t2.value];
           switch (op[0]) {
             case 0:
             case 1:
-              t = op;
+              t2 = op;
               break;
             case 4:
               _.label++;
@@ -13873,25 +15794,25 @@ var require_isReadableStreamLike = __commonJS((exports) => {
               _.trys.pop();
               continue;
             default:
-              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              if (!(t2 = _.trys, t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                 _ = 0;
                 continue;
               }
-              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
                 _.label = op[1];
                 break;
               }
-              if (op[0] === 6 && _.label < t[1]) {
-                _.label = t[1];
-                t = op;
+              if (op[0] === 6 && _.label < t2[1]) {
+                _.label = t2[1];
+                t2 = op;
                 break;
               }
-              if (t && _.label < t[2]) {
-                _.label = t[2];
+              if (t2 && _.label < t2[2]) {
+                _.label = t2[2];
                 _.ops.push(op);
                 break;
               }
-              if (t[2])
+              if (t2[2])
                 _.ops.pop();
               _.trys.pop();
               continue;
@@ -13901,7 +15822,7 @@ var require_isReadableStreamLike = __commonJS((exports) => {
           op = [6, e];
           y = 0;
         } finally {
-          f = t = 0;
+          f = t2 = 0;
         }
       if (op[0] & 5)
         throw op[1];
@@ -14028,10 +15949,10 @@ var require_innerFrom = __commonJS((exports) => {
   };
   var __generator = exports && exports.__generator || function(thisArg, body) {
     var _ = { label: 0, sent: function() {
-      if (t[0] & 1)
-        throw t[1];
-      return t[1];
-    }, trys: [], ops: [] }, f, y, t, g;
+      if (t2[0] & 1)
+        throw t2[1];
+      return t2[1];
+    }, trys: [], ops: [] }, f, y, t2, g;
     return g = { next: verb(0), throw: verb(1), return: verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
       return this;
     }), g;
@@ -14045,14 +15966,14 @@ var require_innerFrom = __commonJS((exports) => {
         throw new TypeError("Generator is already executing.");
       while (_)
         try {
-          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-            return t;
-          if (y = 0, t)
-            op = [op[0] & 2, t.value];
+          if (f = 1, y && (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && !(t2 = t2.call(y, op[1])).done)
+            return t2;
+          if (y = 0, t2)
+            op = [op[0] & 2, t2.value];
           switch (op[0]) {
             case 0:
             case 1:
-              t = op;
+              t2 = op;
               break;
             case 4:
               _.label++;
@@ -14067,25 +15988,25 @@ var require_innerFrom = __commonJS((exports) => {
               _.trys.pop();
               continue;
             default:
-              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              if (!(t2 = _.trys, t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                 _ = 0;
                 continue;
               }
-              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
                 _.label = op[1];
                 break;
               }
-              if (op[0] === 6 && _.label < t[1]) {
-                _.label = t[1];
-                t = op;
+              if (op[0] === 6 && _.label < t2[1]) {
+                _.label = t2[1];
+                t2 = op;
                 break;
               }
-              if (t && _.label < t[2]) {
-                _.label = t[2];
+              if (t2 && _.label < t2[2]) {
+                _.label = t2[2];
                 _.ops.push(op);
                 break;
               }
-              if (t[2])
+              if (t2[2])
                 _.ops.pop();
               _.trys.pop();
               continue;
@@ -14095,7 +16016,7 @@ var require_innerFrom = __commonJS((exports) => {
           op = [6, e];
           y = 0;
         } finally {
-          f = t = 0;
+          f = t2 = 0;
         }
       if (op[0] & 5)
         throw op[1];
@@ -15544,10 +17465,10 @@ var require_fromEventPattern = __commonJS((exports) => {
 var require_generate = __commonJS((exports) => {
   var __generator = exports && exports.__generator || function(thisArg, body) {
     var _ = { label: 0, sent: function() {
-      if (t[0] & 1)
-        throw t[1];
-      return t[1];
-    }, trys: [], ops: [] }, f, y, t, g;
+      if (t2[0] & 1)
+        throw t2[1];
+      return t2[1];
+    }, trys: [], ops: [] }, f, y, t2, g;
     return g = { next: verb(0), throw: verb(1), return: verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
       return this;
     }), g;
@@ -15561,14 +17482,14 @@ var require_generate = __commonJS((exports) => {
         throw new TypeError("Generator is already executing.");
       while (_)
         try {
-          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
-            return t;
-          if (y = 0, t)
-            op = [op[0] & 2, t.value];
+          if (f = 1, y && (t2 = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t2 = y["return"]) && t2.call(y), 0) : y.next) && !(t2 = t2.call(y, op[1])).done)
+            return t2;
+          if (y = 0, t2)
+            op = [op[0] & 2, t2.value];
           switch (op[0]) {
             case 0:
             case 1:
-              t = op;
+              t2 = op;
               break;
             case 4:
               _.label++;
@@ -15583,25 +17504,25 @@ var require_generate = __commonJS((exports) => {
               _.trys.pop();
               continue;
             default:
-              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              if (!(t2 = _.trys, t2 = t2.length > 0 && t2[t2.length - 1]) && (op[0] === 6 || op[0] === 2)) {
                 _ = 0;
                 continue;
               }
-              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              if (op[0] === 3 && (!t2 || op[1] > t2[0] && op[1] < t2[3])) {
                 _.label = op[1];
                 break;
               }
-              if (op[0] === 6 && _.label < t[1]) {
-                _.label = t[1];
-                t = op;
+              if (op[0] === 6 && _.label < t2[1]) {
+                _.label = t2[1];
+                t2 = op;
                 break;
               }
-              if (t && _.label < t[2]) {
-                _.label = t[2];
+              if (t2 && _.label < t2[2]) {
+                _.label = t2[2];
                 _.ops.push(op);
                 break;
               }
-              if (t[2])
+              if (t2[2])
                 _.ops.pop();
               _.trys.pop();
               continue;
@@ -15611,7 +17532,7 @@ var require_generate = __commonJS((exports) => {
           op = [6, e];
           y = 0;
         } finally {
-          f = t = 0;
+          f = t2 = 0;
         }
       if (op[0] & 5)
         throw op[1];
@@ -16473,13 +18394,13 @@ var require_catchError = __commonJS((exports) => {
   var innerFrom_1 = require_innerFrom();
   var OperatorSubscriber_1 = require_OperatorSubscriber();
   var lift_1 = require_lift();
-  function catchError(selector) {
+  function catchError2(selector) {
     return lift_1.operate(function(source, subscriber) {
       var innerSub = null;
       var syncUnsub = false;
       var handledResult;
       innerSub = source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, undefined, undefined, function(err) {
-        handledResult = innerFrom_1.innerFrom(selector(err, catchError(selector)(source)));
+        handledResult = innerFrom_1.innerFrom(selector(err, catchError2(selector)(source)));
         if (innerSub) {
           innerSub.unsubscribe();
           innerSub = null;
@@ -16495,7 +18416,7 @@ var require_catchError = __commonJS((exports) => {
       }
     });
   }
-  exports.catchError = catchError;
+  exports.catchError = catchError2;
 });
 
 // ../../node_modules/rxjs/dist/cjs/internal/operators/scanInternals.js
@@ -20204,8 +22125,8 @@ var require_break_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class BreakTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, input) {
       this.logger.info(`Executing BreakTask: ${taskName}`);
@@ -20253,8 +22174,8 @@ var require_do_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class DoTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(_taskName, task, input) {
       const result = await task_executor_helper_1.TaskExecutorHelper.executeTaskList(task.do, input, this.workflowConfig, this.getRuntimeExpressionArgs(), this.logger, this.expressionHandler, task.variables);
@@ -20276,8 +22197,8 @@ var require_do_while_task_handler = __commonJS((exports) => {
   var MAX_ITERATIONS = 1e4;
 
   class DoWhileTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, previousStepOutput) {
       this.logger.info(`Executing DoWhileTask: ${taskName}`);
@@ -20334,8 +22255,8 @@ var require_for_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class ForTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, previousStepOutput) {
       this.logger.info(`Executing ForTask: ${taskName}`);
@@ -20589,8 +22510,8 @@ var require_task_utils = __commonJS((exports) => {
   }
   var getHttpErrorDetails = (httpResult) => {
     const providerMessage = httpResult?.content?.providerMessage;
-    const errorMessage = httpResult?.content?.message;
-    let details = providerMessage && errorMessage ? `${errorMessage} - ${providerMessage}` : providerMessage || errorMessage;
+    const errorMessage2 = httpResult?.content?.message;
+    let details = providerMessage && errorMessage2 ? `${errorMessage2} - ${providerMessage}` : providerMessage || errorMessage2;
     if (!details) {
       const content = httpResult?.content;
       details = content ? JSON.stringify(content) : "";
@@ -20613,8 +22534,8 @@ var require_http_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class HttpTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, input) {
       let endpoint = task.with?.endpoint;
@@ -20733,10 +22654,10 @@ var require_intsvc_task_handler_util = __commonJS((exports) => {
       headers[constants_1.X_UIPATH_ORIGINATOR] = workflowConfig.source || constants_1.ApiWorkflowJobSource;
       return headers;
     }
-    static resolveConnectionId(task, workflowConfig, logger, bindingKey) {
+    static resolveConnectionId(task, workflowConfig, logger2, bindingKey) {
       const originalConnectionId = typeof task.with?.connectionId === "string" ? task.with.connectionId : "";
       const solutionResourceKey = typeof task.with?.connectionResourceId === "string" ? task.with.connectionResourceId : "";
-      return resource_override_resolver_1.ResourceOverrideResolver.getOverriddenValue(workflowConfig, logger, bindingKey, "ConnectionId", originalConnectionId, solutionResourceKey);
+      return resource_override_resolver_1.ResourceOverrideResolver.getOverriddenValue(workflowConfig, logger2, bindingKey, "ConnectionId", originalConnectionId, solutionResourceKey);
     }
     static getBaseUrl(workflowConfig) {
       if (workflowConfig.automationEdgeFqdn) {
@@ -20744,16 +22665,16 @@ var require_intsvc_task_handler_util = __commonJS((exports) => {
       }
       return workflowConfig.baseUrl;
     }
-    static extractDateFieldsFromConfig(configuration, logger) {
+    static extractDateFieldsFromConfig(configuration, logger2) {
       if (!configuration || typeof configuration !== "string") {
-        logger.warn("Configuration is empty or invalid, no date fields to extract");
+        logger2.warn("Configuration is empty or invalid, no date fields to extract");
         return [];
       }
       try {
         const config = JSON.parse(configuration);
         const inputFields = config?.fieldsContainer?.inputFields;
         if (!Array.isArray(inputFields)) {
-          logger.warn("No input fields found in configuration");
+          logger2.warn("No input fields found in configuration");
           return [];
         }
         const dateFields = inputFields.filter((field) => {
@@ -20767,15 +22688,15 @@ var require_intsvc_task_handler_util = __commonJS((exports) => {
           format: field.format
         }));
         if (dateFields.length > 0) {
-          logger.debug(`Extracted ${dateFields.length} date field(s) from configuration: ${dateFields.map((f) => f.name).join(", ")}`);
+          logger2.debug(`Extracted ${dateFields.length} date field(s) from configuration: ${dateFields.map((f) => f.name).join(", ")}`);
         }
         return dateFields;
       } catch (error) {
-        logger.error(`Failed to parse configuration for date fields: ${error.message}`);
+        logger2.error(`Failed to parse configuration for date fields: ${error.message}`);
         return [];
       }
     }
-    static collectDateFieldOffsets(bodyParameters, queryParameters, logger) {
+    static collectDateFieldOffsets(bodyParameters, queryParameters, logger2) {
       const dateFieldOffsets = new Map;
       const datePattern = /new\s+Date\s*\(/;
       try {
@@ -20787,7 +22708,7 @@ var require_intsvc_task_handler_util = __commonJS((exports) => {
             if (!datePattern.test(value)) {
               continue;
             }
-            const offset = date_format_utils_1.DateFormatUtils.extractOffsetFromDateExpression(value, logger);
+            const offset = date_format_utils_1.DateFormatUtils.extractOffsetFromDateExpression(value, logger2);
             const finalOffset = offset || constants_1.DEFAULT_TIMEZONE_OFFSET;
             dateFieldOffsets.set(fieldName, finalOffset);
           }
@@ -20800,22 +22721,22 @@ var require_intsvc_task_handler_util = __commonJS((exports) => {
             if (!datePattern.test(value)) {
               continue;
             }
-            const offset = date_format_utils_1.DateFormatUtils.extractOffsetFromDateExpression(value, logger);
+            const offset = date_format_utils_1.DateFormatUtils.extractOffsetFromDateExpression(value, logger2);
             const finalOffset = offset || constants_1.DEFAULT_TIMEZONE_OFFSET;
             dateFieldOffsets.set(fieldName, finalOffset);
           }
         }
         return dateFieldOffsets;
       } catch (error) {
-        logger.error(`Failed to collect date field offsets: ${error.message}`);
+        logger2.error(`Failed to collect date field offsets: ${error.message}`);
         return dateFieldOffsets;
       }
     }
-    static formatDateFieldsInParameters(configuration, dateFieldOffsets, queryParameters, bodyParameters, logger) {
+    static formatDateFieldsInParameters(configuration, dateFieldOffsets, queryParameters, bodyParameters, logger2) {
       try {
-        const dateFields = this.extractDateFieldsFromConfig(configuration, logger);
+        const dateFields = this.extractDateFieldsFromConfig(configuration, logger2);
         if (dateFields.length === 0) {
-          logger.warn("No date fields found in configuration, skipping date formatting");
+          logger2.warn("No date fields found in configuration, skipping date formatting");
           return;
         }
         const configLookup = new Map;
@@ -20825,34 +22746,34 @@ var require_intsvc_task_handler_util = __commonJS((exports) => {
         for (const [fieldName, offset] of dateFieldOffsets) {
           const mask = configLookup.get(fieldName);
           if (!mask) {
-            logger.warn(`Field ${fieldName} not found in configuration, skipping`);
+            logger2.warn(`Field ${fieldName} not found in configuration, skipping`);
             continue;
           }
           if (queryParameters && fieldName in queryParameters) {
             const fieldValue = queryParameters[fieldName];
             if (fieldValue && typeof fieldValue.toISOString === "function") {
               const dateValue = fieldValue;
-              const formattedValue = date_format_utils_1.DateFormatUtils.formatDate(dateValue.toISOString(), mask, offset, logger);
+              const formattedValue = date_format_utils_1.DateFormatUtils.formatDate(dateValue.toISOString(), mask, offset, logger2);
               queryParameters[fieldName] = formattedValue;
-              logger.info(`Formatted query param ${fieldName}: ${dateValue.toISOString()} → ${formattedValue} (offset: ${offset}, mask: ${mask})`);
+              logger2.info(`Formatted query param ${fieldName}: ${dateValue.toISOString()} → ${formattedValue} (offset: ${offset}, mask: ${mask})`);
             } else {
-              logger.warn(`Field ${fieldName} is not a Date object, skipping formatting. Value: ${fieldValue}`);
+              logger2.warn(`Field ${fieldName} is not a Date object, skipping formatting. Value: ${fieldValue}`);
             }
           }
           if (bodyParameters && fieldName in bodyParameters) {
             const fieldValue = bodyParameters[fieldName];
             if (fieldValue && typeof fieldValue.toISOString === "function") {
               const dateValue = fieldValue;
-              const formattedValue = date_format_utils_1.DateFormatUtils.formatDate(dateValue.toISOString(), mask, offset, logger);
+              const formattedValue = date_format_utils_1.DateFormatUtils.formatDate(dateValue.toISOString(), mask, offset, logger2);
               bodyParameters[fieldName] = formattedValue;
-              logger.info(`Formatted body param ${fieldName}: ${dateValue.toISOString()} → ${formattedValue} (offset: ${offset}, mask: ${mask})`);
+              logger2.info(`Formatted body param ${fieldName}: ${dateValue.toISOString()} → ${formattedValue} (offset: ${offset}, mask: ${mask})`);
             } else {
-              logger.warn(`Field ${fieldName} is not a Date object, skipping formatting. Value: ${fieldValue}`);
+              logger2.warn(`Field ${fieldName} is not a Date object, skipping formatting. Value: ${fieldValue}`);
             }
           }
         }
       } catch (error) {
-        logger.error(`Error during date formatting: ${error.message}. Skipping date formatting.`);
+        logger2.error(`Error during date formatting: ${error.message}. Skipping date formatting.`);
       }
     }
   }
@@ -20875,8 +22796,8 @@ var require_intsvcs_event_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class IntSvcsEventTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task) {
       let runtimeExpressionArgs = this.getRuntimeExpressionArgs();
@@ -21055,8 +22976,8 @@ var require_intsvcs_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class IntSvcsTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task) {
       let runtimeExpressionArgs = this.getRuntimeExpressionArgs();
@@ -21249,8 +23170,8 @@ var require_raise_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class RaiseTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task) {
       this.logger.debug(`Processing raise task for "${taskName}" with values:`, { error: task.raise?.error?.toString() });
@@ -21295,8 +23216,8 @@ var require_response_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class ResponseTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task) {
       try {
@@ -21336,8 +23257,8 @@ var require_set_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class SetTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task) {
       try {
@@ -21372,8 +23293,8 @@ var require_switch_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class SwitchTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, input) {
       try {
@@ -21387,8 +23308,8 @@ var require_switch_task_handler = __commonJS((exports) => {
         const { caseName, caseTask } = getMatchedCaseTask(matchedCase, taskName);
         if (!this.taskHandlerArgs.workflowResult || !this.taskHandlerArgs.allCurrentLevelTasks || !this.taskHandlerArgs.taskIndexRef) {
           const missingContext = !this.taskHandlerArgs.workflowResult ? "workflowResult" : !this.taskHandlerArgs.allCurrentLevelTasks ? "allCurrentLevelTasks" : "taskIndexRef";
-          const errorMessage = `Missing required switch task context: ${missingContext}`;
-          this.logger.error(errorMessage);
+          const errorMessage2 = `Missing required switch task context: ${missingContext}`;
+          this.logger.error(errorMessage2);
           throw new utils_1.WorkflowErrorBuilder().setType(models_1.WorkflowErrorType.RUNTIME_ERROR).setStatus(models_1.WorkflowErrorStatus.INTERNAL_SERVER_ERROR).setTitle((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR)).build();
         }
         this.taskHandlerArgs.workflowResult.addToWorkflowExecutions(`Switch: ${task.name} > Case: ${caseName}`);
@@ -21422,7 +23343,7 @@ var require_switch_task_handler = __commonJS((exports) => {
     }
   }
   exports.SwitchTaskHandler = SwitchTaskHandler;
-  async function evaluateSwitchCondition(task, previousStepOutput, logger, expressionHandler) {
+  async function evaluateSwitchCondition(task, previousStepOutput, logger2, expressionHandler) {
     if (!task.switch)
       return;
     const switchCases = task.switch;
@@ -21437,18 +23358,18 @@ var require_switch_task_handler = __commonJS((exports) => {
         throw new Error((0, localization_1.t)(localization_1.ErrorKeys.MISSING_WHEN_CONDITION, { caseName }));
       }
       if (await expressionHandler.evaluateConditionExpression(caseDetails.when)) {
-        logger.debug(`Switch case matched: '${caseName}' with expression: ${JSON.stringify(caseDetails.when)}`);
+        logger2.debug(`Switch case matched: '${caseName}' with expression: ${JSON.stringify(caseDetails.when)}`);
         return switchCase;
       }
       if (previousStepOutput && previousStepOutput.content) {
         const contentObject = previousStepOutput.content;
         if (contentObject && await expressionHandler.evaluateConditionExpression(caseDetails.when)) {
-          logger.debug(`Switch case matched in 'content': '${caseName}' with expression: ${JSON.stringify(caseDetails.when)}`);
+          logger2.debug(`Switch case matched in 'content': '${caseName}' with expression: ${JSON.stringify(caseDetails.when)}`);
           return switchCase;
         }
       }
     }
-    logger.debug("No switch case matched, falling back to default case.");
+    logger2.debug("No switch case matched, falling back to default case.");
     return defaultCase;
   }
   function getMatchedCaseTask(matchedCase, stepName) {
@@ -21471,8 +23392,8 @@ var require_try_catch_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class TryCatchTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, input) {
       this.logger.info(`Executing Try: ${taskName}`);
@@ -21526,9 +23447,9 @@ var require_unified_http_task_handler = __commonJS((exports) => {
   var intsvcs_task_handler_1 = require_intsvcs_task_handler();
 
   class UnifiedHttpTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
       this.taskHandlerArgs = taskHandlerArgs;
-      this.logger = logger;
+      this.logger = logger2;
       this.expressionHandler = expressionHandler;
     }
     async handleTask(taskName, task, runtimeExpressionArgs) {
@@ -21594,8 +23515,8 @@ var require_wait_task_handler = __commonJS((exports) => {
   var abstract_task_handler_1 = require_abstract_task_handler();
 
   class WaitTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, _input) {
       try {
@@ -21648,8 +23569,8 @@ var require_while_task_handler = __commonJS((exports) => {
   var MAX_ITERATIONS = 1e4;
 
   class WhileTaskHandler extends abstract_task_handler_1.AbstractTaskHandler {
-    constructor(taskHandlerArgs, logger, expressionHandler) {
-      super(taskHandlerArgs, logger, expressionHandler);
+    constructor(taskHandlerArgs, logger2, expressionHandler) {
+      super(taskHandlerArgs, logger2, expressionHandler);
     }
     async internalHandleTask(taskName, task, previousStepOutput) {
       this.logger.info(`Executing WhileTask: ${taskName}`);
@@ -21743,8 +23664,8 @@ var require_task_invoker = __commonJS((exports) => {
     }
     return taskResult;
   }
-  var invokeTask = async (task, taskName, taskHandlerArgs, runtimeExpressionArgs, stepInput, logger, expressionHandler, customHandlers) => {
-    const handler = getTaskHandler(task, taskHandlerArgs, logger, expressionHandler, customHandlers);
+  var invokeTask = async (task, taskName, taskHandlerArgs, runtimeExpressionArgs, stepInput, logger2, expressionHandler, customHandlers) => {
+    const handler = getTaskHandler(task, taskHandlerArgs, logger2, expressionHandler, customHandlers);
     const taskDescriptor = {
       name: taskName,
       input: stepInput,
@@ -21753,66 +23674,66 @@ var require_task_invoker = __commonJS((exports) => {
     await expressionHandler.setVariables({ $task: taskDescriptor });
     return await handler.handleTask(taskName, task, runtimeExpressionArgs);
   };
-  var getTaskHandler = (task, taskHandlerArgs, logger, expressionHandler, customHandlers) => {
+  var getTaskHandler = (task, taskHandlerArgs, logger2, expressionHandler, customHandlers) => {
     const taskWithBreak = task;
     if (taskWithBreak.break && taskWithBreak.then === constants_1.EXIT) {
-      return new break_task_handler_1.BreakTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new break_task_handler_1.BreakTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.call) {
       if ((0, task_utils_1.isUnifiedHttpTask)(task)) {
-        return new unified_http_task_handler_1.UnifiedHttpTaskHandler(taskHandlerArgs, logger, expressionHandler);
+        return new unified_http_task_handler_1.UnifiedHttpTaskHandler(taskHandlerArgs, logger2, expressionHandler);
       } else if ((0, task_utils_1.isIntSvcTask)(task)) {
-        return new intsvcs_task_handler_1.IntSvcsTaskHandler(taskHandlerArgs, logger, expressionHandler);
+        return new intsvcs_task_handler_1.IntSvcsTaskHandler(taskHandlerArgs, logger2, expressionHandler);
       } else if ((0, task_utils_1.isIntSvcEventTask)(task)) {
-        return new intsvcs_event_task_handler_1.IntSvcsEventTaskHandler(taskHandlerArgs, logger, expressionHandler);
+        return new intsvcs_event_task_handler_1.IntSvcsEventTaskHandler(taskHandlerArgs, logger2, expressionHandler);
       } else {
-        return new http_task_handler_1.HttpTaskHandler(taskHandlerArgs, logger, expressionHandler);
+        return new http_task_handler_1.HttpTaskHandler(taskHandlerArgs, logger2, expressionHandler);
       }
     }
     if (task.run) {
       const customScriptHandler = customHandlers?.[models_1.TaskType.SCRIPT];
       if (customScriptHandler) {
-        return customScriptHandler(taskHandlerArgs, logger, expressionHandler);
+        return customScriptHandler(taskHandlerArgs, logger2, expressionHandler);
       }
-      return script_task_handler_1.DefaultScriptTaskHandler.create(taskHandlerArgs, logger, expressionHandler);
+      return script_task_handler_1.DefaultScriptTaskHandler.create(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.set !== undefined && !(0, task_utils_1.isResponseTask)(task)) {
-      return new set_task_handler_1.SetTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new set_task_handler_1.SetTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.try) {
-      return new try_catch_task_handler_1.TryCatchTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new try_catch_task_handler_1.TryCatchTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.for && task.do) {
       if (task.while) {
         const forLoop = task.for;
         if (forLoop.each) {
-          return new for_task_handler_1.ForTaskHandler(taskHandlerArgs, logger, expressionHandler);
+          return new for_task_handler_1.ForTaskHandler(taskHandlerArgs, logger2, expressionHandler);
         } else {
-          return new while_task_handler_1.WhileTaskHandler(taskHandlerArgs, logger, expressionHandler);
+          return new while_task_handler_1.WhileTaskHandler(taskHandlerArgs, logger2, expressionHandler);
         }
       } else if (task.doWhile) {
-        return new do_while_task_handler_1.DoWhileTaskHandler(taskHandlerArgs, logger, expressionHandler);
+        return new do_while_task_handler_1.DoWhileTaskHandler(taskHandlerArgs, logger2, expressionHandler);
       } else {
-        return new for_task_handler_1.ForTaskHandler(taskHandlerArgs, logger, expressionHandler);
+        return new for_task_handler_1.ForTaskHandler(taskHandlerArgs, logger2, expressionHandler);
       }
     }
     if (task.do) {
-      return new do_task_handler_1.DoTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new do_task_handler_1.DoTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.raise) {
-      return new raise_task_handler_1.RaiseTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new raise_task_handler_1.RaiseTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.switch) {
       if (!taskHandlerArgs.allCurrentLevelTasks || !taskHandlerArgs.taskIndexRef || !taskHandlerArgs.workflowResult) {
-        logger.error("Switch task handler missing required context: allCurrentLevelTasks, taskIndexRef, or workflowResult");
+        logger2.error("Switch task handler missing required context: allCurrentLevelTasks, taskIndexRef, or workflowResult");
         throw new utils_1.WorkflowErrorBuilder().setType(models_1.WorkflowErrorType.RUNTIME_ERROR).setStatus(models_1.WorkflowErrorStatus.INTERNAL_SERVER_ERROR).setTitle((0, localization_1.t)(localization_1.ErrorKeys.FAILED_SWITCH_TASK, { taskName: "switch" })).build();
       }
-      return new switch_task_handler_1.SwitchTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new switch_task_handler_1.SwitchTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     if (task.wait) {
-      return new wait_task_handler_1.WaitTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new wait_task_handler_1.WaitTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     } else if ((0, task_utils_1.isResponseTask)(task)) {
-      return new response_task_handler_1.ResponseTaskHandler(taskHandlerArgs, logger, expressionHandler);
+      return new response_task_handler_1.ResponseTaskHandler(taskHandlerArgs, logger2, expressionHandler);
     }
     throw new utils_1.WorkflowErrorBuilder().setType(models_1.WorkflowErrorType.VALIDATION_ERROR).setStatus(models_1.WorkflowErrorStatus.BAD_REQUEST).setTitle((0, localization_1.t)(localization_1.ErrorKeys.UNSUPPORTED_TASK_TYPE)).setDetail((0, localization_1.t)(localization_1.ErrorKeys.UNSUPPORTED_TASK_TYPE_DETAIL, { taskType: String(task.type || "unknown") })).build();
   };
@@ -21836,7 +23757,7 @@ var require_task_executor_helper = __commonJS((exports) => {
   var utils_2 = require_utils3();
 
   class TaskExecutorHelper {
-    static async executeTaskList(taskList, previousStepOutput, workflowConfig, runtimeExpressionArgs, logger, expressionHandler, workFlowTaskVariables) {
+    static async executeTaskList(taskList, previousStepOutput, workflowConfig, runtimeExpressionArgs, logger2, expressionHandler, workFlowTaskVariables) {
       let result = { success: true, data: {} };
       if (!taskList || taskList.length === 0) {
         return result;
@@ -21851,7 +23772,7 @@ var require_task_executor_helper = __commonJS((exports) => {
           continue;
         }
         const workflowExecutionResults = serverless_workflow_executor_1.ServerlessWorkflowExecutor.getExecutor(runtimeExpressionArgs.$runtime.metadata.workflowRunId).workflowExecutionResults;
-        result = await this.executeFlowTask(taskToRun, taskList, previousStepOutput, taskIndexRef, workflowConfig, runtimeExpressionArgs, workflowExecutionResults, logger, expressionHandler, workFlowTaskVariables);
+        result = await this.executeFlowTask(taskToRun, taskList, previousStepOutput, taskIndexRef, workflowConfig, runtimeExpressionArgs, workflowExecutionResults, logger2, expressionHandler, workFlowTaskVariables);
         const lastExecutedStep = TaskExecutorHelper.readAsExtendedTask(taskList[taskIndexRef.value]);
         if (!result.success) {
           if ((0, utils_1.isWorkflowError)(result.error)) {
@@ -21860,11 +23781,11 @@ var require_task_executor_helper = __commonJS((exports) => {
           throw new utils_1.WorkflowErrorBuilder().fromError(result.error).setTitle((0, localization_1.t)(localization_1.ErrorKeys.UNKNOWN_TASK_ERROR, { taskName: lastExecutedStep.name })).setData({ taskName: lastExecutedStep.name, result }).build();
         }
         if (runtimeExpressionArgs.$runtime.control?.signalWorkflowEnd) {
-          logger.debug(`TaskExecutorHelper.executeTaskList: signalWorkflowEnd detected after processing task '${lastExecutedStep.name}'. Halting current task list.`);
+          logger2.debug(`TaskExecutorHelper.executeTaskList: signalWorkflowEnd detected after processing task '${lastExecutedStep.name}'. Halting current task list.`);
           return result;
         }
         if (runtimeExpressionArgs.$runtime.control?.signalLoopExit === true) {
-          logger.debug(`TaskExecutorHelper.executeTaskList: signalLoopExit detected after processing task '${lastExecutedStep.name}'. Halting current task list execution.`);
+          logger2.debug(`TaskExecutorHelper.executeTaskList: signalLoopExit detected after processing task '${lastExecutedStep.name}'. Halting current task list execution.`);
           return result;
         }
         if (result.success && result.data) {
@@ -21880,10 +23801,10 @@ var require_task_executor_helper = __commonJS((exports) => {
               return result;
             }
           } else {
-            const nextTaskIndex = taskList.findIndex((t) => TaskExecutorHelper.readAsExtendedTask(t).name === lastExecutedStep.then);
+            const nextTaskIndex = taskList.findIndex((t2) => TaskExecutorHelper.readAsExtendedTask(t2).name === lastExecutedStep.then);
             if (nextTaskIndex === -1) {
-              const errorMessage = `Invalid transition from task '${lastExecutedStep.name}': Next task '${lastExecutedStep.then}' not found`;
-              logger.error(errorMessage);
+              const errorMessage2 = `Invalid transition from task '${lastExecutedStep.name}': Next task '${lastExecutedStep.then}' not found`;
+              logger2.error(errorMessage2);
               throw new utils_1.WorkflowErrorBuilder().setType(models_1.WorkflowErrorType.RUNTIME_ERROR).setStatus(models_1.WorkflowErrorStatus.INTERNAL_SERVER_ERROR).setTitle((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR)).setData({
                 taskName: lastExecutedStep.name,
                 nextTask: lastExecutedStep.then,
@@ -21924,7 +23845,7 @@ var require_task_executor_helper = __commonJS((exports) => {
       }
       return;
     }
-    static async executeFlowTask(currentTask, allCurrentLevelTasks, previousStepOutput, taskIndexRef, workflowConfig, runtimeExpressionArgs, workflowResult, logger, expressionHandler, workFlowTaskVariables) {
+    static async executeFlowTask(currentTask, allCurrentLevelTasks, previousStepOutput, taskIndexRef, workflowConfig, runtimeExpressionArgs, workflowResult, logger2, expressionHandler, workFlowTaskVariables) {
       const task = TaskExecutorHelper.readAsExtendedTask(currentTask, workFlowTaskVariables);
       let result = { success: true, data: {} };
       try {
@@ -21947,14 +23868,14 @@ var require_task_executor_helper = __commonJS((exports) => {
             const resumeCommand$ = executor2?.commandStream$?.pipe((0, rxjs_1.filter)((command) => command.command === models_1.WorkflowCommandEvent.Resume));
             const resumeCommandPromise = (0, rxjs_1.firstValueFrom)(resumeCommand$ ?? rxjs_1.EMPTY);
             console.debug(`Paused on: ${task.name} [breakpoint: ${breakpointId}], waiting for command to continue...`);
-            await logging_helper_1.LoggingHelper.logTaskData(logger, taskLogParams, expressionHandler);
+            await logging_helper_1.LoggingHelper.logTaskData(logger2, taskLogParams, expressionHandler);
             await resumeCommandPromise;
             console.debug(`Resume command received on: ${task.name} [breakpoint:${breakpointId}], continuing...`);
           } else {
-            await logging_helper_1.LoggingHelper.logTaskData(logger, taskLogParams, expressionHandler);
+            await logging_helper_1.LoggingHelper.logTaskData(logger2, taskLogParams, expressionHandler);
           }
         } else {
-          await logging_helper_1.LoggingHelper.logTaskData(logger, taskLogParams, expressionHandler);
+          await logging_helper_1.LoggingHelper.logTaskData(logger2, taskLogParams, expressionHandler);
         }
         workflowResult.addToWorkflowExecutions(task.name);
         const taskHandlerArgs = this.setupTaskHandlerArgs(workflowConfig, allCurrentLevelTasks, taskIndexRef, workflowResult);
@@ -21965,7 +23886,7 @@ var require_task_executor_helper = __commonJS((exports) => {
           taskHandlerArgs,
           runtimeExpressionArgs,
           taskInput: previousStepOutput,
-          logger,
+          logger: logger2,
           expressionHandler,
           customTaskHandlerFactories: executor?.customTaskHandlerFactories
         });
@@ -21975,7 +23896,7 @@ var require_task_executor_helper = __commonJS((exports) => {
         }
         const taskData = task.raise ? result.error.toObject() : result.data;
         const isUiPathInternalServiceCall = this.detectUiPathInternalServiceCall(task, result.resolvedProperties);
-        await logging_helper_1.LoggingHelper.logTaskData(logger, {
+        await logging_helper_1.LoggingHelper.logTaskData(logger2, {
           taskId: task.name,
           taskType: (0, task_utils_1.getTaskType)(task),
           displayName: task.metadata?.displayName,
@@ -22003,7 +23924,7 @@ var require_task_executor_helper = __commonJS((exports) => {
         const workflowError = builder.build();
         const eventToLog = isErrorOriginatingTask ? models_1.TaskEvent.TASK_FAILED : models_1.TaskEvent.TASK_STOPPED;
         const isUiPathInternalServiceCall = this.detectUiPathInternalServiceCall(task, result.resolvedProperties);
-        await logging_helper_1.LoggingHelper.logTaskData(logger, {
+        await logging_helper_1.LoggingHelper.logTaskData(logger2, {
           taskId: task.name,
           taskType: (0, task_utils_1.getTaskType)(task),
           displayName: task.metadata?.displayName,
@@ -22045,13 +23966,13 @@ var require_serverless_workflow_executor = __commonJS((exports) => {
   var task_executor_helper_1 = require_task_executor_helper();
 
   class ServerlessWorkflowExecutor {
-    constructor(workflow, workflowConfig, logger, options, workflowRunId, input) {
+    constructor(workflow, workflowConfig, logger2, options, workflowRunId, input) {
       this.workflowStartedAt = undefined;
       this.customTaskHandlerFactories = {};
       this.commandStream$ = undefined;
       this.workflowStartedAt = new Date;
       this.workflow = workflow;
-      this.logger = logger;
+      this.logger = logger2;
       this.workflowConfig = workflowConfig;
       this.workflowRunId = workflowRunId || (0, api_workflow_commons_1.getNewGuid)();
       this.workflowExecutionResults = new models_1.WorkflowExecutionResults(this.workflowRunId, workflowConfig.debugConfig?.enableTaskTracking === true);
@@ -22063,17 +23984,17 @@ var require_serverless_workflow_executor = __commonJS((exports) => {
       return ServerlessWorkflowExecutor.workflowExecutorMap.get(workflowRunId);
     }
     static async execute(workflow, workflowConfig, input, options, workflowRunId) {
-      const logger = options?.logger ?? default_logger_1.defaultLogger;
+      const logger2 = options?.logger ?? default_logger_1.defaultLogger;
       await (0, localization_1.initLocalization)(workflowConfig.languageCode);
       let executor = null;
       let commandSubscription = null;
       try {
-        executor = new ServerlessWorkflowExecutor(workflow, workflowConfig, logger, options, workflowRunId, input);
+        executor = new ServerlessWorkflowExecutor(workflow, workflowConfig, logger2, options, workflowRunId, input);
         ServerlessWorkflowExecutor.workflowExecutorMap.set(executor.workflowRunId, executor);
         if (workflowConfig.debugConfig?.runInDebugMode) {
           if (!options?.commandStream$) {
-            const errorMessage = "$commandStream is required in WorkflowExecutorOptions when debug mode is enabled";
-            logger.error(errorMessage);
+            const errorMessage2 = "$commandStream is required in WorkflowExecutorOptions when debug mode is enabled";
+            logger2.error(errorMessage2);
             throw new Error((0, localization_1.t)(localization_1.ErrorKeys.INTERNAL_ERROR));
           }
           executor.commandStream$ = options.commandStream$;
@@ -22091,11 +24012,11 @@ var require_serverless_workflow_executor = __commonJS((exports) => {
         const signalJobFailure = workflowResult.success === false || responseTaskSignal?.signalJobFailure === true;
         const response = workflowResult.success === false ? workflowResult.error : isResponseStepExecuted ? workflowResult.data : undefined;
         const workflowResponse = new models_1.WorkflowResponse(signalJobFailure, response);
-        await logger.shutdown();
+        await logger2.shutdown();
         return workflowResponse;
       } catch (error) {
-        logger?.error("Workflow execution failed", undefined, error instanceof Error ? error : new Error((0, api_workflow_commons_1.getErrorMessage)(error)));
-        await logger.shutdown();
+        logger2?.error("Workflow execution failed", undefined, error instanceof Error ? error : new Error((0, api_workflow_commons_1.getErrorMessage)(error)));
+        await logger2.shutdown();
         const workflowError = (0, utils_1.isWorkflowError)(error) ? error : new utils_1.WorkflowErrorBuilder().fromError(error).setTitle((0, localization_1.t)(localization_1.ErrorKeys.WORKFLOW_EXECUTION_FAILED)).build();
         throw workflowError;
       } finally {
@@ -22214,7 +24135,7 @@ import"./packager-tool.js";
 // package.json
 var package_default = {
   name: "@uipath/api-workflow-tool",
-  version: "0.1.12",
+  version: "0.1.14",
   description: "Run UiPath API Workflows locally.",
   private: false,
   repository: {
@@ -22248,36 +24169,174 @@ var package_default = {
   },
   peerDependencies: {
     commander: "^14.0.3",
-    "@uipath/common": "^0.1.12",
+    "@uipath/common": "^0.1.13",
     "@uipath/auth": "^0.1.9",
     "@uipath/filesystem": "^0.1.6",
     "@uipath/solutionpackager-tool-core": "workspace:*"
   },
   devDependencies: {
     "@uipath/packager-tool-apiworkflow": "workspace:*",
+    "@uipath/project-packager": "workspace:*",
     "@types/node": "^25.5.0",
     typescript: "^5"
   }
 };
 
-// src/commands/run.ts
+// src/commands/build.ts
 import { processContext } from "@uipath/common";
 
-// src/services/workflow-run-service.ts
-var import_api_workflow_executor2 = __toESM(require_dist2(), 1);
-import { getLoginStatusAsync } from "@uipath/auth";
+// src/commands/packager-shared.ts
 import {
   catchError,
   FailureOutput,
-  logger as logger2,
+  LogLevel as LogLevel3,
+  logger,
   OutputFormatter,
   SuccessOutput
 } from "@uipath/common";
 import { getFileSystem } from "@uipath/filesystem";
+import {
+  LogLevel as SdkLogLevel
+} from "@uipath/solutionpackager-tool-core";
+var fs = getFileSystem();
+async function createPackager() {
+  const { createNodeProjectPackager: createNodeProjectPackager2 } = await Promise.resolve().then(() => (init_node2(), exports_node));
+  return await createNodeProjectPackager2({
+    logHandler: logger.handleLog
+  });
+}
+async function setupProject(packager, projectPath) {
+  const absPath = fs.path.resolve(projectPath);
+  const stats = await fs.stat(absPath);
+  if (!stats)
+    throw new Error(`Path not found: ${absPath}`);
+  if (stats.isFile() && !absPath.endsWith(".uip")) {
+    throw new Error(`Unsupported file type: ${absPath}. Provide a .uip file or a project directory.`);
+  }
+  if (stats.isFile() && absPath.endsWith(".uip")) {
+    const data = await fs.readFile(absPath);
+    if (!data)
+      throw new Error(`Failed to read file: ${absPath}`);
+    return packager.setupAsync(new Uint8Array(data));
+  }
+  return packager.setupAsync(absPath);
+}
+async function buildBaseOptions() {
+  const { ProjectPackOptions: ProjectPackOptions2 } = await Promise.resolve().then(() => (init_node2(), exports_node));
+  const sdkLogLevelMap = {
+    [LogLevel3.DEBUG]: SdkLogLevel.Debug,
+    [LogLevel3.INFO]: SdkLogLevel.Info,
+    [LogLevel3.WARN]: SdkLogLevel.Warn,
+    [LogLevel3.ERROR]: SdkLogLevel.Error
+  };
+  const options = new ProjectPackOptions2;
+  options.logLevel = sdkLogLevelMap[logger.getLevel()] ?? SdkLogLevel.Error;
+  return options;
+}
+function formatError(label, hint, error) {
+  OutputFormatter.error(new FailureOutput(`${label} failed`, error.message, hint));
+}
+async function runPackagerCommand(opts, config) {
+  const [packagerError, packager] = await catchError(createPackager());
+  if (packagerError) {
+    formatError(config.label, config.hint, packagerError);
+    return false;
+  }
+  const [setupError, inputPath] = await catchError(setupProject(packager, opts.projectPath));
+  if (setupError) {
+    formatError(config.label, config.hint, setupError);
+    return false;
+  }
+  const [optsError, options] = await catchError(buildBaseOptions());
+  if (optsError) {
+    formatError(config.label, config.hint, optsError);
+    return false;
+  }
+  options.inputPath = inputPath;
+  const [execError, result] = await catchError(config.execute(packager, options, opts));
+  if (execError) {
+    formatError(config.label, config.hint, execError);
+    return false;
+  }
+  if (result.isSuccess) {
+    const data = config.formatSuccess?.(result) ?? { Success: true };
+    OutputFormatter.success(new SuccessOutput(config.label, data));
+    return true;
+  }
+  OutputFormatter.error(new FailureOutput(`${config.label} failed`, result.message ?? (result.errorCode ? `Error code: ${result.errorCode}` : "Unknown error"), config.hint));
+  return false;
+}
+
+// src/commands/build.ts
+var registerBuildCommand = (program) => {
+  program.command("build").description("Build (compile) an API Workflow project").argument("<projectPath>", "Path to the API Workflow project directory or .uip file").trackedAction(processContext, async (projectPath, opts) => {
+    opts.projectPath = projectPath;
+    const success = await runPackagerCommand(opts, {
+      label: "ApiWorkflowBuild",
+      hint: "Check project path and build configuration.",
+      execute: async (packager, options) => {
+        return packager.buildProjectAsync(options);
+      }
+    });
+    if (!success)
+      processContext.exit(1);
+  });
+};
+
+// src/commands/pack.ts
+import { processContext as processContext2 } from "@uipath/common";
+var registerPackCommand = (program) => {
+  program.command("pack").description("Build and package an API Workflow project into a .nupkg").argument("<projectPath>", "Path to the API Workflow project directory or .uip file").argument("<destinationPath>", "Directory where .nupkg is written").option("--package-id <id>", "NuGet package ID").option("--package-version <version>", "NuGet package version").option("--package-author <author>", "NuGet package author").option("--package-description <desc>", "NuGet package description").option("--signing-certificate-path <path>", "Path to .pfx certificate file").option("--signing-certificate-password <password>", "Certificate password").option("--signing-timestamp-server <url>", "Timestamp server URL").trackedAction(processContext2, async (projectPath, destinationPath, opts) => {
+    opts.projectPath = projectPath;
+    opts.destinationPath = destinationPath;
+    const success = await runPackagerCommand(opts, {
+      label: "ApiWorkflowPack",
+      hint: "Check project path and pack configuration.",
+      execute: async (packager, options, opts2) => {
+        options.destinationPath = opts2.destinationPath;
+        options.package = {
+          id: opts2.packageId ?? "",
+          version: opts2.packageVersion ?? "",
+          author: opts2.packageAuthor,
+          description: opts2.packageDescription
+        };
+        if (opts2.signingCertificatePath) {
+          options.signingInfo = {
+            certificatePath: opts2.signingCertificatePath,
+            certificatePassword: opts2.signingCertificatePassword,
+            timestampServer: opts2.signingTimestampServer
+          };
+        }
+        return packager.packProjectAsync(options);
+      },
+      formatSuccess: (result) => ({
+        Success: true,
+        Packages: result.packages
+      })
+    });
+    if (!success)
+      processContext2.exit(1);
+  });
+};
+
+// src/commands/run.ts
+import { processContext as processContext3 } from "@uipath/common";
+
+// src/services/workflow-run-service.ts
+var import_api_workflow_executor2 = __toESM(require_dist2(), 1);
+import { getLoginStatusAsync } from "@uipath/auth";
+import {
+  catchError as catchError2,
+  FailureOutput as FailureOutput2,
+  logger as logger3,
+  OutputFormatter as OutputFormatter2,
+  SuccessOutput as SuccessOutput2
+} from "@uipath/common";
+import { getFileSystem as getFileSystem2 } from "@uipath/filesystem";
 
 // src/services/console-logger.ts
 var import_api_workflow_executor = __toESM(require_dist2(), 1);
-import { logger } from "@uipath/common";
+import { logger as logger2 } from "@uipath/common";
 var SYMBOLS = {
   started: "▶",
   completed: "✓",
@@ -22299,15 +24358,15 @@ function createConsoleLogger() {
       const timestamp = data.timestamp.toISOString();
       switch (event) {
         case import_api_workflow_executor.WorkflowEvent.WORKFLOW_STARTED:
-          logger.info(`
+          logger2.info(`
 [${timestamp}] Workflow started`);
           break;
         case import_api_workflow_executor.WorkflowEvent.WORKFLOW_COMPLETED:
-          logger.info(`
+          logger2.info(`
 [${timestamp}] Workflow completed${data.executionTimeMs ? ` (${data.executionTimeMs}ms)` : ""}`);
           break;
         case import_api_workflow_executor.WorkflowEvent.WORKFLOW_FAILED:
-          logger.error(`
+          logger2.error(`
 [${timestamp}] Workflow failed: ${error?.message ?? "Unknown error"}`);
           break;
       }
@@ -22319,16 +24378,16 @@ function createConsoleLogger() {
       switch (event) {
         case import_api_workflow_executor.TaskEvent.TASK_STARTED:
           startTimes.set(data.taskId, Date.now());
-          logger.info(`  ${SYMBOLS.started} ${label} ${displayName}`);
+          logger2.info(`  ${SYMBOLS.started} ${label} ${displayName}`);
           break;
         case import_api_workflow_executor.TaskEvent.TASK_COMPLETED:
-          logger.info(`  ${SYMBOLS.completed} ${label} ${displayName}${formatDuration(data.taskId)}`);
+          logger2.info(`  ${SYMBOLS.completed} ${label} ${displayName}${formatDuration(data.taskId)}`);
           break;
         case import_api_workflow_executor.TaskEvent.TASK_FAILED:
-          logger.error(`  ${SYMBOLS.failed} ${label} ${displayName}: ${error?.message ?? "error"}`);
+          logger2.error(`  ${SYMBOLS.failed} ${label} ${displayName}: ${error?.message ?? "error"}`);
           break;
         case import_api_workflow_executor.TaskEvent.TASK_STOPPED:
-          logger.info(`  ${SYMBOLS.stopped} ${label} ${displayName}`);
+          logger2.info(`  ${SYMBOLS.stopped} ${label} ${displayName}`);
           break;
       }
     },
@@ -22337,30 +24396,30 @@ function createConsoleLogger() {
         const level = data.logLevel?.toLowerCase() ?? "info";
         const message = typeof data.message === "string" ? data.message : JSON.stringify(data.message);
         if (level === "error") {
-          logger.error(`  [${level}] ${message}`);
+          logger2.error(`  [${level}] ${message}`);
         } else if (level === "warning") {
-          logger.warn(`  [${level}] ${message}`);
+          logger2.warn(`  [${level}] ${message}`);
         } else {
-          logger.info(`  [${level}] ${message}`);
+          logger2.info(`  [${level}] ${message}`);
         }
       }
     },
     async logIterationVariables(taskId, taskType, variables) {
       if (variables) {
-        logger.debug(`  [iteration] ${taskId} (${taskType}): ${JSON.stringify(variables)}`);
+        logger2.debug(`  [iteration] ${taskId} (${taskType}): ${JSON.stringify(variables)}`);
       }
     },
     async debug(message, data) {
-      logger.debug(message, ...data ? [JSON.stringify(data)] : []);
+      logger2.debug(message, ...data ? [JSON.stringify(data)] : []);
     },
     async info(message, data) {
-      logger.info(message, ...data ? [JSON.stringify(data)] : []);
+      logger2.info(message, ...data ? [JSON.stringify(data)] : []);
     },
     async warn(message, data) {
-      logger.warn(message, ...data ? [JSON.stringify(data)] : []);
+      logger2.warn(message, ...data ? [JSON.stringify(data)] : []);
     },
     async error(message, data, error) {
-      logger.error(message, ...data ? [JSON.stringify(data)] : [], ...error ? [String(error)] : []);
+      logger2.error(message, ...data ? [JSON.stringify(data)] : [], ...error ? [String(error)] : []);
     },
     async shutdown() {
       startTimes.clear();
@@ -22371,68 +24430,68 @@ function createConsoleLogger() {
 // src/services/workflow-run-service.ts
 class WorkflowRunService {
   async execute(filePath, options, context) {
-    const fs = getFileSystem();
-    const resolvedPath = fs.path.resolve(filePath);
-    if (!await fs.exists(resolvedPath)) {
-      OutputFormatter.error(new FailureOutput("Failure", `File not found: ${resolvedPath}`, "Provide a valid path to a workflow JSON file."));
+    const fs2 = getFileSystem2();
+    const resolvedPath = fs2.path.resolve(filePath);
+    if (!await fs2.exists(resolvedPath)) {
+      OutputFormatter2.error(new FailureOutput2("Failure", `File not found: ${resolvedPath}`, "Provide a valid path to a workflow JSON file."));
       context.exit(1);
       return;
     }
-    const [readError, raw] = await catchError(fs.readFile(resolvedPath, "utf-8"));
+    const [readError, raw] = await catchError2(fs2.readFile(resolvedPath, "utf-8"));
     if (readError) {
-      OutputFormatter.error(new FailureOutput("Failure", `Failed to parse workflow file: ${readError.message}`, "Ensure the file contains valid JSON."));
+      OutputFormatter2.error(new FailureOutput2("Failure", `Failed to parse workflow file: ${readError.message}`, "Ensure the file contains valid JSON."));
       context.exit(1);
       return;
     }
-    const [parseError, workflow] = catchError(() => JSON.parse(raw ?? ""));
+    const [parseError, workflow] = catchError2(() => JSON.parse(raw ?? ""));
     if (parseError) {
-      OutputFormatter.error(new FailureOutput("Failure", `Failed to parse workflow file: ${parseError.message}`, "Ensure the file contains valid JSON."));
+      OutputFormatter2.error(new FailureOutput2("Failure", `Failed to parse workflow file: ${parseError.message}`, "Ensure the file contains valid JSON."));
       context.exit(1);
       return;
     }
     let input = {};
     if (options.inputArguments) {
       const rawInput = options.inputArguments;
-      const [inputParseError, parsedInput] = catchError(() => JSON.parse(rawInput));
+      const [inputParseError, parsedInput] = catchError2(() => JSON.parse(rawInput));
       if (inputParseError) {
-        OutputFormatter.error(new FailureOutput("Failure", `Failed to parse --input-arguments JSON: ${inputParseError.message}`, `Provide valid JSON (e.g. '{"name": "World"}').`));
+        OutputFormatter2.error(new FailureOutput2("Failure", `Failed to parse --input-arguments JSON: ${inputParseError.message}`, `Provide valid JSON (e.g. '{"name": "World"}').`));
         context.exit(1);
         return;
       }
       input = parsedInput;
     }
     const workflowLogger = createConsoleLogger();
-    const [configError, workflowConfig] = await catchError(this.buildWorkflowConfig(options.auth));
+    const [configError, workflowConfig] = await catchError2(this.buildWorkflowConfig(options.auth));
     if (configError) {
       await workflowLogger.shutdown();
-      OutputFormatter.error(new FailureOutput("Failure", `Execution error: ${configError.message}`, "Check the workflow definition and try again with --log-level debug for more details."));
+      OutputFormatter2.error(new FailureOutput2("Failure", `Execution error: ${configError.message}`, "Check the workflow definition and try again with --log-level debug for more details."));
       context.exit(1);
       return;
     }
-    logger2.info(`
-Running workflow: ${fs.path.basename(resolvedPath)}`);
+    logger3.info(`
+Running workflow: ${fs2.path.basename(resolvedPath)}`);
     if (workflowConfig.accessToken) {
-      logger2.info(`Auth: connected to ${workflowConfig.baseUrl}`);
+      logger3.info(`Auth: connected to ${workflowConfig.baseUrl}`);
     } else {
-      logger2.info("Auth: local mode (no credentials)");
+      logger3.info("Auth: local mode (no credentials)");
     }
     if (Object.keys(input).length > 0) {
-      logger2.info(`Input: ${JSON.stringify(input, null, 2)}`);
+      logger3.info(`Input: ${JSON.stringify(input, null, 2)}`);
     }
-    const [execError, result] = await catchError(import_api_workflow_executor2.ServerlessWorkflowExecutor.execute(workflow, workflowConfig, input, { logger: workflowLogger }));
+    const [execError, result] = await catchError2(import_api_workflow_executor2.ServerlessWorkflowExecutor.execute(workflow, workflowConfig, input, { logger: workflowLogger }));
     if (execError) {
       await workflowLogger.shutdown();
-      OutputFormatter.error(new FailureOutput("Failure", `Execution error: ${execError.message}`, "Check the workflow definition and try again with --log-level debug for more details."));
+      OutputFormatter2.error(new FailureOutput2("Failure", `Execution error: ${execError.message}`, "Check the workflow definition and try again with --log-level debug for more details."));
       context.exit(1);
       return;
     }
     await workflowLogger.shutdown();
-    logger2.debug(`Raw response: ${JSON.stringify(result, null, 2)}`);
+    logger3.debug(`Raw response: ${JSON.stringify(result, null, 2)}`);
     if (result.status === "Successful") {
       const data = result.data ?? { message: "(no output)" };
-      OutputFormatter.success(new SuccessOutput("WorkflowRun", data));
+      OutputFormatter2.success(new SuccessOutput2("WorkflowRun", data));
     } else {
-      OutputFormatter.error(new FailureOutput("Failure", result.errorMessage ?? "Unknown error", "Check the workflow definition and input parameters."));
+      OutputFormatter2.error(new FailureOutput2("Failure", result.errorMessage ?? "Unknown error", "Check the workflow definition and input parameters."));
       context.exit(1);
     }
   }
@@ -22445,10 +24504,10 @@ Running workflow: ${fs.path.basename(resolvedPath)}`);
       source: "uipcli"
     };
     if (!authEnabled) {
-      logger2.debug("Auth disabled via --no-auth flag");
+      logger3.debug("Auth disabled via --no-auth flag");
       return localConfig;
     }
-    const [error, status] = await catchError(getLoginStatusAsync({
+    const [error, status] = await catchError2(getLoginStatusAsync({
       ensureTokenValidityMinutes: 10
     }));
     if (error) {
@@ -22463,16 +24522,16 @@ Running workflow: ${fs.path.basename(resolvedPath)}`);
         source: "uipcli"
       };
     }
-    logger2.debug("Not logged in, using local mode");
+    logger3.debug("Not logged in, using local mode");
     return localConfig;
   }
 }
 
 // src/commands/run.ts
 var registerRunCommand = (program) => {
-  program.command("run").description("Execute an API Workflow JSON file locally using the Serverless Workflow executor").argument("<file>", "Path to the workflow JSON file").option("-i, --input-arguments <json>", `Input arguments as a JSON string (e.g. '{"name": "World"}')`).option("--no-auth", "Skip credential loading (local-only mode, no connector support)").trackedAction(processContext, async (file, options) => {
+  program.command("run").description("Execute an API Workflow JSON file locally using the Serverless Workflow executor").argument("<file>", "Path to the workflow JSON file").option("-i, --input-arguments <json>", `Input arguments as a JSON string (e.g. '{"name": "World"}')`).option("--no-auth", "Skip credential loading (local-only mode, no connector support)").trackedAction(processContext3, async (file, options) => {
     const service = new WorkflowRunService;
-    await service.execute(file, options, processContext);
+    await service.execute(file, options, processContext3);
   });
 };
 
@@ -22484,6 +24543,8 @@ var metadata = {
   commandPrefix: "api-workflow"
 };
 var registerCommands = async (program) => {
+  registerPackCommand(program);
+  registerBuildCommand(program);
   registerRunCommand(program);
 };
 export {