@uipath/solution-sdk 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/scripts/generate-sdk.js

@@ -3,7 +3,8 @@
 
 // src/scripts/generate-sdk.ts
 import { execSync } from "child_process";
-import { mkdir, rm, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 var SWAGGER_URL = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_/swagger/v1.0/swagger.json";
@@ -20,12 +21,32 @@ var IGNORED_GENERATOR_OUTPUTS = [
   ".gitignore"
 ];
 async function downloadSwagger() {
-  console.log("Downloading swagger.json...");
-  const response = await fetch(SWAGGER_URL);
-  if (!response.ok) {
-    throw new Error(`Failed to download swagger: ${response.statusText}`);
+  const savedSpec = join(GENERATE_DIR, "swagger.json");
+  if (!process.argv.includes("--offline")) {
+    console.log("Downloading swagger.json...");
+    const [error, swagger] = await tryFetchSwagger();
+    if (!error) {
+      return swagger;
+    }
+    console.warn(`Download failed (${error}); falling back to ${savedSpec}`);
+  } else {
+    console.log(`--offline: reading ${savedSpec}`);
+  }
+  if (!existsSync(savedSpec)) {
+    throw new Error(`No swagger available: download failed and ${savedSpec} is missing.`);
+  }
+  return JSON.parse(await readFile(savedSpec, "utf-8"));
+}
+async function tryFetchSwagger() {
+  try {
+    const response = await fetch(SWAGGER_URL);
+    if (!response.ok) {
+      return [response.statusText, undefined];
+    }
+    return [undefined, await response.json()];
+  } catch (err) {
+    return [err instanceof Error ? err.message : String(err), undefined];
   }
-  return await response.json();
 }
 function filterSwaggerPaths(swagger) {
   const filteredPaths = {};
@@ -50,6 +71,8 @@ function filterSwaggerPaths(swagger) {
   const explicitlyIncludedPaths = [
     "/api/deployments/{deploymentKey}",
     "/api/deployments/{deploymentKey}/upgrade",
+    "/api/deployments/{deploymentKey}/run",
+    "/api/deployments/{deploymentKey}/validation-result",
     "/api/deployments/deploy",
     "/api/search/packages",
     "/api/v3/search/deployments"
@@ -176,4 +199,4 @@ export {
   main as generateSdk
 };
 
-//# debugId=D1A97AA940E1052064756E2164756E21
+//# debugId=DC425A840998D54264756E2164756E21

package/dist/solution-auth.js

@@ -19,12 +19,14 @@ var __toESM = (mod, isNodeMode, target) => {
   }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
   if (canCache)
     cache.set(mod, to);
   return to;
@@ -432,9 +434,9 @@ var init_is_in_ssh = __esm(() => {
 // ../../node_modules/open/index.js
 var exports_open = {};
 __export(exports_open, {
-  openApp: () => openApp,
+  apps: () => apps,
   default: () => open_default,
-  apps: () => apps
+  openApp: () => openApp
 });
 import process8 from "node:process";
 import path from "node:path";
@@ -982,7 +984,7 @@ class InvalidBaseUrlError extends Error {
     super(`Invalid base URL: "${url}"
 ` + `Reason: ${reason}
 
-` + `Expected format: an https:// URL, e.g. https://cloud.uipath.com (commercial), https://govcloud.uipath.us (Public Sector), or your Automation Suite host (https://<your-host>).
+` + `Expected format: an https:// URL (or bare host — https:// is assumed), e.g. https://cloud.uipath.com (commercial), https://govcloud.uipath.us (Public Sector), or your Automation Suite host (https://<your-host>).
 ` + `You can specify the URL via:
 ` + `  • --authority flag
 ` + `  • UIPATH_URL environment variable
@@ -1003,10 +1005,16 @@ var normalizeAndValidateBaseUrl = (rawUrl) => {
   while (baseUrl.endsWith("/")) {
     baseUrl = baseUrl.slice(0, -1);
   }
+  const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseUrl);
+  const [hostCandidate] = baseUrl.split(/[/?#]/, 1);
+  if (!hasScheme && hostCandidate.includes(".")) {
+    baseUrl = `https://${baseUrl}`;
+  }
   const resolvedBaseUrl = baseUrl;
   const [urlError, url] = catchError(() => new URL(resolvedBaseUrl));
   if (urlError) {
-    throw new InvalidBaseUrlError(baseUrl, `Malformed URL. ${urlError instanceof Error ? urlError.message : "Unknown error"}`);
+    const shapeHint = !hasScheme && !hostCandidate.includes(".") ? ` "${rawUrl.trim()}" is not a URL or a host name. Pass the full authority URL — https://<host>, or just <host> (https:// is assumed).` : ` ${urlError instanceof Error ? urlError.message : "Unknown error"}`;
+    throw new InvalidBaseUrlError(baseUrl, `Malformed URL.${shapeHint}`);
   }
   if (url.protocol !== "https:") {
     throw new InvalidBaseUrlError(baseUrl, `Authority must use https:// scheme, got ${url.protocol}//. OIDC token exchange requires TLS end-to-end.`);
@@ -1293,6 +1301,17 @@ var requireEnv = (name) => {
   }
   return value;
 };
+var OPAQUE_TOKEN_BASE_URL_VAR = "UIPATH_URL";
+var resolveBaseUrl = (rawUrl, failureContext) => {
+  const [baseUrlError, baseUrl] = catchError(() => normalizeAndValidateBaseUrl(rawUrl));
+  if (baseUrlError) {
+    if (baseUrlError instanceof InvalidBaseUrlError) {
+      throw baseUrlError;
+    }
+    throw new EnvAuthConfigError(`${failureContext}: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
+  }
+  return baseUrl;
+};
 var readAuthFromEnv = () => {
   const accessToken = requireEnv(ENV_AUTH_VARS.token);
   const organizationName = requireEnv(ENV_AUTH_VARS.organizationName);
@@ -1301,19 +1320,29 @@ var readAuthFromEnv = () => {
   const tenantId = requireEnv(ENV_AUTH_VARS.tenantId);
   const [parseError, payload] = catchError(() => parseJWT(accessToken));
   if (parseError) {
-    throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a valid JWT: ` + `${parseError instanceof Error ? parseError.message : String(parseError)}`);
+    const parseErrorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+    const rawUrl = process.env[OPAQUE_TOKEN_BASE_URL_VAR];
+    if (!rawUrl) {
+      throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} is not a JWT (treating it as an opaque token, ` + `e.g. a Personal Access Token). Set ${OPAQUE_TOKEN_BASE_URL_VAR} to the ` + `UiPath base URL if this is a PAT, or fix the token if it was meant to ` + `be a JWT (parse error: ${parseErrorMessage}).`);
+    }
+    const baseUrl2 = resolveBaseUrl(rawUrl, `Failed to validate ${OPAQUE_TOKEN_BASE_URL_VAR}`);
+    return {
+      loginStatus: "Logged in",
+      accessToken,
+      baseUrl: baseUrl2,
+      organizationName,
+      organizationId,
+      tenantName,
+      tenantId,
+      source: "env-vars" /* EnvironmentVariables */,
+      hint: "Token is opaque (not a JWT) - expiration and identity cannot be " + "determined locally. Commands will fail with 401 once it is revoked or " + `expired. If this was meant to be a JWT instead of a PAT, note: ${parseErrorMessage}`
+    };
   }
   const iss = payload.iss;
   if (typeof iss !== "string" || iss.length === 0) {
     throw new EnvAuthConfigError(`${ENV_AUTH_VARS.token} has no 'iss' claim; cannot determine ` + `the UiPath server. Ensure the token was issued by a UiPath identity server.`);
   }
-  const [baseUrlError, baseUrl] = catchError(() => normalizeAndValidateBaseUrl(iss));
-  if (baseUrlError) {
-    if (baseUrlError instanceof InvalidBaseUrlError) {
-      throw baseUrlError;
-    }
-    throw new EnvAuthConfigError(`Failed to derive server URL from token 'iss' claim: ` + `${baseUrlError instanceof Error ? baseUrlError.message : String(baseUrlError)}`);
-  }
+  const baseUrl = resolveBaseUrl(iss, "Failed to derive server URL from token 'iss' claim");
   const expiration = getTokenExpiration(accessToken);
   const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
   const identity = resolveSessionIdentity(accessToken);
@@ -2256,6 +2285,7 @@ init_constants();
 
 // ../auth/src/interactive.ts
 init_src();
+init_constants();
 // ../auth/src/tenantSelection.ts
 var IDENTIFIER_STATUSES = new Set([400, 403, 404]);
 
@@ -2291,4 +2321,4 @@ export {
   getSolutionAuthContext
 };
 
-//# debugId=C583A49A0405670664756E2164756E21
+//# debugId=816F278E3910A4D864756E2164756E21

package/dist/src/index.d.ts

@@ -8,7 +8,9 @@ export { type PackageVersionSearchFilter, type PackageVersionSearchRow, type Pac
 export type { AutoCreatedSolution, ParentSolutionDiscovery, PrepareProjectLocationOptions, PrepareProjectLocationResult, ProjectSolutionRegistration, RegisterProjectOptions, SolutionManifestCreation, } from "./solution-file";
 export { autoScaffoldSolution, createSolutionManifest, findNearestParentUipxFile, findSolutionFile, findSolutionFileUpward, isProjectRegisteredInSolution, normalizeProjectType, prepareProjectLocation, readSolutionManifest, readUipxFile, toPortableRelativePath, tryRegisterProjectInParentSolution, updateSolutionFile, updateUipxSolutionId, } from "./solution-file";
 export { getStudioWebSolutionProjects, type ListStudioWebSolutionsOptions, listStudioWebSolutions, type StudioWebSolutionsPage, } from "./solution-info";
+export { StudioWebIncompatibleProjectError } from "./studio-web-compat";
 export type { BundleResult, SolutionImportResponse, StudioWebConfig, StudioWebSolutionProject, UipxFile, UipxProject, } from "./types";
-export { importSolution, overwriteSolution, solutionExistsOnStudioWeb, uploadOrOverwriteSolution, } from "./upload-service";
+export type { SolutionUploadOperation } from "./upload-service";
+export { buildSolutionUploadFailureOutput, importSolution, isSolutionUploadHttpError, overwriteSolution, SolutionUploadHttpError, solutionExistsOnStudioWeb, uploadOrOverwriteSolution, } from "./upload-service";
 export { SDK_USER_AGENT } from "./user-agent.js";
 export { collectFiles, createZipFromDir } from "./zip-utils";

package/dist/src/resources/services/local-resource-matcher.d.ts

@@ -25,3 +25,39 @@ export declare function normalizeFolderPath(path: string | undefined): string |
  * the virtual idempotency check, and `resources add --source local`.
  */
 export declare function findMatchingLocalResource(resources: ResourceDefinition[], kind: string, name: string, folderPath: string | undefined): ResourceDefinition | undefined;
+/**
+ * Find the member artefact declaration covering (kind, name | name_<N>) —
+ * folder-agnostic on purpose.
+ *
+ * A solution provisions its own members wherever it is installed, so a
+ * binding that names a member must resolve to that member's declaration no
+ * matter which cloud folder the binding points at. Without this, a binding
+ * carrying a real folder (the folder the solution is deployed into) escapes
+ * the solution-relative guard, the RCS lookup finds the DEPLOYED member, and
+ * every `pack`/`upload` imports it as a fresh `name_<N>` clone plus a
+ * feed-pinned package declaration (UV-15817).
+ */
+export declare function findMatchingMemberResource(resources: ResourceDefinition[], kind: string, name: string, memberProjectKeys: ReadonlySet<string>): ResourceDefinition | undefined;
+/**
+ * Collect the imported `name_<N>` clones of member artefact declarations — the
+ * ones an earlier `pack`/`upload` accumulated before the guard above existed.
+ *
+ * This list gets deleted, so every condition is there to keep a resource the
+ * author meant to keep out of it. A clone must:
+ *
+ * - not be an artefact declaration itself (no `projectKey`) — those belong to
+ *   a project and the SDK refuses to delete them anyway;
+ * - carry a `package`-kind dependency. An import of a deployed project drags
+ *   the feed package in with it; a `resources add --source local` stub has no
+ *   dependencies at all. This is what separates a clone from a `name_<N>`
+ *   resource an author created on purpose, and root scope cannot: the SDK
+ *   homes an import in `solution_folder` too and records its cloud folder in
+ *   `debug_overwrites.json` instead;
+ * - match a member declaration on both `kind` and `type`. RCS matched the
+ *   deployed copy by name and kind, so it is the same project type — a stub
+ *   added by hand carries no subtype;
+ * - carry a *strictly* suffixed variant of that member's name. The bare name
+ *   is the member's own declaration, and `addResourceWithUniqueName` always
+ *   suffixes an import that collides with it.
+ */
+export declare function findMemberCloneResources(resources: ResourceDefinition[], memberProjectKeys: ReadonlySet<string>): ResourceDefinition[];

package/dist/src/resources/services/resource-refresh-service.d.ts

@@ -14,6 +14,8 @@ export interface ResourceRefreshSuccess {
     imported: number;
     /** Bindings whose cloud key was already in the solution (no-op this run). */
     skipped: number;
+    /** Stale `name_<N>` clones of the solution's own member projects removed this run. */
+    pruned: number;
     /** Non-fatal advisories (e.g. unresolved connections, link-before-deploy hints). */
     warnings: string[];
 }

package/dist/src/resources/services/sync-resources-from-bindings.d.ts

@@ -4,7 +4,7 @@ interface RequiredPropertyDefault {
     /** Empty placeholder value matching the property's declared type. */
     placeholder: unknown;
 }
-interface ResolvedKindMetadata {
+export interface ResolvedKindMetadata {
     /** Subtype to pass to createVirtualResourceAsync (e.g. "StringAsset"). */
     type?: string;
     /** SDK's `supportsInLineCreation` — whether a virtual stub can be created. */
@@ -16,12 +16,23 @@ interface ResolvedKindMetadata {
      * type-appropriate placeholder.
      */
     requiredDefaults: RequiredPropertyDefault[];
+    /**
+     * Lowercased spec property names the kind declares, unioned across every
+     * metadata version of the kind. Callers use this to ask what a kind
+     * carries without hardcoding a table — e.g. whether it has a `version`
+     * (`app`, `appVersion`, `package`, `process` do; `queue`, `asset` do not).
+     * Unioned rather than read off `versions[0]` so a property added in a
+     * newer metadata version still counts.
+     */
+    specProperties: Set<string>;
 }
-export { findMatchingLocalResource, normalizeFolderPath, } from "./local-resource-matcher";
+export { findMatchingLocalResource, findMatchingMemberResource, findMemberCloneResources, normalizeFolderPath, } from "./local-resource-matcher";
 interface SyncResult {
     created: number;
     imported: number;
     skipped: number;
+    /** Stale `name_<N>` clones of member projects removed this run (UV-15817). */
+    pruned: number;
     warnings: string[];
 }
 /**
@@ -75,6 +86,13 @@ export declare function findResourceByKeyInRcs(builder: ISolutionBuilder, kind:
  */
 export declare function searchRcsResources(builder: ISolutionBuilder, kind: string, name: string): Promise<RcsMatch[]>;
 export declare function findResourceInRcs(builder: ISolutionBuilder, kind: string, name: string, folderPath?: string): Promise<RcsMatch | undefined>;
+/**
+ * Build a resolver that answers kind-metadata questions for many (kind, type)
+ * pairs off one `getOrderedAsync` fetch, caching per pair. Prefer this over
+ * calling `resolveResourceKindMetadata` in a loop — that re-reads SDK metadata
+ * on every call.
+ */
+export declare function createResourceKindMetadataResolver(services: IResourceBuilderServices): Promise<(kind: string, type?: string) => Promise<ResolvedKindMetadata | undefined>>;
 /**
  * Resolve a resource kind's metadata via the SDK (`kind`, optional `type`) so
  * callers outside the bindings sync can fill required spec defaults the same

package/dist/src/studio-web-compat.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Studio Web import-contract knowledge, kept out of the generic bundler.
+ *
+ * Studio Web's solution import accepts only `project.uiproj`-manifested
+ * projects for API Workflows: it drops a `project.json` Api project from a
+ * mixed solution, and fails an Api-only solution with HTTP 400 code 20001
+ * ("the project archive is corrupt or the compression isn't supported").
+ * Studio-Web-bound bundlers pass {@link assertStudioWebCompatibleProjects}
+ * to `bundleSolution`'s `validateProjects` hook so the defect is caught
+ * client-side, with its real cause, before anything is uploaded.
+ * UV-15161 / STUD-81261.
+ *
+ * This module is the rule's single shared home: tool packages must not
+ * import each other, so the two Studio-Web-bound callers (solution-tool's
+ * upload, agent-tool's debug) can only share the rule through solution-sdk.
+ */
+import type { UipxProject } from "./types";
+/**
+ * Thrown by {@link assertStudioWebCompatibleProjects} when the `.uipx`
+ * references an API Workflow project manifested by `project.json`.
+ */
+export declare class StudioWebIncompatibleProjectError extends Error {
+    readonly offendingProjects: string[];
+    constructor(offendingProjects: string[]);
+}
+/**
+ * Throws {@link StudioWebIncompatibleProjectError} when any project is an
+ * API Workflow manifested by `project.json`. `Type` comes from user-owned
+ * `.uipx` JSON with no runtime validation, so it is narrowed before string
+ * methods — a malformed value falls through to the regular bundle path.
+ */
+export declare function assertStudioWebCompatibleProjects(projects: UipxProject[]): void;

package/dist/src/upload-service.d.ts

@@ -2,8 +2,76 @@
  * Upload/overwrite solutions to UiPath Studio Web.
  * Consolidates the upload logic previously duplicated in solution-tool and maestro-sdk.
  */
+import { type FailureOutput } from "@uipath/common";
 import type { IFileSystem } from "@uipath/filesystem";
 import type { SolutionImportResponse, StudioWebConfig } from "./types";
+/** Which Studio Web endpoint refused the upload. */
+export type SolutionUploadOperation = "import" | "overwrite";
+/** An overwrite always names its target; an import has none yet. */
+type SolutionUploadFailureDetails = {
+    status: number;
+    method: string;
+    /** Request path as the URL carries it: no scheme or host, but the
+     *  organization prefix is part of the path and stays. */
+    endpoint: string;
+    /** Full request URL, for diagnostics. */
+    url: string;
+    body: string;
+    message: string;
+} & ({
+    operation: "import";
+} | {
+    operation: "overwrite";
+    solutionId: string;
+});
+/**
+ * A Studio Web upload endpoint answered non-2xx.
+ *
+ * Carries what a caller needs to report the failure without re-parsing
+ * anything: which endpoint ran, the status, the raw body, and the platform's
+ * own `code` / `message` when the body carries them.
+ *
+ * `status` and the `message` wording are part of the contract —
+ * `uip solution upload` shape-matches `status === 404` and quotes `message` in
+ * its stale-id envelope.
+ */
+export declare class SolutionUploadHttpError extends Error {
+    readonly status: number;
+    readonly operation: SolutionUploadOperation;
+    readonly method: string;
+    readonly endpoint: string;
+    readonly url: string;
+    readonly body: string;
+    /** Present only for an overwrite. */
+    readonly solutionId?: string;
+    /** From a `{"code":…,"message":…}` body; undefined for any other shape. */
+    readonly parsedErrorCode?: string;
+    readonly parsedErrorMessage?: string;
+    constructor(details: SolutionUploadFailureDetails);
+}
+/** Matched by shape, not `instanceof`: tools bundle their own copy of this
+ *  package, so a cross-bundle `instanceof` is not reliable. */
+export declare function isSolutionUploadHttpError(error: unknown): error is SolutionUploadHttpError;
+/**
+ * Build the CLI failure envelope for a Studio Web upload refusal.
+ *
+ * The upload runs before anything executes, so on a refusal nothing reached
+ * the tenant and nothing ran: the envelope points at the upload, not at the
+ * project's contents. Shared by every command that pushes a solution, so the
+ * text names no command of its own.
+ *
+ * `subject` names what the caller was pushing ("flow", "case", "process",
+ * "agent"), so the text can say which artifact is off the hook. `importCheckHint`
+ * is appended on an import refusal, where the package itself was rejected and
+ * the caller has a command for checking it; an overwrite refusal is about the
+ * target solution, not the package.
+ *
+ * `Context.httpStatus` is what gives the envelope its `ErrorCode`.
+ */
+export declare function buildSolutionUploadFailureOutput(err: SolutionUploadHttpError, options?: {
+    subject?: string;
+    importCheckHint?: string;
+}): FailureOutput;
 /**
  * Escape hatch for very large solutions or unusually slow links:
  * `UIPATH_SOLUTION_UPLOAD_TIMEOUT_MS=300000`. Anything non-numeric or
@@ -31,9 +99,13 @@ export declare function solutionExistsOnStudioWeb(config: StudioWebConfig, organ
  */
 export declare function importSolution(config: StudioWebConfig, organizationName: string, fileBuffer: Uint8Array, fileName: string): Promise<SolutionImportResponse>;
 /**
- * Overwrite an existing solution on Studio Web.
+ * Overwrite an existing solution on Studio Web: replaces its contents in
+ * place under the same id, keeping existing version history. With
+ * `createSnapshot` the replaced contents are first recorded as a restorable
+ * version; the default (false) matches the server's and keeps debug pushes
+ * from minting a version per iteration — `uip solution upload` opts in.
  */
-export declare function overwriteSolution(config: StudioWebConfig, organizationName: string, fileBuffer: Uint8Array, fileName: string, solutionId: string): Promise<SolutionImportResponse>;
+export declare function overwriteSolution(config: StudioWebConfig, organizationName: string, fileBuffer: Uint8Array, fileName: string, solutionId: string, createSnapshot?: boolean): Promise<SolutionImportResponse>;
 /**
  * Upload or overwrite a solution on Studio Web.
  * If solutionId is provided, tries overwrite first with 404 fallback to import.
@@ -41,3 +113,4 @@ export declare function overwriteSolution(config: StudioWebConfig, organizationN
  * Accepts either a file buffer or a file path (reads the file using fs).
  */
 export declare function uploadOrOverwriteSolution(config: StudioWebConfig, organizationName: string, fileBufferOrPath: Uint8Array | string, solutionId: string | undefined, fs?: IFileSystem): Promise<SolutionImportResponse>;
+export {};

package/dist/src/zip-utils.d.ts

@@ -14,6 +14,9 @@ import type { IFileSystem } from "@uipath/filesystem";
  *   node_modules   Node dependency cache; same reasoning as .venv.
  *   __pycache__    Python bytecode; regenerated on import.
  *   .git           VCS metadata; never belongs in an upload.
+ *   .local         Studio's per-project NuGet restore cache. Studio Web
+ *                  restores its own packages on import, so uploading this one
+ *                  only costs bundle size and time.
  *
  * Callers can extend this set per-walk via the `additionalExcludeDirs` option
  * (sourced from a `.uipignore` file at the solution root by bundle-service).
@@ -77,3 +80,28 @@ export declare function collectFiles(fs: IFileSystem, dir: string, options?: {
 export declare function createZipFromDir(fs: IFileSystem, dir: string, options?: {
     additionalExcludeDirs?: Iterable<string>;
 }): Promise<Uint8Array>;
+/**
+ * Give an archive a zip64 tail once it holds more entries than the classic
+ * end-of-central-directory record can count.
+ *
+ * fflate writes zip32 only. Its EOCD entry count is a 16-bit field, and its
+ * byte writer stops at the first zero byte rather than clamping to the field
+ * width, so an archive of 65,536 entries reports 0 and one of 70,000 reports
+ * 4,464 - with no error raised. Readers that trust the count (fflate's own
+ * `unzipSync` bails at `if (!c) return {}`; .NET's `ZipArchive` throws when the
+ * walked central directory disagrees with it) then see an empty or corrupt
+ * archive. That is how a solution bundle large enough to cross the ceiling
+ * reaches Studio Web's import as "the project archive is corrupt or the
+ * compression isn't supported" - a valid-looking file that strict readers
+ * refuse.
+ *
+ * The fix is the one zip64 prescribes for a count-only overflow: keep the
+ * central directory exactly as written, saturate the classic EOCD's count
+ * fields, and put the true counts in a zip64 EOCD record plus its locator. Per-
+ * entry zip64 extra fields are not involved, because no individual entry's size
+ * or offset overflows here.
+ *
+ * @param zip - Archive as fflate produced it.
+ * @returns The same archive, with a zip64 tail when one is needed.
+ */
+export declare function finalizeZip64(zip: Uint8Array): Uint8Array;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@uipath/solution-sdk",
     "license": "MIT",
-    "version": "1.201.0-preview.133",
+    "version": "1.202.0-preview.134",
     "repository": {
         "type": "git",
         "url": "https://github.com/UiPath/cli.git",
@@ -39,5 +39,5 @@
         "dist"
     ],
     "private": false,
-    "gitHead": "7933378ad5276ac369900293a1447474dcec6826"
+    "gitHead": "a335728adbdb02f28308e4f55d8936d0b150444b"
 }