@uipath/data-fabric-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool.js

@@ -0,0 +1,2568 @@
+import"./packager-tool-1de529jm.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;
+  }
+}
+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 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);
+  }
+}
+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-datafabric/dist/index.js
+var RESERVED_SQL_KEYWORDS_LOWER = new Set(["group", "order"]);
+var RESERVED_FIELD_NAMES_LOWER = new Set([
+  "id",
+  "createdby",
+  "createtime",
+  "updatedby",
+  "updatetime",
+  "recordowner",
+  "version"
+]);
+var RESERVED_KEYWORDS_LOWER = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "boolean",
+  "byref",
+  "byval",
+  "call",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "cint",
+  "clng",
+  "cobj",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "declare",
+  "dim",
+  "directcast",
+  "each",
+  "elseif",
+  "end",
+  "endif",
+  "erase",
+  "error",
+  "exit",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "getxmlnamespace",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "implements",
+  "imports",
+  "inherits",
+  "integer",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "narrowing",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "of",
+  "on",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "property",
+  "raiseevent",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "single",
+  "step",
+  "stop",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "to",
+  "trycast",
+  "uinteger",
+  "ushort",
+  "variant",
+  "wend",
+  "when",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+]);
+function findReservedNameError(name, kind) {
+  if (kind === "field" && RESERVED_FIELD_NAMES_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Field name '${name}' is reserved`,
+      instructions: "The following field names are reserved by the platform (case-insensitive): Id, CreatedBy, CreateTime, UpdatedBy, UpdateTime, RecordOwner, Version. Pick a different name."
+    };
+  }
+  if (RESERVED_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `${kind === "entity" ? "Entity" : kind === "field" ? "Field" : "Choice set"} name '${name}' is a reserved C# or VB keyword`,
+      instructions: "Reserved keywords are rejected with RESERVED_LANGUAGE_KEYWORDS. Pick a domain-specific rename, for example 'Case' -> 'WorkItem', 'Class' -> 'Category', 'New' -> 'IsNew'."
+    };
+  }
+  if (kind === "entity" && RESERVED_SQL_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Entity name '${name}' is a reserved SQL keyword`,
+      instructions: "The platform rejects 'Order' and 'Group' as entity names. Pick a domain-specific name such as 'PurchaseOrder' or 'TeamGroup'."
+    };
+  }
+  return null;
+}
+var SqlTypeName = {
+  UNIQUEIDENTIFIER: "UNIQUEIDENTIFIER",
+  NVARCHAR: "NVARCHAR",
+  INT: "INT",
+  DATETIME2: "DATETIME2",
+  DATETIMEOFFSET: "DATETIMEOFFSET",
+  FLOAT: "FLOAT",
+  REAL: "REAL",
+  BIGINT: "BIGINT",
+  DATE: "DATE",
+  BIT: "BIT",
+  DECIMAL: "DECIMAL",
+  MULTILINE: "MULTILINE",
+  MULTILINE_MAX: "MULTILINE_MAX",
+  UNKNOWN: "UNKNOWN"
+};
+var FieldDisplayType = {
+  Basic: "Basic",
+  Relationship: "Relationship",
+  File: "File",
+  ChoiceSetSingle: "ChoiceSetSingle",
+  ChoiceSetMultiple: "ChoiceSetMultiple",
+  AutoNumber: "AutoNumber",
+  MultiLineText: "MultiLineText"
+};
+var NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9]{2,99}$/;
+var GA_TYPE_PAIRS = [
+  [FieldDisplayType.Basic, SqlTypeName.NVARCHAR],
+  [FieldDisplayType.Basic, SqlTypeName.DECIMAL],
+  [FieldDisplayType.Basic, SqlTypeName.FLOAT],
+  [FieldDisplayType.Basic, SqlTypeName.BIT],
+  [FieldDisplayType.Basic, SqlTypeName.DATE],
+  [FieldDisplayType.Basic, SqlTypeName.DATETIMEOFFSET],
+  [FieldDisplayType.Basic, SqlTypeName.UNIQUEIDENTIFIER],
+  [FieldDisplayType.AutoNumber, SqlTypeName.DECIMAL],
+  [FieldDisplayType.Basic, SqlTypeName.MULTILINE],
+  [FieldDisplayType.Basic, SqlTypeName.MULTILINE_MAX],
+  [FieldDisplayType.File, SqlTypeName.UNIQUEIDENTIFIER]
+];
+var ALLOWED_TYPE_PAIRS = new Set(GA_TYPE_PAIRS.map(([display, sql]) => `${display}:${sql}`));
+var SYSTEM_FIELD_DEFAULTS = {
+  IsPrimaryKey: false,
+  IsForeignKey: false,
+  IsExternalField: false,
+  IsHiddenField: true,
+  FieldCategoryId: 0,
+  IsUnique: false,
+  ReferenceType: "ManyToOne",
+  Transformation: null,
+  IsRequired: false,
+  IsEncrypted: false,
+  Description: "",
+  IsSystemField: true,
+  FieldDisplayType: FieldDisplayType.Basic,
+  IsAttachment: false,
+  IsRbacEnabled: false,
+  IsModelReserved: false
+};
+var SYSTEM_FIELD_TEMPLATES = [
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "Id",
+    DisplayName: "Id",
+    IsPrimaryKey: true,
+    SqlType: { Name: SqlTypeName.UNIQUEIDENTIFIER }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "CreateTime",
+    DisplayName: "CreateTime",
+    SqlType: { Name: SqlTypeName.DATETIMEOFFSET }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "CreatedBy",
+    DisplayName: "CreatedBy",
+    FieldDisplayType: FieldDisplayType.Relationship,
+    SqlType: { Name: SqlTypeName.UNIQUEIDENTIFIER }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "UpdateTime",
+    DisplayName: "UpdateTime",
+    SqlType: { Name: SqlTypeName.DATETIMEOFFSET }
+  },
+  {
+    ...SYSTEM_FIELD_DEFAULTS,
+    Name: "UpdatedBy",
+    DisplayName: "UpdatedBy",
+    FieldDisplayType: FieldDisplayType.Relationship,
+    SqlType: { Name: SqlTypeName.UNIQUEIDENTIFIER }
+  }
+];
+var DIAGNOSTIC_CODES = {
+  entityNameInvalid: "ENTITY_NAME_INVALID",
+  entityNameNotUnique: "ENTITY_NAME_NOT_UNIQUE",
+  fieldNameInvalid: "FIELD_NAME_INVALID",
+  duplicateFieldName: "DUPLICATE_FIELD_NAME",
+  fieldTypeNotAllowed: "FIELD_TYPE_NOT_ALLOWED",
+  nameReserved: "NAME_RESERVED",
+  systemFieldMissing: "SYSTEM_FIELD_MISSING",
+  systemFieldModified: "SYSTEM_FIELD_MODIFIED"
+};
+function validateEntity(entity, ctx) {
+  const diagnostics = [];
+  if (!NAME_PATTERN.test(entity.Name)) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.entityNameInvalid,
+      message: `Entity name '${entity.Name}' must start with a letter and contain 3-100 letters or digits.`,
+      severity: "error"
+    });
+  }
+  const reservedEntityName = findReservedNameError(entity.Name, "entity");
+  if (reservedEntityName) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.nameReserved,
+      message: `${reservedEntityName.message}. ${reservedEntityName.instructions}`,
+      severity: "error"
+    });
+  }
+  const entityNameLower = entity.Name.toLowerCase();
+  if (ctx.siblingNames.some((sibling) => sibling.toLowerCase() === entityNameLower)) {
+    diagnostics.push({
+      code: DIAGNOSTIC_CODES.entityNameNotUnique,
+      message: `An entity named '${entity.Name}' already exists in this solution. Entity names are solution-wide unique.`,
+      severity: "error"
+    });
+  }
+  const seenFieldNames = new Map;
+  for (const field of entity.Fields) {
+    if (!field.IsSystemField && !NAME_PATTERN.test(field.Name)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldNameInvalid,
+        message: `Field name '${field.Name}' must start with a letter and contain 3-100 letters or digits.`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    }
+    if (!field.IsSystemField) {
+      const reservedFieldName = findReservedNameError(field.Name, "field");
+      if (reservedFieldName) {
+        diagnostics.push({
+          code: DIAGNOSTIC_CODES.nameReserved,
+          message: `${reservedFieldName.message}. ${reservedFieldName.instructions}`,
+          severity: "error",
+          fieldName: field.Name
+        });
+      }
+    }
+    const fieldNameLower = field.Name.toLowerCase();
+    const firstWithName = seenFieldNames.get(fieldNameLower);
+    if (firstWithName !== undefined) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.duplicateFieldName,
+        message: `Duplicate field name '${field.Name}' (names are case-insensitive; first defined as '${firstWithName}').`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    } else {
+      seenFieldNames.set(fieldNameLower, field.Name);
+    }
+    if (!field.IsSystemField && !ALLOWED_TYPE_PAIRS.has(`${field.FieldDisplayType}:${field.SqlType.Name}`)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.fieldTypeNotAllowed,
+        message: `Field '${field.Name}' uses an unsupported type combination ` + `(${field.FieldDisplayType} / ${field.SqlType.Name}).`,
+        severity: "error",
+        fieldName: field.Name
+      });
+    }
+  }
+  diagnostics.push(...validateSystemFields(entity));
+  return diagnostics;
+}
+var SERVER_ASSIGNED_FIELD_PROPS = new Set([
+  "Id",
+  "CreateTime",
+  "CreatedBy",
+  "UpdateTime",
+  "UpdatedBy"
+]);
+function isUnmodifiedSystemField(template, actual) {
+  const equal = (left, right) => JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+  for (const key of Object.keys(template)) {
+    if (!equal(template[key], actual[key])) {
+      return false;
+    }
+  }
+  return Object.keys(actual).every((key) => (key in template) || SERVER_ASSIGNED_FIELD_PROPS.has(key));
+}
+function validateSystemFields(entity) {
+  const diagnostics = [];
+  for (const template of SYSTEM_FIELD_TEMPLATES) {
+    const actual = entity.Fields.find((field) => field.Name === template.Name);
+    if (!actual) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.systemFieldMissing,
+        message: `System field '${template.Name}' is missing. System fields cannot be removed.`,
+        severity: "error",
+        fieldName: template.Name
+      });
+      continue;
+    }
+    if (!isUnmodifiedSystemField(template, actual)) {
+      diagnostics.push({
+        code: DIAGNOSTIC_CODES.systemFieldModified,
+        message: `System field '${template.Name}' was modified. System fields are read-only.`,
+        severity: "error",
+        fieldName: template.Name
+      });
+    }
+  }
+  return diagnostics;
+}
+var ENTITY_EXTENSION_CONST = ".entity";
+var ENTITY_VALIDATION_FAILED = "ENTITY_VALIDATION_FAILED";
+var PACK_DIAGNOSTIC_CODES = {
+  misplacedMainFile: "MISPLACED_MAIN_FILE",
+  noParentSolution: "NO_PARENT_SOLUTION"
+};
+var ENTITY_RESOURCE_KIND = "entity";
+class EntityResourceError extends Error {
+  failure;
+  constructor(failure, message) {
+    super(message);
+    this.failure = failure;
+    this.name = "EntityResourceError";
+  }
+}
+function unwrapResource(file) {
+  if (typeof file !== "object" || file === null || Array.isArray(file)) {
+    throw new EntityResourceError("NotAnObject", "Resource file is not a JSON object.");
+  }
+  const resource = file.resource;
+  if (typeof resource !== "object" || resource === null) {
+    throw new EntityResourceError("MissingResource", "Resource file has no 'resource' object.");
+  }
+  if (resource.kind !== ENTITY_RESOURCE_KIND) {
+    throw new EntityResourceError("NotAnEntityResource", `Resource kind is '${String(resource.kind)}', expected '${ENTITY_RESOURCE_KIND}'.`);
+  }
+  const spec = resource.spec;
+  if (typeof spec !== "object" || spec === null || typeof spec.resourceJson !== "string") {
+    throw new EntityResourceError("MissingSpec", "Resource file has no 'spec.resourceJson' string.");
+  }
+  try {
+    return JSON.parse(spec.resourceJson);
+  } catch {
+    throw new EntityResourceError("ResourceJsonUnparsable", "'spec.resourceJson' is not valid JSON.");
+  }
+}
+async function verifyPair(stubFile, solutionDir, fs) {
+  const parsedStub = await readStub(stubFile, fs);
+  if ("failure" in parsedStub) {
+    return { ok: false, failure: parsedStub.failure };
+  }
+  const stub = parsedStub.stub;
+  const baseName = fs.path.basename(stubFile, ENTITY_EXTENSION_CONST);
+  if (baseName !== stub.name) {
+    return fail("StubFileNameMismatch", `Stub file '${baseName}${ENTITY_EXTENSION_CONST}' names entity '${stub.name}' — the filename and the entity name must match.`);
+  }
+  const solutionRoot = fs.path.resolve(solutionDir);
+  const resourceFile = fs.path.resolve(solutionRoot, ...stub.resourcePath.split("/"));
+  const boundary = resourceFile.charAt(solutionRoot.length);
+  if (!resourceFile.startsWith(solutionRoot) || boundary !== "/" && boundary !== "\\") {
+    return fail("ResourcePathEscapes", `'${stub.name}': resourcePath '${stub.resourcePath}' points outside the solution.`);
+  }
+  const parsedResource = await readResource(resourceFile, stub.name, stub.resourcePath, fs);
+  if ("failure" in parsedResource) {
+    return { ok: false, failure: parsedResource.failure };
+  }
+  const resourceRaw = parsedResource.raw;
+  let entity;
+  try {
+    entity = unwrapResource(resourceRaw);
+  } catch (error) {
+    const detail = error instanceof EntityResourceError ? ` (${error.failure})` : "";
+    return fail("ResourceInvalid", `'${stub.name}': resource '${stub.resourcePath}' is not a valid entity resource${detail}.`);
+  }
+  if (entity.Name !== stub.name) {
+    return fail("NameCoupling", `Stub '${stub.name}' points at a resource defining entity '${entity.Name}' — the names must match.`);
+  }
+  return { ok: true, entityName: stub.name, resourceFile, entity };
+}
+function fail(code, message) {
+  return { ok: false, failure: { code, message } };
+}
+async function readStub(stubFile, fs) {
+  let parsed;
+  try {
+    const raw = await fs.readFile(stubFile);
+    if (raw === null) {
+      return failure("StubUnparsable", `'${stubFile}' could not be read.`);
+    }
+    parsed = JSON.parse(decode(raw));
+  } catch {
+    return failure("StubUnparsable", `'${stubFile}' is not valid JSON.`);
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.name !== "string" || typeof parsed.resourcePath !== "string") {
+    return failure("StubUnparsable", `'${stubFile}' must be an object with string 'name' and 'resourcePath'.`);
+  }
+  return { stub: { name: parsed.name, resourcePath: parsed.resourcePath } };
+}
+async function readResource(resourceFile, entityName, resourcePath, fs) {
+  const missing = failure("ResourceMissing", `'${entityName}': definition resource '${resourcePath}' is missing. Restore it (check trash/backup) or delete the entity.`);
+  try {
+    const raw = await fs.readFile(resourceFile);
+    if (raw === null) {
+      return missing;
+    }
+    return { raw: JSON.parse(decode(raw)) };
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      return failure("ResourceInvalid", `'${entityName}': resource '${resourcePath}' is not valid JSON.`);
+    }
+    return missing;
+  }
+}
+function decode(raw) {
+  return typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+}
+function failure(code, message) {
+  return { failure: { code, message } };
+}
+async function findSolutionRoot(startDir, fs) {
+  let dir = fs.path.resolve(startDir);
+  for (;; ) {
+    let entries = [];
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      entries = [];
+    }
+    if (entries.some((name) => name.endsWith(".uipx"))) {
+      return dir;
+    }
+    const parent = fs.path.dirname(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+}
+
+class EntityProjectTool extends ProjectTool {
+  async validateAsync(options, _cancellationToken) {
+    return this.checkProjectAsync(options.projectPath);
+  }
+  async packAsync(options, _cancellationToken) {
+    const result = await this.checkProjectAsync(options.projectPath);
+    if (result.isSuccess) {
+      this.logger.info("Entity project is valid — no package emitted; the entity resources are the deployable payload.");
+    }
+    return result;
+  }
+  async checkProjectAsync(projectPath) {
+    const fs = this.fileSystem;
+    const diagnostics = [];
+    let entries = [];
+    try {
+      entries = await fs.readdir(projectPath);
+    } catch {
+      return new ToolResult(ENTITY_VALIDATION_FAILED, `Entity project directory '${projectPath}' could not be read.`, [], "Check that the project path in the solution manifest points at an existing directory.");
+    }
+    const stubs = sorted(entries.filter((name) => name.endsWith(ENTITY_EXTENSION_CONST)));
+    for (const foreign of sorted(entries.filter((name) => name.endsWith(".flow")))) {
+      diagnostics.push({
+        file: fs.path.join(projectPath, foreign),
+        code: PACK_DIAGNOSTIC_CODES.misplacedMainFile,
+        message: `'${foreign}' is a Flow main file inside an Entity project — move it to a Flow project.`
+      });
+    }
+    const solutionDir = await findSolutionRoot(projectPath, fs);
+    if (solutionDir === undefined) {
+      if (stubs.length > 0) {
+        diagnostics.push({
+          file: projectPath,
+          code: PACK_DIAGNOSTIC_CODES.noParentSolution,
+          message: "Entity project has no parent solution (.uipx not found) — the stubs' solution-relative resource pointers cannot resolve."
+        });
+      }
+    } else {
+      diagnostics.push(...await this.checkStubsAsync(projectPath, solutionDir, stubs));
+    }
+    if (diagnostics.length === 0) {
+      return ToolResult.success();
+    }
+    const result = new ToolResult(ENTITY_VALIDATION_FAILED, `Entity validation failed with ${diagnostics.length} issue(s). First: ${diagnostics[0]?.message}`, [], "Fix the listed entities (open them in the entity editor, or restore missing resources) and pack again.");
+    result.details = { diagnostics };
+    return result;
+  }
+  async checkStubsAsync(projectPath, solutionDir, stubs) {
+    const fs = this.fileSystem;
+    const diagnostics = [];
+    const allEntityNames = await collectSolutionEntityNames(solutionDir, fs);
+    for (const stubName of stubs) {
+      const stubFile = fs.path.join(projectPath, stubName);
+      const pair = await verifyPair(stubFile, solutionDir, fs);
+      if (!pair.ok) {
+        diagnostics.push({
+          file: stubFile,
+          code: pair.failure.code,
+          message: pair.failure.message
+        });
+        continue;
+      }
+      for (const diagnostic of validateEntity(pair.entity, {
+        siblingNames: withoutOneOccurrence(allEntityNames, pair.entityName)
+      })) {
+        diagnostics.push({
+          file: pair.resourceFile,
+          code: diagnostic.code,
+          message: diagnostic.message,
+          fieldName: diagnostic.fieldName
+        });
+      }
+    }
+    return diagnostics;
+  }
+}
+function sorted(names) {
+  return [...names].sort(compareCodeUnits);
+}
+function compareCodeUnits(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  return left > right ? 1 : 0;
+}
+function withoutOneOccurrence(names, name) {
+  const siblings = [...names];
+  const self = siblings.indexOf(name);
+  if (self >= 0) {
+    siblings.splice(self, 1);
+  }
+  return siblings;
+}
+async function collectSolutionEntityNames(solutionDir, fs) {
+  const names = [];
+  let topLevel = [];
+  try {
+    topLevel = await fs.readdir(solutionDir);
+  } catch {
+    return names;
+  }
+  for (const entry of topLevel) {
+    if (entry === "resources" || entry.startsWith(".")) {
+      continue;
+    }
+    const dir = fs.path.join(solutionDir, entry);
+    try {
+      const stat = await fs.stat(dir);
+      if (!stat?.isDirectory()) {
+        continue;
+      }
+      for (const file of await fs.readdir(dir)) {
+        if (file.endsWith(ENTITY_EXTENSION_CONST)) {
+          names.push(fs.path.basename(file, ENTITY_EXTENSION_CONST));
+        }
+      }
+    } catch {}
+  }
+  return names;
+}
+
+class EntityToolFactory {
+  supportedTypes = ["Entity"];
+  async createAsync(logger, fileSystem) {
+    return new EntityProjectTool(fileSystem, logger);
+  }
+}
+// ../packager/packager-core/src/i18n/types.ts
+function isPluralForm2(value) {
+  return typeof value === "object" && value !== null && "other" in value;
+}
+function selectPluralForm2(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;
+}
+
+// ../packager/packager-core/src/i18n/i18n-manager.ts
+class I18nManager2 {
+  static translations = {};
+  static currentLocale = "en";
+  static fallbackLocale = "en";
+  static registerTranslations(locale, catalog) {
+    if (!I18nManager2.translations[locale]) {
+      I18nManager2.translations[locale] = {};
+    }
+    I18nManager2.translations[locale] = I18nManager2.deepMerge(I18nManager2.translations[locale], catalog);
+  }
+  static setLocale(locale) {
+    const normalized = I18nManager2.normalizeLocale(locale);
+    if (I18nManager2.translations[normalized]) {
+      I18nManager2.currentLocale = normalized;
+      return normalized;
+    }
+    const baseLocale = normalized.split("-")[0];
+    if (baseLocale !== normalized && I18nManager2.translations[baseLocale]) {
+      I18nManager2.currentLocale = baseLocale;
+      return baseLocale;
+    }
+    return I18nManager2.currentLocale;
+  }
+  static getLocale() {
+    return I18nManager2.currentLocale;
+  }
+  static setFallbackLocale(locale) {
+    I18nManager2.fallbackLocale = I18nManager2.normalizeLocale(locale);
+  }
+  static t(key, params, locale) {
+    const targetLocale = locale ? I18nManager2.normalizeLocale(locale) : I18nManager2.currentLocale;
+    let value = I18nManager2.getTranslationValue(key, targetLocale);
+    if (value === undefined && targetLocale !== I18nManager2.fallbackLocale) {
+      value = I18nManager2.getTranslationValue(key, I18nManager2.fallbackLocale);
+    }
+    if (value === undefined) {
+      return key;
+    }
+    if (isPluralForm2(value) && params && "count" in params) {
+      const count = typeof params.count === "number" ? params.count : Number(params.count);
+      value = selectPluralForm2(value, count);
+    } else if (isPluralForm2(value)) {
+      value = value.other;
+    }
+    if (typeof value !== "string") {
+      return key;
+    }
+    return params ? I18nManager2.interpolate(value, params) : value;
+  }
+  static has(key, locale) {
+    const targetLocale = locale ? I18nManager2.normalizeLocale(locale) : I18nManager2.currentLocale;
+    const value = I18nManager2.getTranslationValue(key, targetLocale);
+    if (value !== undefined) {
+      return true;
+    }
+    if (targetLocale !== I18nManager2.fallbackLocale) {
+      return I18nManager2.getTranslationValue(key, I18nManager2.fallbackLocale) !== undefined;
+    }
+    return false;
+  }
+  static getAvailableLocales() {
+    return Object.keys(I18nManager2.translations);
+  }
+  static clearTranslations() {
+    I18nManager2.translations = {};
+    I18nManager2.currentLocale = "en";
+  }
+  static getTranslationValue(key, locale) {
+    const catalog = I18nManager2.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] = I18nManager2.deepMerge(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+    return result;
+  }
+}
+
+// ../packager/packager-core/src/i18n/locales/de.ts
+var de2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/en.ts
+var en2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/es.ts
+var es2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/es-MX.ts
+var es_MX2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/fr.ts
+var fr2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ja.ts
+var ja2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ko.ts
+var ko2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/pt.ts
+var pt2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/pt-BR.ts
+var pt_BR2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ro.ts
+var ro2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/ru.ts
+var ru2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/tr.ts
+var tr2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/zh-CN.ts
+var zh_CN2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/zh-TW.ts
+var zh_TW2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/locales/zu.ts
+var zu2 = {
+  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"
+      }
+    }
+  }
+};
+
+// ../packager/packager-core/src/i18n/translation-service.ts
+class TranslationService2 {
+  static instance;
+  currentLocale = "en";
+  constructor() {}
+  static getInstance() {
+    if (!TranslationService2.instance) {
+      TranslationService2.instance = new TranslationService2;
+    }
+    return TranslationService2.instance;
+  }
+  setLocale(locale) {
+    this.currentLocale = I18nManager2.setLocale(locale);
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  t(key, params) {
+    return I18nManager2.t(key, params, this.currentLocale);
+  }
+  tLocale(key, locale, params) {
+    return I18nManager2.t(key, params, locale);
+  }
+  has(key) {
+    return I18nManager2.has(key, this.currentLocale);
+  }
+  getAvailableLocales() {
+    return I18nManager2.getAvailableLocales();
+  }
+}
+var translate2 = TranslationService2.getInstance();
+
+// ../packager/packager-core/src/i18n/index.ts
+I18nManager2.registerTranslations("en", en2);
+I18nManager2.registerTranslations("de", de2);
+I18nManager2.registerTranslations("es", es2);
+I18nManager2.registerTranslations("es-mx", es_MX2);
+I18nManager2.registerTranslations("fr", fr2);
+I18nManager2.registerTranslations("ja", ja2);
+I18nManager2.registerTranslations("ko", ko2);
+I18nManager2.registerTranslations("pt", pt2);
+I18nManager2.registerTranslations("pt-br", pt_BR2);
+I18nManager2.registerTranslations("ro", ro2);
+I18nManager2.registerTranslations("ru", ru2);
+I18nManager2.registerTranslations("tr", tr2);
+I18nManager2.registerTranslations("zh-cn", zh_CN2);
+I18nManager2.registerTranslations("zh-tw", zh_TW2);
+I18nManager2.registerTranslations("zu", zu2);
+I18nManager2.setLocale("en");
+// ../packager/packager-core/src/services/tools-factory-repository.ts
+class ToolsFactoryRepository2 {
+  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_KEY2 = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
+var _global2 = globalThis;
+if (!_global2[REGISTRY_KEY2]) {
+  _global2[REGISTRY_KEY2] = new ToolsFactoryRepository2;
+}
+var toolsFactoryRepository2 = _global2[REGISTRY_KEY2];
+// src/packager-tool.ts
+function registerPackagerFactories() {
+  toolsFactoryRepository2.registerProjectToolFactory(new EntityToolFactory);
+}
+export {
+  registerPackagerFactories
+};
+
+//# debugId=FE1A9AF3349DA14F64756E2164756E21