@uipath/solution-tool 1.204.0 → 1.205.0-preview.258

package/dist/{packager-tool-fehvgd51.js → packager-tool-e7vczxa8.js}

@@ -1,135 +1,65 @@
+import {
+  inspectSolutionPackageProjectTypes,
+  trackSolutionShipSucceeded
+} from "./packager-tool-amhyxzz6.js";
 import {
   getStudioWebAuthWithOrganizationId,
   useStudioWebAuth
-} from "./packager-tool-v8bkkqdb.js";
+} from "./packager-tool-gmwva4yv.js";
 import {
   resolveFeedScopeOrFailureAsync
-} from "./packager-tool-9ex75r32.js";
+} from "./packager-tool-8q4tvv8d.js";
 import {
   activateDeploymentAsync,
-  deployRunAsync,
-  extractDeploymentErrors,
-  formatDeploymentErrorsAsText,
   listDeploymentsAsync,
   listPackagesAsync,
   uninstallDeploymentAsync,
   upgradeDeploymentAsync
-} from "./packager-tool-kdwsw2x7.js";
+} from "./packager-tool-q5j6k3fy.js";
+import {
+  extractDeploymentErrors,
+  formatDeploymentErrorsAsText
+} from "./packager-tool-act5r386.js";
 import {
   SolutionInitError,
   solutionInitAsync
-} from "./packager-tool-px1j9kre.js";
+} from "./packager-tool-3bwnkjdq.js";
 import {
-  GOVERNANCE_OPTION_INSTRUCTIONS,
-  PackCommandService,
-  SOLUTION_PATH_INSTRUCTIONS,
-  SolutionPackOptions,
-  applyAuthConnection,
-  checkSolutionPathAsync,
-  createSolutionPackager,
-  packSolutionAsync,
-  readSolutionFileAsUint8Array,
-  resolveSdkLogLevel,
-  validateGovernanceOptions
-} from "./packager-tool-wfkv9v8b.js";
-import {
-  prepareSolutionResources
-} from "./packager-tool-gab9y5ct.js";
-import {
-  ensurePackagerTools,
-  isUnpackableProjectTypeError,
-  toolVerbForProjectType
-} from "./packager-tool-e2rtr49j.js";
+  validatePackProjectOptions
+} from "./packager-tool-gs3f3tf7.js";
 import {
   publishSolutionAsync
-} from "./packager-tool-g8kjzrg7.js";
-import {
-  Configuration,
-  PipelinesApi
-} from "./packager-tool-7gr2nphb.js";
+} from "./packager-tool-wknfv4p5.js";
 import {
   feedScopeInitOverride,
   listSelectablePublishLocations
-} from "./packager-tool-stsnbewn.js";
-import {
-  DeploymentActivationStatus,
-  DeploymentOperationStatus,
-  StudioWebIncompatibleProjectError,
-  UipignoreExcludesProjectError,
-  buildSolutionUploadFailureOutput,
-  bundleSolution,
-  getProjectDebugStatus,
-  importSolution,
-  isDebugProvisioningSucceeded,
-  isDebugProvisioningTerminal,
-  isSolutionUploadHttpError,
-  overwriteSolution,
-  solutionExistsOnStudioWeb
-} from "./packager-tool-j3520gxw.js";
+} from "./packager-tool-6x35kvbx.js";
 import {
-  applyEntryPointEnhancementAsync,
-  assertSolutionManifest,
-  createLocalResource,
-  createProjectInSolutionBuilder,
-  createResourceBuilderServices,
-  createResourceKindMetadataResolver,
-  exportResourceDefinitionAsync,
-  findCatalogEntityAsync,
-  findMatchingLocalResource,
-  findProjectFile,
-  findResourceByKeyInRcs,
-  formatResourceSubtypes,
-  getRemoteResourceClients,
-  hasAnyTemplateRow,
-  hasBareTemplateRow,
-  isMissingProjectTypeError,
-  isProjectManifestError,
-  normalizeFolderPath,
-  normalizeResourceFileCasing,
-  readProjectFile,
-  readSolutionFile,
-  readSpecProperty,
-  resolveResourceKindMetadata,
-  resolveSolutionFilePath,
-  resourceRefreshAsync,
-  resourceRemoteSyncAsync,
-  restoreSolutionFile,
-  sameResourceSubtype,
-  saveCasingNormalized,
-  searchRcsResources,
-  syncResourcesFromBindings,
-  toResourceReference,
-  validateResourceName,
-  writeSolutionFile
-} from "./packager-tool-yrz4mwfn.js";
+  Configuration,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
 import {
-  ToolResult
-} from "./packager-tool-fv7xyzg2.js";
+  DeploymentActivationStatus,
+  DeploymentOperationStatus
+} from "./packager-tool-an5bpbwe.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-f5gq77m5.js";
+} from "./packager-tool-61pwb567.js";
 import {
-  resolveSolutionDir,
-  toPortableRelativePath,
-  updateUipxSolutionId
-} from "./packager-tool-f2e9rzxk.js";
+  getLoginStatusAsync
+} from "./packager-tool-43ahv5mn.js";
 import {
-  CommandDimensions,
   DEFAULT_PAGE_SIZE,
   Option,
   OutputFormatter,
   Pagination,
   PollOutcome,
   RESULTS,
-  ShipDimensions,
+  addDeprecatedOptionAlias,
   carriedErrorCode,
-  carriedInstructions,
   carriedRetry,
-  catchError,
   createHiddenDeprecatedTenantOption,
-  extractErrorDetails,
-  extractErrorMessage,
-  isGuid,
+  httpStatusOf,
   isPreviewBuild,
   logger,
   mapPackageMetadataOptions,
@@ -146,18 +76,18 @@ import {
   unsupportedSolutionProjectType,
   warnDeprecatedOptionAlias,
   withCompleter
-} from "./packager-tool-kswwd3hp.js";
+} from "./packager-tool-tx834spe.js";
 import {
-  getLoginStatusAsync
-} from "./packager-tool-gb35b4qs.js";
+  CommandDimensions,
+  ShipDimensions,
+  carriedInstructions,
+  catchError,
+  extractErrorDetails,
+  extractErrorMessage
+} from "./packager-tool-6ybywxxn.js";
 import {
   getFileSystem
-} from "./packager-tool-zf3929se.js";
-import {
-  strFromU8,
-  unzip,
-  unzipSync
-} from "./packager-tool-dfrk01gn.js";
+} from "./packager-tool-v1f5e8t9.js";
 import {
   __require
 } from "./packager-tool-1de529jm.js";
