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

package/dist/services/deploy-run-service.d.ts

@@ -1,6 +1,7 @@
 import { type CliErrorCode, type RetryHint } from "@uipath/common";
 import { type PendingResource } from "./deployment-state";
 import { type FeedScope } from "./feed-resolver";
+import { type PermanentDeletionResource } from "./permanent-deletion-consent";
 /** Discriminator for {@link DeployFailure}; library callers can ignore the tag and read `.message`/`.instructions`. */
 export type DeployFailureReason = "auth_failed"
 /**
@@ -41,7 +42,16 @@ export type DeployFailureReason = "auth_failed"
 /** Activation poll didn't reach a terminal state. */
  | "activation_poll_failed"
 /** Activation reached a terminal state but it was a failure. */
- | "activation_failed";
+ | "activation_failed"
+/**
+ * The server wants the permanent deletion of installed resources replaced
+ * by links confirmed (schedule error 4026), and `acknowledgePermanentDeletion`
+ * was not set, the resources could not be listed, or the re-run after
+ * acknowledging them was refused again. Nothing was installed.
+ */
+ | "permanent_deletion_confirmation_required"
+/** Acknowledging a flagged resource failed; the install was not re-run. */
+ | "acknowledge_failed";
 export interface DeployOptions {
     /** Override the active tenant for auth + folder-lookup. The CLI's deprecated `--tenant` flag flows through here. */
     tenant?: string;
@@ -85,6 +95,15 @@ export interface DeployOptions {
      * that really do want a second, independent copy opt in here.
      */
     yes?: boolean;
+    /**
+     * Confirm that installed resources this deployment replaces with a link
+     * are permanently deleted with their data. Without it a deploy the server
+     * stops for that confirmation fails with
+     * `permanent_deletion_confirmation_required` and lists them; with it they
+     * are acknowledged and the identical install runs once more, inside the
+     * same `timeout`.
+     */
+    acknowledgePermanentDeletion?: boolean;
     /** Host-side cancellation for both poll loops (e.g. VS Code's cancel button); replaces `processContext.pollSignal`. */
     signal?: AbortSignal;
 }
@@ -131,6 +150,11 @@ export interface DeploySuccess {
     packageVersion?: string;
     /** Which feed the deploy targeted — drives telemetry `target`. */
     feedKind: FeedScope["kind"];
+    /**
+     * The installed resources acknowledged for permanent deletion before the
+     * install that succeeded (`kind 'name'`). Absent when none were.
+     */
+    permanentlyDeletedResources?: string[];
 }
 export interface DeployFailure {
     ok: false;
@@ -152,6 +176,15 @@ export interface DeployFailure {
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;
+    /** The refused attempt's draft, on a permanent-deletion refusal. */
+    deploymentKey?: string;
+    /** What the server wants confirmed, on a permanent-deletion refusal. */
+    permanentDeletionResources?: PermanentDeletionResource[];
+    /**
+     * Resources already acknowledged for permanent deletion when the deploy
+     * failed after the install that deleted them (activation failures).
+     */
+    permanentlyDeletedResources?: string[];
 }
 export type DeployResult = DeploySuccess | DeployFailure;
 /**

package/dist/services/deploy-uninstall-service.d.ts

@@ -1,5 +1,10 @@
 import { type CliErrorCode, type RetryHint } from "@uipath/common";
-export type UninstallDeploymentFailureReason = "auth_failed" | "uninstall_request_failed"
+import { type FeedSelectionFlags } from "./feed-selection";
+export type UninstallDeploymentFailureReason = "auth_failed"
+/** `--feed` named no feed this session can reach. */
+ | "feed_resolution_failed"
+/** `--feed` / `--personal-workspace` with a session the server would not scope. */
+ | "feed_requires_user_session" | "uninstall_request_failed"
 /**
  * Orchestrator refused the uninstall because the deployment still had an
  * operation running, and it was still running when the wait ran out —
@@ -9,8 +14,13 @@ export type UninstallDeploymentFailureReason = "auth_failed" | "uninstall_reques
 /** Uninstall poll didn't reach a terminal state — recommended exit 2 (CI distinguishability). */
  | "poll_timeout" | "poll_failed" | "poll_aborted"
 /** Uninstall reached a terminal state but it was `FailedUninstall`. */
- | "uninstall_failed";
-export interface UninstallDeploymentOptions {
+ | "uninstall_failed"
+/**
+ * Refused for a cause only `--force` gets past: uncompleted jobs, or the
+ * permanent deletion of installed resources replaced by links.
+ */
+ | "uninstall_confirmation_required";
+export interface UninstallDeploymentOptions extends Pick<FeedSelectionFlags, "personalWorkspace" | "feed"> {
     /**
      * Override the active tenant for auth resolution. The CLI's deprecated
      * `--tenant` flag flows through here; library callers usually omit it.
@@ -30,6 +40,12 @@ export interface UninstallDeploymentOptions {
     loginValidity?: number;
     /** Host-side cancellation for the poll loop; replaces `processContext.pollSignal`. */
     signal?: AbortSignal;
+    /**
+     * Send `forceUninstall`: uninstall past uncompleted jobs and the
+     * permanent deletion of resources replaced by links. The caller's consent;
+     * never set on the caller's behalf.
+     */
+    force?: boolean;
 }
 export interface UninstallDeploymentSuccess {
     ok: true;
@@ -55,6 +71,8 @@ export interface UninstallDeploymentFailure {
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;
+    /** Structured facts for the failure envelope's `Data`, keys as printed. */
+    data?: Record<string, unknown>;
 }
 export type UninstallDeploymentResult = UninstallDeploymentSuccess | UninstallDeploymentFailure;
 /**

package/dist/services/deploy-upgrade-service.d.ts

@@ -1,6 +1,7 @@
 import type { CliErrorCode, PollFailureReason, RetryHint } from "@uipath/common";
 import type { PipelineDeploymentStatus } from "@uipath/pipelines-sdk";
 import { type PendingResource } from "./deployment-state";
+import { type PermanentDeletionResource } from "./permanent-deletion-consent";
 export type UpgradeDeploymentFailureReason = 
 /** Neither a deployment key nor a name+package pair was given, or both were. */
 "invalid_target" | "auth_failed"
@@ -51,7 +52,16 @@ export type UpgradeDeploymentFailureReason =
  * interrupted / aborted. Distinct from `install_timeout`: the deadline was
  * never reached, so a longer `--timeout` is not the fix.
  */
- | PollFailureReason;
+ | PollFailureReason
+/**
+ * The server wants the permanent deletion of installed resources replaced
+ * by links confirmed (schedule error 4026), and `acknowledgePermanentDeletion`
+ * was not set, the resources could not be listed, or the re-run after
+ * acknowledging them was refused again. Nothing was installed.
+ */
+ | "permanent_deletion_confirmation_required"
+/** Acknowledging a flagged resource failed; the upgrade was not re-run. */
+ | "acknowledge_failed";
 export interface UpgradeDeploymentOptions {
     /**
      * Key of the deployment to upgrade, as `deploy list` reports it. Resolved
@@ -105,6 +115,19 @@ export interface UpgradeDeploymentOptions {
      * the deployment by key.
      */
     discardDraft?: boolean;
+    /**
+     * Confirm that installed resources the new version replaces with a link
+     * are permanently deleted with their data. Without it an upgrade the
+     * server stops for that confirmation fails with
+     * `permanent_deletion_confirmation_required` and lists them; with it they
+     * are acknowledged and the identical install runs once more, inside the
+     * same `timeout`. Has no effect with `noWait`, which never sees the run end.
+     * Also lets through a pending draft of the requested version (or, with no
+     * version given, of its own) whose only open question is this
+     * confirmation: that draft is re-run instead of refused, so the links it
+     * carries are kept and acknowledged.
+     */
+    acknowledgePermanentDeletion?: boolean;
     /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
     loginValidity?: number;
     /**
@@ -192,6 +215,11 @@ export interface UpgradeDeploymentSuccess {
     pendingResources?: PendingResource[];
     /** What is left before the new version runs; absent when it does. */
     nextSteps?: string[];
+    /**
+     * The installed resources acknowledged for permanent deletion before the
+     * install that succeeded (`kind 'name'`). Absent when none were.
+     */
+    permanentlyDeletedResources?: string[];
 }
 export interface UpgradeDeploymentFailure {
     ok: false;
@@ -208,6 +236,12 @@ export interface UpgradeDeploymentFailure {
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;
+    /** The refused run, on a permanent-deletion refusal. */
+    pipelineDeploymentId?: string;
+    /** The refused attempt's draft, on a permanent-deletion refusal. */
+    deploymentKey?: string;
+    /** What the server wants confirmed, on a permanent-deletion refusal. */
+    permanentDeletionResources?: PermanentDeletionResource[];
 }
 export type UpgradeDeploymentResult = UpgradeDeploymentSuccess | UpgradeDeploymentFailure;
 /**

package/dist/services/deployment-feed-locator.d.ts

@@ -1,6 +1,6 @@
 import type { DeploymentSearchItemDto2, InitOverrideFunction } from "@uipath/solution-sdk";
 import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
-import { type FeedKind } from "./feed-resolver";
+import { type FeedKind, type FeedScope } from "./feed-resolver";
 import type { SkippedFeed } from "./incomplete-feed-sweep";
 /** A deployment and the feed header every call about it needs. */
 export interface DeploymentLocation {
@@ -46,17 +46,28 @@ export interface DeploymentLocationOptions {
      * the feed rather than to the tenant's history row.
      */
     includeUninstalled?: boolean;
+    /**
+     * The feed the caller named (`--feed` / `--personal-workspace`, or the
+     * feed a generated follow-up command carried forward). Only that feed is
+     * searched: no publish-locations listing, no sweep. A selection that names
+     * the tenant feed is still a selection and searches the tenant alone.
+     */
+    selectedFeed?: FeedScope;
 }
 /**
  * Locate a deployment and the feed it lives in.
  *
- * `uninstall` and `activate` take no feed flag, so they have to work this out
- * themselves: every Pipelines call about a deployment resolves against the
+ * Without a feed flag, `uninstall`, `activate` and `delete` have to work this
+ * out themselves: every Pipelines call about a deployment resolves against the
  * tenant feed unless it carries `X-UIPATH-FolderKey`, and a deployment created
  * by `deploy run --personal-workspace` or `--feed <folder-feed>` is invisible
  * to the tenant-scoped search, so an unscoped call is answered "not found".
  *
- * Tenant first — that is the default feed and the one most deployments live in,
+ * With `options.selectedFeed`, that feed alone is searched: the caller said
+ * where the deployment lives, so the sweep and its publish-locations call are
+ * skipped. A search that fails there is a sweep that skipped that feed.
+ *
+ * Otherwise tenant first — that is the default feed and the one most deployments live in,
  * so the common case costs one request. Only on a tenant miss does the sweep
  * run, and it is best-effort throughout: a feed whose search fails is skipped
  * rather than allowed to end the sweep, since the next feed may hold the

package/dist/services/deployment-search-client.d.ts

@@ -1,55 +1,7 @@
-import { type DeploymentActivationStatus, type DeploymentOperationStatus, type DeploymentSearchItemDto2, type InitOverrideFunction } from "@uipath/solution-sdk";
-import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
-export type DeploymentSearchSource = "pipelines" | "legacy-v3";
-/** One page of the deployment search, in the terms both routes understand. */
-export interface DeploymentSearchQuery {
-    take: number;
-    skip: number;
-    /**
-     * Exact name. Filtered by the server on the Pipelines route; a substring
-     * term on the legacy one, so callers keep their exact match.
-     */
-    deploymentName?: string;
-    packageName?: string;
-    /** The row's parent folder by full path: exact, case-insensitive, subfolders excluded. */
-    targetFolderName?: string;
-    searchTerm?: string;
-    orderByColumn?: string;
-    orderByDirection?: "Ascending" | "Descending";
-    operationStatuses?: DeploymentOperationStatus[];
-    activationStatuses?: DeploymentActivationStatus[];
-}
-export interface DeploymentSearchPage {
-    /** The filtered total; `undefined` when the server omits it. */
-    count?: number;
-    values: DeploymentSearchItemDto2[];
-    /** Which route answered — for logs and tests, never for output. */
-    source: DeploymentSearchSource;
-}
 /**
- * The server has only the legacy search, and that one reads user tokens only.
- * Thrown instead of making a request that can only answer 403, so a caller can
- * tell "cannot be read with this login" from an outage — the distinction the
- * application-session gates were written for.
+ * The deployment search lives in `@uipath/solution-sdk/deployments`: the
+ * Pipelines route first, the deprecated V3 route only on a server without it.
+ * Re-exported here so this package's callers, and the specs that mock this
+ * module, keep one local path to it.
  */
-export declare class DeploymentSearchNeedsUserSessionError extends Error {
-    constructor();
-}
-/**
- * Whether an error from the Pipelines search means the server has no such
- * route (and the legacy search should answer), as opposed to a failure of
- * the route itself. Measured on a server without it: the POST falls onto
- * `GET deployments/{deploymentKey}` and answers **405** with no body; a path
- * matching nothing answers 404 with no body. A 404 with *any* body — an
- * `errorCode`, or a plain ProblemDetails — is the route answering, and must
- * reach the caller.
- */
-export declare function isMissingPipelinesSearchRoute(error: unknown): Promise<boolean>;
-/**
- * The one deployment search every command goes through: the Pipelines route
- * (SOL-7807), which reads application sessions too and filters an exact name
- * on the server; the deprecated `/api/v3/search/deployments` only on a server
- * without it. Rows come back as the solution-sdk's DTO either way — the
- * Pipelines row is a superset of it, so its extra fields are dropped.
- */
-export declare function searchDeploymentsPage(auth: SolutionAuthContext, query: DeploymentSearchQuery, scope?: InitOverrideFunction): Promise<DeploymentSearchPage>;
+export { DeploymentSearchNeedsUserSessionError, searchDeploymentsPage, } from "@uipath/solution-sdk/deployments";

package/dist/services/deployment-search.d.ts

@@ -1,7 +1,62 @@
-import type { PipelineDeploymentResult, PipelineDeploymentStatus } from "@uipath/pipelines-sdk";
+import { type PipelineDeploymentResult, type PipelineDeploymentStatus } from "@uipath/pipelines-sdk";
 import type { DeploymentOperationStatus, DeploymentSearchItemDto2, InitOverrideFunction } from "@uipath/solution-sdk";
 import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
 export { httpStatusOf } from "./http-status";
+/** A deployment read by key: the fields the callers act on, from either route. */
+export interface DeploymentByKey {
+    deploymentKey: string;
+    operationStatus: DeploymentOperationStatus;
+    installedRootFolderKey?: string | null;
+    /**
+     * Which route answered. `solutions` is the deprecated fallback, and it
+     * answers differently: the exact row asked for, never the current
+     * generation.
+     */
+    source: "pipelines" | "solutions";
+}
+export interface ReadDeploymentByKeyOptions {
+    /**
+     * The feed header for the deprecated Solutions fallback, which is
+     * feed-scoped. The Pipelines lookup spans every feed and is sent without it.
+     */
+    scope?: InitOverrideFunction;
+    /**
+     * Skip the Pipelines lookup: the caller has already seen it answer 404 and
+     * the Solutions read answer instead, so a poll does not pay a 404 on every
+     * interval.
+     */
+    solutionsOnly?: boolean;
+}
+/**
+ * Read a deployment by key once a caller holds one, instead of searching its
+ * name again.
+ *
+ * `GET /pipelines/deployments/by-key/{key}` goes first: S2S-capable, sent
+ * without a feed header (it spans every feed in the tenant), and one indexed
+ * read where a search is a filtered scan. It answers a superseded key with
+ * the deployment's *current* generation, so a caller that needs this exact
+ * row compares `deploymentKey` itself.
+ *
+ * On a 404 from it (a server without the route, or a key it does not know;
+ * not told apart, the same rule as `deploy status` and `deploy upgrade`), a
+ * user session falls back to the **deprecated** Solutions read
+ * ({@link readDeploymentByKeyViaSolutionsAsync}). An application session gets
+ * `undefined`. `undefined` from either route means the caller falls back to
+ * the search. Any other failure throws.
+ */
+export declare function readDeploymentByKeyAsync(auth: SolutionAuthContext, deploymentKey: string, options?: ReadDeploymentByKeyOptions): Promise<DeploymentByKey | undefined>;
+/**
+ * @deprecated Fallback for servers without
+ * `GET /pipelines/deployments/by-key/{key}`. Remove it once that lookup is on
+ * every production ring, together with the `deploy status` / `deploy upgrade`
+ * fallbacks to the same route (see the package CLAUDE.md).
+ *
+ * `GET /api/deployments/{key}` (Automation Solutions): user tokens only, so
+ * never on an S2S path (SOL-7805). It is feed-scoped (it needs the feed's
+ * header), and it returns the exact row asked for rather than the current
+ * generation. A 404 is `undefined`; any other failure throws.
+ */
+export declare function readDeploymentByKeyViaSolutionsAsync(auth: SolutionAuthContext, deploymentKey: string, scope?: InitOverrideFunction): Promise<DeploymentByKey | undefined>;
 /**
  * Look up a deployment by name in the persistent search/list service.
  * Returns the deployment's **current generation** — every upgrade and
@@ -37,7 +92,7 @@ export declare function isCompletedUninstall(row: Pick<DeploymentSearchItemDto2,
  *
  * `packageName` is the server-side filter, which keeps the result set small;
  * on the deprecated V3 route it also travels as the substring `searchTerm`
- * (see `toLegacyV3Request`), so the lookup still works if that server ignores
+ * (see the V3 request mapping in `@uipath/solution-sdk/deployments`), so the lookup still works if that server ignores
  * `packageName`. The client-side `===` check is what makes the answer exact
  * either way.
  *
@@ -245,7 +300,7 @@ export declare function deploymentToTerminalPipelineResult(deployment: Deploymen
  * whether the deployment really landed on the requested name, so callers can
  * say so when it did not.
  */
-export declare function resolveInstalledFolder(deployment: DeploymentSearchItemDto2 | undefined, requested: {
+export declare function resolveInstalledFolder(deployment: Pick<DeploymentSearchItemDto2, "installedRootFolderKey" | "installedRootFolderName" | "folderPath"> | undefined, requested: {
     folderName: string;
     folderPath: string;
     parentFolderPath?: string;

package/dist/services/deployment-state.d.ts

@@ -1,4 +1,6 @@
-import type { DeploymentsApi, InitOverrideFunction } from "@uipath/solution-sdk";
+import { quoteForShell } from "@uipath/common";
+import { PipelinesApi } from "@uipath/pipelines-sdk";
+import { DeploymentsApi, type InitOverrideFunction } from "@uipath/solution-sdk";
 /**
  * A deployed resource the service flags `requiresConfiguration` — the reason a
  * deployment sits in `NeedsSetupToActivate` instead of running.
@@ -17,7 +19,46 @@ export interface PendingResource {
      * no error for the resource.
      */
     reason?: string;
+    /**
+     * The Orchestrator folders the resource lives in (`Shared/Sales`), from
+     * the Pipelines validation result. Absent when the reasons came from the
+     * Solutions routes, which do not carry them.
+     */
+    folderPaths?: string[];
+}
+/**
+ * The two clients {@link readPendingResourcesAsync} reads with: the Pipelines
+ * one first, which takes an external-app token, and the Solutions one as the
+ * fallback, which takes a user token only.
+ */
+export interface PendingResourceApis {
+    pipelines: PipelinesApi;
+    deployments: DeploymentsApi;
 }
+/** Both clients for a session. */
+export declare function pendingResourceApis(auth: {
+    basePath: string;
+    accessToken: string;
+}): PendingResourceApis;
+/** The deployment whose pending resources are read. */
+export interface PendingResourceTarget {
+    /** What the Pipelines route is addressed by: the name's newest record. */
+    name: string;
+    /** What the Solutions routes are addressed by. */
+    key: string;
+}
+/**
+ * The activation state the run record itself reports, or `undefined` when it
+ * reports none.
+ *
+ * `deploymentResult.activationStatus` arrived with SOL-7883 (s205); an older
+ * server leaves it out, and the callers then derive the state the way they
+ * did before. `None` is left out too: the server sends it for a record the
+ * activation check never covered, which says nothing about a landed install.
+ */
+export declare function reportedActivationStatus(record: {
+    activationStatus?: string | null;
+} | null | undefined): string | undefined;
 /** The fields the state helpers read. Both deployment DTOs carry them. */
 export interface DeploymentStateRecord {
     name: string;
@@ -27,33 +68,50 @@ export interface DeploymentStateRecord {
     packageVersion?: string | null;
     currentPackageVersion?: string | null;
 }
-/**
- * A deployment name as an argument in a suggested command, for the shells the
- * suggestion is pasted into. Single quotes only: neither PowerShell nor a
- * POSIX shell evaluates anything inside them, so a name carrying `$(…)` or a
- * backtick stays a name. Double quotes would not do — both shells expand
- * `$(…)` inside them. A name with an apostrophe uses the POSIX
- * close-and-reopen escape, `'\''`; PowerShell reads that as a parse error
- * rather than running anything, which is the acceptable failure for a name
- * that rare.
- */
-export declare function quoteForShell(name: string): string;
+export { quoteForShell };
 /**
  * The resources a deployment still needs configured before it can be
- * activated.
+ * activated, and why.
  *
- * `GET /api/deployments/{key}/resources` is the one place the service says
- * *why* a deployment is not live: every row carries `requiresConfiguration`.
- * Ask with the deployment key alone. Its `folderKey` parameter is the
- * solution-internal folder, not the Orchestrator folder the deployment landed
- * in, and the wrong one is a 400 (measured 2026-09-23).
+ * The Pipelines validation result is read first: it takes an external-app
+ * token, names the folders, and is the activation check's own list of what
+ * blocks the deployment. A server before SOL-7883 (s205) does not have the
+ * route, and one with it answers 404 when no validation is held; then — and
+ * whenever it holds another action's validation — the Solutions routes
+ * answer, as before, for a user session.
  *
- * Best-effort: `undefined` when the read fails — or when the page cap cut the
- * listing short, because a partial list presented as "the pending resources"
- * would omit rows. Every caller is reporting a state that is already final,
- * so neither turns into a failed command; the callers say the read failed.
+ * Best-effort: `undefined` when neither could be read. Every caller is
+ * reporting a state that is already final, so a failed read never fails the
+ * command; the callers say it failed.
+ */
+export declare function readPendingResourcesAsync(apis: PendingResourceApis, deployment: PendingResourceTarget, scope?: InitOverrideFunction): Promise<PendingResource[] | undefined>;
+/**
+ * What the activation check left unresolved, from
+ * `GET /v1/pipelines/deployments/{name}/validation-result` with no action:
+ * the server answers with the validation the deployment holds and names it,
+ * and only an `Activate` one is the check that keeps a deployment from
+ * running. One entry per resource, its error-level texts joined into the
+ * reason. `undefined` when the route is missing (an older server), holds no
+ * validation, is still running, or holds another action's — the caller falls
+ * back. `undefined` as well for an error-level entry that names no resource
+ * (a `GeneralError`): it blocks the deployment, but is no resource to list,
+ * and an answer without it would claim the resources are the whole story.
+ *
+ * The route reads the name's newest record, not a key, and its answer names
+ * no key. It is this record's only while `deployment.key` is still the
+ * current one, so the Pipelines by-key lookup is read *after* the answer and
+ * the answer kept only when it resolves the key to itself; a key another
+ * operation superseded meanwhile, or a lookup that fails, falls back.
+ */
+export declare function readActivationBlockersAsync(api: PipelinesApi, deployment: PendingResourceTarget, scope?: InitOverrideFunction): Promise<PendingResource[] | undefined>;
+/**
+ * Whether `key` is still its deployment's current record. The lookup answers
+ * a superseded key with the current generation, so a different key back
+ * means another operation landed. Sent without a feed header, like every
+ * by-key read: it spans every feed. `init` may bound the read (a signal), so
+ * pass one without the feed scope.
  */
-export declare function readPendingResourcesAsync(api: DeploymentsApi, deploymentKey: string, scope?: InitOverrideFunction): Promise<PendingResource[] | undefined>;
+export declare function isCurrentRecordAsync(api: PipelinesApi, key: string, init?: InitOverrideFunction): Promise<boolean>;
 /**
  * One line naming the resources and, when known, why each needs
  * configuration: `connection 'Outlook' (uipath-microsoft-outlook365): [CNS1072]
@@ -73,8 +131,10 @@ export declare function formatPendingResources(resources: PendingResource[]): st
  *
  * `pendingResources` is what {@link readPendingResourcesAsync} returned:
  * `undefined` when the read failed, which is said rather than hidden.
+ * `feedSelector` (`feedSelectorFlag`) goes on the commands the steps name, so
+ * they search the deployment's feed alone instead of sweeping every feed.
  */
-export declare function activationNextSteps(deployment: DeploymentStateRecord, pendingResources?: PendingResource[]): string[] | undefined;
+export declare function activationNextSteps(deployment: DeploymentStateRecord, pendingResources?: PendingResource[], feedSelector?: string): string[] | undefined;
 /**
  * Append the deployment's own state to error instructions when that state is
  * the reason the command was refused — a pending draft, or an install that is

package/dist/services/deployment-validation.d.ts

@@ -12,6 +12,11 @@ export declare const NO_SERVER_REASON = "the server reported no reason.";
  * about.
  */
 export declare const LOOKUP_TIMEOUT_MS = 15000;
+/**
+ * The caller's scope override plus a deadline, and the caller's own abort
+ * signal when it has one, so Ctrl-C still ends the command here.
+ */
+export declare function boundedScope(scope: InitOverrideFunction | undefined, signal: AbortSignal | undefined): InitOverrideFunction;
 /**
  * Ask the server why an install/upgrade failed. Deployment records carry a
  * status and no error field, so the validation result is the only place an

package/dist/services/emit-runtime-dependencies.d.ts

@@ -1,3 +1,4 @@
+import { type ContributedBinding } from "@uipath/solution-sdk/resources";
 export interface EmitRuntimeDependenciesResult {
     processed: number;
     warnings: string[];
@@ -34,4 +35,4 @@ export interface EmitRuntimeDependenciesResult {
  * that doesn't have it set before save; that workaround can come out once
  * SOL-7012 lands (cleanup tracked under SOL-7013).
  */
-export declare function emitRuntimeDependenciesForProcesses(solutionDir: string): Promise<EmitRuntimeDependenciesResult>;
+export declare function emitRuntimeDependenciesForProcesses(solutionDir: string, projectBindings?: ReadonlyMap<string, readonly ContributedBinding[]>): Promise<EmitRuntimeDependenciesResult>;

package/dist/services/feed-resolver.d.ts

@@ -52,10 +52,12 @@ export interface FeedResolutionFailure {
 /**
  * Describe a {@link resolveFeedScope} that threw.
  *
- * An external app has no Personal Workspace, and the Orchestrator lookup
- * refuses it with a generated-client error that says nothing on its own
- * ("Response returned an error code"). So when an external app's lookup is
- * refused — the server answered with a 4xx — the failure names the cause.
+ * Both lookups answer an external app's refusal with a generated-client
+ * error that says nothing on its own ("Response returned an error code"). An
+ * external app has no Personal Workspace, and a `--feed` is checked against
+ * the Studio Web publish locations, which an app reads only with a
+ * `StudioWebS2S` grant. So when an external app's lookup is refused — the
+ * server answered with a 4xx — the failure names the cause.
  * Anything else keeps the error's own classification, for an external app
  * too: a 5xx, a timeout or a network failure is an outage that another
  * session would not fix, and must not read as `RetryWillNotFix`.

package/dist/services/feed-selection.d.ts

@@ -0,0 +1,47 @@
+import { type CliErrorCode, type RetryHint } from "@uipath/common";
+import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
+import { type FeedScope } from "./feed-resolver";
+/** The feed flags of a command that acts on one deployment by name. */
+export interface FeedSelectionFlags {
+    /** `--personal-workspace`: the deployment lives in the caller's own PW. */
+    personalWorkspace?: boolean;
+    /** `--feed <name-or-key>`: the deployment lives in this feed. */
+    feed?: string;
+    tenant?: string;
+    loginValidity?: number;
+    envFilePath?: string;
+}
+export type FeedSelection = 
+/** `selectedFeed` undefined: no flag, so the caller sweeps the feeds. */
+{
+    ok: true;
+    selectedFeed?: FeedScope;
+} | {
+    ok: false;
+    reason: "feed_resolution_failed" | "feed_requires_user_session";
+    message: string;
+    instructions: string;
+    errorCode?: CliErrorCode;
+    retry?: RetryHint;
+};
+/**
+ * Turn `--personal-workspace` / `--feed` into the feed the deployment lookup
+ * reads, so `uninstall`, `activate` and `delete` search that feed alone
+ * instead of sweeping every feed (`findDeploymentAcrossFeeds`). The flags are
+ * what `feedSelectorFlag` prints into the follow-up commands other commands
+ * generate. `--personal-workspace` then costs one search: the workspace is
+ * resolved through Orchestrator, not the publish-locations listing. `--feed`
+ * costs one publish-locations call (`resolveFeedScope` validates every
+ * `--feed` value against the listing, so a raw key is never sent) and one
+ * search. Either way it is never a search per feed.
+ *
+ * These commands mutate, so a non-tenant feed fails **closed** on any session
+ * that is not shown to be a user's, like `deploy run`: the server ignores the
+ * feed header on client-credentials requests, and the request would act on a
+ * tenant deployment of the same name. A Personal Workspace is refused before
+ * it is resolved; a `--feed` after, and only when it is not the tenant feed.
+ * A flag naming the tenant feed is still a selection: the tenant alone.
+ *
+ * @param action what the command does, e.g. "Uninstalling a deployment"
+ */
+export declare function resolveFeedSelectionAsync(auth: Pick<SolutionAuthContext, "accessToken" | "identity">, flags: FeedSelectionFlags, action: string): Promise<FeedSelection>;

package/dist/services/http-status.d.ts

@@ -1,9 +1,4 @@
-/**
- * The HTTP status an SDK error carries — from the `Response` a generated
- * client attaches, or from the error's own `status` — and `undefined` when it
- * carries none (a transport failure, a thrown string). Lets a caller tell the
- * one status that means "no such record" (404) from every other failure.
- */
-export declare function httpStatusOf(error: unknown): number | undefined;
+import { httpStatusOf } from "@uipath/common";
+export { httpStatusOf };
 /** A 401/403: the server refused this login, as opposed to failing. */
 export declare function isAuthRefusal(error: unknown): boolean;

package/dist/services/pack-command-service.d.ts

@@ -34,6 +34,13 @@ export declare class PackCommandService {
      * Execute the pack command and return result (for programmatic usage and testing)
      */
     executeAsync(solutionPath: string, options: PackCommandOptions): Promise<ToolResult>;
+    /**
+     * `--project`: pack one project of the solution on its own, as a
+     * stand-alone project packs (see `pack-project.ts`). Nothing solution-wide
+     * runs — no resource sync, no runtime-dependency emit — so the solution
+     * folder is not prepared.
+     */
+    private packProjectAsync;
     /**
      * Copy a solution directory into a fresh temp workspace so a dry run can
      * mutate it freely. Returns `undefined` when no copy is needed (a real
@@ -74,6 +81,8 @@ export declare class PackCommandService {
      */
     private resolvePackageName;
     private createPackOptions;
+    /** The `project-packager` options for a `--project` pack of `project`. */
+    private createProjectPackOptions;
 }
 /**
  * The failure envelope for a pack the packager refused.