@uipath/codedapp-tool 1.201.0-preview.132 → 1.202.0-preview.134

package/dist/packager-tool-14ha5twz.js

@@ -0,0 +1,1838 @@
+import {
+  zipSync
+} from "./packager-tool-jke4p8q1.js";
+
+// ../packager/packager-core/dist/index.js
+class Path {
+  static normalize(path) {
+    return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+  }
+  static join(...segments) {
+    return Path.normalize(segments.filter((s) => s.length > 0).join("/"));
+  }
+  static dirname(path) {
+    const normalized = Path.normalize(path).replace(/\/$/, "");
+    if (normalized === "")
+      return ".";
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash === -1)
+      return ".";
+    if (lastSlash === 0)
+      return "/";
+    return normalized.substring(0, lastSlash);
+  }
+  static basename(path) {
+    const normalized = Path.normalize(path).replace(/\/$/, "");
+    if (normalized === "")
+      return "";
+    const lastSlash = normalized.lastIndexOf("/");
+    return lastSlash >= 0 ? normalized.substring(lastSlash + 1) : normalized;
+  }
+  static extname(path) {
+    const base = Path.basename(path);
+    const lastDot = base.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === 0 || lastDot === base.length - 1) {
+      return "";
+    }
+    return base.substring(lastDot);
+  }
+  static async walkDirectory(fs, rootPath, currentRelativePath = "") {
+    const entries = [];
+    const absolutePath = currentRelativePath ? Path.join(rootPath, currentRelativePath) : rootPath;
+    const items = await fs.readdir(absolutePath);
+    for (const item of items) {
+      const itemRelativePath = currentRelativePath ? Path.join(currentRelativePath, item) : item;
+      const itemAbsolutePath = Path.join(rootPath, itemRelativePath);
+      const stat = await fs.stat(itemAbsolutePath);
+      if (stat?.isDirectory()) {
+        const subEntries = await Path.walkDirectory(fs, rootPath, itemRelativePath);
+        entries.push(...subEntries);
+      } else if (stat?.isFile()) {
+        entries.push({
+          relativePath: Path.normalize(itemRelativePath),
+          absolutePath: Path.normalize(itemAbsolutePath)
+        });
+      }
+    }
+    return entries;
+  }
+}
+
+class TemporaryStorageService {
+  fileSystem;
+  _tempFolderPath = null;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async getTempFolderPath() {
+    if (!this._tempFolderPath) {
+      const systemTempDir = await this.fileSystem.getTempDir();
+      const uniqueFolderName = this.generateUniqueFolderName();
+      this._tempFolderPath = Path.join(systemTempDir, uniqueFolderName);
+      await this.fileSystem.mkdir(this._tempFolderPath);
+    }
+    return this._tempFolderPath;
+  }
+  generateUniqueFolderName() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `tool-temp-${timestamp}-${random}`;
+  }
+  async getTempSubfolderPathAsync(subfolder) {
+    const tempFolderPath = await this.getTempFolderPath();
+    const inputPath = Path.join(tempFolderPath, subfolder);
+    await this.fileSystem.mkdir(inputPath);
+    return inputPath;
+  }
+  async cleanup() {
+    try {
+      if (!this._tempFolderPath) {
+        return;
+      }
+      try {
+        const stats = await this.fileSystem.stat(this._tempFolderPath);
+        if (!stats) {
+          return;
+        }
+      } catch {
+        return;
+      }
+      const _pathToCleanup = this._tempFolderPath;
+      await this.fileSystem.rm(this._tempFolderPath);
+      this._tempFolderPath = null;
+    } catch {}
+  }
+}
+function isPluralForm(value) {
+  return typeof value === "object" && value !== null && "other" in value;
+}
+function selectPluralForm(forms, count) {
+  if (count === 0 && forms.zero !== undefined) {
+    return forms.zero;
+  }
+  if (count === 1 && forms.one !== undefined) {
+    return forms.one;
+  }
+  if (count === 2 && forms.two !== undefined) {
+    return forms.two;
+  }
+  if (forms.few !== undefined) {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) {
+      return forms.few;
+    }
+  }
+  if (forms.many !== undefined) {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (count === 0 || mod10 === 0 && mod100 !== 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14) {
+      return forms.many;
+    }
+  }
+  return forms.other;
+}
+
+class I18nManager {
+  static translations = {};
+  static currentLocale = "en";
+  static fallbackLocale = "en";
+  static registerTranslations(locale, catalog) {
+    if (!I18nManager.translations[locale]) {
+      I18nManager.translations[locale] = {};
+    }
+    I18nManager.translations[locale] = I18nManager.deepMerge(I18nManager.translations[locale], catalog);
+  }
+  static setLocale(locale) {
+    const normalized = I18nManager.normalizeLocale(locale);
+    if (I18nManager.translations[normalized]) {
+      I18nManager.currentLocale = normalized;
+      return normalized;
+    }
+    const baseLocale = normalized.split("-")[0];
+    if (baseLocale !== normalized && I18nManager.translations[baseLocale]) {
+      I18nManager.currentLocale = baseLocale;
+      return baseLocale;
+    }
+    return I18nManager.currentLocale;
+  }
+  static getLocale() {
+    return I18nManager.currentLocale;
+  }
+  static setFallbackLocale(locale) {
+    I18nManager.fallbackLocale = I18nManager.normalizeLocale(locale);
+  }
+  static t(key, params, locale) {
+    const targetLocale = locale ? I18nManager.normalizeLocale(locale) : I18nManager.currentLocale;
+    let value = I18nManager.getTranslationValue(key, targetLocale);
+    if (value === undefined && targetLocale !== I18nManager.fallbackLocale) {
+      value = I18nManager.getTranslationValue(key, I18nManager.fallbackLocale);
+    }
+    if (value === undefined) {
+      return key;
+    }
+    if (isPluralForm(value) && params && "count" in params) {
+      const count = typeof params.count === "number" ? params.count : Number(params.count);
+      value = selectPluralForm(value, count);
+    } else if (isPluralForm(value)) {
+      value = value.other;
+    }
+    if (typeof value !== "string") {
+      return key;
+    }
+    return params ? I18nManager.interpolate(value, params) : value;
+  }
+  static has(key, locale) {
+    const targetLocale = locale ? I18nManager.normalizeLocale(locale) : I18nManager.currentLocale;
+    const value = I18nManager.getTranslationValue(key, targetLocale);
+    if (value !== undefined) {
+      return true;
+    }
+    if (targetLocale !== I18nManager.fallbackLocale) {
+      return I18nManager.getTranslationValue(key, I18nManager.fallbackLocale) !== undefined;
+    }
+    return false;
+  }
+  static getAvailableLocales() {
+    return Object.keys(I18nManager.translations);
+  }
+  static clearTranslations() {
+    I18nManager.translations = {};
+    I18nManager.currentLocale = "en";
+  }
+  static getTranslationValue(key, locale) {
+    const catalog = I18nManager.translations[locale];
+    if (!catalog) {
+      return;
+    }
+    const keys = key.split(".");
+    let value = catalog;
+    for (const k of keys) {
+      if (value && typeof value === "object" && k in value) {
+        value = value[k];
+      } else {
+        return;
+      }
+    }
+    return value;
+  }
+  static interpolate(template, params) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+      const value = params[key];
+      return value !== undefined ? String(value) : `{${key}}`;
+    });
+  }
+  static normalizeLocale(locale) {
+    const normalized = locale.toLowerCase().replace(/_/g, "-");
+    const specialLocales = ["es-mx", "pt-br", "zh-cn", "zh-tw"];
+    if (specialLocales.includes(normalized)) {
+      return normalized;
+    }
+    return normalized.split("-")[0];
+  }
+  static deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = I18nManager.deepMerge(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+    return result;
+  }
+}
+var de = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var en = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var es = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var es_MX = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var fr = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ja = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ko = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var pt = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var pt_BR = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ro = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ru = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var tr = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var zh_CN = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var zh_TW = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var zu = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+class TranslationService {
+  static instance;
+  currentLocale = "en";
+  constructor() {}
+  static getInstance() {
+    if (!TranslationService.instance) {
+      TranslationService.instance = new TranslationService;
+    }
+    return TranslationService.instance;
+  }
+  setLocale(locale) {
+    this.currentLocale = I18nManager.setLocale(locale);
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  t(key, params) {
+    return I18nManager.t(key, params, this.currentLocale);
+  }
+  tLocale(key, locale, params) {
+    return I18nManager.t(key, params, locale);
+  }
+  has(key) {
+    return I18nManager.has(key, this.currentLocale);
+  }
+  getAvailableLocales() {
+    return I18nManager.getAvailableLocales();
+  }
+}
+var translate = TranslationService.getInstance();
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de);
+I18nManager.registerTranslations("es", es);
+I18nManager.registerTranslations("es-mx", es_MX);
+I18nManager.registerTranslations("fr", fr);
+I18nManager.registerTranslations("ja", ja);
+I18nManager.registerTranslations("ko", ko);
+I18nManager.registerTranslations("pt", pt);
+I18nManager.registerTranslations("pt-br", pt_BR);
+I18nManager.registerTranslations("ro", ro);
+I18nManager.registerTranslations("ru", ru);
+I18nManager.registerTranslations("tr", tr);
+I18nManager.registerTranslations("zh-cn", zh_CN);
+I18nManager.registerTranslations("zh-tw", zh_TW);
+I18nManager.registerTranslations("zu", zu);
+I18nManager.setLocale("en");
+var BuildConfiguration;
+((BuildConfiguration2) => {
+  BuildConfiguration2["Debug"] = "Debug";
+  BuildConfiguration2["Release"] = "Release";
+})(BuildConfiguration ||= {});
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2["Debug"] = "Debug";
+  LogLevel2["Info"] = "Information";
+  LogLevel2["Warn"] = "Warning";
+  LogLevel2["Error"] = "Error";
+})(LogLevel ||= {});
+var NugetConstants = {
+  OutputFolderName: "bundle",
+  ContentFolderName: "content",
+  OperateFileName: "operate.json",
+  EntryPointsFileName: "entry-points.json",
+  PackageDescriptorFileName: "package-descriptor.json",
+  BindingsV2FileName: "bindings_v2.json",
+  BindingsFileId: "bindings.json"
+};
+var PackJobTargetKind;
+((PackJobTargetKind2) => {
+  PackJobTargetKind2["Serverless"] = "Serverless";
+  PackJobTargetKind2["LocalRobot"] = "LocalRobot";
+})(PackJobTargetKind ||= {});
+var ProjectTypes;
+((ProjectTypes2) => {
+  ProjectTypes2["Agent"] = "Agent";
+  ProjectTypes2["Api"] = "Api";
+  ProjectTypes2["BusinessRules"] = "BusinessRules";
+  ProjectTypes2["Connector"] = "Connector";
+  ProjectTypes2["CaseManagement"] = "CaseManagement";
+  ProjectTypes2["Flow"] = "Flow";
+  ProjectTypes2["Function"] = "Function";
+  ProjectTypes2["ProcessOrchestration"] = "ProcessOrchestration";
+  ProjectTypes2["Process"] = "Process";
+  ProjectTypes2["Library"] = "Library";
+  ProjectTypes2["WebApp"] = "WebApp";
+  ProjectTypes2["Tests"] = "Tests";
+  ProjectTypes2["AppV2"] = "AppV2";
+})(ProjectTypes ||= {});
+var TargetFramework;
+((TargetFramework2) => {
+  TargetFramework2["Portable"] = "Portable";
+  TargetFramework2["Windows"] = "Windows";
+})(TargetFramework ||= {});
+var ToolErrorCodes;
+((ToolErrorCodes2) => {
+  ToolErrorCodes2["Success"] = "SUCCESS";
+  ToolErrorCodes2["InternalError"] = "INTERNAL_ERROR";
+  ToolErrorCodes2["Canceled"] = "CANCELED";
+})(ToolErrorCodes ||= {});
+
+class ToolResult {
+  errorCode;
+  message;
+  packages;
+  details;
+  instructions;
+  constructor(errorCode, message, packages = [], instructions) {
+    this.errorCode = errorCode;
+    this.message = message;
+    this.packages = packages;
+    this.instructions = instructions;
+  }
+  get isSuccess() {
+    return this.errorCode === "SUCCESS";
+  }
+  static success() {
+    return new ToolResult("SUCCESS");
+  }
+  static error(errorCode, message, instructions) {
+    return new ToolResult(errorCode, message, [], instructions);
+  }
+}
+function escapeXml(str) {
+  if (str === null || str === undefined) {
+    return "";
+  }
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function optionalElement(name, value) {
+  if (value === undefined || value === "")
+    return "";
+  return `    <${name}>${escapeXml(value)}</${name}>
+`;
+}
+function generateDependenciesXml(dependencies) {
+  if (!dependencies || dependencies.length === 0)
+    return "";
+  const deps = dependencies.map((d) => `      <dependency id="${escapeXml(d.id)}" version="${escapeXml(d.version)}" />`).join(`
+`);
+  return `    <dependencies>
+${deps}
+    </dependencies>
+`;
+}
+function generateRepositoryXml(packageInfo) {
+  if (!packageInfo.repositoryType || !packageInfo.repositoryUrl)
+    return "";
+  let repoXml = `    <repository type="${escapeXml(packageInfo.repositoryType)}" url="${escapeXml(packageInfo.repositoryUrl)}"`;
+  if (packageInfo.repositoryBranch) {
+    repoXml += ` branch="${escapeXml(packageInfo.repositoryBranch)}"`;
+  }
+  if (packageInfo.repositoryCommit) {
+    repoXml += ` commit="${escapeXml(packageInfo.repositoryCommit)}"`;
+  }
+  repoXml += ` />
+`;
+  return repoXml;
+}
+function generateNuspecXml(packageInfo) {
+  const author = packageInfo.author?.trim() || "UiPath";
+  const description = packageInfo.description?.trim() || "Created by UiPath";
+  const title = packageInfo.title?.trim() || packageInfo.id;
+  const requireLicenseAcceptance = packageInfo.requireLicenseAcceptance === true ? "true" : "false";
+  const releaseNotes = packageInfo.releaseNotes ?? "";
+  const xml = `\uFEFF<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata>
+    <id>${escapeXml(packageInfo.id)}</id>
+    <version>${escapeXml(packageInfo.version)}</version>
+    <title>${escapeXml(title)}</title>
+    <authors>${escapeXml(author)}</authors>
+    <requireLicenseAcceptance>${requireLicenseAcceptance}</requireLicenseAcceptance>
+    <description>${escapeXml(description)}</description>
+    <releaseNotes>${escapeXml(releaseNotes)}</releaseNotes>
+${optionalElement("tags", packageInfo.tags)}${optionalElement("iconUrl", packageInfo.iconUrl)}${optionalElement("projectUrl", packageInfo.projectUrl)}${optionalElement("licenseUrl", packageInfo.licenseUrl)}${optionalElement("copyright", packageInfo.copyright)}${generateRepositoryXml(packageInfo)}${generateDependenciesXml(packageInfo.dependencies)}  </metadata>
+</package>
+`;
+  return xml;
+}
+function generatePsmdcpXml(packageInfo) {
+  const author = packageInfo.author?.trim() || "UiPath";
+  const description = packageInfo.description?.trim() || "Created by UiPath";
+  return `<?xml version="1.0" encoding="utf-8"?>
+<coreProperties xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.openxmlformats.org/package/2006/metadata/core-properties">
+  <dc:creator>${escapeXml(author)}</dc:creator>
+  <dc:description>${escapeXml(description)}</dc:description>
+  <dc:identifier>${escapeXml(packageInfo.id)}</dc:identifier>
+  <version>${escapeXml(packageInfo.version)}</version>
+  <keywords></keywords>
+  <lastModifiedBy>NuGet.Packaging, Version=6.12.1.1, Culture=neutral, PublicKeyToken=31bf3856ad364e35;.NET 5.0</lastModifiedBy>
+</coreProperties>`;
+}
+
+class NugetPackager {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async packAsync(rootPath, packageInfo, outputPath) {
+    const normalizedOutputPath = Path.normalize(outputPath);
+    const nuspecXml = generateNuspecXml(packageInfo);
+    const nuspecFileName = `${packageInfo.id}.nuspec`;
+    const fileEntries = await Path.walkDirectory(this.fileSystem, rootPath);
+    const zipContents = {};
+    const encoder = new TextEncoder;
+    const psmdcpId = Array.from({ length: 4 }, () => Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0")).join("");
+    const psmdcpFileName = `${psmdcpId}.psmdcp`;
+    const psmdcpPath = `package/services/metadata/core-properties/${psmdcpFileName}`;
+    const contentTypesXml = `<?xml version="1.0" encoding="utf-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
+  <Default Extension="psmdcp" ContentType="application/vnd.openxmlformats-package.core-properties+xml" />
+  <Default Extension="uiproj" ContentType="application/octet" />
+  <Default Extension="json" ContentType="application/octet" />
+  <Default Extension="nuspec" ContentType="application/octet" />
+</Types>`;
+    zipContents["[Content_Types].xml"] = encoder.encode(contentTypesXml);
+    const manifestRelId = `R${Date.now().toString(16).toUpperCase()}`;
+    const corePropsRelId = `R${(Date.now() + 1).toString(16).toUpperCase()}`;
+    const relsXml = `<?xml version="1.0" encoding="utf-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Type="http://schemas.microsoft.com/packaging/2010/07/manifest" Target="/${nuspecFileName}" Id="${manifestRelId}" />
+  <Relationship Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="/${psmdcpPath}" Id="${corePropsRelId}" />
+</Relationships>`;
+    zipContents["_rels/.rels"] = encoder.encode(relsXml);
+    zipContents[psmdcpPath] = encoder.encode(generatePsmdcpXml(packageInfo));
+    zipContents[nuspecFileName] = encoder.encode(nuspecXml);
+    for (const entry of fileEntries) {
+      const content = await this.fileSystem.readFile(entry.absolutePath);
+      if (content !== null) {
+        zipContents[entry.relativePath] = content;
+      }
+    }
+    const zippedData = zipSync(zipContents);
+    await this.fileSystem.writeFile(normalizedOutputPath, zippedData);
+    return {
+      outputPath: normalizedOutputPath
+    };
+  }
+}
+
+class ProjectTool {
+  fileSystem;
+  logger;
+  static ProjectFileName = "project.uiproj";
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is a noop");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is a noop");
+    return ToolResult.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation is a noop");
+    return ToolResult.success();
+  }
+  async packAsync(_options, _cancellationToken) {
+    this.logger.info("Pack operation is a noop");
+    return ToolResult.success();
+  }
+  async cleanupAsync(_options, _cancellationToken) {
+    this.logger.info("Cleanup operation is a noop");
+    return ToolResult.success();
+  }
+  async getUiProjectAsync(projectPath) {
+    const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
+    if (!await this.fileSystem.exists(filePath)) {
+      return;
+    }
+    const raw = await this.fileSystem.readFile(filePath);
+    if (!raw) {
+      return;
+    }
+    const json = typeof raw === "string" ? raw : new TextDecoder("utf-8").decode(raw);
+    return JSON.parse(json);
+  }
+  async dispose() {}
+}
+class ToolsFactoryRepository {
+  projectFactoryMap = new Map;
+  solutionFactory = null;
+  registerProjectToolFactory(factory) {
+    for (const type of factory.supportedTypes) {
+      const existing = this.projectFactoryMap.get(type);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          console.warn(`Tool factory conflict for project type '${type}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.projectFactoryMap.set(type, factory);
+    }
+  }
+  registerSolutionToolFactory(factory) {
+    this.solutionFactory = factory;
+  }
+  getSolutionToolFactory() {
+    if (!this.solutionFactory) {
+      throw new Error("No solution tool factory is registered");
+    }
+    return this.solutionFactory;
+  }
+  canHandleProject(projectType) {
+    return this.projectFactoryMap.has(projectType);
+  }
+  getProjectToolFactory(projectType) {
+    const factory = this.projectFactoryMap.get(projectType);
+    if (!factory) {
+      const known = [...this.projectFactoryMap.keys()].join(", ");
+      throw new Error(`Cannot pack project type '${projectType}': no packager is installed for it. ` + `Project types that can be packed: ${known || "none"}.`);
+    }
+    return factory;
+  }
+  reset() {
+    this.projectFactoryMap.clear();
+    this.solutionFactory = null;
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ToolsFactoryRepository;
+}
+var toolsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../packager/packager-tool-webapp/src/constants.ts
+var PROJECT_JSON_FILE = "project.json";
+var DEFAULT_BUNDLE_PATH = "source/dist";
+var APP_FOLDER_NAME = ".app";
+var CONTENT_APP_FOLDER_NAME = "app";
+var TARGET_RUNTIME = "Coded";
+var TARGET_JS_RUNTIME = "JS";
+var DEFAULT_ENTRY_POINT_TYPE = "api";
+var ERROR_MESSAGES = {
+  MANIFEST_NOT_FOUND: (file) => `WebApp manifest not found: ${file}. This file is required for WebApp projects.`,
+  PROJECT_JSON_FOUND: "project.json found in WebApp project. The WebApp tool only supports Coded web apps without project.json.",
+  MANIFEST_LOAD_FAILED: (file) => `Failed to load or parse ${file}`,
+  BUNDLE_NOT_FOUND: (path) => `Compiled bundle not found at ${path}. Ensure the project is built before packing.`,
+  BUNDLE_NOT_DIRECTORY: (path) => `Bundle path ${path} exists but is not a directory.`,
+  APP_FOLDER_NOT_FOUND: (path) => `.app folder not found at ${path}. Ensure the project contains a .app folder.`,
+  APP_FOLDER_NOT_DIRECTORY: (path) => `.app path ${path} exists but is not a directory.`,
+  BUILD_NOT_SUPPORTED: "Build execution (isCompiled=false) is not yet supported. Please build the project manually and set isCompiled=true.",
+  VALIDATION_FAILED: (context) => `Validation failed: ${context}`,
+  PACKING_FAILED: (context) => `An error occurred while packing WebApp project: ${context}`,
+  PACKAGE_NAME_REQUIRED: "Package name is required",
+  PACKAGE_VERSION_REQUIRED: "Package version is required",
+  PROJECT_PATH_REQUIRED: "Project path is required",
+  OUTPUT_PATH_REQUIRED: "Output path is required"
+};
+
+// ../packager/packager-tool-webapp/src/models/webapp-manifest.ts
+var WebAppVariantType;
+((WebAppVariantType2) => {
+  WebAppVariantType2["Coded"] = "Coded";
+  WebAppVariantType2["JS"] = "JS";
+})(WebAppVariantType ||= {});
+var WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
+
+// ../packager/packager-tool-webapp/src/utils/fs-helpers.ts
+async function copyDirectoryAsync(fileSystem, sourcePath, destinationPath) {
+  await fileSystem.mkdir(destinationPath);
+  const entries = await fileSystem.readdir(sourcePath);
+  for (const entry of entries) {
+    const sourceEntry = Path.join(sourcePath, entry);
+    const destEntry = Path.join(destinationPath, entry);
+    const stat = await fileSystem.stat(sourceEntry);
+    if (stat?.isDirectory()) {
+      await copyDirectoryAsync(fileSystem, sourceEntry, destEntry);
+    } else if (stat?.isFile()) {
+      const content = await fileSystem.readFile(sourceEntry);
+      if (content) {
+        await fileSystem.writeFile(destEntry, content);
+      }
+    }
+  }
+}
+
+// ../packager/packager-tool-webapp/src/utils/manifest-loader.ts
+async function loadWebAppManifest(fileSystem, projectPath) {
+  const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  const exists = await fileSystem.exists(manifestPath);
+  if (!exists) {
+    return null;
+  }
+  const content = await fileSystem.readFile(manifestPath);
+  if (!content) {
+    return null;
+  }
+  try {
+    const text = new TextDecoder().decode(content);
+    const manifest = JSON.parse(text);
+    return manifest;
+  } catch (error) {
+    throw new Error(`Failed to parse ${WEBAPP_MANIFEST_FILE_NAME}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function ensureWebAppProjectId(fileSystem, projectPath) {
+  const manifest = await loadWebAppManifest(fileSystem, projectPath);
+  if (manifest && typeof manifest.projectId === "string" && manifest.projectId.length > 0) {
+    return manifest.projectId;
+  }
+  const id = crypto.randomUUID();
+  if (manifest) {
+    const updated = { ...manifest, projectId: id };
+    const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    await fileSystem.writeFile(manifestPath, `${JSON.stringify(updated, null, 2)}
+`);
+  }
+  return id;
+}
+
+// ../packager/packager-tool-webapp/src/strategies/coded-app-strategy.ts
+class CodedAppStrategy {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(args) {
+    const { projectPath, manifest, logger } = args;
+    const typed = manifest;
+    let bundlePath = typed.config?.bundlePath;
+    if (typeof bundlePath !== "string" || bundlePath.length === 0) {
+      bundlePath = DEFAULT_BUNDLE_PATH;
+    }
+    const isCompiled = typed.config?.isCompiled ?? true;
+    if (isCompiled) {
+      const fullBundlePath = Path.join(projectPath, bundlePath);
+      const exists = await this.fileSystem.exists(fullBundlePath);
+      if (!exists) {
+        const message = ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
+        const warnable = logger;
+        if (warnable?.warn) {
+          warnable.warn(message);
+        } else {
+          logger?.info(`Warning: ${message}`);
+        }
+      }
+    }
+  }
+  async packageAsync(args) {
+    const { projectPath, manifest, outputPath, packageInfo, logger } = args;
+    logger?.info(`Packaging Coded variant: ${packageInfo.id}@${packageInfo.version}`);
+    let bundlePath = manifest.config?.bundlePath;
+    if (typeof bundlePath !== "string" || bundlePath.length === 0) {
+      bundlePath = DEFAULT_BUNDLE_PATH;
+    }
+    const isCompiled = manifest.config?.isCompiled ?? true;
+    const fullBundlePath = Path.join(projectPath, bundlePath);
+    if (isCompiled) {
+      logger?.progress("Validating compiled bundle...");
+      const bundleExists = await this.fileSystem.exists(fullBundlePath);
+      if (!bundleExists) {
+        throw new Error(ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath));
+      }
+      const bundleStat = await this.fileSystem.stat(fullBundlePath);
+      if (!bundleStat?.isDirectory()) {
+        throw new Error(ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath));
+      }
+    } else {
+      logger?.info("Build mode (isCompiled=false) is not yet implemented in v1.");
+      throw new Error(ERROR_MESSAGES.BUILD_NOT_SUPPORTED);
+    }
+    const localBuildFolder = Path.join(outputPath, NugetConstants.OutputFolderName);
+    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    await this.fileSystem.mkdir(contentFolder);
+    try {
+      logger?.progress("Copying bundle to content folder...");
+      await copyDirectoryAsync(this.fileSystem, fullBundlePath, contentFolder);
+      logger?.progress("Preparing metadata files...");
+      await this.prepareMetadataFiles(localBuildFolder, contentFolder, packageInfo, manifest, projectPath);
+      logger?.progress("Creating NuGet package...");
+      const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+      const nupkgPath = Path.join(outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
+      logger?.info(`Package created successfully: ${result.outputPath}`);
+      return result.outputPath;
+    } finally {
+      try {
+        await this.fileSystem.rm(localBuildFolder);
+      } catch (cleanupError) {
+        logger?.error(`Failed to cleanup build folder: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+      }
+    }
+  }
+  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, _manifest, projectPath) {
+    let mainFile = "index.html";
+    const indexHtmlPath = Path.join(contentFolder, "index.html");
+    const indexHtmlExists = await this.fileSystem.exists(indexHtmlPath);
+    if (!indexHtmlExists) {
+      const possibleEntries = ["index.html", "main.html", "app.html"];
+      for (const entry of possibleEntries) {
+        const entryPath = Path.join(contentFolder, entry);
+        if (await this.fileSystem.exists(entryPath)) {
+          mainFile = entry;
+          break;
+        }
+      }
+    }
+    const operatePath = Path.join(contentFolder, NugetConstants.OperateFileName);
+    const operateModel = {
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
+      main: mainFile,
+      contentType: ProjectTypes.WebApp,
+      targetFramework: TargetFramework.Portable,
+      targetRuntime: TARGET_RUNTIME,
+      runtimeOptions: {
+        requiresUserInteraction: false,
+        isAttended: false
+      }
+    };
+    const operateJson = JSON.stringify(operateModel, null, 2);
+    await this.fileSystem.writeFile(operatePath, operateJson);
+    const manifestSourcePath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestExists = await this.fileSystem.exists(manifestSourcePath);
+    if (manifestExists) {
+      const manifestContent = await this.fileSystem.readFile(manifestSourcePath, "utf-8");
+      if (manifestContent) {
+        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
+      }
+    }
+    const uipathJsonSourcePath = Path.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path.join(contentFolder, "uipath.json");
+    const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
+    if (uipathJsonExists) {
+      const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath, "utf-8");
+      if (uipathJsonContent) {
+        await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
+      }
+    }
+    const actionSchemaSourcePath = Path.join(projectPath, "action-schema.json");
+    const actionSchemaDestPath = Path.join(contentFolder, "action-schema.json");
+    const actionSchemaExists = await this.fileSystem.exists(actionSchemaSourcePath);
+    if (actionSchemaExists) {
+      const actionSchemaContent = await this.fileSystem.readFile(actionSchemaSourcePath, "utf-8");
+      if (actionSchemaContent) {
+        await this.fileSystem.writeFile(actionSchemaDestPath, actionSchemaContent);
+      }
+    }
+    const bindingsPath = Path.join(contentFolder, "bindings.json");
+    const bindingsExists = await this.fileSystem.exists(bindingsPath);
+    if (!bindingsExists) {
+      const bindingsJson = JSON.stringify({
+        version: "1.0",
+        resources: []
+      }, null, 2);
+      await this.fileSystem.writeFile(bindingsPath, bindingsJson);
+    }
+    const bindingsV2Path = Path.join(contentFolder, "bindings_v2.json");
+    const bindingsCandidatePaths = [
+      Path.join(projectPath, "source", "bindings_v2.json"),
+      Path.join(projectPath, "source", "bindings.json"),
+      Path.join(projectPath, "bindings.json"),
+      Path.join(projectPath, "bindings_v2.json")
+    ];
+    let bindingsV2Json = null;
+    for (const candidate of bindingsCandidatePaths) {
+      if (await this.fileSystem.exists(candidate)) {
+        bindingsV2Json = await this.fileSystem.readFile(candidate, "utf-8");
+        if (bindingsV2Json)
+          break;
+      }
+    }
+    if (!bindingsV2Json && await this.fileSystem.exists(bindingsV2Path)) {
+      bindingsV2Json = await this.fileSystem.readFile(bindingsV2Path, "utf-8");
+    }
+    if (!bindingsV2Json) {
+      bindingsV2Json = JSON.stringify({
+        version: "2.0",
+        resources: []
+      }, null, 2);
+    }
+    await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
+    const entryPointsPath = Path.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path.join(projectPath, "entry-points.json");
+    let entryPointsContent;
+    const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
+    if (projectEntryPointsExists) {
+      const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath, "utf-8");
+      if (entryPointsData) {
+        entryPointsContent = entryPointsData;
+      } else {
+        entryPointsContent = this.createDefaultEntryPoints(mainFile);
+      }
+    } else {
+      entryPointsContent = this.createDefaultEntryPoints(mainFile);
+    }
+    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
+    const packageDescriptorPath = Path.join(contentFolder, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptor = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+      files: {
+        [NugetConstants.OperateFileName]: Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
+        "entry-points.json": Path.join(NugetConstants.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path.join(NugetConstants.ContentFolderName, "bindings_v2.json")
+      }
+    };
+    const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+  createDefaultEntryPoints(mainFile) {
+    const uniqueId = this.generateUniqueId();
+    const entryPoints = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+      $id: "entry-points-doc-001",
+      entryPoints: [
+        {
+          filePath: mainFile,
+          uniqueId,
+          type: DEFAULT_ENTRY_POINT_TYPE,
+          input: {
+            amount: { type: "integer" },
+            id: { type: "string" }
+          },
+          output: {
+            status: { type: "string" }
+          }
+        }
+      ]
+    };
+    return JSON.stringify(entryPoints, null, 2);
+  }
+  generateUniqueId() {
+    const randomBytes = new Uint8Array(16);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(randomBytes);
+    } else {
+      throw new Error("crypto.getRandomValues is not available");
+    }
+    randomBytes[6] = randomBytes[6] & 15 | 64;
+    randomBytes[8] = randomBytes[8] & 63 | 128;
+    const hex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return [
+      hex.substring(0, 8),
+      hex.substring(8, 12),
+      hex.substring(12, 16),
+      hex.substring(16, 20),
+      hex.substring(20, 32)
+    ].join("-");
+  }
+}
+
+// ../packager/packager-tool-webapp/src/strategies/js-apps-strategy.ts
+class JsAppsStrategy {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(args) {
+    const { projectPath, logger } = args;
+    const appFolder = Path.join(projectPath, APP_FOLDER_NAME);
+    const exists = await this.fileSystem.exists(appFolder);
+    if (!exists) {
+      const message = ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder);
+      if (logger?.warn) {
+        logger.warn(message);
+      } else {
+        logger?.info(`Warning: ${message}`);
+      }
+      return;
+    }
+    const stat = await this.fileSystem.stat(appFolder);
+    if (!stat?.isDirectory()) {
+      const message = ERROR_MESSAGES.APP_FOLDER_NOT_DIRECTORY(appFolder);
+      if (logger?.warn) {
+        logger.warn(message);
+      } else {
+        logger?.info(`Warning: ${message}`);
+      }
+    }
+  }
+  async packageAsync(args) {
+    const { projectPath, manifest, outputPath, packageInfo, logger } = args;
+    logger?.info(`Packaging JS variant: ${packageInfo.id}@${packageInfo.version}`);
+    const appFolder = Path.join(projectPath, APP_FOLDER_NAME);
+    logger?.progress("Validating .app folder...");
+    const appFolderExists = await this.fileSystem.exists(appFolder);
+    if (!appFolderExists) {
+      throw new Error(ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder));
+    }
+    const appFolderStat = await this.fileSystem.stat(appFolder);
+    if (!appFolderStat?.isDirectory()) {
+      throw new Error(ERROR_MESSAGES.APP_FOLDER_NOT_DIRECTORY(appFolder));
+    }
+    const localBuildFolder = Path.join(outputPath, NugetConstants.OutputFolderName);
+    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    const contentAppFolder = Path.join(contentFolder, CONTENT_APP_FOLDER_NAME);
+    await this.fileSystem.mkdir(contentFolder);
+    try {
+      logger?.progress("Copying .app folder into content/app...");
+      await copyDirectoryAsync(this.fileSystem, appFolder, contentAppFolder);
+      logger?.progress("Preparing metadata files...");
+      await this.prepareMetadataFiles(contentFolder, contentAppFolder, packageInfo, manifest, projectPath);
+      logger?.progress("Creating NuGet package...");
+      const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+      const nupkgPath = Path.join(outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
+      logger?.info(`Package created successfully: ${result.outputPath}`);
+      return result.outputPath;
+    } finally {
+      try {
+        await this.fileSystem.rm(localBuildFolder);
+      } catch (cleanupError) {
+        logger?.error(`Failed to cleanup build folder: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+      }
+    }
+  }
+  async prepareMetadataFiles(contentFolder, _contentAppFolder, _packageInfo, _manifest, projectPath) {
+    const mainFile = "index.html";
+    const mainRelativeToContent = `${CONTENT_APP_FOLDER_NAME}/${mainFile}`;
+    const operatePath = Path.join(contentFolder, NugetConstants.OperateFileName);
+    const operateModel = {
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
+      main: mainRelativeToContent,
+      contentType: ProjectTypes.WebApp,
+      targetFramework: TargetFramework.Portable,
+      targetRuntime: TARGET_JS_RUNTIME,
+      runtimeOptions: {
+        requiresUserInteraction: false,
+        isAttended: false
+      }
+    };
+    const operateJson = JSON.stringify(operateModel, null, 2);
+    await this.fileSystem.writeFile(operatePath, operateJson);
+    const manifestSourcePath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestExists = await this.fileSystem.exists(manifestSourcePath);
+    if (manifestExists) {
+      const manifestContent = await this.fileSystem.readFile(manifestSourcePath);
+      if (manifestContent) {
+        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
+      }
+    }
+    const uipathJsonSourcePath = Path.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path.join(contentFolder, "uipath.json");
+    const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
+    if (uipathJsonExists) {
+      const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath);
+      if (uipathJsonContent) {
+        await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
+      }
+    }
+    const bindingsPath = Path.join(contentFolder, "bindings.json");
+    const bindingsExists = await this.fileSystem.exists(bindingsPath);
+    if (!bindingsExists) {
+      const bindingsJson = JSON.stringify({ version: "1.0", resources: [] }, null, 2);
+      await this.fileSystem.writeFile(bindingsPath, bindingsJson);
+    }
+    const bindingsV2Path = Path.join(contentFolder, "bindings_v2.json");
+    const bindingsV2Exists = await this.fileSystem.exists(bindingsV2Path);
+    if (!bindingsV2Exists) {
+      const bindingsV2Json = JSON.stringify({ version: "2.0", resources: [] }, null, 2);
+      await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
+    }
+    const entryPointsPath = Path.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path.join(projectPath, "entry-points.json");
+    let entryPointsContent;
+    const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
+    if (projectEntryPointsExists) {
+      const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath);
+      if (entryPointsData) {
+        entryPointsContent = new TextDecoder().decode(entryPointsData);
+      } else {
+        entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
+      }
+    } else {
+      entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
+    }
+    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
+    const packageDescriptorPath = Path.join(contentFolder, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptor = {
+      files: {
+        [NugetConstants.OperateFileName]: Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
+        "entry-points.json": Path.join(NugetConstants.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path.join(NugetConstants.ContentFolderName, "bindings_v2.json")
+      }
+    };
+    const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+  createDefaultEntryPoints(mainFilePath) {
+    const uniqueId = this.generateUniqueId();
+    const entryPoints = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+      $id: "entry-points-doc-001",
+      entryPoints: [
+        {
+          filePath: mainFilePath,
+          uniqueId,
+          type: DEFAULT_ENTRY_POINT_TYPE,
+          input: {
+            amount: { type: "integer" },
+            id: { type: "string" }
+          },
+          output: {
+            status: { type: "string" }
+          }
+        }
+      ]
+    };
+    return JSON.stringify(entryPoints, null, 2);
+  }
+  generateUniqueId() {
+    const randomBytes = new Uint8Array(16);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(randomBytes);
+    } else {
+      throw new Error("crypto.getRandomValues is not available");
+    }
+    randomBytes[6] = randomBytes[6] & 15 | 64;
+    randomBytes[8] = randomBytes[8] & 63 | 128;
+    const hex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return [
+      hex.substring(0, 8),
+      hex.substring(8, 12),
+      hex.substring(12, 16),
+      hex.substring(16, 20),
+      hex.substring(20, 32)
+    ].join("-");
+  }
+}
+
+// ../packager/packager-tool-webapp/src/strategies/variant-strategy-factory.ts
+class VariantStrategyFactory {
+  static createStrategy(manifest, fileSystem) {
+    const variant = manifest.type;
+    switch (variant) {
+      case "Coded" /* Coded */:
+        return new CodedAppStrategy(fileSystem);
+      case "JS" /* JS */:
+        return new JsAppsStrategy(fileSystem);
+      default:
+        throw new Error(`Unknown WebApp variant: ${manifest.type}. Supported variants: ${Object.values(WebAppVariantType).join(", ")}`);
+    }
+  }
+}
+
+// ../packager/packager-tool-webapp/src/webapp-tool.ts
+class WebAppTool extends ProjectTool {
+  _temporaryStorage;
+  _tempBuildFolder = null;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for WebApp projects");
+    return ToolResult.success();
+  }
+  async validateAsync(options, _cancellationToken) {
+    if (!options.projectPath) {
+      return this.handleError(new Error(ERROR_MESSAGES.PROJECT_PATH_REQUIRED), "Validation");
+    }
+    try {
+      this.logger.info("Validating WebApp project...");
+      let manifest;
+      let strategy;
+      try {
+        const prepared = await this.getManifestAndStrategy(options.projectPath);
+        manifest = prepared.manifest;
+        strategy = prepared.strategy;
+      } catch (error) {
+        return this.handleError(error, "Validation");
+      }
+      try {
+        if (strategy.validateAsync) {
+          await strategy.validateAsync({
+            fileSystem: this.fileSystem,
+            projectPath: options.projectPath,
+            manifest,
+            logger: this.createStrategyLogger()
+          });
+        }
+      } catch (error) {
+        return this.handleError(error, "Validation");
+      }
+      this.logger.info("WebApp project validation completed");
+      return ToolResult.success();
+    } catch (error) {
+      return this.handleError(error, "Validation");
+    }
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation for WebApp is lightweight (metadata preparation only)");
+    return ToolResult.success();
+  }
+  async packAsync(options, _cancellationToken) {
+    if (!options.projectPath) {
+      return this.handleError(new Error(ERROR_MESSAGES.PROJECT_PATH_REQUIRED), "Packing");
+    }
+    if (!options.outputPath) {
+      return this.handleError(new Error(ERROR_MESSAGES.OUTPUT_PATH_REQUIRED), "Packing");
+    }
+    if (!options.package?.id) {
+      return this.handleError(new Error(ERROR_MESSAGES.PACKAGE_NAME_REQUIRED), "Packing");
+    }
+    if (!options.package?.version) {
+      return this.handleError(new Error(ERROR_MESSAGES.PACKAGE_VERSION_REQUIRED), "Packing");
+    }
+    try {
+      this.logger.info(`Packing WebApp project: ${options.package.id}@${options.package.version}`);
+      let manifest;
+      let strategy;
+      try {
+        const prepared = await this.getManifestAndStrategy(options.projectPath);
+        manifest = prepared.manifest;
+        strategy = prepared.strategy;
+      } catch (error) {
+        return this.handleError(error, `Packing WebApp project '${options.package.id}'`);
+      }
+      const nupkgPath = await strategy.packageAsync({
+        fileSystem: this.fileSystem,
+        projectPath: options.projectPath,
+        manifest,
+        outputPath: options.outputPath,
+        packageInfo: options.package,
+        logger: this.createStrategyLogger()
+      });
+      this.logger.info(`WebApp package created successfully: ${nupkgPath}`);
+      return new ToolResult(ToolErrorCodes.Success, "done", [nupkgPath]);
+    } catch (error) {
+      return this.handleError(error, `Packing WebApp project '${options.package.id}'`);
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing WebApp Tool");
+    try {
+      if (this._tempBuildFolder) {
+        await this.fileSystem.rm(this._tempBuildFolder);
+        this._tempBuildFolder = null;
+      }
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async getManifestAndStrategy(projectPath) {
+    const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestExists = await this.fileSystem.exists(manifestPath);
+    if (!manifestExists) {
+      throw new Error(ERROR_MESSAGES.MANIFEST_NOT_FOUND(WEBAPP_MANIFEST_FILE_NAME));
+    }
+    const projectJsonPath = Path.join(projectPath, PROJECT_JSON_FILE);
+    if (await this.fileSystem.exists(projectJsonPath)) {
+      throw new Error(ERROR_MESSAGES.PROJECT_JSON_FOUND);
+    }
+    const manifest = await loadWebAppManifest(this.fileSystem, projectPath);
+    if (!manifest) {
+      throw new Error(ERROR_MESSAGES.MANIFEST_LOAD_FAILED(WEBAPP_MANIFEST_FILE_NAME));
+    }
+    const strategy = VariantStrategyFactory.createStrategy(manifest, this.fileSystem);
+    return { manifest, strategy };
+  }
+  handleError(error, context) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    this.logger.error(`${context}: ${errorMessage}`);
+    let userMessage;
+    if (context === "Validation") {
+      userMessage = ERROR_MESSAGES.VALIDATION_FAILED(errorMessage);
+    } else if (context.startsWith("Packing")) {
+      userMessage = ERROR_MESSAGES.PACKING_FAILED(errorMessage);
+    } else {
+      userMessage = errorMessage;
+    }
+    return ToolResult.error(ToolErrorCodes.InternalError, userMessage);
+  }
+  createStrategyLogger() {
+    return {
+      info: (msg) => this.logger.info(msg),
+      error: (msg) => this.logger.error(msg),
+      progress: (msg) => this.logger.progress(msg),
+      warn: (msg) => this.logger.warn(msg)
+    };
+  }
+}
+
+// ../packager/packager-tool-webapp/src/webapp-tool-factory.ts
+class WebAppToolFactory {
+  supportedTypes = [ProjectTypes.AppV2];
+  async createAsync(logger, fileSystem) {
+    return new WebAppTool(fileSystem, logger);
+  }
+}
+export { WEBAPP_MANIFEST_FILE_NAME, WebAppToolFactory };
+
+//# debugId=858B2D102CDBECEC64756E2164756E21