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

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.

package/dist/services/pack-project-selection.d.ts

@@ -0,0 +1,51 @@
+import { type CliErrorCode } from "@uipath/common";
+import type { IFileSystem } from "@uipath/filesystem";
+/**
+ * `--package-id` renames the one project `--project` packs, so it means nothing
+ * without it; `--name` names the solution `.zip`, which `--project` does not
+ * produce. Returns the error message, or `undefined` when the options are valid.
+ */
+export declare function validatePackProjectOptions(options: {
+    project?: string;
+    packageId?: string;
+    name?: string;
+}): string | undefined;
+/** One `.uipx` project entry, as `solution pack --project` sees it. */
+export interface PackProjectEntry {
+    /** The `.uipx` `Id`. */
+    id: string;
+    /** The `.uipx` `Type`. */
+    type: string;
+    /** The `.uipx` `ProjectRelativePath`, as written. */
+    relativePath: string;
+}
+/**
+ * Input `solution pack --project` cannot pack from: a `--project` that names no
+ * project of the solution, or more than one, or one with no folder of its own
+ * inside the solution; a missing or broken `.uipx`; a solution that is not a
+ * folder. Bad input, so it carries `invalid_argument` and the next step.
+ */
+export declare class PackProjectError extends Error {
+    readonly instructions: string;
+    readonly errorCode: CliErrorCode;
+    constructor(message: string, instructions: string);
+}
+/**
+ * Resolve `--project` to exactly one `.uipx` project entry: by `Id`, or by its
+ * path relative to the solution — the project folder or the
+ * `ProjectRelativePath` itself. Separators and case are ignored, so a
+ * Windows-authored `.uipx` matches a POSIX-typed path and the other way round.
+ *
+ * Also returns the solution's own name, the `.uipx` basename, which a
+ * project's default package id is composed from.
+ *
+ * Throws {@link PackProjectError} when nothing or more than one entry matches,
+ * when the match has no folder of its own inside the solution, and when the
+ * `.uipx` is missing or cannot be parsed.
+ */
+export declare function resolvePackProjectAsync(fs: IFileSystem, solutionDir: string, selector: string): Promise<{
+    project: PackProjectEntry;
+    solutionName: string;
+}>;
+/** The project folder part of a `.uipx` `ProjectRelativePath`, with forward slashes. */
+export declare function projectFolder(relativePath: string): string;

package/dist/services/pack-project.d.ts

@@ -0,0 +1,26 @@
+import type { IFileSystem } from "@uipath/filesystem";
+import { type UiPathProject } from "@uipath/project-packager";
+import { type ProjectPackOptions } from "@uipath/project-packager/node";
+import type { ToolResult } from "@uipath/solutionpackager-tool-core";
+/** The project `--project` named, and the package id to pack it under. */
+export interface SolutionProjectToPack {
+    project: UiPathProject;
+    packageId: string;
+}
+/**
+ * Resolve `--project`, load the tool that packs its type, and run the
+ * contribution gate a whole-solution pack runs, for this project only: it is
+ * what rejects, say, a Coded Action with no `action-schema.json`.
+ *
+ * The package id is `--package-id`, else the id a whole-solution pack gives
+ * the project — the one the solution saved, else
+ * `<solution>.<short type>.<project folder>` — sanitized as the packager will.
+ */
+export declare function prepareSolutionProjectAsync(fs: IFileSystem, solutionDir: string, selector: string, packageIdOverride: string | undefined): Promise<SolutionProjectToPack>;
+/**
+ * Pack a project {@link prepareSolutionProjectAsync} prepared. A failure keeps
+ * the per-project findings a whole-solution pack reports, in
+ * `details.projects`, so a caller reads both the same way. A success reports
+ * native absolute package paths, and the id in `details.packageIds`.
+ */
+export declare function packSolutionProjectAsync(fs: IFileSystem, project: UiPathProject, packOptions: ProjectPackOptions): Promise<ToolResult>;

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

@@ -11,12 +11,16 @@ export interface PackResult {
     errorCode: string;
     /** Human-readable message; populated on failure. */
     message: string;
-    /** Absolute paths to the produced `.zip` package(s). */
+    /**
+     * Absolute paths to the produced package(s): the solution `.zip`, or with
+     * `options.project` that project's `.nupkg`.
+     */
     packages: string[];
 }
 /**
  * Programmatic core of `uip solution pack`: packs a UiPath solution into a
- * deployable `.zip`. Returns `{ ok: false, … }` on pack failure (does not
- * throw); only propagates unexpected JS errors.
+ * deployable `.zip`, or with `options.project` one of its projects into a
+ * `.nupkg`. Returns `{ ok: false, … }` on pack failure (does not throw); only
+ * propagates unexpected JS errors.
  */
 export declare function packSolutionAsync(solutionPath: string, options: PackCommandOptions): Promise<PackResult>;

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

@@ -0,0 +1,7 @@
+/**
+ * The package search lives in `@uipath/solution-sdk/packages`: the Pipelines
+ * route first, the deprecated `POST /api/search/packages` 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 { PackageSearchNeedsUserSessionError, searchPackagesPage, } from "@uipath/solution-sdk/packages";

package/dist/services/packager-tool-resolver.d.ts

@@ -28,5 +28,11 @@ export { toolVerbForProjectType } from "./project-type-tools";
  * This is the only place that registers — no tool registers at module load —
  * so a run that loads several tool bundles never registers the same factory
  * twice.
+ *
+ * `onlyProjectRelativePath` narrows the check to the one project a
+ * `pack --project` run packs, so a sibling of a type nothing packs does not
+ * block it and the tools for its siblings are not loaded.
  */
-export declare function ensurePackagerTools(solutionDir: string, fs: IFileSystem): Promise<void>;
+export declare function ensurePackagerTools(solutionDir: string, fs: IFileSystem, options?: {
+    onlyProjectRelativePath?: string;
+}): Promise<void>;

package/dist/services/packages-list-service.d.ts

@@ -19,7 +19,7 @@ export interface PackageSummary {
     solutionRootFolderName: string;
     hasUpgradeableDeployments: boolean;
 }
-export type ListPackagesFailureReason = "auth_failed" | "feed_resolution_failed" | "list_request_failed";
+export type ListPackagesFailureReason = "auth_failed" | "feed_resolution_failed" | "feed_requires_user_session" | "list_request_failed";
 export interface ListPackagesOptions {
     /** Override the active tenant for auth. The CLI's deprecated `--tenant` flag flows through here. */
     tenant?: string;