@uipath/solution-packager 1.202.0 → 1.203.0-preview.160

package/dist/index.js

@@ -391,6 +391,7 @@ import { ToolLogger as ToolLogger2 } from "@uipath/project-packager";
 import { BaseBrowserPackagerFactory } from "@uipath/project-packager/browser";
 
 // src/services/solution-packager.ts
+import { carriedInstructions } from "@uipath/common";
 import {
   GovernancePolicyService,
   PackService,
@@ -399,7 +400,7 @@ import {
   ToolsFactory
 } from "@uipath/project-packager";
 import {
-  Path as Path4,
+  Path as Path6,
   TargetFramework,
   TemporaryStorageService,
   ToolErrorCodes as ToolErrorCodes5,
@@ -906,6 +907,7 @@ class SolutionPackOptionsValidator extends PackagerParametersValidator {
 
 // src/services/solution-pack-service.ts
 import {
+  isPackageIdTooLongError,
   resolveProducedNupkgsAsync,
   signNupkgsAsync
 } from "@uipath/project-packager";
@@ -914,13 +916,84 @@ import {
   ToolResult as ToolResult2
 } from "@uipath/solutionpackager-tool-core";
 
+// src/services/member-package-ids.ts
+import { Path as Path4 } from "@uipath/solutionpackager-tool-core";
+var INVALID_PACKAGE_ID = "INVALID_PACKAGE_ID";
+function memberFolder(project) {
+  return Path4.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.`;
+}
+
 // src/services/tool-result-helpers.ts
+import { Path as Path5 } from "@uipath/solutionpackager-tool-core";
 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 toProjectDiagnostics(projects, results) {
+  return projects.map((project, index) => {
+    const result = results[index];
+    const findings = result?.details?.findings;
+    return {
+      Path: Path5.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;
+}
 
 // src/services/solution-pack-service.ts
 class SolutionPackService {
@@ -942,19 +1015,27 @@ class SolutionPackService {
   }
   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 ToolResult2.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(parameters, solution.Projects, solution.Name, context, cancellationToken)
+          ...this.packAllProjectsAsync(prepared.options, context, cancellationToken)
         ]);
         const restoreAndPackResults = [
           restoreResult,
           ...projectResults
         ];
         if (hasFailedResults(restoreAndPackResults)) {
-          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
+          const failure = ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
+          failure.details = {
+            projects: toProjectDiagnostics(solution.Projects, projectResults)
+          };
+          return failure;
         }
         const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
         if (!buildResult.isSuccess) {
@@ -979,13 +1060,49 @@ class SolutionPackService {
       }
     }
   }
-  packAllProjectsAsync(parameters, projects, solutionName, context, cancellationToken) {
-    return projects.map((project) => this.packSingleProjectAsync(parameters, project, solutionName, context, cancellationToken));
+  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 : ToolErrorCodes2.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(parameters, project, solutionName, context, cancellationToken) {
+  async packSingleProjectAsync(prepared, context, cancellationToken) {
     try {
-      const projectOptions = await this.optionsBuilder.buildProjectPackOptions(parameters, project, solutionName);
-      return await this.projectExecutor.packAsync(projectOptions, project, context, cancellationToken);
+      return await this.projectExecutor.packAsync(prepared.options, prepared.project, context, cancellationToken);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       return ToolResult2.error(ToolErrorCodes2.InternalError, errorMessage);
@@ -1177,7 +1294,7 @@ class SolutionPackager {
     await this.zipService.extractAsync(input, inputPath);
     const entries = await this.fileSystem.readdir(inputPath);
     if (entries.length === 1) {
-      const innerPath = Path4.join(inputPath, entries[0]);
+      const innerPath = Path6.join(inputPath, entries[0]);
       const stat = await this.fileSystem.stat(innerPath);
       if (stat?.isDirectory()) {
         return innerPath;
@@ -1222,7 +1339,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution pack failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution pack failed: ${errorMessage}`, carriedInstructions(error));
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1231,7 +1348,7 @@ class SolutionPackager {
   async validateSolutionAsync(options, cancellationToken) {
     return await this.telemetryService.trackDependencyOperation("SolutionPackager.ValidateSolution" /* SolutionPackagerValidateSolution */, "validate", async () => {
       try {
-        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken, "analyze");
         const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
         if (!validationResult.isSuccess) {
           return validationResult;
@@ -1249,7 +1366,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution validate failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution validate failed: ${errorMessage}`, carriedInstructions(error));
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1402,6 +1519,7 @@ class SolutionPackOptions extends PackagerParameters {
 }
 export {
   BuildConfiguration2 as BuildConfiguration,
+  INVALID_PACKAGE_ID,
   LogLevel,
   RulesConfigFileType2 as RulesConfigFileType,
   SolutionPackOptions,
@@ -1409,4 +1527,4 @@ export {
   createBrowserSolutionPackager
 };
 
-//# debugId=E42C0DAAD1D016BD64756E2164756E21
+//# debugId=CF29C179DF2F6E6F64756E2164756E21

package/dist/node.js

@@ -421,6 +421,7 @@ import {
 } from "@uipath/project-packager/node";
 
 // src/services/solution-packager.ts
+import { carriedInstructions } from "@uipath/common";
 import {
   GovernancePolicyService,
   PackService,
@@ -429,7 +430,7 @@ import {
   ToolsFactory
 } from "@uipath/project-packager";
 import {
-  Path as Path4,
+  Path as Path6,
   TargetFramework,
   TemporaryStorageService,
   ToolErrorCodes as ToolErrorCodes5,
@@ -936,6 +937,7 @@ class SolutionPackOptionsValidator extends PackagerParametersValidator {
 
 // src/services/solution-pack-service.ts
 import {
+  isPackageIdTooLongError,
   resolveProducedNupkgsAsync,
   signNupkgsAsync
 } from "@uipath/project-packager";
@@ -944,13 +946,84 @@ import {
   ToolResult as ToolResult2
 } from "@uipath/solutionpackager-tool-core";
 
+// src/services/member-package-ids.ts
+import { Path as Path4 } from "@uipath/solutionpackager-tool-core";
+var INVALID_PACKAGE_ID = "INVALID_PACKAGE_ID";
+function memberFolder(project) {
+  return Path4.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.`;
+}
+
 // src/services/tool-result-helpers.ts
+import { Path as Path5 } from "@uipath/solutionpackager-tool-core";
 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 toProjectDiagnostics(projects, results) {
+  return projects.map((project, index) => {
+    const result = results[index];
+    const findings = result?.details?.findings;
+    return {
+      Path: Path5.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;
+}
 
 // src/services/solution-pack-service.ts
 class SolutionPackService {
@@ -972,19 +1045,27 @@ class SolutionPackService {
   }
   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 ToolResult2.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(parameters, solution.Projects, solution.Name, context, cancellationToken)
+          ...this.packAllProjectsAsync(prepared.options, context, cancellationToken)
         ]);
         const restoreAndPackResults = [
           restoreResult,
           ...projectResults
         ];
         if (hasFailedResults(restoreAndPackResults)) {
-          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
+          const failure = ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
+          failure.details = {
+            projects: toProjectDiagnostics(solution.Projects, projectResults)
+          };
+          return failure;
         }
         const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
         if (!buildResult.isSuccess) {
@@ -1009,13 +1090,49 @@ class SolutionPackService {
       }
     }
   }
-  packAllProjectsAsync(parameters, projects, solutionName, context, cancellationToken) {
-    return projects.map((project) => this.packSingleProjectAsync(parameters, project, solutionName, context, cancellationToken));
+  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 : ToolErrorCodes2.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(parameters, project, solutionName, context, cancellationToken) {
+  async packSingleProjectAsync(prepared, context, cancellationToken) {
     try {
-      const projectOptions = await this.optionsBuilder.buildProjectPackOptions(parameters, project, solutionName);
-      return await this.projectExecutor.packAsync(projectOptions, project, context, cancellationToken);
+      return await this.projectExecutor.packAsync(prepared.options, prepared.project, context, cancellationToken);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       return ToolResult2.error(ToolErrorCodes2.InternalError, errorMessage);
@@ -1207,7 +1324,7 @@ class SolutionPackager {
     await this.zipService.extractAsync(input, inputPath);
     const entries = await this.fileSystem.readdir(inputPath);
     if (entries.length === 1) {
-      const innerPath = Path4.join(inputPath, entries[0]);
+      const innerPath = Path6.join(inputPath, entries[0]);
       const stat = await this.fileSystem.stat(innerPath);
       if (stat?.isDirectory()) {
         return innerPath;
@@ -1252,7 +1369,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution pack failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution pack failed: ${errorMessage}`, carriedInstructions(error));
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1261,7 +1378,7 @@ class SolutionPackager {
   async validateSolutionAsync(options, cancellationToken) {
     return await this.telemetryService.trackDependencyOperation("SolutionPackager.ValidateSolution" /* SolutionPackagerValidateSolution */, "validate", async () => {
       try {
-        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken, "analyze");
         const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
         if (!validationResult.isSuccess) {
           return validationResult;
@@ -1279,7 +1396,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution validate failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution validate failed: ${errorMessage}`, carriedInstructions(error));
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1404,10 +1521,11 @@ async function createNodeSolutionPackager(options) {
   return factory.createAsync(options);
 }
 export {
+  INVALID_PACKAGE_ID,
   RulesConfigFileType2 as RulesConfigFileType,
   SolutionPackOptions,
   SolutionPackager,
   createNodeSolutionPackager
 };
 
-//# debugId=0773CC8956B6196964756E2164756E21
+//# debugId=170B238929E3651264756E2164756E21

package/dist/src/index.d.ts

@@ -4,5 +4,6 @@ export { RulesConfigFileType } from "@uipath/project-packager";
 export { BuildConfiguration, LogLevel, } from "@uipath/solutionpackager-tool-core";
 export { createBrowserSolutionPackager } from "./browser-solution-packager-factory.js";
 export { SolutionPackOptions } from "./models/solution-pack-options.js";
+export { INVALID_PACKAGE_ID } from "./services/member-package-ids.js";
 export type { ISolutionPackager } from "./services/solution-packager.js";
 export { SolutionPackager } from "./services/solution-packager.js";

package/dist/src/node.d.ts

@@ -2,5 +2,6 @@ import "./i18n/index.js";
 export { RulesConfigFileType } from "@uipath/project-packager";
 export { SolutionPackOptions } from "./models/solution-pack-options.js";
 export { createNodeSolutionPackager } from "./node-solution-packager-factory.js";
+export { INVALID_PACKAGE_ID } from "./services/member-package-ids.js";
 export type { ISolutionPackager } from "./services/solution-packager.js";
 export { SolutionPackager } from "./services/solution-packager.js";

package/dist/src/services/member-package-ids.d.ts

@@ -0,0 +1,39 @@
+import type { UiPathProject } from "@uipath/project-packager";
+/**
+ * Error code every refusal in this module reports, so a caller can tell "the
+ * member ids are wrong" from "the pack broke".
+ *
+ * `ToolErrorCode` is `ToolErrorCodes | string` on purpose — a tool may add its
+ * own codes — so this rides that door rather than widening the core enum.
+ */
+export declare const INVALID_PACKAGE_ID = "INVALID_PACKAGE_ID";
+/** A member and the NuGet id it would be published under. */
+export interface MemberPackageId {
+    /** The member's folder, i.e. the directory of its `.uipx` relative path. */
+    folder: string;
+    id: string;
+}
+/** Two or more members that compose the same id. */
+export interface PackageIdConflict {
+    id: string;
+    folders: string[];
+}
+/** The folder a member lives in — the first segment of its relative path. */
+export declare function memberFolder(project: UiPathProject): string;
+/**
+ * Group members by the id they would publish under and return every group
+ * holding more than one.
+ *
+ * Compared case-insensitively because NuGet ids are: `Foo` and `foo` are one
+ * package in a feed, so letting both through would be the same defect with a
+ * quieter symptom.
+ */
+export declare function findPackageIdConflicts(members: MemberPackageId[]): PackageIdConflict[];
+/**
+ * What to tell the user when members collide.
+ *
+ * Names the id and every folder that produced it: the ids are composed from
+ * the solution name, the project type and the folder, so the folder list is
+ * the only part the author can act on.
+ */
+export declare function packageIdConflictMessage(conflicts: PackageIdConflict[]): string;

package/dist/src/services/solution-pack-service.d.ts

@@ -22,20 +22,31 @@ export declare class SolutionPackService implements ISolutionPackService {
     private readonly packageSignService?;
     constructor(optionsBuilder: IOptionsBuilder, toolsFactory: IToolsFactory, projectExecutor: IProjectToolExecutor, zipService: IZipService, fileSystem: IFileSystem, telemetry: ITelemetryService, packageSignService?: IPackageSignService | undefined);
     packAsync(parameters: SolutionPackOptions, solution: LoadedUiPathSolution, context: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Build the pack options for every member, then refuse the ids that cannot
+     * be published: one longer than NuGet allows, or two members composing the
+     * same id.
+     *
+     * The composed id is `<solution>.<short type>.<member folder>`, so both
+     * failures are the author's to fix by renaming, and both are cheaper to
+     * report here than after a compile.
+     *
+     * Every member's options are built concurrently, as they were when each
+     * project built its own, and every failure is collected: a solution with
+     * two unpublishable ids names both rather than making the author rerun to
+     * find the second.
+     */
+    private prepareProjectPackOptionsAsync;
     /**
      * Pack all projects in parallel
-     * @param parameters Solution pack parameters
-     * @param projects Array of projects to pack
-     * @param solutionName The solution's `.uipx` basename, anchoring member package ids
+     * @param prepared Members with their already-built pack options
      * @param cancellationToken Optional cancellation token
      * @returns Array of promises for packing each project
      */
     private packAllProjectsAsync;
     /**
      * Pack a single project
-     * @param parameters Solution pack parameters
-     * @param project Project to pack
-     * @param solutionName The solution's `.uipx` basename, anchoring the member package id
+     * @param prepared The member and its pack options
      * @param cancellationToken Optional cancellation token
      * @param context Optional operation context
      * @returns Result of the pack operation

package/dist/src/services/tool-result-helpers.d.ts

@@ -1,4 +1,5 @@
-import type { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { UiPathProject } from "@uipath/project-packager";
+import { type ToolResult } from "@uipath/solutionpackager-tool-core";
 /**
  * Result-aggregation helpers shared by the solution pack and restore services,
  * which both fan a batch of tool operations out in parallel and need to report
@@ -8,3 +9,24 @@ import type { ToolResult } from "@uipath/solutionpackager-tool-core";
 export declare function hasFailedResults(results: ToolResult[]): boolean;
 /** Combined, comma-separated message of every failed result in the batch. */
 export declare function getFailedResultsMessage(results: ToolResult[]): string;
+/**
+ * One project's outcome inside a solution operation, in the shape the CLI puts on the wire under
+ * `Data.Projects`. Field names mirror the flattened findings the workflow compiler already emits, so
+ * a consumer reads one vocabulary for `uip rpa analyze` and for a solution pack alike.
+ */
+export interface ProjectDiagnostics {
+    /** The project directory, relative to the solution directory, with forward slashes. */
+    Path: string;
+    Type: string;
+    Result: "Success" | "Failure";
+    Message?: string;
+    Findings: unknown[];
+}
+/**
+ * Pair each project with its result. Positional: the caller builds the results by mapping over the
+ * same array and awaits them with `Promise.all`, which resolves in input order.
+ *
+ * Without this the per-project detail dies in {@link getFailedResultsMessage} — the joined string is
+ * all a caller gets, and it names neither the file nor the activity that failed. See STUD-81458.
+ */
+export declare function toProjectDiagnostics(projects: UiPathProject[], results: ToolResult[]): ProjectDiagnostics[];

package/dist/tests/member-package-ids.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@uipath/solution-packager",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.202.0",
+    "version": "1.203.0-preview.160",
     "description": "UiPath Solution Packager - core library for packing UiPath solutions",
     "type": "module",
     "main": "./dist/index.js",
@@ -28,11 +29,11 @@
         "dist"
     ],
     "dependencies": {
-        "@uipath/project-packager": "1.202.0",
-        "@uipath/solutionpackager-tool-core": "1.202.0"
+        "@uipath/project-packager": "1.203.0",
+        "@uipath/solutionpackager-tool-core": "1.203.0"
     },
     "peerDependencies": {
         "fflate": "^0.8.2"
     },
-    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
+    "gitHead": "3a42062ba731afca4595ba9aa8a80afc9667528d"
 }