@uipath/solution-tool 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/packager-tool-wz34ma3s.js

@@ -0,0 +1,1333 @@
+import {
+  PackageIdReader
+} from "./packager-tool-09swr9cp.js";
+import {
+  BaseNodePackagerFactory,
+  DotnetDiscoveryService,
+  NodePackageSignService
+} from "./packager-tool-b03rva43.js";
+import {
+  GovernancePolicyService,
+  PackService,
+  PackagerParameters,
+  PackagerParametersValidator,
+  ProjectLoader,
+  ProjectToolExecutor,
+  ToolLogger,
+  ToolsFactory,
+  isPackageIdTooLongError,
+  resolveProducedNupkgsAsync,
+  signNupkgsAsync
+} from "./packager-tool-n5d5dx5j.js";
+import {
+  I18nManager,
+  Path,
+  TemporaryStorageService,
+  ToolResult,
+  ZipService,
+  toolsFactoryRepository,
+  translate
+} from "./packager-tool-pbmqk39a.js";
+import {
+  PackagerDimensions,
+  carriedInstructions
+} from "./packager-tool-6ybywxxn.js";
+
+// ../packager/solution-packager/src/models/solution-pack-options.ts
+class SolutionPackOptions extends PackagerParameters {
+  destinationPath;
+  projectDesignIds;
+  validateOptions = {
+    skipAnalyze: false,
+    skipValidate: false,
+    governanceFileType: "Default" /* Default */
+  };
+  package;
+  solutionType;
+  configuration = "Release" /* Release */;
+  signingInfo;
+  packOptions;
+  publishInfo;
+  cleanupOptions = {
+    dryRun: false,
+    skipImports: false
+  };
+  lockKey;
+  localSourcePath;
+}
+
+// ../packager/solution-packager/src/services/member-package-ids.ts
+var INVALID_PACKAGE_ID = "INVALID_PACKAGE_ID";
+function memberFolder(project) {
+  return Path.dirname(project.ProjectRelativePath);
+}
+function findPackageIdConflicts(members) {
+  const byId = new Map;
+  for (const member of members) {
+    if (!member.id) {
+      continue;
+    }
+    const key = member.id.toLowerCase();
+    const existing = byId.get(key);
+    if (existing) {
+      existing.folders.push(member.folder);
+      continue;
+    }
+    byId.set(key, { id: member.id, folders: [member.folder] });
+  }
+  return [...byId.values()].filter((conflict) => conflict.folders.length > 1);
+}
+function packageIdConflictMessage(conflicts) {
+  const described = conflicts.map((conflict) => `'${conflict.id}' from ${conflict.folders.map((folder) => `'${folder}'`).join(" and ")}`).join("; ");
+  return `Solution members share a package id: ${described}. A NuGet feed stores one package per id and version, so one member's package would replace the other's.`;
+}
+
+// ../packager/solution-packager/src/services/tool-result-helpers.ts
+function hasFailedResults(results) {
+  return results.some((result) => !result.isSuccess);
+}
+function getFailedResultsMessage(results) {
+  return results.filter((result) => !result.isSuccess).map((r) => r.message || "Unknown error").join(", ");
+}
+function getFailedResultsInstructions(results) {
+  const instructions = new Set;
+  for (const result of results) {
+    const next = result.isSuccess ? undefined : result.instructions?.trim();
+    if (next) {
+      instructions.add(next);
+    }
+  }
+  return instructions.size > 0 ? [...instructions].join(" ") : undefined;
+}
+function toProjectDiagnostics(projects, results) {
+  return projects.map((project, index) => {
+    const result = results[index];
+    const findings = result?.details?.findings;
+    return {
+      Path: Path.dirname(project.ProjectRelativePath),
+      Type: project.Type,
+      Result: result?.isSuccess ? "Success" : "Failure",
+      Message: result?.message,
+      Findings: Array.isArray(findings) ? findings.map(toFindingContract) : []
+    };
+  });
+}
+var FINDING_FIELDS = [
+  "Level",
+  "Source",
+  "ErrorCode",
+  "RuleName",
+  "Description",
+  "FilePath",
+  "ActivityIdRef",
+  "DocumentationLink"
+];
+var CAMEL_TO_CONTRACT = new Map(FINDING_FIELDS.map((field) => [
+  field[0].toLowerCase() + field.slice(1),
+  field
+]));
+function toFindingContract(finding) {
+  if (typeof finding !== "object" || finding === null) {
+    return {};
+  }
+  const source = finding;
+  const normalized = {};
+  for (const [key, value] of Object.entries(source)) {
+    const contractName = CAMEL_TO_CONTRACT.get(key);
+    if (contractName === undefined) {
+      normalized[key] = value;
+    } else if (source[contractName] === undefined) {
+      normalized[contractName] = value;
+    }
+  }
+  return normalized;
+}
+// ../packager/solution-packager/src/i18n/locales/de.json
+var de_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+
+// ../packager/solution-packager/src/i18n/locales/en.ts
+var en = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/es.json
+var es_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/es-MX.json
+var es_MX_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/fr.json
+var fr_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/ja.json
+var ja_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/ko.json
+var ko_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/pt.json
+var pt_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/ro.json
+var ro_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/ru.json
+var ru_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/tr.json
+var tr_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// ../packager/solution-packager/src/i18n/locales/zu.json
+var zu_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution projects add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+
+// ../packager/solution-packager/src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+// ../packager/solution-packager/src/services/options-builder.ts
+class OptionsBuilder {
+  packageIdReader;
+  packService;
+  fileSystem;
+  constructor(packageIdReader, packService, fileSystem) {
+    this.packageIdReader = packageIdReader;
+    this.packService = packService;
+    this.fileSystem = fileSystem;
+  }
+  static FILES_DIRECTORY_NAME = "files";
+  static DEFAULT_AUTHOR = "UiPath";
+  static DEFAULT_DESCRIPTION = "Created by UiPath";
+  async buildSolutionPackOptions(parameters, solution) {
+    if (!parameters.outputPath) {
+      throw new Error(translate.t("solutionpackager.optionsBuilder.errors.outputPathRequired"));
+    }
+    await this.createOutputFilesDirectoryAsync(parameters.outputPath);
+    if (!parameters.package.id || parameters.package.id.trim() === "") {
+      parameters.package.id = solution.Name;
+    }
+    return {
+      solutionFilePath: solution.filePath,
+      outputPath: parameters.outputPath,
+      connection: parameters.connection,
+      configuration: parameters.configuration,
+      package: parameters.package,
+      solutionType: parameters.solutionType,
+      publishId: parameters.publishInfo?.id,
+      projectsToBuild: solution.Projects.map((p) => p.Id)
+    };
+  }
+  async resolveMemberMetadataAsync(solutionOptions, projectPath) {
+    const declared = await this.loadDeclaredMetadataAsync(projectPath);
+    return {
+      author: solutionOptions.package.author?.trim() || declared?.author || OptionsBuilder.DEFAULT_AUTHOR,
+      description: solutionOptions.package.description?.trim() || declared?.description || OptionsBuilder.DEFAULT_DESCRIPTION
+    };
+  }
+  async loadDeclaredMetadataAsync(projectPath) {
+    try {
+      const loaded = await new ProjectLoader(this.fileSystem).loadProject(projectPath);
+      return {
+        author: loaded.author,
+        description: loaded.description
+      };
+    } catch {
+      return;
+    }
+  }
+  async createOutputFilesDirectoryAsync(outputPath) {
+    const filesDir = Path.join(outputPath, OptionsBuilder.FILES_DIRECTORY_NAME);
+    await this.fileSystem.mkdir(filesDir);
+  }
+  async buildProjectPackOptions(solutionOptions, project, solutionName) {
+    const projectPath = this.resolveProjectPath(solutionOptions, project);
+    const packageInfo = {
+      ...solutionOptions.package,
+      id: await this.packageIdReader.read(project, solutionOptions.inputPath, solutionName) || "",
+      ...await this.resolveMemberMetadataAsync(solutionOptions, projectPath)
+    };
+    if (!solutionOptions.outputPath) {
+      throw new Error(translate.t("solutionpackager.optionsBuilder.errors.outputPathRequired"));
+    }
+    const packageId = !packageInfo.id || packageInfo.id.trim() === "" ? Path.basename(projectPath) : packageInfo.id;
+    packageInfo.id = this.packService.sanitizePackageId(packageId);
+    return {
+      projectPath,
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      feedFolder: solutionOptions.feedFolder,
+      logLevel: solutionOptions.logLevel,
+      skipAnalyze: solutionOptions.validateOptions.skipAnalyze,
+      skipValidate: solutionOptions.validateOptions.skipValidate,
+      ignoredRules: solutionOptions.validateOptions.ignoredRules,
+      projectStorageId: project.StorageId,
+      detailedLogPath: solutionOptions.detailedLogPath,
+      policyFilePath: solutionOptions.validateOptions.governanceFilePath,
+      policyFileType: solutionOptions.validateOptions.governanceFileType,
+      outputPath: await this.buildProjectOutputPath(solutionOptions.outputPath, project),
+      outputType: undefined,
+      projectType: project.Type,
+      package: packageInfo,
+      skipDependencyOptimization: solutionOptions.packOptions?.skipDependencyOptimization ?? false,
+      includeSources: solutionOptions.packOptions?.includeSources ?? false,
+      splitPackages: solutionOptions.packOptions?.splitPackages ?? false
+    };
+  }
+  buildProjectValidateOptions(solutionOptions, project) {
+    return {
+      projectPath: this.resolveProjectPath(solutionOptions, project),
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      feedFolder: solutionOptions.feedFolder,
+      logLevel: solutionOptions.logLevel,
+      skipAnalyze: solutionOptions.validateOptions.skipAnalyze,
+      skipValidate: solutionOptions.validateOptions.skipValidate,
+      ignoredRules: solutionOptions.validateOptions.ignoredRules,
+      defaultSeverity: solutionOptions.validateOptions.defaultSeverity,
+      detailedLogPath: solutionOptions.detailedLogPath,
+      policyFilePath: solutionOptions.validateOptions.governanceFilePath,
+      policyFileType: solutionOptions.validateOptions.governanceFileType
+    };
+  }
+  async buildProjectRestoreOptions(solutionOptions, project) {
+    if (!solutionOptions.outputPath) {
+      throw new Error(translate.t("solutionpackager.optionsBuilder.errors.outputPathRequired"));
+    }
+    return {
+      projectPath: this.resolveProjectPath(solutionOptions, project),
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      feedFolder: solutionOptions.feedFolder,
+      logLevel: solutionOptions.logLevel,
+      outputPath: await this.buildProjectOutputPath(solutionOptions.outputPath, project)
+    };
+  }
+  buildProjectCleanupOptions(solutionOptions, project) {
+    return {
+      projectPath: this.resolveProjectPath(solutionOptions, project),
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      feedFolder: solutionOptions.feedFolder,
+      logLevel: solutionOptions.logLevel,
+      dryRun: solutionOptions.cleanupOptions.dryRun,
+      skipImports: solutionOptions.cleanupOptions.skipImports
+    };
+  }
+  resolveProjectPath(solutionOptions, project) {
+    return Path.join(solutionOptions.inputPath, Path.dirname(project.ProjectRelativePath));
+  }
+  async buildProjectOutputPath(solutionOutputPath, project) {
+    const filesDir = Path.join(solutionOutputPath, OptionsBuilder.FILES_DIRECTORY_NAME);
+    const projectOutputPath = Path.join(filesDir, project.Id);
+    await this.fileSystem.mkdir(projectOutputPath);
+    return projectOutputPath;
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-cleanup-service.ts
+class SolutionCleanupService {
+  optionsBuilder;
+  projectExecutor;
+  telemetry;
+  constructor(optionsBuilder, projectExecutor, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.projectExecutor = projectExecutor;
+    this.telemetry = telemetry;
+  }
+  async cleanupAsync(parameters, solution, context, cancellationToken) {
+    return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Cleanup" /* SolutionCleanup */, "cleanup", async () => {
+      const projectResults = await Promise.all(solution.Projects.map(async (project) => {
+        if (project.ProjectPath == null) {
+          return {
+            project,
+            result: ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before cleanup.`)
+          };
+        }
+        const result2 = await this.projectExecutor.cleanupAsync(this.optionsBuilder.buildProjectCleanupOptions(parameters, project), project, context, cancellationToken);
+        return { project, result: result2 };
+      }));
+      const failed = projectResults.find((r) => !r.result.isSuccess);
+      if (failed) {
+        return failed.result;
+      }
+      const result = ToolResult.success();
+      const details = {};
+      const changedFilesByProject = this.mergeChangedFiles(projectResults.map((r) => r.result));
+      if (Object.keys(changedFilesByProject).length > 0) {
+        details.changedFilesByProject = changedFilesByProject;
+      }
+      const cleanupByProject = this.collectProjectCleanups(projectResults);
+      if (Object.keys(cleanupByProject).length > 0) {
+        details.cleanupByProject = cleanupByProject;
+      }
+      if (Object.keys(details).length > 0) {
+        result.details = details;
+      }
+      return result;
+    }, { [PackagerDimensions.SolutionId]: solution.SolutionId });
+  }
+  mergeChangedFiles(results) {
+    const merged = {};
+    for (const result of results) {
+      const changed = result.details?.changedFilesByProject;
+      if (!changed) {
+        continue;
+      }
+      for (const [projectId, files] of Object.entries(changed)) {
+        merged[projectId] = files;
+      }
+    }
+    return merged;
+  }
+  collectProjectCleanups(results) {
+    const byProject = {};
+    for (const { project, result } of results) {
+      const info = result.details?.projectCleanup;
+      if (info) {
+        byProject[project.Id] = info;
+      }
+    }
+    return byProject;
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-loader.ts
+class SolutionLoader {
+  fileSystem;
+  static SolutionStorageFileName = "SolutionStorage.json";
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async loadSolution(solutionPath) {
+    if (!solutionPath) {
+      throw new Error(translate.t("solutionpackager.solutionLoader.errors.pathRequired"));
+    }
+    const solutionFilePath = await this.getSolutionFilePathAsync(solutionPath);
+    const fileContent = await this.fileSystem.readFile(solutionFilePath);
+    if (!fileContent) {
+      throw new Error(translate.t("solutionpackager.solutionLoader.errors.fileNotFound", {
+        path: solutionFilePath
+      }));
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const parsed = JSON.parse(json);
+    const solution = validateSolutionFile(parsed, solutionFilePath);
+    const loadedSolution = {
+      ...solution,
+      Name: GetSolutionName(),
+      filePath: solutionFilePath
+    };
+    for (const project of loadedSolution.Projects) {
+      const projectRelativeDir = Path.dirname(project.ProjectRelativePath);
+      project.ProjectPath = Path.join(solutionPath, projectRelativeDir);
+    }
+    await this.populateStorageIds(loadedSolution, solutionPath);
+    return loadedSolution;
+    function GetSolutionName() {
+      const uipxFileName = Path.basename(solutionFilePath);
+      return uipxFileName.replace(/\.uipx$/i, "");
+    }
+  }
+  async getSolutionFilePathAsync(solutionPath) {
+    const files = await this.fileSystem.readdir(solutionPath);
+    const uipxFile = files.find((file) => file.endsWith(".uipx"));
+    if (!uipxFile) {
+      throw new Error(translate.t("solutionpackager.solutionLoader.errors.noSolutionFile", {
+        path: solutionPath
+      }));
+    }
+    return Path.join(solutionPath, uipxFile);
+  }
+  async populateStorageIds(solution, rootDirectory) {
+    const storageFile = Path.join(rootDirectory, SolutionLoader.SolutionStorageFileName);
+    const exists = await this.fileSystem.exists(storageFile);
+    if (!exists) {
+      return;
+    }
+    const fileContent = await this.fileSystem.readFile(storageFile);
+    if (!fileContent) {
+      return;
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const storage = JSON.parse(json);
+    if (!storage?.Projects) {
+      throw new Error(translate.t("solutionpackager.solutionLoader.errors.invalidStorageFile", {
+        fileName: SolutionLoader.SolutionStorageFileName
+      }));
+    }
+    for (const project of solution.Projects) {
+      const storageProject = storage.Projects.find((sp) => sp.ProjectRelativePath === project.ProjectRelativePath);
+      if (storageProject) {
+        project.StorageId = storageProject.ProjectId;
+      }
+    }
+  }
+}
+function validateSolutionFile(parsed, solutionFilePath) {
+  if (!isRecord(parsed)) {
+    throw new Error(translate.t("solutionpackager.solutionLoader.errors.invalidSolution", {
+      path: solutionFilePath
+    }));
+  }
+  if (!Array.isArray(parsed.Projects)) {
+    throw new Error(translate.t("solutionpackager.solutionLoader.errors.invalidSolution", {
+      path: solutionFilePath
+    }));
+  }
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      throw new Error(translate.t("solutionpackager.solutionLoader.errors.projectMustBeObject", {
+        path: solutionFilePath,
+        index
+      }));
+    }
+    if (typeof project.ProjectRelativePath !== "string" || !project.ProjectRelativePath.trim()) {
+      const pathHint = typeof project.Path === "string" ? translate.t("solutionpackager.solutionLoader.errors.projectRelativePathPathHint") : "";
+      throw new Error(translate.t("solutionpackager.solutionLoader.errors.projectMissingProjectRelativePath", {
+        path: solutionFilePath,
+        index,
+        pathHint
+      }));
+    }
+  }
+  return parsed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// ../packager/solution-packager/src/services/solution-pack-options-validator.ts
+class SolutionPackOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    const destinationResult = this.validateDestinationPath(options.destinationPath);
+    if (!destinationResult.isSuccess) {
+      return destinationResult;
+    }
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-pack-service.ts
+class SolutionPackService {
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  zipService;
+  fileSystem;
+  telemetry;
+  packageSignService;
+  constructor(optionsBuilder, toolsFactory, projectExecutor, zipService, fileSystem, telemetry, packageSignService) {
+    this.optionsBuilder = optionsBuilder;
+    this.toolsFactory = toolsFactory;
+    this.projectExecutor = projectExecutor;
+    this.zipService = zipService;
+    this.fileSystem = fileSystem;
+    this.telemetry = telemetry;
+    this.packageSignService = packageSignService;
+  }
+  async packAsync(parameters, solution, context, cancellationToken) {
+    const solutionOptions = await this.optionsBuilder.buildSolutionPackOptions(parameters, solution);
+    const prepared = await this.prepareProjectPackOptionsAsync(parameters, solution.Projects, solution.Name);
+    if (!prepared.ok) {
+      return ToolResult.error(prepared.errorCode, `Solution pack failed: ${prepared.message}`);
+    }
+    const solutionTool = await this.toolsFactory.createSolutionToolAsync(solution.SolutionId);
+    try {
+      return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Pack" /* SolutionPack */, "pack", async () => {
+        const [restoreResult, ...projectResults] = await Promise.all([
+          solutionTool.restoreAsync(solutionOptions, cancellationToken),
+          ...this.packAllProjectsAsync(prepared.options, context, cancellationToken)
+        ]);
+        const restoreAndPackResults = [
+          restoreResult,
+          ...projectResults
+        ];
+        if (hasFailedResults(restoreAndPackResults)) {
+          const failure = ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`, getFailedResultsInstructions(restoreAndPackResults));
+          failure.details = {
+            projects: toProjectDiagnostics(solution.Projects, projectResults)
+          };
+          return failure;
+        }
+        const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
+        if (!buildResult.isSuccess) {
+          return ToolResult.error(buildResult.errorCode, `Solution build failed: ${buildResult.message || "Unknown error"}`);
+        }
+        if (!solutionOptions.outputPath) {
+          return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "Solution output path is not defined");
+        }
+        const signResult = await this.signProjectPackagesAsync(projectResults, parameters.signingInfo);
+        if (!signResult.isSuccess) {
+          return signResult;
+        }
+        const archivePath = await this.compressSolutionAsync(parameters, solutionOptions.outputPath);
+        return new ToolResult("SUCCESS" /* Success */, undefined, [
+          archivePath
+        ]);
+      }, { [PackagerDimensions.SolutionId]: solution.SolutionId });
+    } finally {
+      const disposeResult = solutionTool.dispose();
+      if (disposeResult instanceof Promise) {
+        await disposeResult;
+      }
+    }
+  }
+  async prepareProjectPackOptionsAsync(parameters, projects, solutionName) {
+    const settled = await Promise.allSettled(projects.map((project) => this.optionsBuilder.buildProjectPackOptions(parameters, project, solutionName)));
+    const prepared = [];
+    const failures = [];
+    settled.forEach((result, index) => {
+      const project = projects[index];
+      if (result.status === "fulfilled") {
+        prepared.push({ project, options: result.value });
+        return;
+      }
+      const error = result.reason;
+      const message = error instanceof Error ? error.message : String(error);
+      failures.push(isPackageIdTooLongError(error) ? {
+        message: `${message} (member '${memberFolder(project)}')`,
+        isIdFailure: true
+      } : { message, isIdFailure: false });
+    });
+    if (failures.length > 0) {
+      return {
+        ok: false,
+        errorCode: failures.every((failure) => failure.isIdFailure) ? INVALID_PACKAGE_ID : "INTERNAL_ERROR" /* InternalError */,
+        message: failures.map((failure) => failure.message).join("; ")
+      };
+    }
+    const conflicts = findPackageIdConflicts(prepared.map((entry) => ({
+      folder: memberFolder(entry.project),
+      id: entry.options.package?.id ?? ""
+    })));
+    if (conflicts.length > 0) {
+      return {
+        ok: false,
+        errorCode: INVALID_PACKAGE_ID,
+        message: packageIdConflictMessage(conflicts)
+      };
+    }
+    return { ok: true, options: prepared };
+  }
+  packAllProjectsAsync(prepared, context, cancellationToken) {
+    return prepared.map((entry) => this.packSingleProjectAsync(entry, context, cancellationToken));
+  }
+  async packSingleProjectAsync(prepared, context, cancellationToken) {
+    try {
+      return await this.projectExecutor.packAsync(prepared.options, prepared.project, context, cancellationToken);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, errorMessage);
+    }
+  }
+  async signProjectPackagesAsync(projectResults, signingInfo) {
+    if (!signingInfo?.certificatePath) {
+      return ToolResult.success();
+    }
+    const producedPaths = projectResults.flatMap((result) => result.packages);
+    const resolved = await Promise.all(producedPaths.map(async (producedPath) => ({
+      producedPath,
+      nupkgs: await resolveProducedNupkgsAsync(this.fileSystem, producedPath)
+    })));
+    const unresolved = resolved.filter((entry) => entry.nupkgs.length === 0).map((entry) => entry.producedPath);
+    if (unresolved.length > 0) {
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Package signing was required but no .nupkg was found to sign for: ${unresolved.join(", ")}.`);
+    }
+    const nupkgsToSign = resolved.flatMap((entry) => entry.nupkgs);
+    return signNupkgsAsync(this.packageSignService, nupkgsToSign, signingInfo);
+  }
+  async compressSolutionAsync(parameters, outputPath) {
+    return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Compress" /* SolutionCompress */, "compress", async () => {
+      const packageName = parameters.package.id || "solution";
+      const version = parameters.package.version || "1.0.0";
+      await this.writePackageMetadataAsync(parameters, outputPath);
+      const archiveFileName = `${packageName}_${version}.zip`;
+      const archivePath = `${parameters.destinationPath}/${archiveFileName}`;
+      const zipData = await this.zipService.compressAsync(outputPath);
+      await this.fileSystem.writeFile(archivePath, zipData);
+      return archivePath;
+    });
+  }
+  async writePackageMetadataAsync(parameters, outputPath) {
+    const pkg = parameters.package;
+    const metadata = {
+      name: pkg.id || "solution",
+      version: pkg.version || "1.0.0"
+    };
+    const optional = {
+      releaseNotes: pkg.releaseNotes,
+      projectUrl: pkg.projectUrl,
+      repositoryType: pkg.repositoryType,
+      repositoryUrl: pkg.repositoryUrl,
+      repositoryBranch: pkg.repositoryBranch,
+      repositoryCommit: pkg.repositoryCommit
+    };
+    for (const [key, value] of Object.entries(optional)) {
+      if (value !== undefined && value !== "") {
+        metadata[key] = value;
+      }
+    }
+    const metadataPath = `${outputPath}/package.metadata.json`;
+    await this.fileSystem.writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`);
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-restore-service.ts
+class SolutionRestoreService {
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  telemetry;
+  constructor(optionsBuilder, toolsFactory, projectExecutor, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.toolsFactory = toolsFactory;
+    this.projectExecutor = projectExecutor;
+    this.telemetry = telemetry;
+  }
+  async restoreAsync(parameters, solution, context, cancellationToken) {
+    const solutionOptions = await this.optionsBuilder.buildSolutionPackOptions(parameters, solution);
+    const solutionTool = await this.toolsFactory.createSolutionToolAsync(solution.SolutionId);
+    try {
+      return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Restore" /* SolutionRestore */, "restore", async () => {
+        const restoreResults = await Promise.all([
+          solutionTool.restoreAsync(solutionOptions, cancellationToken),
+          ...solution.Projects.map(async (project) => {
+            const projectRestoreOptions = await this.optionsBuilder.buildProjectRestoreOptions(parameters, project);
+            return this.projectExecutor.restoreAsync(projectRestoreOptions, project, context, cancellationToken);
+          })
+        ]);
+        if (hasFailedResults(restoreResults)) {
+          return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Solution restore failed: ${getFailedResultsMessage(restoreResults)}`, getFailedResultsInstructions(restoreResults));
+        }
+        return ToolResult.success();
+      }, { [PackagerDimensions.SolutionId]: solution.SolutionId });
+    } finally {
+      const disposeResult = solutionTool.dispose();
+      if (disposeResult instanceof Promise) {
+        await disposeResult;
+      }
+    }
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-validate-options-validator.ts
+class SolutionValidateOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-validate-service.ts
+class SolutionValidateService {
+  optionsBuilder;
+  projectExecutor;
+  telemetry;
+  constructor(optionsBuilder, projectExecutor, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.projectExecutor = projectExecutor;
+    this.telemetry = telemetry;
+  }
+  async validateAsync(parameters, solution, context, cancellationToken) {
+    return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Validate" /* SolutionValidate */, "validate", async () => {
+      const projectResults = await Promise.all(solution.Projects.map((project) => {
+        if (project.ProjectPath == null) {
+          return Promise.resolve(ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before validation.`));
+        }
+        return this.projectExecutor.validateAsync(this.optionsBuilder.buildProjectValidateOptions(parameters, project), project, context, cancellationToken);
+      }));
+      const failed = projectResults.find((r) => !r.isSuccess);
+      return failed ?? ToolResult.success();
+    }, { [PackagerDimensions.SolutionId]: solution.SolutionId });
+  }
+}
+
+// ../packager/solution-packager/src/services/solution-packager.ts
+class SolutionPackager {
+  fileSystem;
+  telemetryService;
+  packageSignService;
+  repository;
+  temporaryStorage;
+  zipService;
+  logger;
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  solutionLoader;
+  solutionPackService;
+  solutionRestoreService;
+  solutionValidateService;
+  solutionCleanupService;
+  packOptionsValidator;
+  validateOptionsValidator;
+  governancePolicyService;
+  constructor(fileSystem, telemetryService, packageSignService) {
+    this.fileSystem = fileSystem;
+    this.telemetryService = telemetryService;
+    this.packageSignService = packageSignService;
+    this.repository = toolsFactoryRepository;
+    this.temporaryStorage = new TemporaryStorageService(this.fileSystem);
+    this.zipService = new ZipService(this.fileSystem);
+    this.logger = new ToolLogger("SolutionPackager", "PackSolution");
+    this.packOptionsValidator = new SolutionPackOptionsValidator(this.logger, this.fileSystem);
+    this.validateOptionsValidator = new SolutionValidateOptionsValidator(this.logger, this.fileSystem);
+    const packService = new PackService;
+    const packageIdReader = new PackageIdReader(this.fileSystem, packService);
+    this.optionsBuilder = new OptionsBuilder(packageIdReader, packService, this.fileSystem);
+    this.toolsFactory = new ToolsFactory(this.repository, this.fileSystem);
+    this.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService);
+    this.solutionLoader = new SolutionLoader(this.fileSystem);
+    this.governancePolicyService = new GovernancePolicyService(this.fileSystem, this.temporaryStorage);
+    this.solutionPackService = new SolutionPackService(this.optionsBuilder, this.toolsFactory, this.projectExecutor, this.zipService, this.fileSystem, this.telemetryService, this.packageSignService);
+    this.solutionRestoreService = new SolutionRestoreService(this.optionsBuilder, this.toolsFactory, this.projectExecutor, this.telemetryService);
+    this.solutionValidateService = new SolutionValidateService(this.optionsBuilder, this.projectExecutor, this.telemetryService);
+    this.solutionCleanupService = new SolutionCleanupService(this.optionsBuilder, this.projectExecutor, this.telemetryService);
+  }
+  async setupAsync(input, operationId) {
+    this.telemetryService.setOperationId(operationId);
+    await this.temporaryStorage.cleanup();
+    if (typeof input === "string") {
+      return input;
+    }
+    const inputPath = await this.temporaryStorage.getTempSubfolderPathAsync("input");
+    await this.zipService.extractAsync(input, inputPath);
+    const entries = await this.fileSystem.readdir(inputPath);
+    if (entries.length === 1) {
+      const innerPath = Path.join(inputPath, entries[0]);
+      const stat = await this.fileSystem.stat(innerPath);
+      if (stat?.isDirectory()) {
+        return innerPath;
+      }
+    }
+    return inputPath;
+  }
+  async setupWithUrlAsync(downloadUrl, accessToken, operationId) {
+    const headers = {};
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`;
+    }
+    const response = await fetch(downloadUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to download solution: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const zipData = new Uint8Array(arrayBuffer);
+    return this.setupAsync(zipData, operationId);
+  }
+  async packSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackDependencyOperation("SolutionPackager.PackSolution" /* SolutionPackagerPackSolution */, "pack", async () => {
+      try {
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        let result = await this.packOptionsValidator.validateAsync(options, cancellationToken);
+        if (!result.isSuccess) {
+          return result;
+        }
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+        }
+        const loadedSolution = await this.solutionLoader.loadSolution(options.inputPath);
+        const solution = this.filterSolutionProjects(loadedSolution, options.projectDesignIds);
+        const context = this.createOperationContext(options, solution);
+        result = await this.solutionPackService.packAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info(`Solution pack completed successfully. Packages: ${result.packages.join(", ")}`);
+        } else {
+          this.logger.error(`Solution pack failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Solution pack failed: ${errorMessage}`, carriedInstructions(error));
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async validateSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackDependencyOperation("SolutionPackager.ValidateSolution" /* SolutionPackagerValidateSolution */, "validate", async () => {
+      try {
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken, "analyze");
+        const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
+        if (!validationResult.isSuccess) {
+          return validationResult;
+        }
+        const loadedSolution = await this.solutionLoader.loadSolution(options.inputPath);
+        const solution = this.filterSolutionProjects(loadedSolution, options.projectDesignIds);
+        const context = this.createOperationContext(options, solution);
+        const result = await this.solutionValidateService.validateAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info("Solution validate completed successfully.");
+        } else {
+          this.logger.error(`Solution validate failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Solution validate failed: ${errorMessage}`, carriedInstructions(error));
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async restoreSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackDependencyOperation("SolutionPackager.RestoreSolution" /* SolutionPackagerRestoreSolution */, "restore", async () => {
+      try {
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("restore");
+        }
+        const loadedSolution = await this.solutionLoader.loadSolution(options.inputPath);
+        const solution = this.filterSolutionProjects(loadedSolution, options.projectDesignIds);
+        const context = this.createOperationContext(options, solution);
+        const result = await this.solutionRestoreService.restoreAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info("Solution restore completed successfully.");
+        } else {
+          this.logger.error(`Solution restore failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Solution restore failed: ${errorMessage}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async cleanupSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackDependencyOperation("SolutionPackager.CleanupSolution" /* SolutionPackagerCleanupSolution */, "cleanup", async () => {
+      try {
+        const loadedSolution = await this.solutionLoader.loadSolution(options.inputPath);
+        const solution = this.filterSolutionProjects(loadedSolution, options.projectDesignIds);
+        const context = this.createOperationContext(options, solution);
+        const result = await this.solutionCleanupService.cleanupAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info("Solution cleanup completed successfully.");
+        } else {
+          this.logger.error(`Solution cleanup failed with error code ${result.errorCode}: ${result.message}`);
+        }
+        return result;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Processing error: ${errorMessage}`);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Solution cleanup failed: ${errorMessage}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  filterSolutionProjects(solution, projectDesignIds) {
+    if (!projectDesignIds?.length)
+      return solution;
+    const solutionProjectIds = new Set(solution.Projects.map((p) => p.Id));
+    const unknownIds = projectDesignIds.filter((id) => !solutionProjectIds.has(id));
+    if (unknownIds.length > 0) {
+      this.logger.warn(translate.t("solutionpackager.optionsBuilder.errors.invalidProjectIds", { ids: unknownIds.join(",") }));
+    }
+    const requested = new Set(projectDesignIds);
+    return {
+      ...solution,
+      Projects: solution.Projects.filter((p) => requested.has(p.Id))
+    };
+  }
+  createOperationContext(options, solution) {
+    return {
+      id: crypto.randomUUID(),
+      projects: solution.Projects,
+      solutionRoot: this.fileSystem.path.dirname(solution.filePath),
+      downloadUrl: options.downloadUrl,
+      solutionId: solution.SolutionId,
+      configuration: options.configuration,
+      targetFramework: options.targetFramework ?? "Portable" /* Portable */,
+      connection: options.connection,
+      logger: this.logger,
+      workflowCompilerVersion: options.workflowCompilerVersion,
+      functionsPackagerVersion: options.functionsPackagerVersion,
+      codedAppsPackagerVersion: options.codedAppsPackagerVersion,
+      lockKey: options.lockKey,
+      jobTarget: options.jobTarget,
+      localSourcePath: options.localSourcePath
+    };
+  }
+  async getPackageStreamsAsync(result) {
+    if (!result.isSuccess) {
+      throw new Error(`Cannot get package streams from failed result. Error code: ${result.errorCode}, message: ${result.message}`);
+    }
+    if (!result.packages || result.packages.length === 0) {
+      return [];
+    }
+    const packageStreams = [];
+    for (const packagePath of result.packages) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        throw new Error(`Failed to read package file: ${packagePath}`);
+      }
+      const name = packagePath.split(/[\\/]/).pop() || packagePath;
+      packageStreams.push({ name, data });
+    }
+    return packageStreams;
+  }
+}
+
+// ../packager/solution-packager/src/node-solution-packager-factory.ts
+class NodeSolutionPackagerFactory extends BaseNodePackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger("SolutionPackagerFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating SolutionPackager instance...");
+    const fileSystem = this.getOrCreateFileSystem(config);
+    const telemetryService = this.getOrCreateTelemetryService(config);
+    this.dotnetDiscovery = new DotnetDiscoveryService;
+    const packageSignService = new NodePackageSignService(this.dotnetDiscovery, logger);
+    const solutionPackager = new SolutionPackager(fileSystem, telemetryService, packageSignService);
+    this.checkDotnetAvailability(logger);
+    logger.info("SolutionPackager created successfully.");
+    return solutionPackager;
+  }
+}
+async function createNodeSolutionPackager(options) {
+  const factory = new NodeSolutionPackagerFactory;
+  return factory.createAsync(options);
+}
+export { SolutionPackOptions, INVALID_PACKAGE_ID, toProjectDiagnostics, createNodeSolutionPackager };
+
+//# debugId=1B09B0F65CFCA09D64756E2164756E21