@@ -166,7 +96,7 @@ var package_default = {
   name: "@uipath/solution-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0",
+  version: "1.205.0-preview.258",
   description: "Create, pack, publish, and deploy UiPath Automation Solutions.",
   repository: {
     type: "git",
@@ -229,7 +159,8 @@ var package_default = {
     "@uipath/packager-tool-connector": "workspace:*",
     "@uipath/pipelines-sdk": "workspace:*",
     "@uipath/project-executor": "workspace:*",
-    "@uipath/resource-builder-sdk": "2025.11.0-alpha6004-4107",
+    "@uipath/project-packager": "workspace:*",
+    "@uipath/resource-builder-sdk": "2025.11.0-alpha6584-4367",
     "@uipath/resource-builder-tool": "2025.11.0-alpha6004-4107",
     "@uipath/solution-packager": "workspace:*",
     "@uipath/solution-sdk": "workspace:*",
@@ -241,113 +172,6 @@ var package_default = {
   }
 };
 
-// src/services/cleanup-command-service.ts
-class CleanupCommandService {
-  packager = null;
-  fs;
-  constructor() {
-    this.fs = getFileSystem();
-  }
-  async execute(solutionPath, options, context) {
-    const check = await checkSolutionPathAsync(this.fs, solutionPath);
-    if (!check.ok) {
-      this.reportFailureAndExit(context, check.message, SOLUTION_PATH_INSTRUCTIONS, check.statError, check.errorCode);
-      return;
-    }
-    const { absoluteSolutionPath } = check;
-    logger.info(options.dryRun ? `
-Detecting unused items (dry-run)...
-` : `
-Removing unused items...
-`);
-    logger.info("Details:");
-    logger.info(`  Solution: ${absoluteSolutionPath}`);
-    logger.info("");
-    const [error, result] = await catchError(this.executeAsync(solutionPath, options));
-    if (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      this.reportFailureAndExit(context, msg, carriedInstructions(error) ?? "Check that the solution can be loaded, the required packager tools are available, and the current login has access to the tenant.", error);
-      return;
-    }
-    if (result.errorCode !== "SUCCESS" /* Success */) {
-      this.reportFailureAndExit(context, `Error code: ${result.errorCode} : ${result.message}`, result.instructions ?? result.message ?? "");
-      return;
-    }
-    const changedFilesByProject = result.details?.changedFilesByProject ?? {};
-    const cleanupByProject = result.details?.cleanupByProject ?? {};
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "SolutionCleanup",
-      Data: {
-        DryRun: Boolean(options.dryRun),
-        ChangedFilesByProject: changedFilesByProject,
-        CleanupByProject: cleanupByProject
-      }
-    });
-  }
-  reportFailureAndExit(context, message, instructions, error, errorCode) {
-    OutputFormatter.error({
-      Result: RESULTS.Failure,
-      Message: message,
-      Instructions: instructions,
-      ErrorCode: errorCode
-    });
-    if (error instanceof Error && error.stack) {
-      logger.error("Stack trace:");
-      logger.error(error.stack);
-    }
-    context.exit(1);
-  }
-  async executeAsync(solutionPath, options) {
-    if (options.loginValidity !== undefined && Number.isNaN(options.loginValidity)) {
-      return new ToolResult("INTERNAL_ERROR" /* InternalError */, `Invalid --login-validity value: ${options.loginValidity}`, []);
-    }
-    const check = await checkSolutionPathAsync(this.fs, solutionPath);
-    if (!check.ok) {
-      return new ToolResult("INTERNAL_ERROR" /* InternalError */, check.message, []);
-    }
-    const { absoluteSolutionPath, isUisFile } = check;
-    if (isUisFile && !options.dryRun) {
-      return new ToolResult("INTERNAL_ERROR" /* InternalError */, `In-place cleanup of a .uis file is not supported: changes would be written to a temporary extraction and then discarded, leaving '${absoluteSolutionPath}' unchanged. Re-run with --dry-run to only detect unused items, or point at an unpacked solution directory to modify it in place.`, []);
-    }
-    const [error, result] = await catchError(async () => {
-      const packager = await this.ensurePackagerAsync();
-      let inputPath;
-      if (isUisFile) {
-        const uint8Array = await readSolutionFileAsUint8Array(this.fs, absoluteSolutionPath);
-        inputPath = await packager.setupAsync(uint8Array);
-      } else {
-        inputPath = await packager.setupAsync(absoluteSolutionPath);
-      }
-      await ensurePackagerTools(inputPath, this.fs);
-      const cleanupOptions = await this.createCleanupOptions(inputPath, options);
-      return packager.cleanupSolutionAsync(cleanupOptions);
-    });
-    if (error) {
-      return new ToolResult("INTERNAL_ERROR" /* InternalError */, error instanceof Error ? error.message : String(error), [], carriedInstructions(error));
-    }
-    return result;
-  }
-  async ensurePackagerAsync() {
-    this.packager ??= await createSolutionPackager();
-    return this.packager;
-  }
-  async createCleanupOptions(inputPath, options) {
-    const cleanupOptions = new SolutionPackOptions;
-    cleanupOptions.inputPath = inputPath;
-    cleanupOptions.cleanupOptions = {
-      dryRun: options.dryRun ?? false,
-      skipImports: options.skipImports ?? false
-    };
-    cleanupOptions.logLevel = resolveSdkLogLevel();
-    cleanupOptions.nuGetSourcesConfigPath = options.nugetSourcesConfigPath;
-    cleanupOptions.excludeConfiguredSources = options.excludeConfiguredSources ?? false;
-    cleanupOptions.feedFolder = options.feedFolder;
-    await applyAuthConnection(cleanupOptions, options.loginValidity);
-    return cleanupOptions;
-  }
-}
-
 // src/commands/cleanup.ts
 var SOLUTION_CLEANUP_EXAMPLES = [
   {
@@ -388,7 +212,8 @@ var SOLUTION_CLEANUP_EXAMPLES = [
   }
 ];
 var registerCleanupCommand = (program) => {
-  program.command("cleanup").description("Remove unused items from every project in a UiPath solution. Accepts a solution directory (containing .uipx) or a .uis file. For a directory the project sources are modified in place. Pass --dry-run to only detect unused items.").argument("<solutionPath>", "Path to a solution directory (containing .uipx) or a .uis file").option("--dry-run", "Detect unused items but do not modify any project files.").option("--skip-imports", "Do not clean up now-unused references to removed items in the project's files.").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").option("--exclude-configured-sources", "Resolve project dependencies only from the tenant feeds and any --nuget-sources-config-path. Drops the built-in UiPath and nuget.org feeds, so a dependency that is not on those feeds fails to restore.").option("--feed-folder <name>", "Resolve project dependencies from this Orchestrator folder's library feed instead of every tenant feed. Accepts a folder name or fully qualified path.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", (value) => Number.parseInt(value, 10), 10).examples(SOLUTION_CLEANUP_EXAMPLES).trackedAction(processContext, async (solutionPath, options) => {
+  program.command("cleanup").description("Remove unused items from every project in a UiPath solution. Accepts a solution directory (containing .uipx) or a .uis file. For a directory the project sources are modified in place. Pass --dry-run to only detect unused items.").argument("<solution-path>", "Path to a solution directory (containing .uipx) or a .uis file").option("--dry-run", "Detect unused items but do not modify any project files.").option("--skip-imports", "Do not clean up now-unused references to removed items in the project's files.").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").option("--exclude-configured-sources", "Resolve project dependencies only from the tenant feeds and any --nuget-sources-config-path. Drops the built-in UiPath and nuget.org feeds, so a dependency that is not on those feeds fails to restore.").option("--feed-folder <name>", "Resolve project dependencies from this Orchestrator folder's library feed instead of every tenant feed. Accepts a folder name or fully qualified path.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", (value) => Number.parseInt(value, 10), 10).examples(SOLUTION_CLEANUP_EXAMPLES).trackedAction(processContext, async (solutionPath, options) => {
+    const { CleanupCommandService } = await import("./cleanup-command-service-rc5e42hk.js");
     const service = new CleanupCommandService;
     const cleanupOptions = {
       dryRun: options.dryRun,
@@ -492,9 +317,11 @@ var SOLUTION_DEPLOY_ACTIVATE_EXAMPLES = [
   }
 ];
 var registerDeployActivateCommand = (program) => {
-  program.command("activate").description("Activate a deployed solution that was deployed without auto-activation. Activation provisions all solution components.").argument("<deployment-name>", "Name of the deployment to activate. Use 'solution deploy list' to find deployment names.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--timeout <seconds>", "Timeout in seconds for activation polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between activation status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(SOLUTION_DEPLOY_ACTIVATE_EXAMPLES).trackedAction(processContext, async (deploymentName, options) => {
+  program.command("activate").description("Activate a deployed solution that was deployed without auto-activation. Activation provisions all solution components.").argument("<deployment-name>", "Name of the deployment to activate. Use 'solution deploy list' to find deployment names.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--timeout <seconds>", "Timeout in seconds for activation polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between activation status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).addOption(new Option("--feed <name-or-key>", "The feed the deployment lives in (name or folder key, from 'solution feeds list'). Only that feed is searched; without it the tenant feed, your Personal Workspace and the folder feeds are tried in turn. Needs a user session for a feed other than the tenant's. Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace")).option("--personal-workspace", "The deployment lives in your Personal Workspace feed: only that feed is searched. Needs a user session.").examples(SOLUTION_DEPLOY_ACTIVATE_EXAMPLES).trackedAction(processContext, async (deploymentName, options) => {
     const result = await activateDeploymentAsync(deploymentName, {
       tenant: options.tenant,
+      personalWorkspace: options.personalWorkspace,
+      feed: options.feed,
       timeout: options.timeout,
       pollInterval: options.pollInterval,
       loginValidity: options.loginValidity,
@@ -1049,13 +876,15 @@ var SOLUTION_DEPLOY_DELETE_EXAMPLES = [
   }
 ];
 var registerDeployDeleteCommand = (program) => {
-  program.command("delete").description("Delete a deployment from the tenant. Use this for a deployment that 'deploy uninstall' cannot remove: one left inactive after an uninstall, one superseded by a newer version, or one left behind by a failed install — Orchestrator refuses to uninstall those with error 4007. The command reads the deployment first, and refuses when its own action list offers actions but not Delete, naming the state and the actions that are available. A record that lists no actions at all says nothing, so there the request goes to the server and the server decides.").argument("<deployment-name>", "Name of the deployment to delete. Use 'solution deploy list' to find deployment names.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(SOLUTION_DEPLOY_DELETE_EXAMPLES).trackedAction(processContext, async (deploymentName, options) => {
+  program.command("delete").description("Delete a deployment from the tenant. Use this for a deployment that 'deploy uninstall' cannot remove: one left inactive after an uninstall, one superseded by a newer version, or one left behind by a failed install — Orchestrator refuses to uninstall those with error 4007. The command reads the deployment first, and refuses when its own action list offers actions but not Delete, naming the state and the actions that are available. A record that lists no actions at all says nothing, so there the request goes to the server and the server decides.").argument("<deployment-name>", "Name of the deployment to delete. Use 'solution deploy list' to find deployment names.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").addOption(new Option("--feed <name-or-key>", "The feed the deployment lives in (name or folder key, from 'solution feeds list'). Only that feed is searched; without it the tenant feed, your Personal Workspace and the folder feeds are tried in turn. Needs a user session for a feed other than the tenant's. Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace")).option("--personal-workspace", "The deployment lives in your Personal Workspace feed: only that feed is searched. Needs a user session.").examples(SOLUTION_DEPLOY_DELETE_EXAMPLES).trackedAction(processContext, async (deploymentName, options) => {
     if (!requireConfirmation(options, `delete deployment '${deploymentName}'`)) {
       return;
     }
-    const { deleteDeploymentAsync } = await import("./deploy-delete-service-1zydyyhj.js");
+    const { deleteDeploymentAsync } = await import("./deploy-delete-service-qdbtj3qd.js");
     const result = await deleteDeploymentAsync(deploymentName, {
       tenant: options.tenant,
+      personalWorkspace: options.personalWorkspace,
+      feed: options.feed,
       loginValidity: options.loginValidity
     });
     if (!result.ok) {
@@ -1388,12 +1217,13 @@ var SOLUTION_DEPLOY_RUN_FEED_EXAMPLE = {
   }
 };
 var registerDeployRunCommand = (program) => {
-  const command = program.command("run").description("Deploy a solution package to Orchestrator. Creates a folder, provisions resources, and (by default) activates the solution. The deployment is keyed on --name: a name that does not exist yet gets a NEW deployment in a NEW folder (the normal case), while re-using an existing deployment's name updates that deployment in place — use 'deploy upgrade' when that is what you want. If the package is already deployed the command stops and points you at the upgrade path; pass --yes with a different --name to deploy a second, separate copy anyway. Pass --skip-activate to leave the deployment in 'Inactive (Ready to activate)' state and activate later with 'deploy activate'. A deployment whose resources need 'Setup activation' in Orchestrator is installed but not activated: the command reports Result: Success with ActivationStatus: NeedsSetupToActivate, the resources and the steps left — do not deploy it again. To customize resource settings before deploying, use 'config get' to fetch the default config, 'config set' / 'config link' to edit it, then pass it here with --config-file.").requiredOption("-n, --name <deployment-name>", "Name for the deployment").addOption(withCompleter(new Option("--package-name <name>", "Solution package name to deploy. Use 'solution packages list' to find available names.").makeOptionMandatory(), packageNameCompleter)).addOption(withCompleter(new Option("--package-version <version>", "Solution package version to deploy. Use 'solution packages list' to find available versions.").makeOptionMandatory(), packageVersionCompleter)).requiredOption("--folder-name <name>", "Name for the new Orchestrator folder created for this deployment (created under --parent-folder-path if specified)").addOption(new Option("--parent-folder-path <path>", "Parent folder path (e.g., 'Shared'). Solution folder is created under this.").conflicts("parentFolderKey")).option("--parent-folder-key <key>", "Parent folder key (GUID). Alternative to --parent-folder-path.").addOption(new Option("--personal-workspace", "Deploy into the current user's Personal Workspace. Resolves the workspace name from Orchestrator automatically; needs a user session (an external app has no workspace, and the server ignores the feed header on client-credentials requests). Mutually exclusive with --parent-folder-path and --parent-folder-key.").conflicts(["parentFolderPath", "parentFolderKey"])).option("--config-file <path>", "JSON or YAML configuration file. Generate with: uip solution deploy config get <name> -d config.json, then customize with 'config set' or 'config link'.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--timeout <seconds>", "Timeout in seconds applied per polling phase — deploy and (when not skipped) activate (default: 360 each)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between status polls during the deploy and activate phases (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).addOption(new Option("--wait", "Deprecated and ignored: every deploy now waits for the install to finish (bounded by --timeout).").hideHelp()).option("--skip-activate", "Skip auto-activation; leave the deployment in 'Inactive (Ready to activate)' state. Activate later with 'uip solution deploy activate <name>'.").option("-y, --yes", "Deploy even when this package already has a deployment. Without it, deploy run looks the package up and stops if it is already deployed. That check is best-effort, not a guarantee: a lookup failure only warns, and under an application (client-credentials) login it never stops the deploy — an existing deployment is reported as a warning, or the check is skipped on servers without the Pipelines deployment search. --yes only skips that check: the install is keyed on --name, so re-using an existing deployment's name updates that deployment in place rather than creating a second copy — pass a different --name for a separate deployment.");
+  const command = program.command("run").description("Deploy a solution package to Orchestrator. Creates a folder, provisions resources, and (by default) activates the solution. The deployment is keyed on --name: a name that does not exist yet gets a NEW deployment in a NEW folder (the normal case), while re-using an existing deployment's name updates that deployment in place — use 'deploy upgrade' when that is what you want. If the package is already deployed the command stops and points you at the upgrade path; pass --yes with a different --name to deploy a second, separate copy anyway. Pass --skip-activate to leave the deployment in 'Inactive (Ready to activate)' state and activate later with 'deploy activate'. A deployment whose resources need 'Setup activation' in Orchestrator is installed but not activated: the command reports Result: Success with ActivationStatus: NeedsSetupToActivate, the resources and the steps left — do not deploy it again. To customize resource settings before deploying, use 'config get' to fetch the default config, 'config set' / 'config link' to edit it, then pass it here with --config-file. When the deploy replaces an installed resource with a link (a config-file link to an existing resource), the server deletes the installed copy and its data, and asks for confirmation first: the command stops and lists those resources unless --acknowledge-permanent-deletion is passed.").requiredOption("-n, --name <deployment-name>", "Name for the deployment").addOption(withCompleter(new Option("--package-name <name>", "Solution package name to deploy. Use 'solution packages list' to find available names.").makeOptionMandatory(), packageNameCompleter)).addOption(withCompleter(new Option("--package-version <version>", "Solution package version to deploy. Use 'solution packages list' to find available versions.").makeOptionMandatory(), packageVersionCompleter)).requiredOption("--folder-name <name>", "Name for the new Orchestrator folder created for this deployment (created under --parent-folder-path if specified)").addOption(new Option("--parent-folder-path <path>", "Parent folder path (e.g., 'Shared'). Solution folder is created under this.").conflicts("parentFolderKey")).option("--parent-folder-key <key>", "Parent folder key (GUID). Alternative to --parent-folder-path.").addOption(new Option("--personal-workspace", "Deploy into the current user's Personal Workspace. Resolves the workspace name from Orchestrator automatically; needs a user session (an external app has no workspace, and the server ignores the feed header on client-credentials requests). Mutually exclusive with --parent-folder-path and --parent-folder-key.").conflicts(["parentFolderPath", "parentFolderKey"])).option("--config-file <path>", "JSON or YAML configuration file. Generate with: uip solution deploy config get <name> -d config.json, then customize with 'config set' or 'config link'.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--timeout <seconds>", "Timeout in seconds applied per polling phase — deploy and (when not skipped) activate (default: 360 each)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between status polls during the deploy and activate phases (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).addOption(new Option("--wait", "Deprecated and ignored: every deploy now waits for the install to finish (bounded by --timeout).").hideHelp()).option("--skip-activate", "Skip auto-activation; leave the deployment in 'Inactive (Ready to activate)' state. Activate later with 'uip solution deploy activate <name>'.").option("-y, --yes", "Deploy even when this package already has a deployment. Without it, deploy run looks the package up and stops if it is already deployed. That check is best-effort, not a guarantee: a lookup failure only warns, and under an application (client-credentials) login it never stops the deploy — an existing deployment is reported as a warning, or the check is skipped on servers without the Pipelines deployment search. --yes only skips that check: the install is keyed on --name, so re-using an existing deployment's name updates that deployment in place rather than creating a second copy — pass a different --name for a separate deployment.").option("--acknowledge-permanent-deletion", "Confirm that installed resources this deployment replaces with a link are permanently deleted, along with their data. Without it the deploy stops at the server's confirmation request and lists those resources; nothing is installed. With it each listed resource is acknowledged and the same install runs once more, within the same --timeout. Independent of --yes.");
   command.addOption(new Option("--feed <name-or-key>", "Deploy a package from a specific feed (name or folder key, from 'solution feeds list') instead of the tenant feed. Needs a user session: the server ignores the feed header on client-credentials requests, so an external app is refused rather than deploying to the tenant feed by accident. Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace"));
   command.examples([
     ...SOLUTION_DEPLOY_RUN_EXAMPLES,
     SOLUTION_DEPLOY_RUN_FEED_EXAMPLE
   ]).trackedAction(processContext, async (options) => {
+    const { deployRunAsync } = await import("./deploy-run-service-m9mg34n5.js");
     const result = await deployRunAsync({
       tenant: options.tenant,
       deploymentName: options.name,
@@ -1410,6 +1240,7 @@ var registerDeployRunCommand = (program) => {
       loginValidity: options.loginValidity,
       skipActivate: options.skipActivate,
       yes: options.yes,
+      acknowledgePermanentDeletion: options.acknowledgePermanentDeletion,
       signal: processContext.pollSignal
     });
     if (!result.ok) {
@@ -1418,7 +1249,24 @@ var registerDeployRunCommand = (program) => {
         Message: result.message,
         Instructions: result.instructions,
         ErrorCode: result.errorCode,
-        Retry: result.retry
+        Retry: result.retry,
+        ...result.permanentDeletionResources ? {
+          Data: {
+            PipelineDeploymentId: result.pipelineDeploymentId,
+            DeploymentKey: result.deploymentKey,
+            PermanentDeletionResources: result.permanentDeletionResources.map((resource) => ({
+              Key: resource.key,
+              Kind: resource.kind ?? null,
+              Name: resource.name
+            }))
+          }
+        } : {},
+        ...result.permanentlyDeletedResources ? {
+          Data: {
+            PipelineDeploymentId: result.pipelineDeploymentId,
+            PermanentlyDeletedResources: result.permanentlyDeletedResources
+          }
+        } : {}
       });
       processContext.exit(result.exitCode);
       return;
@@ -1441,10 +1289,12 @@ var registerDeployRunCommand = (program) => {
             Kind: resource.kind,
             Name: resource.name,
             Type: resource.type ?? null,
-            Reason: resource.reason ?? null
+            Reason: resource.reason ?? null,
+            FolderPaths: resource.folderPaths ?? null
           }))
         } : {},
         ...result.nextSteps ? { NextSteps: result.nextSteps } : {},
+        PermanentlyDeletedResources: result.permanentlyDeletedResources,
         DeploymentName: result.deploymentName,
         PackageName: result.packageName,
         PackageVersion: result.packageVersion
@@ -1581,8 +1431,8 @@ var registerDeployStatusCommand = (program) => {
       processContext.exit(1);
       return;
     }
-    const { feedScopeInitOverride: feedScopeInitOverride2 } = await import("./feed-resolver-bxj9xkgr.js");
-    const { FeedReadRefusedError, feedReadRefusalForApplication } = await import("./feed-session-sxga31vn.js");
+    const { feedScopeInitOverride: feedScopeInitOverride2 } = await import("./feed-resolver-3xb7ayx4.js");
+    const { FeedReadRefusedError, feedReadRefusalForApplication } = await import("./feed-session-7xqphdrg.js");
     const refuseFeed = (action) => {
       const refusal = feedReadRefusalForApplication(auth, action);
       if (!refusal) {
@@ -1601,14 +1451,14 @@ var registerDeployStatusCommand = (program) => {
     if (options.personalWorkspace === true && refuseFeed("Reading a Personal Workspace deployment")) {
       return;
     }
-    const { resolveFeedScopeOrFailureAsync: resolveFeedScopeOrFailureAsync2 } = await import("./feed-scope-failure-2kndwpf6.js");
+    const { resolveFeedScopeOrFailureAsync: resolveFeedScopeOrFailureAsync2 } = await import("./feed-scope-failure-qps17dv3.js");
     const [scopeFailure, feedScope] = await resolveFeedScopeOrFailureAsync2(options, auth);
     if (scopeFailure) {
       OutputFormatter.error(scopeFailure);
       processContext.exit(1);
       return;
     }
-    const { describeDeploymentAsync, looksLikeDeploymentKey } = await import("./deploy-status-service-3req7hje.js");
+    const { describeDeploymentAsync, looksLikeDeploymentKey } = await import("./deploy-status-service-kz3nk43q.js");
     if (feedScope.kind !== "tenant" && !looksLikeDeploymentKey(deployment) && refuseFeed(`Reading a deployment in the feed '${feedScope.name ?? feedScope.folderKey}'`)) {
       return;
     }
@@ -1649,7 +1499,7 @@ var registerDeployStatusCommand = (program) => {
     const api = new PipelinesApi(configuration);
     const [statusError, result] = await catchError(api.pipelinesGetPipelineDeploymentStatus({ pipelineDeploymentId: deployment }, feedSelected ? feedScopeInitOverride2(feedScope) : undefined));
     if (statusError) {
-      const { isPipelineDeploymentNotFoundError } = await import("./deployment-search-3mah6f0a.js");
+      const { isPipelineDeploymentNotFoundError } = await import("./deployment-search-jvwyaqek.js");
       if (await isPipelineDeploymentNotFoundError(statusError)) {
         const [stateError, state] = await catchError(describe());
         if (stateError instanceof FeedReadRefusedError) {
@@ -1741,7 +1591,8 @@ function deploymentStateData(state) {
         Kind: resource.kind,
         Name: resource.name,
         Type: resource.type ?? null,
-        Reason: resource.reason ?? null
+        Reason: resource.reason ?? null,
+        FolderPaths: resource.folderPaths ?? null
       }))
     } : {},
     ...state.nextSteps ? { NextSteps: state.nextSteps } : {}
@@ -1764,15 +1615,18 @@ var SOLUTION_DEPLOY_UNINSTALL_EXAMPLES = [
   }
 ];
 var registerDeployUninstallCommand = (program) => {
-  program.command("uninstall").description("Uninstall a deployed solution. Removes all provisioned resources and the solution folder.").argument("<deployment-name>", "Name of the deployment to uninstall. Use 'solution deploy list' to find deployment names.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--timeout <seconds>", "Timeout in seconds for uninstall polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between uninstall status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").examples(SOLUTION_DEPLOY_UNINSTALL_EXAMPLES).trackedAction(processContext, async (deploymentName, options) => {
+  program.command("uninstall").description("Uninstall a deployed solution. Removes all provisioned resources and the solution folder.").argument("<deployment-name>", "Name of the deployment to uninstall. Use 'solution deploy list' to find deployment names.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--timeout <seconds>", "Timeout in seconds for uninstall polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between uninstall status polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("-y, --yes", "Confirm this irreversible operation (required; the CLI never prompts)").option("--force", "Force the uninstall past the two refusals Orchestrator lets you override: uncompleted jobs, and the permanent deletion of installed resources that were replaced by links. Also confirms the operation, so --yes is not needed in addition. Flag only; the CLI never prompts.").addOption(new Option("--feed <name-or-key>", "The feed the deployment lives in (name or folder key, from 'solution feeds list'). Only that feed is searched; without it the tenant feed, your Personal Workspace and the folder feeds are tried in turn. Needs a user session for a feed other than the tenant's. Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace")).option("--personal-workspace", "The deployment lives in your Personal Workspace feed: only that feed is searched. Needs a user session.").examples(SOLUTION_DEPLOY_UNINSTALL_EXAMPLES).trackedAction(processContext, async (deploymentName, options) => {
     if (!requireConfirmation(options, `uninstall deployment '${deploymentName}'`)) {
       return;
     }
     const result = await uninstallDeploymentAsync(deploymentName, {
       tenant: options.tenant,
+      personalWorkspace: options.personalWorkspace,
+      feed: options.feed,
       timeout: options.timeout,
       pollInterval: options.pollInterval,
       loginValidity: options.loginValidity,
+      force: options.force,
       signal: processContext.pollSignal
     });
     if (!result.ok) {
@@ -1781,7 +1635,8 @@ var registerDeployUninstallCommand = (program) => {
         Message: result.message,
         Instructions: result.instructions,
         ErrorCode: result.errorCode,
-        Retry: result.retry
+        Retry: result.retry,
+        ...result.data ? { Data: result.data } : {}
       });
       processContext.exit(result.exitCode);
       return;
@@ -1943,7 +1798,7 @@ var SOLUTION_DEPLOY_UPGRADE_EXAMPLES = [
   }
 ];
 var registerDeployUpgradeCommand = (program) => {
-  program.command("upgrade").description("Upgrade an existing deployment to another published version of its package in place — the CLI equivalent of the Orchestrator UI 'Upgrade' button. Use this when 'deploy run' is blocked because a deployment already exists. The deployment's existing configuration is preserved, so values already set on it (for example a credential asset's secret) are not reset to the package defaults. The package is validated against the target before anything is installed; a validation failure reports the errors and leaves the deployment on its current version. Address the deployment either by key (positional) or by --name with --package-name. Every call this command makes is an external-app (client-credentials) capable Pipelines endpoint, so both forms work from a CI/CD pipeline (on a server that predates the Pipelines deployment lookup, the key form falls back to the Solutions API for a user session); a deployment in a Personal Workspace or folder feed needs a user session, because the server ignores the feed header on client-credentials requests. Waits for the upgrade to finish unless --no-wait is passed; track a running upgrade with 'deploy status <pipeline-deployment-id>'.").argument("[deployment-key]", "Key of the deployment to upgrade, as 'solution deploy list' reports it (Key), or a stored InstallDeploymentKey. Resolved through the Pipelines deployment lookup: the deployment's name, package, current version and feed come from the server, so --package-name and --personal-workspace are not needed. On a server without that lookup, a user session reads the key through the Solutions API instead, where a Personal Workspace deployment needs --personal-workspace. Use either this or --name with --package-name.").option("-n, --name <deployment-name>", "Name of the deployment to upgrade, as reported by 'solution deploy list'. Goes with --package-name. The name is checked to exist first, because the install route would create a new deployment for a name it cannot find; this form never does.").option("--package-name <name>", "The deployment's package, for the --name form. Required there: it identifies the package version to install, and nothing name-keyed in Pipelines reports it.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--version <version>", "Target package version (default: the newest published). Any published version of the same package is accepted, including an older one.").option("--personal-workspace", "With --name: upgrade a deployment in your Personal Workspace feed instead of the tenant. With a key the feed is read from the deployment itself and this flag is not needed, except on a server without the Pipelines deployment lookup, where a key is read on the tenant feed unless you pass it.").option("--discard-draft", "When the deployment has a pending draft (an earlier attempt that never completed, usually one rejected by validation), discard it first and upgrade the live version. Without it such a deployment is refused, because the server would re-run the draft, with the configuration it was rejected for, in place of this upgrade. With --name the draft is found through a user session only; under an external app, pass the deployment key.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("--no-wait", "Return as soon as the upgrade is accepted instead of waiting for it to finish.").option("--timeout <seconds>", "Seconds to wait for the upgrade to finish (default: 300)", (v) => parseInt(v, 10), 300).option("--poll-interval <ms>", "Milliseconds between status polls (default: 5000)", (v) => parseInt(v, 10), 5000).examples(SOLUTION_DEPLOY_UPGRADE_EXAMPLES).trackedAction(processContext, async (deploymentKey, options) => {
+  program.command("upgrade").description("Upgrade an existing deployment to another published version of its package in place — the CLI equivalent of the Orchestrator UI 'Upgrade' button. Use this when 'deploy run' is blocked because a deployment already exists. The deployment's existing configuration is preserved, so values already set on it (for example a credential asset's secret) are not reset to the package defaults. The package is validated against the target before anything is installed; a validation failure reports the errors and leaves the deployment on its current version. Address the deployment either by key (positional) or by --name with --package-name. Every call this command makes is an external-app (client-credentials) capable Pipelines endpoint, so both forms work from a CI/CD pipeline (on a server that predates the Pipelines deployment lookup, the key form falls back to the Solutions API for a user session); a deployment in a Personal Workspace or folder feed needs a user session, because the server ignores the feed header on client-credentials requests. Waits for the upgrade to finish unless --no-wait is passed; track a running upgrade with 'deploy status <pipeline-deployment-id>'. When the new version replaces an installed resource with a link, the server deletes the installed copy and its data, and asks for confirmation first: the command stops and lists those resources unless --acknowledge-permanent-deletion is passed.").argument("[deployment-key]", "Key of the deployment to upgrade, as 'solution deploy list' reports it (Key), or a stored InstallDeploymentKey. Resolved through the Pipelines deployment lookup: the deployment's name, package, current version and feed come from the server, so --package-name and --personal-workspace are not needed. On a server without that lookup, a user session reads the key through the Solutions API instead, where a Personal Workspace deployment needs --personal-workspace. Use either this or --name with --package-name.").option("-n, --name <deployment-name>", "Name of the deployment to upgrade, as reported by 'solution deploy list'. Goes with --package-name. The name is checked to exist first, because the install route would create a new deployment for a name it cannot find; this form never does.").option("--package-name <name>", "The deployment's package, for the --name form. Required there: it identifies the package version to install, and nothing name-keyed in Pipelines reports it.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--version <version>", "Target package version (default: the newest published). Any published version of the same package is accepted, including an older one.").option("--personal-workspace", "With --name: upgrade a deployment in your Personal Workspace feed instead of the tenant. With a key the feed is read from the deployment itself and this flag is not needed, except on a server without the Pipelines deployment lookup, where a key is read on the tenant feed unless you pass it.").option("--discard-draft", "When the deployment has a pending draft (an earlier attempt that never completed, usually one rejected by validation), discard it first and upgrade the live version. Without it such a deployment is refused, because the server would re-run the draft, with the configuration it was rejected for, in place of this upgrade. With --name the draft is found through a user session only; under an external app, pass the deployment key.").option("--acknowledge-permanent-deletion", "Confirm that installed resources the new version replaces with a link are permanently deleted, along with their data. Without it the upgrade stops at the server's confirmation request and lists those resources; nothing is installed. With it each listed resource is acknowledged and the same upgrade runs once more, within the same --timeout. Also re-runs a pending draft of the same version that awaits this confirmation instead of refusing it. Has no effect with --no-wait, which never sees the run end: such a draft is then refused as without the flag.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("--no-wait", "Return as soon as the upgrade is accepted instead of waiting for it to finish.").option("--timeout <seconds>", "Seconds to wait for the upgrade to finish (default: 300)", (v) => parseInt(v, 10), 300).option("--poll-interval <ms>", "Milliseconds between status polls (default: 5000)", (v) => parseInt(v, 10), 5000).examples(SOLUTION_DEPLOY_UPGRADE_EXAMPLES).trackedAction(processContext, async (deploymentKey, options) => {
     const result = await upgradeDeploymentAsync({
       deploymentKey,
       deploymentName: options.name,
@@ -1952,6 +1807,7 @@ var registerDeployUpgradeCommand = (program) => {
       version: options.version,
       personalWorkspace: options.personalWorkspace,
       discardDraft: options.discardDraft,
+      acknowledgePermanentDeletion: options.acknowledgePermanentDeletion,
       loginValidity: options.loginValidity,
       noWait: options.wait === false,
       timeout: options.timeout,
@@ -1964,7 +1820,18 @@ var registerDeployUpgradeCommand = (program) => {
         Message: result.message,
         Instructions: result.instructions,
         ErrorCode: result.errorCode,
-        Retry: result.retry
+        Retry: result.retry,
+        ...result.permanentDeletionResources ? {
+          Data: {
+            PipelineDeploymentId: result.pipelineDeploymentId,
+            DeploymentKey: result.deploymentKey,
+            PermanentDeletionResources: result.permanentDeletionResources.map((resource) => ({
+              Key: resource.key,
+              Kind: resource.kind ?? null,
+              Name: resource.name
+            }))
+          }
+        } : {}
       });
       processContext.exit(result.exitCode);
       return;
@@ -1983,7 +1850,8 @@ var registerDeployUpgradeCommand = (program) => {
             Kind: resource.kind,
             Name: resource.name,
             Type: resource.type ?? null,
-            Reason: resource.reason ?? null
+            Reason: resource.reason ?? null,
+            FolderPaths: resource.folderPaths ?? null
           }))
         } : {},
         ...result.nextSteps ? { NextSteps: result.nextSteps } : {},
@@ -1993,7 +1861,8 @@ var registerDeployUpgradeCommand = (program) => {
         PipelineDeploymentId: result.pipelineDeploymentId,
         DeploymentKey: result.deploymentKey,
         InstallDeploymentKey: result.installDeploymentKey,
-        DiscardedDraftKey: result.discardedDraftKey
+        DiscardedDraftKey: result.discardedDraftKey,
+        PermanentlyDeletedResources: result.permanentlyDeletedResources
       }
     });
   });
@@ -2060,104 +1929,6 @@ async function writeMissingBriefingFilesAsync(solutionDir) {
   return written;
 }
 
-// ../common/src/zip.ts
-function resolveZipEntryPath(fs, root, entryName) {
-  if (entryName.includes("\x00")) {
-    throw new Error(`Invalid zip entry path: ${entryName}`);
-  }
-  const normalizedEntry = entryName.replace(/\\/g, "/");
-  if (normalizedEntry.startsWith("/")) {
-    throw new Error(`Unsafe absolute zip entry path: ${entryName}`);
-  }
-  const target = fs.path.resolve(root, normalizedEntry);
-  if (!isUnder(fs, root, target)) {
-    throw new Error(`Unsafe zip entry path: ${entryName}`);
-  }
-  return target;
-}
-function isUnder(fs, root, path) {
-  const relative = fs.path.relative(root, path);
-  return relative === "" || !relative.startsWith("..") && !fs.path.isAbsolute(relative);
-}
-async function assertNoEscapeThroughSymlink(fs, lexicalRoot, realRoot, path, entryName) {
-  const resolved = await fs.realpath(path);
-  if (isUnder(fs, realRoot, resolved) || isUnder(fs, lexicalRoot, resolved)) {
-    return;
-  }
-  throw new Error(`Unsafe zip entry path (escapes via a symlink at the destination): ${entryName}`);
-}
-async function mkdirUnderRoot(fs, lexicalRoot, realRoot, dir, entryName) {
-  const relative = fs.path.relative(lexicalRoot, dir);
-  if (relative === "") {
-    return;
-  }
-  let current = lexicalRoot;
-  for (const segment of relative.split(/[\\/]/)) {
-    if (segment === "") {
-      continue;
-    }
-    current = fs.path.join(current, segment);
-    await fs.mkdir(current);
-    await assertNoEscapeThroughSymlink(fs, lexicalRoot, realRoot, current, entryName);
-  }
-}
-async function extractZipDataToDir(fs, zipData, destinationDir) {
-  await fs.mkdir(destinationDir);
-  const lexicalRoot = fs.path.resolve(destinationDir);
-  const realRoot = await fs.realpath(lexicalRoot);
-  const entries = unzipSync(zipData);
-  for (const [entryName, content] of Object.entries(entries)) {
-    const target = resolveZipEntryPath(fs, lexicalRoot, entryName);
-    if (entryName.endsWith("/")) {
-      await mkdirUnderRoot(fs, lexicalRoot, realRoot, target, entryName);
-      continue;
-    }
-    await mkdirUnderRoot(fs, lexicalRoot, realRoot, fs.path.dirname(target), entryName);
-    await assertNoEscapeThroughSymlink(fs, lexicalRoot, realRoot, target, entryName);
-    await fs.writeFile(target, content);
-  }
-}
-async function extractArchive(archivePath, destinationDir) {
-  const fs = getFileSystem();
-  const data = await fs.readFile(archivePath);
-  if (data === null) {
-    throw new Error(`Archive not found: ${archivePath}`);
-  }
-  await extractZipDataToDir(fs, data, destinationDir);
-}
-
-// src/services/archive-extract.ts
-var SOLUTION_STORAGE_ENTRY = "SolutionStorage.json";
-function isRootUipxEntry(name) {
-  return !name.includes("/") && name.endsWith(".uipx");
-}
-function readSolutionIdField(bytes) {
-  if (!bytes) {
-    return;
-  }
-  const [parseError, parsed] = catchError(() => JSON.parse(strFromU8(bytes)));
-  if (parseError || !parsed) {
-    return;
-  }
-  const id = parsed.SolutionId;
-  return typeof id === "string" && isGuid(id) ? id : undefined;
-}
-function readBundledSolutionId(archive) {
-  const [unzipError, entries] = catchError(() => unzipSync(archive, {
-    filter: (file) => file.name === SOLUTION_STORAGE_ENTRY || isRootUipxEntry(file.name)
-  }));
-  if (unzipError || !entries) {
-    logger.debug(`Could not inspect the solution archive for its SolutionId: ${unzipError?.message ?? "no entries"}`);
-    return;
-  }
-  const rootUipxName = Object.keys(entries).find(isRootUipxEntry);
-  const solutionId = readSolutionIdField(entries[SOLUTION_STORAGE_ENTRY]) ?? readSolutionIdField(rootUipxName ? entries[rootUipxName] : undefined);
-  if (!solutionId) {
-    logger.debug("No SolutionId found in the solution archive.");
-  }
-  return solutionId;
-}
-
 // src/commands/download.ts
 var SOLUTION_DOWNLOAD_EXAMPLES = [
   {
@@ -2217,6 +1988,7 @@ async function downloadSolution(solutionId, options, command) {
   const extractedTo = options.extract ? fs.path.join(outputDir, filename.replace(/\.uis$/, "")) : undefined;
   let briefingFiles = [];
   if (extractedTo) {
+    const { extractArchive } = await import("./archive-extract-x35t9ktj.js");
     await extractArchive(outputPath, extractedTo);
     logger.info(`Extracted to ${extractedTo}`);
     briefingFiles = await writeBriefingFiles(extractedTo);
@@ -2337,7 +2109,7 @@ var SOLUTION_NEW_EXAMPLES = [
   }
 ];
 var registerNewCommand = (program) => {
-  program.command("init").description("Initialize a new empty UiPath solution. Creates a directory named after the solution containing a .uipx manifest file with an empty Projects array, plus AGENTS.md and CLAUDE.md briefing files that orient AI coding agents to the solution. Use 'solution projects add' to add projects afterward.").argument("<solutionName>", "Solution name or path. Creates a directory with this name containing a .uipx manifest file.").examples(SOLUTION_NEW_EXAMPLES).trackedAction(processContext, async (solutionName) => {
+  program.command("init").description("Initialize a new empty UiPath solution. Creates a directory named after the solution containing a .uipx manifest file with an empty Projects array, plus AGENTS.md and CLAUDE.md briefing files that orient AI coding agents to the solution. Use 'solution projects add' to add projects afterward.").argument("<solution-name>", "Solution name or path. Creates a directory with this name containing a .uipx manifest file.").examples(SOLUTION_NEW_EXAMPLES).trackedAction(processContext, async (solutionName) => {
     const [briefingError, briefingContent] = await catchError(renderBriefingTemplateAsync());
     if (briefingError) {
       OutputFormatter.error({
@@ -2413,6 +2185,17 @@ var SOLUTION_PACK_EXAMPLES = [
       }
     }
   },
+  {
+    Description: "Pack one project of the solution into its own .nupkg instead of the solution .zip, as a stand-alone project packs: no solution resources go into it. --project takes the project's Id from the .uipx or its path relative to the solution; --package-id overrides the id a whole-solution pack would give it.",
+    Command: "uip solution pack ./my-solution ./dist --project MyProcess --package-id Acme.MyProcess --version 1.2.0",
+    Output: {
+      Code: "SolutionPack",
+      Data: {
+        Package: "Acme.MyProcess@1.2.0",
+        Packages: "/home/me/dist/Acme.MyProcess.1.2.0.nupkg"
+      }
+    }
+  },
   {
     Description: "Pack without running the workflow analyzer on the RPA projects. Compilation and validation still run — only the analyzer rules are skipped.",
     Command: "uip solution pack ./my-solution ./dist --version 1.2.0 --skip-analyze",
@@ -2429,7 +2212,7 @@ var SOLUTION_PACK_EXAMPLES = [
     Output: PACKED_1_2_0_OUTPUT
   },
   {
-    Description: "Analyze the RPA projects against the governance policy published in AutomationOps for the signed-in tenant. The value is the product whose policy is downloaded — pass StudioWeb for the default one.",
+    Description: "Analyze the RPA projects against the governance policy published in AutomationOps for the signed-in tenant. The value is the product whose policy is downloaded — pass StudioWeb for the default one. Signed in as an external application, the policy is not downloaded yet.",
     Command: "uip solution pack ./my-solution ./dist --version 1.2.0 --governance-product Development",
     Output: PACKED_1_2_0_OUTPUT
   }
@@ -2439,13 +2222,29 @@ function parseIgnoredRules(value, previous = []) {
   return [...new Set([...previous, ...rules])];
 }
 var registerPackCommand = (program) => {
-  const command = program.command("pack").description("Pack a UiPath solution into a deployable .zip package. Accepts a solution directory (containing .uipx) or a .uis file. Output is used with 'solution publish' to upload to UiPath. Pass --dry-run to check that the solution packs without producing a package.").argument("<solutionPath>", "Path to a solution directory (containing .uipx) or a .uis file").argument("[output-path]", "Output directory where the packed solution will be saved. Required unless --dry-run is set.").option("-n, --name <name>", "Package name (default: solution folder name or .uis file name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0").addOption(new Option("--solution-type <type>", "What kind of solution this is. Omitted by default, which means a standard solution.").choices(["standard", "vertical"]).hideHelp()).option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").option("--exclude-configured-sources", "Resolve project dependencies only from the tenant feeds and any --nuget-sources-config-path. Drops the built-in UiPath and nuget.org feeds, so a dependency that is not on those feeds fails to restore.").option("--feed-folder <name>", "Resolve project dependencies from this Orchestrator folder's library feed instead of every tenant feed. Accepts a folder name or fully qualified path.").option("--signing-certificate-path <path>", "Path to .pfx certificate file used to sign each packed project .nupkg").option("--signing-certificate-password <password>", "Certificate password. Use env.ENV_NAME to read from an environment variable.").option("--signing-timestamp-server <url>", "Timestamp server URL").option("--skip-analyze", "Skip the workflow analyzer for every RPA project in the solution. Compilation and validation still run.").option("--ignored-rules <rules>", "Analyzer rule IDs whose findings are ignored for every RPA project, e.g. ST-USG-034,ST-MRD-002. Comma-separated; repeat the flag to add more. The rules still run, but their findings are not reported and do not fail the pack. Applies on top of --governance-file-path or the shipped rules; when the signed-in tenant publishes an AutomationOps policy, the list is not applied and a warning says so.", parseIgnoredRules).option("--governance-file-path <path>", "Analyze every RPA project against this local governance policy file, instead of the analyzer rules shipped with the WorkflowCompiler. When you are signed in the tenant is asked first — about StudioWeb unless --governance-product names another product — and when the tenant publishes a policy of its own, that policy is used instead and this file is ignored with a warning.").option("--governance-product <product>", "Analyze every RPA project against the governance policy published in AutomationOps for the signed-in tenant. The value is the product whose policy is downloaded, e.g. StudioWeb, Development, Business.").addOption(new Option("--automation-ops-profile <profile>").hideHelp());
+  const command = program.command("pack").description("Pack a UiPath solution into a deployable .zip package. Accepts a solution directory (containing .uipx) or a .uis file. Output is used with 'solution publish' to upload to UiPath. Pass --project to pack one project into its own .nupkg instead. Pass --dry-run to check that the solution packs without producing a package.").argument("<solution-path>", "Path to a solution directory (containing .uipx) or a .uis file").argument("[output-path]", "Output directory where the packed solution will be saved. Required unless --dry-run is set.").option("-n, --name <name>", "Package name (default: solution folder name or .uis file name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0").addOption(new Option("--solution-type <type>", "What kind of solution this is. Omitted by default, which means a standard solution.").choices(["standard", "vertical"]).hideHelp()).option("--project <id-or-path>", "Pack only this project of the solution into its own .nupkg, instead of the solution .zip. It packs as a stand-alone project: no solution resources go into it. Takes the project's Id from the .uipx, or its path relative to the solution folder; a .uis file is not supported.").option("--package-id <id>", "Package id for the project packed with --project, instead of the id a whole-solution pack gives it (<solution>.<type>.<project folder>). Requires --project.").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").option("--exclude-configured-sources", "Resolve project dependencies only from the tenant feeds and any --nuget-sources-config-path. Drops the built-in UiPath and nuget.org feeds, so a dependency that is not on those feeds fails to restore.").option("--feed-folder <name>", "Resolve project dependencies from this Orchestrator folder's library feed instead of every tenant feed. Accepts a folder name or fully qualified path.").option("--signing-certificate-path <path>", "Path to .pfx certificate file used to sign each packed project .nupkg").option("--signing-certificate-password <password>", "Certificate password. Use env.ENV_NAME to read from an environment variable.").option("--signing-timestamp-server <url>", "Timestamp server URL").option("--skip-analyze", "Skip the workflow analyzer for every RPA project in the solution. Compilation and validation still run.").option("--ignored-rules <rules>", "Analyzer rule IDs whose findings are ignored for every RPA project, e.g. ST-USG-034,ST-MRD-002. Comma-separated; repeat the flag to add more. The rules still run, but their findings are not reported and do not fail the pack. Applies on top of --governance-file-path or the shipped rules; when the signed-in tenant publishes an AutomationOps policy, the list is not applied and a warning says so.", parseIgnoredRules).option("--governance-file-path <path>", "Analyze every RPA project against this local governance policy file, instead of the analyzer rules shipped with the WorkflowCompiler. When you are signed in as a user the tenant is asked first — about StudioWeb unless --governance-product names another product — and when the tenant publishes a policy of its own, that policy is used instead and this file is ignored with a warning.").option("--governance-product <product>", "Analyze every RPA project against the governance policy published in AutomationOps for the signed-in tenant. The value is the product whose policy is downloaded, e.g. StudioWeb, Development, Business. Signed in as an external application, the policy is not downloaded yet (AutomationOps does not accept external-application tokens): the pack uses --governance-file-path if given, otherwise the rules shipped with the WorkflowCompiler.").addOption(new Option("--automation-ops-profile <profile>").hideHelp());
   registerPackageMetadataOptions(command).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).option("--dry-run", "Run the full pack pipeline against a temporary directory and discard the output. Catches pack-time failures; does not inspect the produced package contents.").examples(SOLUTION_PACK_EXAMPLES).trackedAction(processContext, async (solutionPath, outputPath, options) => {
+    const {
+      GOVERNANCE_OPTION_INSTRUCTIONS,
+      validateGovernanceOptions
+    } = await import("./governance-options-amc1v319.js");
+    const { PackCommandService } = await import("./pack-command-service-8etwpgm9.js");
     if (!options.dryRun && outputPath === undefined) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
-        Message: "Missing required argument: outputPath. Provide an output directory, or pass --dry-run to validate without packing.",
-        Instructions: "Run `uip solution pack <solutionPath> <outputPath>` to produce a package, or `uip solution pack <solutionPath> --dry-run` to validate only."
+        Message: "Missing required argument: output-path. Provide an output directory, or pass --dry-run to validate without packing.",
+        Instructions: "Run `uip solution pack <solution-path> <output-path>` to produce a package, or `uip solution pack <solution-path> --dry-run` to validate only."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const projectError = validatePackProjectOptions(options);
+    if (projectError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: projectError,
+        Instructions: "Pass --project <id-or-path> to pack one project, and --package-id <id> (not --name) only together with it: `uip solution pack <solution-path> <output-path> --project <id-or-path> [--package-id <id>]`."
       });
       processContext.exit(1);
       return;
@@ -2485,6 +2284,8 @@ var registerPackCommand = (program) => {
     const packOptions = {
       output: outputPath,
       name: options.name,
+      project: options.project,
+      packageId: options.packageId,
       version: options.version,
       solutionType: options.solutionType,
       loginValidity: options.loginValidity,
@@ -2840,40 +2641,6 @@ var registerPackagesCommand = (program) => {
 
 // src/commands/project-add.ts
 import { randomUUID } from "node:crypto";
-
-// src/commands/project-command-utils.ts
-function rejectUnsupportedProjectType(projectType, failureMessage) {
-  const reason = unsupportedSolutionProjectType(projectType);
-  if (!reason) {
-    return false;
-  }
-  OutputFormatter.error({
-    Result: RESULTS.Failure,
-    Message: failureMessage,
-    Instructions: reason
-  });
-  processContext.exit(1);
-  return true;
-}
-function projectManifestInstructions(fileName, readProjectError, verb) {
-  if (fileName !== "uipath.json" || !isMissingProjectTypeError(readProjectError)) {
-    return readProjectError.message;
-  }
-  return `${readProjectError.message} If this is a coded app, scaffold it with 'uip codedapp init <project-path>' — that writes the project.uiproj this command registers — then run 'uip solution projects ${verb} <project-path>' again.`;
-}
-function resourcesPendingForProjectType(projectType) {
-  return !hasBareTemplateRow(projectType) && hasAnyTemplateRow(projectType);
-}
-function hostGeneratesResources(projectType) {
-  return hasBareTemplateRow(projectType);
-}
-function resourcesPendingWarning(projectType) {
-  const verb = toolVerbForProjectType(projectType);
-  const needs = verb ? `that needs the '${verb}' tool installed ('uip tools install ${verb}')` : "that needs the tool that owns this project type installed";
-  return `No solution resources were generated for this project yet. Run 'uip solution resources refresh' to create them — ${needs}. 'uip solution pack' and 'uip solution upload' do it too.`;
-}
-
-// src/commands/project-add.ts
 var PROJECT_ADD_EXAMPLES = [
   {
     Description: "Register an existing project subfolder in a solution",
@@ -2890,6 +2657,7 @@ var PROJECT_ADD_EXAMPLES = [
   }
 ];
 async function hasProjectInSolution(fs, solutionDir, projectDir, projects) {
+  const { toPortableRelativePath } = await import("./index-6wak6hg6.js");
   const projectDirReal = await canonicalizePath(fs, projectDir);
   for (const project of projects ?? []) {
     const candidateDir = fs.path.resolve(solutionDir, fs.path.dirname(toPortableRelativePath(project.ProjectRelativePath)));
@@ -2905,9 +2673,29 @@ async function canonicalizePath(fs, path) {
   return error || !realPath ? path : realPath;
 }
 var registerProjectAddCommand = (project) => {
-  project.command("add").description("Register an existing project subfolder in the .uipx solution manifest. The project folder must already reside inside the solution directory. Use 'projects import' instead to copy an external project into the solution.").argument("<project-path>", "Path to the project folder (must contain project.uiproj, project.json, or uipath.json)").argument("[solutionFile]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").examples(PROJECT_ADD_EXAMPLES).trackedAction(processContext, async (projectPath, solutionFile) => {
+  project.command("add").description("Register an existing project subfolder in the .uipx solution manifest. The project folder must already reside inside the solution directory. Use 'projects import' instead to copy an external project into the solution.").argument("<project-path>", "Path to the project folder (must contain project.uiproj, project.json, or uipath.json), or to that manifest file itself").argument("[solution-file]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").examples(PROJECT_ADD_EXAMPLES).trackedAction(processContext, async (projectPath, solutionFile) => {
+    const {
+      createProjectInSolutionBuilder,
+      findProjectFile,
+      isProjectManifestError,
+      readProjectFile,
+      readSolutionFile,
+      resolveSolutionFilePath,
+      restoreSolutionFile,
+      syncResourcesFromBindings,
+      writeSolutionFile
+    } = await import("./index-prm27bvm.js");
+    const { toPortableRelativePath } = await import("./index-6wak6hg6.js");
+    const {
+      hostGeneratesResources,
+      projectManifestInstructions,
+      rejectUnsupportedProjectType,
+      resolveProjectManifestDirectory,
+      resourcesPendingForProjectType,
+      resourcesPendingWarning
+    } = await import("./project-command-utils-t6pmpvq3.js");
     const fs = getFileSystem();
-    const resolvedProjectPath = fs.path.resolve(fs.env.cwd(), projectPath);
+    const resolvedProjectPath = await resolveProjectManifestDirectory(fs, fs.path.resolve(fs.env.cwd(), projectPath));
     const isResolvedProjectPathValid = await fs.exists(resolvedProjectPath);
     if (!isResolvedProjectPathValid) {
       OutputFormatter.error({
@@ -3048,7 +2836,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 var PROJECT_IMPORT_EXAMPLES = [
   {
     Description: "Copy an external project folder into a solution",
-    Command: "uip solution projects import ./external-project --solutionFile ./my-solution/my-solution.uipx",
+    Command: "uip solution projects import ./external-project --solution-file ./my-solution/my-solution.uipx",
     Output: {
       Code: "ProjectImport",
       Data: {
@@ -3061,7 +2849,25 @@ var PROJECT_IMPORT_EXAMPLES = [
   }
 ];
 var registerProjectImportCommand = (project) => {
-  project.command("import").description("Copy an external project folder into the solution directory and register it in the .uipx manifest. Unlike 'projects add' which references an existing subfolder, import copies the source files into the solution tree.").argument("<source>", "Path to the project folder to import (must contain project.uiproj, project.json, or uipath.json)").option("--solutionFile <path>", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the current directory)").examples(PROJECT_IMPORT_EXAMPLES).trackedAction(processContext, async (sourcePath, options) => {
+  const command = project.command("import").description("Copy an external project folder into the solution directory and register it in the .uipx manifest. Unlike 'projects add' which references an existing subfolder, import copies the source files into the solution tree.").argument("<source>", "Path to the project folder to import (must contain project.uiproj, project.json, or uipath.json)").option("--solution-file <path>", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the current directory)").examples(PROJECT_IMPORT_EXAMPLES).trackedAction(processContext, async (sourcePath, options) => {
+    const {
+      createProjectInSolutionBuilder,
+      findProjectFile,
+      isProjectManifestError,
+      readProjectFile,
+      readSolutionFile,
+      resolveSolutionFilePath,
+      syncResourcesFromBindings,
+      writeSolutionFile
+    } = await import("./index-prm27bvm.js");
+    const { toPortableRelativePath } = await import("./index-6wak6hg6.js");
+    const {
+      hostGeneratesResources,
+      projectManifestInstructions,
+      rejectUnsupportedProjectType,
+      resourcesPendingForProjectType,
+      resourcesPendingWarning
+    } = await import("./project-command-utils-t6pmpvq3.js");
     const { solutionFile } = options;
     const fs = getFileSystem();
     const cwd = fs.env.cwd();
@@ -3229,6 +3035,7 @@ var registerProjectImportCommand = (project) => {
       }
     });
   });
+  addDeprecatedOptionAlias(command, "--solutionFile <path>", "--solution-file");
 };
 
 // src/commands/project-list.ts
@@ -3246,6 +3053,13 @@ function fallbackProjectName(fs, solutionDir, projectRelativePath) {
   const projectDir = fs.path.dirname(projectRelativePath);
   return projectDir && projectDir !== "." ? fs.path.basename(projectDir) : fs.path.basename(solutionDir);
 }
+async function createPackageIdReaderAsync(fs, solutionDir, solutionName) {
+  const { readMemberPackageIdAsync } = await import("./package-id-c18sx4mz.js");
+  return async (project) => {
+    const [error, packageId] = await catchError(readMemberPackageIdAsync(fs, project, solutionDir, solutionName));
+    return error ? undefined : packageId ?? undefined;
+  };
+}
 var PROJECT_LIST_EXAMPLES = [
   {
     Description: "List the local projects registered in the .uipx solution manifest (run from inside the solution dir, or pass --solution-folder)",
@@ -3258,14 +3072,16 @@ var PROJECT_LIST_EXAMPLES = [
           Type: "Process",
           Id: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
           ProjectRelativePath: "MyProject/project.uiproj",
-          ProjectFilePath: "/workspace/my-solution/MyProject/project.uiproj"
+          ProjectFilePath: "/workspace/my-solution/MyProject/project.uiproj",
+          PackageId: "my-solution.Rpa.MyProject"
         }
       ]
     }
   }
 ];
 var registerProjectListCommand = (project) => {
-  project.command("list").description("List the projects registered in the local .uipx solution manifest. " + "Reads only on-disk metadata — does not call any backend.").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").examples(PROJECT_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+  project.command("list").description("List the projects registered in the local .uipx solution manifest, each with the package id a solution pack gives it. " + "Reads only on-disk metadata — does not call any backend.").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").examples(PROJECT_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+    const { readSolutionFile, resolveSolutionFilePath } = await import("./index-prm27bvm.js");
     const fs = getFileSystem();
     const solutionPath = options.solutionFolder ?? ".";
     const resolvedPath = fs.path.resolve(fs.env.cwd(), solutionPath);
@@ -3300,6 +3116,7 @@ var registerProjectListCommand = (project) => {
       return;
     }
     const solutionDir = fs.path.dirname(resolvedSolutionFile);
+    const readPackageIdAsync = await createPackageIdReaderAsync(fs, solutionDir, fs.path.basename(resolvedSolutionFile).replace(/\.uipx$/i, ""));
     const projects = parsedSolution.solution.Projects ?? [];
     const data = await Promise.all(projects.map(async (p) => {
       const projectFilePath = fs.path.resolve(solutionDir, p.ProjectRelativePath);
@@ -3309,7 +3126,12 @@ var registerProjectListCommand = (project) => {
         Type: p.Type,
         Id: p.Id,
         ProjectRelativePath: p.ProjectRelativePath,
-        ProjectFilePath: projectFilePath
+        ProjectFilePath: projectFilePath,
+        PackageId: await readPackageIdAsync({
+          Id: p.Id,
+          Type: p.Type,
+          ProjectRelativePath: p.ProjectRelativePath
+        })
       };
     }));
     OutputFormatter.success({
@@ -3492,10 +3314,20 @@ var PROJECT_REMOVE_EXAMPLES = [
   }
 ];
 var registerProjectRemoveCommand = (project) => {
-  project.command("remove").description("Unregister a project from the .uipx solution manifest and remove its entry from the solution builder. Does not delete the project files from disk. Doesn't remove the last project in a solution.").argument("<project-path>", "Path to the project folder to remove").argument("[solutionFile]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").examples(PROJECT_REMOVE_EXAMPLES).trackedAction(processContext, async (projectPath, solutionFile) => {
+  project.command("remove").description("Unregister a project from the .uipx solution manifest and remove its entry from the solution builder. Does not delete the project files from disk. Doesn't remove the last project in a solution.").argument("<project-path>", "Path to the project folder to remove, or to its project manifest file (the form the .uipx records)").argument("[solution-file]", "Path to the .uipx solution file (defaults to the nearest .uipx file found by searching up from the project path)").examples(PROJECT_REMOVE_EXAMPLES).trackedAction(processContext, async (projectPath, solutionFile) => {
+    const {
+      createResourceBuilderServices,
+      readSolutionFile,
+      resolveSolutionFilePath,
+      restoreSolutionFile,
+      writeSolutionFile
+    } = await import("./index-prm27bvm.js");
+    const { toPortableRelativePath } = await import("./index-6wak6hg6.js");
+    const { resolveSolutionSearchStart } = await import("./project-command-utils-t6pmpvq3.js");
     const fs = getFileSystem();
     const resolvedProjectPath = fs.path.resolve(fs.env.cwd(), projectPath);
-    const [solutionFileError, resolvedSolutionFile] = await resolveSolutionFilePath(solutionFile, resolvedProjectPath);
+    const searchStart = solutionFile ? resolvedProjectPath : await resolveSolutionSearchStart(fs, resolvedProjectPath);
+    const [solutionFileError, resolvedSolutionFile] = await resolveSolutionFilePath(solutionFile, searchStart);
     if (solutionFileError) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -3529,7 +3361,11 @@ var registerProjectRemoveCommand = (project) => {
       return;
     }
     const { solution, rawContent: originalSolutionContent } = parsedSolution;
-    const projectIndex = (solution.Projects ?? []).findIndex((p) => fs.path.dirname(toPortableRelativePath(p.ProjectRelativePath)) === toPortableRelativePath(relativePath));
+    const requestedPath = toPortableRelativePath(relativePath);
+    const projectIndex = (solution.Projects ?? []).findIndex((p) => {
+      const recorded = toPortableRelativePath(p.ProjectRelativePath);
+      return recorded === requestedPath || fs.path.dirname(recorded) === requestedPath;
+    });
     if (projectIndex === -1) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -3786,113 +3622,6 @@ var registerProjectCommand = (program) => {
   wireProjectSubcommands(project);
 };
 
-// src/services/ship-telemetry.ts
-var PROJECT_TYPE_MAP = {
-  Agent: "low_code_agent",
-  Api: "api_workflow",
-  AppV2: "coded_app",
-  CaseManagement: "case",
-  Flow: "flow",
-  Process: "rpa",
-  ProcessOrchestration: "bpmn",
-  WebApp: "coded_app",
-  processOrchestration: "bpmn"
-};
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function normalizeShipProjectType(projectType) {
-  return PROJECT_TYPE_MAP[projectType] ?? projectType.trim().toLowerCase();
-}
-function summarizeShipProjectTypes(projectTypes) {
-  const normalized = [
-    ...new Set(projectTypes.map((projectType) => projectType.trim()).filter(Boolean).map(normalizeShipProjectType))
-  ];
-  if (normalized.length === 0) {
-    return { projectType: "unknown" };
-  }
-  if (normalized.length === 1) {
-    return { projectType: normalized[0] };
-  }
-  const sortedProjectTypes = [...normalized];
-  sortedProjectTypes.sort((left, right) => left.localeCompare(right));
-  return {
-    projectType: "mixed",
-    projectTypes: sortedProjectTypes.join(",")
-  };
-}
-function readProjectTypesFromUipx(content) {
-  const parsed = JSON.parse(content);
-  if (!isRecord(parsed) || !Array.isArray(parsed.Projects)) {
-    return [];
-  }
-  return parsed.Projects.map((project) => {
-    if (!isRecord(project)) {
-      return;
-    }
-    return typeof project.Type === "string" ? project.Type : undefined;
-  }).filter((projectType) => projectType !== undefined);
-}
-var MAX_INSPECTABLE_PACKAGE_BYTES = 256 * 1024 * 1024;
-function isProjectManifestEntry(name) {
-  return name.endsWith(".uipx");
-}
-function unzipProjectManifests(archive) {
-  return new Promise((resolve, reject) => {
-    unzip(archive, { filter: (file) => isProjectManifestEntry(file.name) }, (error, entries) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(entries);
-    });
-  });
-}
-async function inspectSolutionPackageProjectTypes(packagePath) {
-  const fs = getFileSystem();
-  const [statError, stats] = await catchError(fs.stat(packagePath));
-  if (statError || !stats) {
-    logger.debug(`[Cli.ShipSucceeded] Could not stat solution package for project type telemetry: ${statError?.message ?? "no stats"}`);
-    return { projectType: "unknown" };
-  }
-  if (stats.size > MAX_INSPECTABLE_PACKAGE_BYTES) {
-    logger.debug(`[Cli.ShipSucceeded] Solution package is ${stats.size} bytes, over the ${MAX_INSPECTABLE_PACKAGE_BYTES}-byte inspection cap; skipping project type telemetry.`);
-    return { projectType: "unknown" };
-  }
-  const [readError, archive] = await catchError(fs.readFile(packagePath));
-  if (readError || !archive) {
-    logger.debug(`[Cli.ShipSucceeded] Could not read solution package for project type telemetry: ${readError?.message ?? "empty archive"}`);
-    return { projectType: "unknown" };
-  }
-  const [unzipError, entries] = await catchError(unzipProjectManifests(new Uint8Array(archive)));
-  if (unzipError || !entries) {
-    logger.debug(`[Cli.ShipSucceeded] Could not inspect solution package zip: ${unzipError?.message ?? "no entries"}`);
-    return { projectType: "unknown" };
-  }
-  const decoder = new TextDecoder;
-  const projectTypes = [];
-  for (const [entryName, entryBytes] of Object.entries(entries)) {
-    if (!isProjectManifestEntry(entryName)) {
-      continue;
-    }
-    const [parseError, parsedTypes] = await catchError(Promise.resolve().then(() => readProjectTypesFromUipx(decoder.decode(entryBytes))));
-    if (parseError) {
-      logger.debug(`[Cli.ShipSucceeded] Could not parse ${entryName} for project type telemetry: ${parseError.message}`);
-      continue;
-    }
-    projectTypes.push(...parsedTypes);
-  }
-  return summarizeShipProjectTypes(projectTypes);
-}
-function trackSolutionShipSucceeded(payload) {
-  const { projectTypeSummary, ...rest } = payload;
-  return trackShipSucceeded({
-    ...rest,
-    [ShipDimensions.ProjectType]: projectTypeSummary.projectType,
-    [ShipDimensions.ProjectTypes]: projectTypeSummary.projectTypes
-  });
-}
-
 // src/commands/publish.ts
 var PUBLISHED_STATUS = "Package is published to Orchestrator but not yet deployed";
 var NEXT_STEPS_MESSAGE = "Package is published to Orchestrator but not yet deployed. " + "Deploy/activate it into an Orchestrator folder before it appears in the " + "processes list or can be started as a job.";
@@ -3987,7 +3716,7 @@ var EXIT_CODES_BY_REASON = {
   poll_timeout: 2
 };
 var registerPublishCommand = (program) => {
-  const command = program.command("publish").description("Publish a solution package (.zip) to the UiPath solution feed. The .zip must be produced by 'solution pack'. By default the package lands in the tenant feed; use --personal-workspace to target the current user's Personal Workspace feed. After publishing, use 'solution deploy run' to deploy it.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).argument("<packagePath>", "Path to a .zip package file produced by 'solution pack'.").option("--personal-workspace", "Upload the package into the current user's Personal Workspace feed instead of the tenant feed. Resolves the workspace folder key from Orchestrator automatically.").option("--package-name <name>", "Publish under this package name instead of the one the .zip was packed with. Rewrites the archive's solutionMetadata.json in memory (with a fresh package version key); the file on disk is left untouched. The bundled project packages keep their own names and versions.").option("--package-version <version>", "Publish under this package version instead of the one the .zip was packed with. Use it to clear a 'version already exists' rejection when you have the packed .zip but not the solution source. Same in-memory rewrite as --package-name.").option("--wait", "Wait until the published package is Ready or Active").option("--timeout <seconds>", "Timeout in seconds for package state polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between package state polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10);
+  const command = program.command("publish").description("Publish a solution package (.zip) to the UiPath solution feed. The .zip must be produced by 'solution pack'. By default the package lands in the tenant feed; use --personal-workspace to target the current user's Personal Workspace feed. After publishing, use 'solution deploy run' to deploy it.").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).argument("<package-path>", "Path to a .zip package file produced by 'solution pack'.").option("--personal-workspace", "Upload the package into the current user's Personal Workspace feed instead of the tenant feed. Resolves the workspace folder key from Orchestrator automatically.").option("--package-name <name>", "Publish under this package name instead of the one the .zip was packed with. Rewrites the archive's solutionMetadata.json in memory (with a fresh package version key); the file on disk is left untouched. The bundled project packages keep their own names and versions.").option("--package-version <version>", "Publish under this package version instead of the one the .zip was packed with. Use it to clear a 'version already exists' rejection when you have the packed .zip but not the solution source. Same in-memory rewrite as --package-name.").option("--wait", "Wait until the published package is Ready or Active").option("--timeout <seconds>", "Timeout in seconds for package state polling (default: 360)", (v) => parseInt(v, 10), 360).option("--poll-interval <ms>", "Milliseconds between package state polls (default: 5000)", (v) => parseInt(v, 10), 5000).option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10);
   command.addOption(new Option("--feed <name-or-key>", "Publish into a feed by its name or folder key (from 'solution feeds list') instead of the tenant feed. Mutually exclusive with --personal-workspace.").conflicts("personalWorkspace"));
   command.examples([...SOLUTION_PUBLISH_EXAMPLES, SOLUTION_PUBLISH_FEED_EXAMPLE]).trackedAction(processContext, async (packagePath, options) => {
     const result = await publishSolutionAsync(packagePath, {
@@ -4050,6 +3779,7 @@ var registerPublishCommand = (program) => {
     });
   });
 };
+
 // src/commands/resource-add.ts
 var RESOURCE_ADD_EXAMPLES = [
   {
@@ -4089,7 +3819,14 @@ var RESOURCE_ADD_EXAMPLES = [
 ];
 var registerResourceAddCommand = (resource) => {
   resource.command("add").description("Add a resource to the solution. Use --source local to create a virtual stub, " + "or --source remote to import an existing Orchestrator resource. Idempotent: " + "if a resource with the same (kind, name, folder) already exists, it is returned unchanged.").option("--source <source>", "Resource source: local (virtual stub) or remote (import from Orchestrator)").option("--kind <kind>", "Resource kind (e.g. Queue, Asset, Bucket, Process, Connection, App, Index, Trigger, Entity, ChoiceSet). Case-insensitive, matched against SDK metadata.").option("--name <name>", "Resource name").option("--type <type>", "Resource subtype, case-insensitive (e.g. Text/Integer/Bool/Credential/Secret or stringAsset/credentialAsset for Asset, connector type for Connection). Rejected when the kind does not declare it or has no subtypes (Queue); with --source remote it must match the resource's type and narrows same-name matches.").option("--folder-path <path>", "Orchestrator folder path for remote lookup. Required to disambiguate when more than one remote match exists. Not valid with --source local.").option("--cloud-key <guid>", "Skip remote search and import this exact resource key. Only valid with --source remote.").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(RESOURCE_ADD_EXAMPLES).trackedAction(processContext, async (options) => {
-    const validation = validateOptions(options);
+    const {
+      assertSolutionManifest,
+      createResourceBuilderServices,
+      normalizeResourceFileCasing,
+      saveCasingNormalized
+    } = await import("./index-prm27bvm.js");
+    const { getSolutionAuthContext: getSolutionAuthContext2 } = await import("./solution-auth-aead70sw.js");
+    const validation = await validateOptions(options);
     if (!validation.ok) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -4122,7 +3859,7 @@ var registerResourceAddCommand = (resource) => {
       return;
     }
     if (source === "remote") {
-      const [authError] = await catchError(getSolutionAuthContext({
+      const [authError] = await catchError(getSolutionAuthContext2({
         loginValidity: options.loginValidity
       }));
       if (authError) {
@@ -4217,7 +3954,8 @@ function canonicalizeKind(kind) {
   return trimmed.charAt(0).toLowerCase() + trimmed.slice(1);
 }
 var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function validateOptions(options) {
+async function validateOptions(options) {
+  const { validateResourceName } = await import("./index-prm27bvm.js");
   if (!options.source) {
     return {
       ok: false,
@@ -4291,6 +4029,7 @@ function validateOptions(options) {
 async function resolveTypeInput(services, kind, type) {
   if (type === undefined)
     return { ok: true, type };
+  const { formatResourceSubtypes, resolveResourceKindMetadata } = await import("./resource-mutations-c3krjqze.js");
   const metadata = await resolveResourceKindMetadata(services, kind, type);
   if (metadata?.typeMatched) {
     return { ok: true, type: metadata.type ?? type };
@@ -4320,6 +4059,13 @@ function formatCandidates(matches) {
 `);
 }
 async function runAdd(builder, services, rawInput) {
+  const { findMatchingLocalResource } = await import("./index-prm27bvm.js");
+  const {
+    createLocalResource,
+    findResourceByKeyInRcs,
+    sameResourceSubtype,
+    searchRcsResources
+  } = await import("./resource-mutations-c3krjqze.js");
   const typeResolution = await resolveTypeInput(services, rawInput.kind, rawInput.type);
   if (!typeResolution.ok)
     return typeResolution.outcome;
@@ -4381,7 +4127,7 @@ async function runAdd(builder, services, rawInput) {
         instructions: searchError.message
       };
     }
-    const inFolder = filterMatchesByFolder(matches, input.folderPath);
+    const inFolder = await filterMatchesByFolder(matches, input.folderPath);
     if (inFolder.length === 0) {
       return {
         kind: "error",
@@ -4478,7 +4224,8 @@ ${formatCandidates(filtered)}`
     data: toResourceAddData(imported, refreshed.folders, "remote", statusToOutputStatus(response.status))
   };
 }
-function filterMatchesByFolder(matches, folderPath) {
+async function filterMatchesByFolder(matches, folderPath) {
+  const { normalizeFolderPath } = await import("./index-prm27bvm.js");
   const normalized = normalizeFolderPath(folderPath);
   if (!normalized)
     return matches;
@@ -4506,8 +4253,31 @@ function toResourceAddData(resource, folders, source, status) {
   };
 }
 
-// src/commands/resource-edit.ts
+// src/commands/resource-command-utils.ts
 var RESOURCE_KEY_REGEX = /^[A-Za-z0-9._:-]{1,256}$/;
+function validateResourceKeyArgument(resourceKey) {
+  if (!resourceKey || resourceKey.trim().length === 0) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Missing required argument <resource-key>",
+      Instructions: "Pass the solution resource key as a positional argument. Use 'uip solution resources list' to discover keys."
+    });
+    processContext.exit(1);
+    return false;
+  }
+  if (!RESOURCE_KEY_REGEX.test(resourceKey)) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "<resource-key> contains unsupported characters",
+      Instructions: "Resource keys use letters, digits, and '. _ - :' only. Use 'uip solution resources list' to find a valid key."
+    });
+    processContext.exit(1);
+    return false;
+  }
+  return true;
+}
+
+// src/commands/resource-edit.ts
 var REMOTE_FAILURE_MESSAGE = {
   solution_not_found: "Failed to edit resource",
   not_a_solution: "Failed to edit resource",
@@ -4600,24 +4370,15 @@ var RESOURCE_EDIT_EXAMPLES = [
 ];
 var registerResourceEditCommand = (resource) => {
   resource.command("edit").description("Edit a resource's spec properties by key. Pass --patch with a JSON object " + "of property → value; the JSON is merged into the existing spec. Properties " + "the SDK metadata marks as reference/read-only/unknown are silently ignored. " + "Use 'uip solution resources get <key>' to inspect the current spec; the " + "get↔edit shapes match, so a round-trip is straightforward. " + "Pass --source remote instead of --patch to take the values from the cloud " + "definition the resource was imported from — the only way to pick up a change " + "made in Orchestrator or Data Fabric after the import, since 'resources refresh' " + "never overwrites an imported resource.").argument("<resource-key>", "Solution resource key (a GUID, or a compound key such as MyFunction.api.MyFunction.1:1.0.0)").option("--patch <json>", `JSON object of spec property → value (e.g. '{"retentionPeriod":14}'). Pass '-' to read the JSON from stdin.`).option("--source <source>", "Where the new values come from: 'local' (default, use --patch) or 'remote' (the cloud definition this resource was imported from)", "local").option("--force", "With --source remote, write the cloud definition over the local one. Without it the command only reports what would change and writes nothing.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10). Only used by --source remote.", "10").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").examples(RESOURCE_EDIT_EXAMPLES).trackedAction(processContext, async (resourceKey, options) => {
-    if (!resourceKey || resourceKey.trim().length === 0) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Missing required argument <resource-key>",
-        Instructions: "Pass the solution resource key as a positional argument. Use 'uip solution resources list' to discover keys."
-      });
-      processContext.exit(1);
-      return;
-    }
-    if (!RESOURCE_KEY_REGEX.test(resourceKey)) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "<resource-key> contains unsupported characters",
-        Instructions: "Resource keys use letters, digits, and '. _ - :' only. Use 'uip solution resources list' to find a valid key."
-      });
-      processContext.exit(1);
+    if (!validateResourceKeyArgument(resourceKey)) {
       return;
     }
+    const {
+      assertSolutionManifest,
+      createResourceBuilderServices,
+      normalizeResourceFileCasing,
+      saveCasingNormalized
+    } = await import("./index-prm27bvm.js");
     const source = (options.source ?? "local").toLowerCase();
     if (source !== "local" && source !== "remote") {
       OutputFormatter.error({
@@ -4753,6 +4514,7 @@ var registerResourceEditCommand = (resource) => {
   });
 };
 async function handleRemoteSourceAsync(resourceKey, options) {
+  const { resourceRemoteSyncAsync } = await import("./index-prm27bvm.js");
   const result = await resourceRemoteSyncAsync(options.solutionFolder ?? ".", resourceKey, {
     force: options.force === true,
     loginValidity: options.loginValidity ? parseInt(options.loginValidity, 10) : undefined
@@ -4833,7 +4595,6 @@ async function readStdin() {
 }
 
 // src/commands/resource-get.ts
-var NOT_FOUND_PATTERN2 = /not\s+found/i;
 var RESOURCE_GET_EXAMPLES = [
   {
     Description: "Get the configuration for a single solution resource (run from inside the solution dir, or pass --solution-folder)",
@@ -4891,6 +4652,11 @@ var RESOURCE_GET_EXAMPLES = [
 ];
 var registerResourceGetCommand = (resource) => {
   resource.command("get").description("Get the configuration of a solution resource by key. Returns the resource spec, locks, and metadata as the SDK exposes them. " + "Use --include-dependencies to also retrieve configurations for every dependency the resource references.").argument("<resource-key>", "Solution resource key (GUID, or composite key like 'TestRPA.process.TestRPA:1.0.0' for packages)").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").option("--include-dependencies", "Also return configurations for the resource's dependencies").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", "10").examples(RESOURCE_GET_EXAMPLES).trackedAction(processContext, async (resourceKey, options) => {
+    const {
+      createResourceBuilderServices,
+      readResourceConfigurationsAsync
+    } = await import("./index-prm27bvm.js");
+    const { getSolutionAuthContext: getSolutionAuthContext2 } = await import("./solution-auth-aead70sw.js");
     const solutionPath = options.solutionFolder ?? ".";
     if (!resourceKey || resourceKey.trim() === "") {
       OutputFormatter.error({
@@ -4914,7 +4680,7 @@ var registerResourceGetCommand = (resource) => {
       return;
     }
     const loginValidityMinutes = options.loginValidity ? parseInt(options.loginValidity, 10) : undefined;
-    const [authError] = await catchError(getSolutionAuthContext({
+    const [authError] = await catchError(getSolutionAuthContext2({
       loginValidity: loginValidityMinutes
     }));
     if (authError) {
@@ -4946,87 +4712,32 @@ var registerResourceGetCommand = (resource) => {
       processContext.exit(1);
       return;
     }
-    const includeDeps = options.includeDependencies === true;
-    const [fetchError, data] = await catchError(includeDeps ? builder.getAllConfigurationsAsync(resourceKey) : builder.getConfigurationAsync(resourceKey));
-    if (!fetchError) {
-      const resource2 = await refreshArtefactSpecAsync(builder, data, includeDeps);
-      if (!includeDeps) {
-        await attachLiveSpecOnMismatchAsync(services, resource2, data);
-      }
-      await builder.disposeAsync();
-      OutputFormatter.success({
-        Result: RESULTS.Success,
-        Code: includeDeps ? "ResourceConfigurations" : "ResourceConfiguration",
-        Data: data
-      });
-      return;
-    }
-    if (NOT_FOUND_PATTERN2.test(fetchError.message)) {
-      const [remoteError, remoteData] = await catchError(getRemoteConfiguration(services, resourceKey, includeDeps));
-      await builder.disposeAsync();
-      if (!remoteError) {
-        OutputFormatter.success({
-          Result: RESULTS.Success,
-          Code: includeDeps ? "ResourceConfigurations" : "ResourceConfiguration",
-          Data: remoteData
-        });
-        return;
-      }
+    const [fetchError, data] = await catchError(options.includeDependencies === true ? readResourceConfigurationsAsync(services, builder, resourceKey) : readWithLiveSpecAsync(services, builder, resourceKey));
+    await builder.disposeAsync();
+    if (fetchError) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
         Message: "Failed to get resource configuration",
-        Instructions: await extractErrorMessage(remoteError)
+        Instructions: await extractErrorMessage(fetchError)
       });
       processContext.exit(1);
       return;
     }
-    await builder.disposeAsync();
-    OutputFormatter.error({
-      Result: RESULTS.Failure,
-      Message: "Failed to get resource configuration",
-      Instructions: await extractErrorMessage(fetchError)
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: options.includeDependencies === true ? "ResourceConfigurations" : "ResourceConfiguration",
+      Data: data
     });
-    processContext.exit(1);
   });
 };
-async function getRemoteConfiguration(services, resourceKey, includeDependencies) {
-  const reference = await findRemoteReferenceByKey(services, resourceKey);
-  if (!reference) {
-    throw new Error(`Resource '${resourceKey}' was not found in the solution or in the resource catalog`);
-  }
-  const { importer } = getRemoteResourceClients(services);
-  const payload = await importer.exportResourceAsync(reference);
-  const definitions = payload.resourceDefinitions ?? [];
-  const primary = definitions.find((d) => d.key === resourceKey) ?? definitions[0];
-  if (!primary) {
-    throw new Error(`FPS export for '${resourceKey}' returned no resource definitions`);
-  }
-  if (!includeDependencies) {
-    return mapDefinitionToConfiguration(primary);
-  }
-  const all = {
-    resources: definitions.map((d) => ({
-      ...mapDefinitionToConfiguration(d),
-      name: d.name ?? "",
-      kind: d.kind ?? "",
-      dependencies: (d.dependencies ?? []).map((dep) => ({
-        kind: dep.kind ?? "",
-        name: dep.name ?? ""
-      }))
-    }))
-  };
-  return all;
-}
-function mapDefinitionToConfiguration(def) {
-  return {
-    key: def.key ?? "",
-    spec: def.spec ?? {},
-    locks: def.locks ?? [],
-    apiVersion: def.apiVersion,
-    isOverridable: def.isOverridable
-  };
+async function readWithLiveSpecAsync(services, builder, resourceKey) {
+  const { readResourceConfigurationAsync } = await import("./index-prm27bvm.js");
+  const { configuration, resource } = await readResourceConfigurationAsync(services, builder, resourceKey);
+  await attachLiveSpecOnMismatchAsync(services, resource, configuration);
+  return configuration;
 }
 async function attachLiveSpecOnMismatchAsync(services, resource, config) {
+  const { getRemoteResourceClients } = await import("./index-prm27bvm.js");
   const overwriteData = config.resourceOverwrite;
   const overwrite = overwriteData?.resourceOverwrite?.overwrite;
   if (overwriteData?.matchingOverwriteConfiguration !== false || !overwrite || !resource) {
@@ -5039,104 +4750,6 @@ async function attachLiveSpecOnMismatchAsync(services, resource, config) {
   }
   config.liveSpec = exported.spec;
 }
-async function refreshArtefactSpecAsync(builder, data, includeDeps) {
-  const [loadError, solution] = await catchError(builder.context.loadAsync());
-  if (loadError || !solution) {
-    return;
-  }
-  let requestedResource;
-  const configs = includeDeps ? data.resources ?? [] : [data];
-  for (const config of configs) {
-    if (!config?.key) {
-      continue;
-    }
-    const resource = solution.resources.find((r) => r.key === config.key);
-    if (!includeDeps) {
-      requestedResource = resource;
-    }
-    if (!resource?.projectKey) {
-      continue;
-    }
-    config.spec = await applyEntryPointEnhancementAsync(builder.context, resource, config.spec ?? {});
-  }
-  return requestedResource;
-}
-async function findRemoteReferenceByKey(services, resourceKey) {
-  const entity = await findCatalogEntityAsync(getRemoteResourceClients(services).catalog, {}, (item) => item.entityKey === resourceKey);
-  return entity ? toResourceReference(entity) : null;
-}
-
-// src/services/resource-version-lookup.ts
-var VERSION_PROPERTY = "version";
-var LOOKUP_CONCURRENCY = 5;
-async function resolveResourceVersionsAsync(services, builder, targets) {
-  const versions = new Map;
-  if (targets.length === 0) {
-    return versions;
-  }
-  const resolveKind = await createResourceKindMetadataResolver(services);
-  const versioned = [];
-  for (const target of targets) {
-    const metadata = await resolveKind(target.kind, target.type);
-    if (metadata?.specProperties.has(VERSION_PROPERTY)) {
-      versioned.push(target);
-    }
-  }
-  if (versioned.length === 0) {
-    return versions;
-  }
-  const { importer } = getRemoteResourceClients(services);
-  for (let i = 0;i < versioned.length; i += LOOKUP_CONCURRENCY) {
-    const batch = versioned.slice(i, i + LOOKUP_CONCURRENCY);
-    const resolved = await Promise.all(batch.map((target) => target.source === "Local" ? readLocalVersionAsync(builder, target) : readRemoteVersionAsync(importer, target)));
-    for (const [id, version] of resolved) {
-      if (version !== undefined) {
-        versions.set(id, version);
-      }
-    }
-  }
-  return versions;
-}
-async function readLocalVersionAsync(builder, target) {
-  const [error, configuration] = await catchError(builder.getConfigurationAsync(target.key));
-  if (error || !configuration) {
-    warnLookupFailed(target, error);
-    return [target.id, undefined];
-  }
-  return [target.id, readVersion(configuration.spec)];
-}
-async function readRemoteVersionAsync(importer, target) {
-  const reference = {
-    kind: target.kind,
-    type: target.type,
-    key: target.key,
-    name: target.name,
-    folder: target.folderFullyQualifiedName ? {
-      fullyQualifiedName: target.folderFullyQualifiedName,
-      folderKey: target.folderKey
-    } : undefined
-  };
-  const [error, primary] = await catchError(exportResourceDefinitionAsync(importer, reference));
-  if (error) {
-    warnLookupFailed(target, error);
-    return [target.id, undefined];
-  }
-  if (!primary) {
-    logger.warn(`Export for ${target.kind} '${target.name ?? target.key}' returned no definition for that key; version omitted.`);
-    return [target.id, undefined];
-  }
-  return [target.id, readVersion(primary.spec)];
-}
-function readVersion(spec) {
-  const value = readSpecProperty(spec, VERSION_PROPERTY);
-  if (value === undefined || value === null || value === "") {
-    return;
-  }
-  return typeof value === "string" ? value : String(value);
-}
-function warnLookupFailed(target, error) {
-  logger.warn(`Failed to read the version of ${target.kind} '${target.name ?? target.key}': ${error?.message ?? "no configuration returned"}`);
-}
 
 // src/commands/resource-list.ts
 var RESOURCE_LIST_EXAMPLES = [
@@ -5177,6 +4790,8 @@ var RESOURCE_LIST_EXAMPLES = [
 ];
 var registerResourceListCommand = (resource) => {
   resource.command("list").description("List resources in the solution and/or available in Orchestrator. " + "Shows local solution resources, remote Orchestrator resources, or both.").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").option("--kind <kind>", "Filter by resource kind (e.g. Queue, Asset, Bucket, Process, Connection, App, Index, Trigger, Entity, ChoiceSet). Any kind RCS indexes is accepted.").option("--search <term>", "Filter resources by name").option("--source <source>", "Resource source: all, local, or remote (default: all)", "all").option("--include-version", "Also report each resource's version, for the kinds that carry one (app, appVersion, package, process). " + "Remote rows report the version live in the folder, local rows the version the solution pins. " + "Costs one extra call per resource, so it is off by default.").option("-l, --limit <number>", "Number of resources to return", parseLimit, DEFAULT_PAGE_SIZE).option("--offset <number>", "Only 0 is accepted: the resource catalog pages by cursor. Use --next-page instead", parseOffset).option("--next-page <cursor>", "Cursor from a previous response's Pagination.NextPage").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(RESOURCE_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
+    const { createResourceBuilderServices } = await import("./index-prm27bvm.js");
+    const { getSolutionAuthContext: getSolutionAuthContext2 } = await import("./solution-auth-aead70sw.js");
     const solutionPath = options.solutionFolder ?? ".";
     const fs = getFileSystem();
     const resolvedPath = fs.path.resolve(fs.env.cwd(), solutionPath);
@@ -5205,7 +4820,7 @@ var registerResourceListCommand = (resource) => {
       return;
     }
     const normalizedKind = options.kind;
-    const [authError] = await catchError(getSolutionAuthContext({
+    const [authError] = await catchError(getSolutionAuthContext2({
       loginValidity: options.loginValidity
     }));
     if (authError) {
@@ -5353,6 +4968,7 @@ function versionLookupId(entry) {
   return `${entry.Source}|${entry.Key}|${entry.Folder ?? ""}`;
 }
 async function annotateVersions(services, builder, entries) {
+  const { resolveResourceVersionsAsync } = await import("./resource-version-lookup-0e3e2j58.js");
   const targets = new Map;
   for (const entry of entries) {
     if (entry.Key === "") {
@@ -5384,6 +5000,7 @@ async function annotateVersions(services, builder, entries) {
   }
 }
 async function allRemotePage(services, search, pageCursor) {
+  const { getRemoteResourceClients } = await import("./index-prm27bvm.js");
   const rcs = getRemoteResourceClients(services).catalog;
   const result = await rcs.searchFolderEntities({
     name: search,
@@ -5450,9 +5067,10 @@ var RESOURCE_REFRESH_EXAMPLES = [
         Imported: 1,
         Skipped: 5,
         Pruned: 0,
+        ProjectResourcesCreated: 2,
         ReconciledSpecs: 1,
         Warnings: [],
-        Status: "Synced 3 resources (5 already in solution). Refresh never overwrites an imported resource — to pull a changed cloud definition, run 'uip solution resources edit <resource-key> --source remote'."
+        Status: "Synced 3 resources (5 already in solution, 2 project resources generated). Refresh never overwrites an imported resource — to pull a changed cloud definition, run 'uip solution resources edit <resource-key> --source remote'."
       }
     }
   }
@@ -5465,31 +5083,39 @@ var FAILURE_MESSAGE = {
 };
 var registerResourceRefreshSubcommand = (resource) => {
   resource.command("refresh").description("Re-scan all projects in the solution and sync each project's authored files into the solution resource JSONs. " + "Bindings: creates new resources for `bindings_v2.json` entries not yet in the solution, imports from Orchestrator when a matching resource exists, and removes duplicate copies of the solution's own projects that earlier runs imported from a deployed folder. " + "Project contributions: each project's owning tool reports what its authored files add to the solution resources, and refresh persists it onto the matching resource. " + "Run this after editing a project's bindings or any file the project's tool contributes from, to update the solution resource inventory. " + "Refresh is import-only for cloud resources: it never overwrites an imported resource, so local edits survive; a project's own artefact resources are rewritten from the project's files on every run. " + "To pull a cloud definition that changed after the import, use 'uip solution resources edit <resource-key> --source remote'.").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", "10").examples(RESOURCE_REFRESH_EXAMPLES).trackedAction(processContext, async (options) => {
+    const { resourceRefreshAsync } = await import("./index-prm27bvm.js");
     const loginValidityMinutes = options.loginValidity ? parseInt(options.loginValidity, 10) : undefined;
     const solutionFolder = options.solutionFolder ?? ".";
     const fs = getFileSystem();
     let contributions;
     const [
-      { ensurePackagerTools: ensurePackagerTools2 },
-      { projectSubTypesFrom },
+      { ensurePackagerTools },
+      { projectBindingsFrom, projectSubTypesFrom },
       {
         applyProjectContributions,
         collectProjectContributions,
         contributionErrorMessages
       }
     ] = await Promise.all([
-      import("./packager-tool-resolver-6zwhec62.js"),
-      import("./prepare-solution-resources-jpb5as2s.js"),
-      import("./project-contributions-6wpff2hm.js")
+      import("./packager-tool-resolver-994z3jkj.js"),
+      import("./prepare-solution-resources-m1djfj62.js"),
+      import("./project-contributions-79ndycrx.js")
     ]);
     const resolveProjectSubTypesAsync = async () => {
-      await ensurePackagerTools2(solutionFolder, fs);
+      await ensurePackagerTools(solutionFolder, fs);
       contributions = await collectProjectContributions(solutionFolder, fs);
       return projectSubTypesFrom(contributions);
     };
+    const resolveProjectBindingsAsync = async () => {
+      if (!contributions) {
+        throw new Error("the project tools could not be loaded");
+      }
+      return projectBindingsFrom(contributions);
+    };
     const result = await resourceRefreshAsync(solutionFolder, {
       loginValidity: loginValidityMinutes,
-      resolveProjectSubTypesAsync
+      resolveProjectSubTypesAsync,
+      resolveProjectBindingsAsync
     });
     if (!result.ok) {
       OutputFormatter.error({
@@ -5501,6 +5127,7 @@ var registerResourceRefreshSubcommand = (resource) => {
       return;
     }
     const prunedNote = result.pruned > 0 ? `, ${result.pruned} duplicates removed` : "";
+    const projectNote = result.projectResourcesCreated > 0 ? `, ${result.projectResourcesCreated} project resources generated` : "";
     const skippedNote = result.skipped > 0 ? " Refresh never overwrites an imported resource — to pull a changed cloud definition, run 'uip solution resources edit <resource-key> --source remote'." : "";
     let applied = { updated: 0, warnings: [] };
     if (contributions) {
@@ -5529,16 +5156,16 @@ var registerResourceRefreshSubcommand = (resource) => {
         Imported: result.imported,
         Skipped: result.skipped,
         Pruned: result.pruned,
+        ProjectResourcesCreated: result.projectResourcesCreated,
         ReconciledSpecs: applied.updated,
         Warnings: warnings,
-        Status: `Synced ${result.created + result.imported} resources (${result.skipped} already in solution${prunedNote}).${skippedNote}`
+        Status: `Synced ${result.created + result.imported} resources (${result.skipped} already in solution${prunedNote}${projectNote}).${skippedNote}`
       }
     });
   });
 };
 
 // src/commands/resource-remove.ts
-var RESOURCE_KEY_REGEX2 = /^[A-Za-z0-9._:-]{1,256}$/;
 var RESOURCE_REMOVE_EXAMPLES = [
   {
     Description: "Remove a resource by its solution key",
@@ -5556,24 +5183,15 @@ var RESOURCE_REMOVE_EXAMPLES = [
 ];
 var registerResourceRemoveCommand = (resource) => {
   resource.command("remove").description("Remove a resource from the solution by its key. Use 'uip solution resources list' " + "or 'uip solution resources get' to discover the key first. " + "Purely local — no auth required, doesn't touch any bindings_v2.json.").argument("<resource-key>", "Solution resource key (a GUID, or a compound key such as MyFunction.api.MyFunction.1:1.0.0)").option("--solution-folder <path>", "Path to the solution root folder (defaults to current directory)").examples(RESOURCE_REMOVE_EXAMPLES).trackedAction(processContext, async (resourceKey, options) => {
-    if (!resourceKey || resourceKey.trim().length === 0) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Missing required argument <resource-key>",
-        Instructions: "Pass the solution resource key as a positional argument. Use 'uip solution resources list' to discover keys."
-      });
-      processContext.exit(1);
-      return;
-    }
-    if (!RESOURCE_KEY_REGEX2.test(resourceKey)) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "<resource-key> contains unsupported characters",
-        Instructions: "Resource keys use letters, digits, and '. _ - :' only. Use 'uip solution resources list' to find a valid key."
-      });
-      processContext.exit(1);
+    if (!validateResourceKeyArgument(resourceKey)) {
       return;
     }
+    const {
+      assertSolutionManifest,
+      createResourceBuilderServices,
+      normalizeResourceFileCasing,
+      saveCasingNormalized
+    } = await import("./index-prm27bvm.js");
     const fs = getFileSystem();
     const resolvedPath = fs.path.resolve(fs.env.cwd(), options.solutionFolder ?? ".");
     if (!await fs.exists(resolvedPath)) {
@@ -5680,118 +5298,6 @@ var registerResourceCommand = (program) => {
   registerResourceEditCommand(resources);
 };
 
-// src/services/restore-command-service.ts
-class RestoreCommandService {
-  packager = null;
-  fs;
-  constructor() {
-    this.fs = getFileSystem();
-  }
-  async execute(solutionPath, options, context) {
-    const check = await checkSolutionPathAsync(this.fs, solutionPath);
-    if (!check.ok) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: check.message,
-        Instructions: SOLUTION_PATH_INSTRUCTIONS,
-        ErrorCode: check.errorCode
-      });
-      if (check.statError?.stack) {
-        logger.error("Stack trace:");
-        logger.error(check.statError.stack);
-      }
-      context.exit(1);
-      return;
-    }
-    const { absoluteSolutionPath, isUisFile } = check;
-    const solutionName = isUisFile ? this.fs.path.basename(solutionPath, ".uis") : this.fs.path.basename(solutionPath);
-    logger.info(`
-Restoring solution dependencies...
-`);
-    logger.info("Details:");
-    logger.info(`  Solution: ${absoluteSolutionPath}`);
-    logger.info("");
-    const [error, result] = await catchError(this.executeAsync(solutionPath, options));
-    if (error) {
-      const msg = error instanceof Error ? error.message : String(error);
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        ...isUnpackableProjectTypeError(error) ? { ErrorCode: "invalid_argument" } : {},
-        Message: msg,
-        Instructions: carriedInstructions(error) ?? "Check that you are logged in (`uip auth login`) and that the solution path is accessible, then rerun: uip solution restore <solutionPath>"
-      });
-      if (error instanceof Error && error.stack && !isUnpackableProjectTypeError(error)) {
-        logger.error("Stack trace:");
-        logger.error(error.stack);
-      }
-      context.exit(1);
-      return;
-    }
-    if (result.errorCode !== "SUCCESS" /* Success */) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: `Error code: ${result.errorCode} : ${result.message}`,
-        Instructions: "Resolve the reported dependency issue, ensure you are logged in with `uip auth login`, then rerun: uip solution restore <solutionPath>"
-      });
-      context.exit(1);
-      return;
-    }
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "SolutionRestore",
-      Data: {
-        Solution: solutionName,
-        Status: "Restored"
-      }
-    });
-  }
-  async executeAsync(solutionPath, options) {
-    const check = await checkSolutionPathAsync(this.fs, solutionPath);
-    if (!check.ok) {
-      if (check.statError) {
-        throw check.statError;
-      }
-      return new ToolResult("INTERNAL_ERROR" /* InternalError */, check.message, []);
-    }
-    const { absoluteSolutionPath, isUisFile } = check;
-    const solutionName = isUisFile ? this.fs.path.basename(solutionPath, ".uis") : this.fs.path.basename(solutionPath);
-    const packager = await this.ensurePackagerAsync();
-    let inputPath;
-    if (isUisFile) {
-      const uint8Array = await readSolutionFileAsUint8Array(this.fs, absoluteSolutionPath);
-      inputPath = await packager.setupAsync(uint8Array);
-    } else {
-      inputPath = await packager.setupAsync(absoluteSolutionPath);
-    }
-    await ensurePackagerTools(inputPath, this.fs);
-    const restoreOptions = await this.createRestoreOptions(inputPath, solutionName, options);
-    return packager.restoreSolutionAsync(restoreOptions);
-  }
-  async ensurePackagerAsync() {
-    if (!this.packager) {
-      this.packager = await createSolutionPackager();
-    }
-    return this.packager;
-  }
-  async createRestoreOptions(inputPath, solutionName, options) {
-    const restoreOptions = new SolutionPackOptions;
-    restoreOptions.inputPath = inputPath;
-    restoreOptions.configuration = "Release" /* Release */;
-    restoreOptions.excludeConfiguredSources = options.excludeConfiguredSources ?? false;
-    restoreOptions.package = {
-      id: solutionName,
-      version: "1.0.0",
-      author: "",
-      description: ""
-    };
-    restoreOptions.logLevel = resolveSdkLogLevel();
-    restoreOptions.nuGetSourcesConfigPath = options.nugetSourcesConfigPath;
-    restoreOptions.feedFolder = options.feedFolder;
-    await applyAuthConnection(restoreOptions, options.loginValidity);
-    return restoreOptions;
-  }
-}
-
 // src/commands/restore.ts
 var SOLUTION_RESTORE_EXAMPLES = [
   {
@@ -5807,7 +5313,8 @@ var SOLUTION_RESTORE_EXAMPLES = [
   }
 ];
 var registerRestoreCommand = (program) => {
-  program.command("restore").description("Restore NuGet dependencies for every project in a UiPath solution using the authenticated session. Accepts a solution directory (containing .uipx) or a .uis file. Resolves dependencies in place and does not produce a package — run it before 'uip solution pack'.").argument("<solutionPath>", "Path to a solution directory (containing .uipx) or a .uis file").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").option("--exclude-configured-sources", "Resolve project dependencies only from the tenant feeds and any --nuget-sources-config-path. Drops the built-in UiPath and nuget.org feeds, so a dependency that is not on those feeds fails to restore.").option("--feed-folder <name>", "Resolve project dependencies from this Orchestrator folder's library feed instead of every tenant feed. Accepts a folder name or fully qualified path.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(SOLUTION_RESTORE_EXAMPLES).trackedAction(processContext, async (solutionPath, options) => {
+  program.command("restore").description("Restore NuGet dependencies for every project in a UiPath solution using the authenticated session. Accepts a solution directory (containing .uipx) or a .uis file. Resolves dependencies in place and does not produce a package — run it before 'uip solution pack'.").argument("<solution-path>", "Path to a solution directory (containing .uipx) or a .uis file").option("--nuget-sources-config-path <path>", "Path to NuGet sources configuration file").option("--exclude-configured-sources", "Resolve project dependencies only from the tenant feeds and any --nuget-sources-config-path. Drops the built-in UiPath and nuget.org feeds, so a dependency that is not on those feeds fails to restore.").option("--feed-folder <name>", "Resolve project dependencies from this Orchestrator folder's library feed instead of every tenant feed. Accepts a folder name or fully qualified path.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(SOLUTION_RESTORE_EXAMPLES).trackedAction(processContext, async (solutionPath, options) => {
+    const { RestoreCommandService } = await import("./restore-command-service-eyx911f2.js");
     const service = new RestoreCommandService;
     await service.execute(solutionPath, {
       loginValidity: options.loginValidity,
@@ -5817,541 +5324,6 @@ var registerRestoreCommand = (program) => {
     }, processContext);
   });
 };
-// ../executor/project-executor/src/models/run-status.ts
-var TERMINAL_RUN_STATUSES = [
-  "Succeeded" /* Succeeded */,
-  "Faulted" /* Faulted */,
-  "Cancelled" /* Cancelled */
-];
-function isTerminalRunStatus(status) {
-  return TERMINAL_RUN_STATUSES.includes(status);
-}
-
-// ../executor/project-executor/src/models/run-result.ts
-class RunResult {
-  status;
-  errorCode;
-  rawStatus;
-  message;
-  jobKey;
-  instanceId;
-  runId;
-  traceId;
-  steps;
-  output;
-  url;
-  details;
-  constructor(status, errorCode = "None" /* None */, message) {
-    this.status = status;
-    this.errorCode = errorCode;
-    this.message = message;
-  }
-  get isSuccess() {
-    return this.status === "Succeeded" /* Succeeded */ && this.errorCode === "None" /* None */;
-  }
-  get isTerminal() {
-    return isTerminalRunStatus(this.status);
-  }
-  static succeeded(init = {}) {
-    return Object.assign(new RunResult("Succeeded" /* Succeeded */, "None" /* None */), init);
-  }
-  static failed(errorCode, message, init = {}) {
-    return Object.assign(new RunResult("Faulted" /* Faulted */, errorCode, message), init);
-  }
-}
-// ../executor/project-executor/src/services/executor-tool-import.ts
-async function importExecutorToolModule(specifier) {
-  try {
-    return { module: await import(specifier) };
-  } catch (error) {
-    return {
-      error: error instanceof Error ? error : new Error(String(error))
-    };
-  }
-}
-
-// ../executor/project-executor/src/services/executor-tool-module.ts
-var EXECUTOR_FACTORY_EXPORT = "createExecutorFactory";
-function isExecutorFactoryModule(module) {
-  return typeof module === "object" && module !== null && typeof module[EXECUTOR_FACTORY_EXPORT] === "function";
-}
-
-// ../executor/project-executor/src/services/executors-factory-repository.ts
-class ExecutorsFactoryRepository {
-  factoryMap = new Map;
-  onConflict;
-  constructor(onConflict) {
-    this.onConflict = onConflict ?? ((message) => console.warn(message));
-  }
-  registerProjectExecutorFactory(factory) {
-    for (const projectType of factory.supportedTypes) {
-      const existing = this.factoryMap.get(projectType);
-      if (existing) {
-        if (existing.constructor?.name !== factory.constructor?.name) {
-          this.onConflict(`Executor factory conflict for project type '${projectType}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
-        }
-        continue;
-      }
-      this.factoryMap.set(projectType, factory);
-    }
-  }
-  canHandleProject(projectType) {
-    return this.factoryMap.has(projectType);
-  }
-  getProjectExecutorFactory(projectType) {
-    const factory = this.factoryMap.get(projectType);
-    if (!factory) {
-      throw new Error(`Cannot run project type '${projectType}': no runner is installed for it. ` + `Project types that can be run: ${this.registeredTypes.join(", ") || "none"}.`);
-    }
-    return factory;
-  }
-  get registeredTypes() {
-    return [...this.factoryMap.keys()];
-  }
-  reset() {
-    this.factoryMap.clear();
-  }
-}
-var REGISTRY_KEY = Symbol.for("@uipath/project-executor/executorsFactoryRepository");
-var _global = globalThis;
-if (!_global[REGISTRY_KEY]) {
-  _global[REGISTRY_KEY] = new ExecutorsFactoryRepository;
-}
-var executorsFactoryRepository = _global[REGISTRY_KEY];
-
-// ../executor/project-executor/src/services/executor-factory-provider.ts
-var PROVIDER_KEY = Symbol.for("@uipath/project-executor/executorFactoryProvider");
-var _global2 = globalThis;
-function registerExecutorFactoryFromModule(module, source) {
-  if (!isExecutorFactoryModule(module)) {
-    throw new Error(`${source} does not export ${EXECUTOR_FACTORY_EXPORT}().`);
-  }
-  const factory = module.createExecutorFactory();
-  executorsFactoryRepository.registerProjectExecutorFactory(factory);
-  return factory;
-}
-async function ensureExecutorFactory(verb, packageName) {
-  const provider = _global2[PROVIDER_KEY];
-  if (provider) {
-    await provider(verb);
-    return;
-  }
-  if (!packageName) {
-    throw new Error(`Running this project type needs the executor factory for '${verb}', and no package provides it.`);
-  }
-  const specifier = `${packageName}/executor-tool`;
-  const { module, error } = await importExecutorToolModule(specifier);
-  if (error) {
-    throw new Error(`Running this project type needs '${packageName}'. Install it.`, { cause: error });
-  }
-  registerExecutorFactoryFromModule(module, specifier);
-}
-// ../executor/project-executor/src/services/executor-logger.ts
-var noopExecutorLogger = {
-  info: () => {},
-  warn: () => {},
-  error: () => {}
-};
-// ../executor/project-executor/src/services/project-runner.ts
-class ProjectRunner {
-  fileSystem;
-  logger;
-  registry;
-  constructor(deps) {
-    this.fileSystem = deps.fileSystem;
-    this.logger = deps.logger ?? noopExecutorLogger;
-    this.registry = deps.registry ?? executorsFactoryRepository;
-  }
-  canRun(projectType) {
-    return this.registry.canHandleProject(projectType);
-  }
-  get runnableTypes() {
-    return this.registry.registeredTypes;
-  }
-  async runAsync(options, cancellationToken) {
-    const { projectType, name } = options.project;
-    if (!this.canRun(projectType)) {
-      const known = this.runnableTypes.join(", ") || "none";
-      return RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `Cannot run project '${name}' (project type '${projectType}'): ` + `no runner is installed for it. Project types that can be run: ${known}.`);
-    }
-    let executor;
-    try {
-      const factory = this.registry.getProjectExecutorFactory(projectType);
-      executor = await factory.createAsync(this.logger, this.fileSystem);
-      this.logger.info(`Running ${name} (${projectType}) on ${options.target}.`);
-      return await executor.runAsync(options, cancellationToken);
-    } catch (error) {
-      return RunResult.failed("Unknown" /* Unknown */, messageOf(error));
-    } finally {
-      try {
-        await executor?.dispose();
-      } catch (error) {
-        this.logger.warn(`Failed to dispose the ${projectType} executor: ${messageOf(error)}`);
-      }
-    }
-  }
-}
-function messageOf(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-// src/services/executor-tool-resolver.ts
-var PROJECT_TYPE_TO_TOOL = new Map([
-  ["Process", "rpa"],
-  ["Tests", "rpa"],
-  ["WebApp", "rpa"],
-  ["Agent", "agent"],
-  ["Api", "api-workflow"]
-]);
-var TOOL_TO_PACKAGE = new Map([
-  ["rpa", "@uipath/rpa-tool"],
-  ["agent", "@uipath/agent-tool"],
-  ["api-workflow", "@uipath/api-workflow-tool"]
-]);
-function hasExecutorToolFor(projectType) {
-  return PROJECT_TYPE_TO_TOOL.has(projectType);
-}
-async function ensureExecutorTools(projectTypes) {
-  const neededTools = new Set;
-  for (const type of projectTypes) {
-    if (executorsFactoryRepository.canHandleProject(type))
-      continue;
-    const toolVerb = PROJECT_TYPE_TO_TOOL.get(type);
-    if (toolVerb) {
-      neededTools.add(toolVerb);
-    } else {
-      logger.warn(`No installable tool runs project type '${type}'. Run may fail.`);
-    }
-  }
-  for (const toolVerb of neededTools) {
-    logger.info(`Loading executor factory for '${toolVerb}' to run project types...`);
-    await ensureExecutorFactory(toolVerb, TOOL_TO_PACKAGE.get(toolVerb));
-  }
-}
-function projectDirOf(fs, declaredPath) {
-  const dir = fs.path.dirname(declaredPath);
-  return dir && dir !== "." ? dir : "";
-}
-async function readSolutionProjects(solutionDir, fs) {
-  const entries = await fs.readdir(solutionDir);
-  const uipxFile = entries.find((f) => f.endsWith(".uipx"));
-  if (!uipxFile) {
-    throw new Error(`No .uipx solution file found in '${solutionDir}'. ` + `Pass a solution directory or run 'uip solution init' first.`);
-  }
-  const content = await fs.readFile(fs.path.join(solutionDir, uipxFile));
-  if (!content) {
-    throw new Error(`Solution file '${uipxFile}' is empty.`);
-  }
-  const json = typeof content === "string" ? content : new TextDecoder().decode(content);
-  const [parseError, solution] = catchError(() => JSON.parse(json));
-  if (parseError) {
-    throw new Error(`Failed to parse ${uipxFile}: ${parseError.message}`);
-  }
-  return (solution.Projects ?? []).map((p) => {
-    const relativePath = projectDirOf(fs, p.ProjectRelativePath ?? "");
-    return {
-      name: p.Name || fs.path.basename(relativePath || solutionDir) || "",
-      projectType: p.Type ?? "",
-      relativePath
-    };
-  });
-}
-
-// src/services/provision-debug-service.ts
-function nextDebugVersion() {
-  return `1.0.${Math.floor(Date.now() / 1000)}`;
-}
-async function defaultGetSolutionBuilder(solutionDir) {
-  const services = await createResourceBuilderServices();
-  return services.getSolutionBuilder(solutionDir, true);
-}
-async function provisionSolutionForDebugAsync(options, deps = {}) {
-  const listLocations = deps.listLocations ?? listSelectablePublishLocations;
-  const pack = deps.pack ?? packSolutionAsync;
-  const publish = deps.publish ?? publishSolutionAsync;
-  const getBuilder = deps.getSolutionBuilder ?? defaultGetSolutionBuilder;
-  const newSessionId = deps.newSessionId ?? (() => crypto.randomUUID());
-  const authOptions = {
-    tenant: options.tenant,
-    loginValidity: options.loginValidity
-  };
-  const getDebugStatus = deps.getDebugStatus ?? (async (solutionKey2, debugSessionId) => {
-    const auth = await getSolutionAuthContext(authOptions);
-    return getProjectDebugStatus({ basePath: auth.basePath, accessToken: auth.accessToken }, solutionKey2, debugSessionId);
-  });
-  logger.info("Resolving the personal workspace to deploy into...");
-  const [locationsError, locations] = await catchError(listLocations(authOptions));
-  if (locationsError) {
-    return fail(`Could not resolve a personal workspace to deploy into: ${locationsError.message}`);
-  }
-  const personal = locations.find((l) => l.isMyPersonalWorkspace);
-  if (!personal) {
-    return fail("This account has no personal workspace, so there is nowhere to deploy the solution for a debug run. " + "Ask an administrator to enable a personal workspace, or run with --no-provision-resources — " + "the run then starts without a deployment, and cross-project calls will not resolve.");
-  }
-  const version = options.version ?? nextDebugVersion();
-  const fs = getFileSystem();
-  const outputPath = fs.path.join(fs.env.tmpdir(), "uip-solution-run", newSessionId());
-  const uploaded = await packAndUploadAsync({
-    options,
-    authOptions,
-    pack,
-    publish,
-    version,
-    outputPath
-  });
-  if (!uploaded.ok) {
-    return fail(uploaded.message);
-  }
-  const packageVersionKey = uploaded.packageVersionKey;
-  logger.info("Provisioning the solution's resources for the run...");
-  const [builderError, builder] = await catchError(getBuilder(options.solutionDir));
-  if (builderError) {
-    return fail(`Could not read the solution: ${builderError.message}`);
-  }
-  const sessionId = newSessionId();
-  const [debugError, debug] = await catchError(builder.debugProjectAsync(personal.key, options.solutionName, sessionId, packageVersionKey, true));
-  let solutionKey;
-  if (!debugError && debug.complete === false) {
-    const [, definition] = await catchError(builder.context.loadAsync());
-    solutionKey = definition?.key;
-  }
-  await builder.disposeAsync().catch(() => {});
-  if (debugError) {
-    return fail(`Provisioning the solution failed: ${debugError.message}`);
-  }
-  if (debug.complete === false) {
-    if (!solutionKey) {
-      return fail("The cloud is still provisioning the solution, but its key could not be read back from the .uipx, so the provisioning cannot be waited on. Retry the run.");
-    }
-    return waitForProvisioningAsync({
-      solutionKey,
-      sessionId,
-      packageVersionKey,
-      options,
-      getDebugStatus
-    });
-  }
-  const folderPath = debug.folderFullyQualifiedName;
-  logger.info(folderPath ? `Solution provisioned into ${folderPath}.` : "Solution provisioned.");
-  return {
-    ok: true,
-    folderPath,
-    packageVersionKey
-  };
-}
-function fail(message) {
-  return { ok: false, message };
-}
-async function packAndUploadAsync(args) {
-  const { options, authOptions, version } = args;
-  logger.info("Packing the solution...");
-  const [packError, packed] = await catchError(args.pack(options.solutionDir, {
-    output: args.outputPath,
-    name: options.solutionName,
-    version,
-    loginValidity: options.loginValidity
-  }));
-  if (packError) {
-    return {
-      ok: false,
-      message: `Packing the solution failed: ${packError.message}`
-    };
-  }
-  if (!packed.ok) {
-    return {
-      ok: false,
-      message: `Packing the solution failed: ${packed.message}`
-    };
-  }
-  const packagePath = packed.packages?.[0];
-  if (!packagePath) {
-    return {
-      ok: false,
-      message: "Packing the solution produced no package."
-    };
-  }
-  logger.info("Uploading the solution to the personal workspace...");
-  const [publishError, published] = await catchError(args.publish(packagePath, {
-    ...authOptions,
-    personalWorkspace: true,
-    packageVersion: version
-  }));
-  if (publishError) {
-    return {
-      ok: false,
-      message: `Uploading the solution failed: ${publishError.message}`
-    };
-  }
-  if (!published.ok) {
-    return {
-      ok: false,
-      message: `Uploading the solution failed: ${published.message}`
-    };
-  }
-  if (!published.packageVersionKey) {
-    return {
-      ok: false,
-      message: "The solution was uploaded but the feed did not report a package version, so it cannot be provisioned. Retry the run."
-    };
-  }
-  return { ok: true, packageVersionKey: published.packageVersionKey };
-}
-async function waitForProvisioningAsync(args) {
-  const { solutionKey, sessionId, packageVersionKey, options } = args;
-  const timeoutMs = options.provisioningTimeoutMs ?? 360000;
-  logger.info("Waiting for the cloud to finish provisioning...");
-  const poll = await pollUntil({
-    fn: () => args.getDebugStatus(solutionKey, sessionId),
-    until: (info2) => isDebugProvisioningTerminal(info2.status),
-    getStatus: (info2) => info2.status ?? "pending",
-    label: `solution provisioning (session ${sessionId})`,
-    logPrefix: "provision",
-    timeoutMs,
-    intervalMs: options.provisioningPollIntervalMs ?? 5000,
-    maxConsecutiveErrors: 5,
-    signal: processContext.pollSignal
-  });
-  if (poll.outcome !== PollOutcome.Completed || !poll.data) {
-    return fail(describeIncompleteWait(poll, timeoutMs));
-  }
-  const info = poll.data;
-  if (!isDebugProvisioningSucceeded(info.status)) {
-    const details = (info.errors ?? []).map((error) => error.resource ? `${error.resource.kind ?? "resource"} '${error.resource.name ?? error.resource.key ?? ""}': ${error.message}` : error.message).join(`
-`);
-    return fail(`Provisioning the solution failed (${info.status}).` + (details ? `
-${details}` : ""));
-  }
-  logger.info("Solution provisioned.");
-  return { ok: true, packageVersionKey };
-}
-function describeIncompleteWait(poll, timeoutMs) {
-  const lastStatus = poll.data?.status ?? "unknown";
-  if (poll.outcome === PollOutcome.Interrupted) {
-    return `The wait for the solution's provisioning was cancelled (last status: ${lastStatus}). ` + "The cloud may still finish it.";
-  }
-  if (poll.outcome === PollOutcome.Failed || poll.outcome === PollOutcome.Aborted) {
-    return `Checking the solution's provisioning status failed: ${poll.error?.message ?? "too many consecutive errors"} ` + `(last status: ${lastStatus}). The provisioning itself may still be running or have finished — ` + "retry the run to check.";
-  }
-  return `The solution was uploaded, but the cloud did not finish provisioning it within ${Math.round(timeoutMs / 1000)}s ` + `(last status: ${lastStatus}). ` + "Running again will not help: each run uploads a new version and provisions that one too. " + "To run a project that calls another project, deploy the solution once " + "('uip solution pack' → 'publish' → 'deploy run') and then run with " + "--no-provision-resources --folder-path <deployed folder>.";
-}
-
-// src/services/run-service.ts
-async function runSolutionAsync(options, deps, cancellationToken) {
-  const { fileSystem } = deps;
-  const solutionDir = fileSystem.path.resolve(options.solutionPath);
-  const [readError, projects] = await catchError(readSolutionProjects(solutionDir, fileSystem));
-  if (readError) {
-    return RunResult.failed("InvalidInput" /* InvalidInput */, readError.message);
-  }
-  const runnable = projects.filter((p) => hasExecutorToolFor(p.projectType));
-  if (runnable.length === 0) {
-    const seen = projects.map((p) => `${p.name} (${p.projectType})`).join(", ") || "none";
-    return RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `No project in this solution can be run. Projects: ${seen}.`);
-  }
-  const [selectionError, selected] = selectProject(runnable, options.projectName);
-  if (selectionError) {
-    return RunResult.failed("InvalidInput" /* InvalidInput */, selectionError);
-  }
-  const provision = deps.provisionForDebug ?? provisionSolutionForDebugAsync;
-  const shouldProvision = options.provisionResources ?? projects.length > 1;
-  const [executorOutcome, provisionOutcome] = await Promise.allSettled([
-    ensureExecutorTools([selected.projectType]),
-    shouldProvision ? provision({
-      solutionDir,
-      solutionName: fileSystem.path.basename(solutionDir),
-      tenant: options.tenant,
-      loginValidity: options.loginValidity
-    }) : Promise.resolve(undefined)
-  ]);
-  if (executorOutcome.status === "rejected") {
-    return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not load the runner for project type '${selected.projectType}': ${describeError(executorOutcome.reason)}`);
-  }
-  if (provisionOutcome.status === "rejected") {
-    return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not deploy the solution before the run: ${describeError(provisionOutcome.reason)}`);
-  }
-  let folderPath = options.folderPath;
-  const provisioned = provisionOutcome.value;
-  if (provisioned) {
-    if (!provisioned.ok) {
-      return RunResult.failed("PrepareFailed" /* PrepareFailed */, provisioned.message ?? "Could not deploy the solution before the run.");
-    }
-    folderPath = provisioned.folderPath;
-  }
-  const projectPath = fileSystem.path.resolve(solutionDir, selected.relativePath);
-  logger.debug(`Running '${selected.name}' (${selected.projectType}) from ${projectPath}` + `${options.entryPoint ? ` with entry point ${options.entryPoint}` : " with its default entry point"}`);
-  const connection = await resolveConnection(folderPath, options, deps);
-  const runner = new ProjectRunner({
-    fileSystem,
-    logger: deps.logger
-  });
-  return runner.runAsync({
-    project: {
-      name: selected.name,
-      projectType: selected.projectType,
-      projectPath
-    },
-    entryPoint: options.entryPoint,
-    inputArguments: options.inputArguments,
-    target: "Local" /* Local */,
-    connection,
-    siblingProjects: projects.filter((p) => p !== selected).map((p) => ({
-      name: p.name,
-      projectType: p.projectType,
-      projectPath: fileSystem.path.resolve(solutionDir, p.relativePath)
-    })),
-    timeoutMs: options.timeoutMs
-  }, cancellationToken);
-}
-async function resolveConnection(folderPath, options, deps) {
-  const getLoginStatus = deps.getLoginStatus ?? getLoginStatusAsync;
-  const [loginError, status] = await catchError(getLoginStatus({
-    ensureTokenValidityMinutes: options.loginValidity
-  }));
-  if (loginError || status.loginStatus !== "Logged in") {
-    logger.debug(`No signed-in session for the run: ${loginError?.message ?? status.loginStatus}. ` + "A project type that needs one will say so.");
-    return {
-      folderPath,
-      baseUrl: "",
-      accessToken: "",
-      organizationId: "",
-      organizationName: ""
-    };
-  }
-  return {
-    folderPath,
-    baseUrl: status.baseUrl ?? "",
-    accessToken: status.accessToken ?? "",
-    organizationId: status.organizationId ?? "",
-    organizationName: status.organizationName ?? "",
-    tenantId: status.tenantId,
-    tenantName: status.tenantName
-  };
-}
-function describeError(reason) {
-  const message = reason instanceof Error ? reason.message : String(reason);
-  const instructions = carriedInstructions(reason);
-  return instructions ? `${message} ${instructions}` : message;
-}
-function selectProject(runnable, requested) {
-  if (requested) {
-    const match = runnable.find((p) => p.name === requested);
-    if (!match) {
-      const names = runnable.map((p) => p.name).join(", ");
-      return [
-        `Project '${requested}' is not a runnable project in this solution. Runnable projects: ${names}.`,
-        runnable[0]
-      ];
-    }
-    return [undefined, match];
-  }
-  if (runnable.length > 1) {
-    const names = runnable.map((p) => p.name).join(", ");
-    return [
-      `This solution has more than one runnable project, so one has to be named with --project-name. Runnable projects: ${names}.`,
-      runnable[0]
-    ];
-  }
-  return [undefined, runnable[0]];
-}
 
 // src/commands/run.ts
 var ERROR_CODE_BY_RUN_ERROR = {
@@ -6366,7 +5338,7 @@ var NEVER_STARTED = new Set([
   "Unauthorized" /* Unauthorized */
 ]);
 var registerRunCommand = (program) => {
-  program.command("run", { hidden: true }).description("Run a project from a UiPath solution. Currently supports RPA projects, agents and API Workflows.").argument("<solutionPath>", "Path to a solution directory (containing .uipx)").option("--project-name <name>", "Name of the project to run. Required only when the solution has more than one runnable project.").option("--entry-point <path>", "Entry point to execute (for RPA, a workflow such as Main.xaml). Defaults to the project's own entry point.").option("--input-arguments <json>", `Input arguments for the entry point, as a JSON object string (e.g. '{"name": "World"}').`).option("--folder-path <path>", "Orchestrator folder the run reports itself under, when the runtime needs one. Ignored when the solution is deployed, which uses the folder it deploys into.").option("--provision-resources", "Pack and deploy the solution into your personal workspace before running, even when the solution holds a single project. Done automatically for a solution with more than one project.").option("--no-provision-resources", "Run without deploying the solution first. Cross-project calls will not resolve.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10).", Number.parseInt, 10).trackedAction(processContext, async (solutionPath, options) => {
+  program.command("run", { hidden: true }).description("Run a project from a UiPath solution. Currently supports RPA projects, agents and API Workflows.").argument("<solution-path>", "Path to a solution directory (containing .uipx)").option("--project-name <name>", "Name of the project to run. Required only when the solution has more than one runnable project.").option("--entry-point <path>", "Entry point to execute (for RPA, a workflow such as Main.xaml). Defaults to the project's own entry point.").option("--input-arguments <json>", `Input arguments for the entry point, as a JSON object string (e.g. '{"name": "World"}').`).option("--folder-path <path>", "Orchestrator folder the run reports itself under, when the runtime needs one. Ignored when the solution is deployed, which uses the folder it deploys into.").option("--provision-resources", "Pack and deploy the solution into your personal workspace before running, even when the solution holds a single project. Done automatically for a solution with more than one project.").option("--no-provision-resources", "Run without deploying the solution first. Cross-project calls will not resolve.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10).", Number.parseInt, 10).trackedAction(processContext, async (solutionPath, options) => {
     const [inputError, inputArguments] = parseInputArguments(options.inputArguments);
     if (inputError) {
       OutputFormatter.error({
@@ -6378,6 +5350,7 @@ var registerRunCommand = (program) => {
       processContext.exit(1);
       return;
     }
+    const { runSolutionAsync } = await import("./run-service-p1vzzqe3.js");
     const result = await runSolutionAsync({
       solutionPath,
       projectName: options.projectName,
@@ -6493,7 +5466,26 @@ var SOLUTION_UPLOAD_EXAMPLES = [
   }
 ];
 var registerUploadCommand = (program) => {
-  program.command("upload").description("Upload a solution to UiPath Studio Web for browser-based editing. Accepts a solution directory, .uipx file, or .uis file. If Studio Web has no solution with the bundled SolutionId, the solution is imported as new and the local .uipx is updated with the assigned id; otherwise it is overwritten in place, with the replaced contents recorded first as a restorable version (skip with --no-snapshot). The output field Data.Action says which happened: 'Imported' or 'Overwritten'.").argument("<solutionPath>", "Path to a solution directory (containing .uipx), a .uipx file, or a .uis file.").option("--force", "Skip the existence check and overwrite the Studio Web solution named by the bundled SolutionId directly. Not normally needed — an upload overwrites an existing cloud solution on its own. Fails if that solution does not exist. No effect when no SolutionId is bundled (a .uis archive without one): the upload imports as new.").option("--no-snapshot", "Do not record a restorable pre-overwrite version of the cloud solution before replacing its contents. Changes made in Studio Web since the last upload are lost; local files are unaffected. No effect when the upload imports a new solution.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(SOLUTION_UPLOAD_EXAMPLES).trackedAction(processContext, async (solutionPath, options) => {
+  program.command("upload").description("Upload a solution to UiPath Studio Web for browser-based editing. Accepts a solution directory, .uipx file, or .uis file. If Studio Web has no solution with the bundled SolutionId, the solution is imported as new and the local .uipx is updated with the assigned id; otherwise it is overwritten in place, with the replaced contents recorded first as a restorable version (skip with --no-snapshot). The output field Data.Action says which happened: 'Imported' or 'Overwritten'.").argument("<solution-path>", "Path to a solution directory (containing .uipx), a .uipx file, or a .uis file.").option("--force", "Skip the existence check and overwrite the Studio Web solution named by the bundled SolutionId directly. Not normally needed — an upload overwrites an existing cloud solution on its own. Fails if that solution does not exist. No effect when no SolutionId is bundled (a .uis archive without one): the upload imports as new.").option("--no-snapshot", "Do not record a restorable pre-overwrite version of the cloud solution before replacing its contents. Changes made in Studio Web since the last upload are lost; local files are unaffected. No effect when the upload imports a new solution.").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(SOLUTION_UPLOAD_EXAMPLES).trackedAction(processContext, async (solutionPath, options) => {
+    const {
+      buildSolutionUploadFailureOutput,
+      bundleSolution,
+      importSolution,
+      isSolutionUploadHttpError,
+      overwriteSolution,
+      resolveSolutionDir,
+      StudioWebIncompatibleProjectError,
+      solutionExistsOnStudioWeb,
+      UipignoreExcludesProjectError
+    } = await import("./index-6wak6hg6.js");
+    const { readBundledSolutionId } = await import("./archive-extract-x35t9ktj.js");
+    const { isUnpackableProjectTypeError } = await import("./packager-tool-resolver-994z3jkj.js");
+    const { prepareSolutionResources } = await import("./prepare-solution-resources-m1djfj62.js");
+    const {
+      inspectSolutionPackageProjectTypes: inspectSolutionPackageProjectTypes2,
+      summarizeShipProjectTypes,
+      trackSolutionShipSucceeded: trackSolutionShipSucceeded2
+    } = await import("./ship-telemetry-myes7ak5.js");
     const fs = getFileSystem();
     const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
       ensureTokenValidityMinutes: options.loginValidity
@@ -6551,10 +5543,12 @@ var registerUploadCommand = (program) => {
       if (prepareError) {
         const errorCode = carriedErrorCode(prepareError) ?? (isUnpackableProjectTypeError(prepareError) ? "invalid_argument" : undefined);
         const contributionCode = prepareError.contributionCode;
+        const retry = carriedRetry(prepareError);
         OutputFormatter.error({
           Result: RESULTS.Failure,
           Message: prepareError.message,
           ...errorCode ? { ErrorCode: errorCode } : {},
+          ...retry ? { Retry: retry } : {},
           ...typeof contributionCode === "string" ? { Context: { errorCode: contributionCode } } : {},
           Instructions: carriedInstructions(prepareError) ?? "Fix the reported problem in the project's files, then re-run the upload."
         });
@@ -6686,8 +5680,8 @@ var registerUploadCommand = (program) => {
           Response: result
         }
       });
-      const projectTypeSummary = bundledProjectTypes.length > 0 ? summarizeShipProjectTypes(bundledProjectTypes) : await inspectSolutionPackageProjectTypes(uisPath);
-      trackSolutionShipSucceeded({
+      const projectTypeSummary = bundledProjectTypes.length > 0 ? summarizeShipProjectTypes(bundledProjectTypes) : await inspectSolutionPackageProjectTypes2(uisPath);
+      trackSolutionShipSucceeded2({
         [ShipDimensions.ShipKind]: "upload",
         [ShipDimensions.Target]: "studio_web",
         [CommandDimensions.CommandName]: "uip solution upload",
@@ -6710,19 +5704,12 @@ async function updateLocalSolutionId(fs, result, solutionId, uipxPath) {
   const shouldUpdateUipx = uipxPath !== undefined && returnedSolutionId !== undefined && returnedSolutionId !== solutionId;
   const rewroteLocalSolutionId = shouldUpdateUipx && solutionId !== undefined;
   if (shouldUpdateUipx && returnedSolutionId && uipxPath) {
+    const { updateUipxSolutionId } = await import("./index-6wak6hg6.js");
     await updateUipxSolutionId(fs, uipxPath, returnedSolutionId);
     logger.info(solutionId ? `Studio Web assigned SolutionId ${returnedSolutionId} — the local .uipx now points at it (was ${solutionId}).` : `Studio Web assigned SolutionId ${returnedSolutionId} — the local .uipx now points at it.`);
   }
   return { returnedSolutionId, rewroteLocalSolutionId };
 }
-function httpStatusOf(error) {
-  if (error instanceof Error && "status" in error) {
-    const status = error.status;
-    if (typeof status === "number")
-      return status;
-  }
-  return;
-}
 function isSolutionNotFoundError(error) {
   return httpStatusOf(error) === 404;
 }
@@ -6749,7 +5736,7 @@ async function buildProbeFailureOutput(probeError, solutionId, identity) {
 }
 function probeAuthInstructions(solutionId, identity) {
   const actor = identity?.type === "Application" ? `This session acts as external application ${identity.clientId ?? "(client id unknown)"}: it needs a Studio Web grant that can read a solution.` : identity?.type === "User" ? "This session acts as a user: check that your account has Studio Web access in this tenant." : "Check that this session may read a solution in Studio Web — an external application needs a StudioWebS2S grant, a user needs Studio Web access in the tenant.";
-  return `Studio Web refused the read, and the session is authenticated, so ` + `re-running 'uip login' mints the same token and fails the same way. ` + `${actor} Also confirm solution ${solutionId} lives in the organization ` + `and tenant this session logged into. Nothing was uploaded.`;
+  return `Studio Web refused the read, and the session is authenticated, so re-running 'uip login' mints the same token and fails the same way. ${actor} Also confirm solution ${solutionId} lives in the organization and tenant this session logged into. Nothing was uploaded.`;
 }
 function outputError(message) {
   OutputFormatter.error({
@@ -6782,7 +5769,7 @@ var registerCommands = async (program) => {
   registerResourceCommand(program);
   registerDeleteCommand(program);
   if (isPreviewBuild()) {
-    const { registerListCommand } = await import("./list-s5pkkefj.js");
+    const { registerListCommand } = await import("./list-7jy11vb4.js");
     registerListCommand(program);
   }
   registerFeedsCommand(program);
@@ -6790,4 +5777,4 @@ var registerCommands = async (program) => {
 
 export { metadata, registerCommands };
 
-//# debugId=E572428E1F435ACA64756E2164756E21
+//# debugId=CB17F3BA78F310B564756E2164756E21