@uipath/solution-sdk 1.204.0-preview.249 → 1.204.0-preview.254

package/dist/THIRD-PARTY-NOTICES.md

@@ -5,7 +5,7 @@ compiled into its `dist/` output rather than installed alongside it.
 Their licences and copyright notices are reproduced here in full, as
 those licences require.
 
-17 bundled dependencies:
+18 bundled dependencies:
 
 - @uipath/resource-builder-sdk@2025.11.0-alpha6004-4107 — ISC
 - bundle-name@4.1.0 — MIT
@@ -14,6 +14,7 @@ those licences require.
 - default-browser-id@5.0.1 — MIT
 - define-lazy-prop@3.0.0 — MIT
 - fflate@0.8.3 — MIT
+- ignore@5.3.2 — MIT
 - is-docker@3.0.0 — MIT
 - is-in-ssh@1.0.0 — MIT
 - is-inside-container@1.0.0 — MIT
@@ -170,6 +171,36 @@ SOFTWARE.
 
 ---
 
+## ignore@5.3.2
+
+SPDX: MIT
+
+```
+Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
+http://kael.me/
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+---
+
 ## is-docker@3.0.0
 
 SPDX: MIT

package/dist/index.js

@@ -24,7 +24,270 @@ import {
   zipSync
 } from "./index-fb21bjwj.js";
 import"./index-g0hcxnae.js";
-import"./index-1de529jm.js";
+import {
+  __commonJS,
+  __toESM
+} from "./index-1de529jm.js";
+
+// ../../node_modules/ignore/index.js
+var require_ignore = __commonJS(function(exports, module) {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.*\/|^\.+$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define = (object, key, value) => Object.defineProperty(object, key, { value });
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ],
+    [
+      /(\^|\\\/)?\\\*$/,
+      (_, p1) => {
+        const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+        return `${prefix}(?=$|\\/$)`;
+      }
+    ]
+  ];
+  var regexCache = Object.create(null);
+  var makeRegex = (pattern, ignoreCase) => {
+    let source = regexCache[pattern];
+    if (!source) {
+      source = REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+      regexCache[pattern] = source;
+    }
+    return ignoreCase ? new RegExp(source, "i") : new RegExp(source);
+  };
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF);
+
+  class IgnoreRule {
+    constructor(origin, pattern, negative, regex) {
+      this.origin = origin;
+      this.pattern = pattern;
+      this.negative = negative;
+      this.regex = regex;
+    }
+  }
+  var createRule = (pattern, ignoreCase) => {
+    const origin = pattern;
+    let negative = false;
+    if (pattern.indexOf("!") === 0) {
+      negative = true;
+      pattern = pattern.substr(1);
+    }
+    pattern = pattern.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regex = makeRegex(pattern, ignoreCase);
+    return new IgnoreRule(origin, pattern, negative, regex);
+  };
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path, originalPath, doThrow) => {
+    if (!isString(path)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define(this, KEY_IGNORE, true);
+      this._rules = [];
+      this._ignoreCase = ignoreCase;
+      this._allowRelativePaths = allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    _addPattern(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules);
+        this._added = true;
+        return;
+      }
+      if (checkPattern(pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._addPattern, this);
+      if (this._added) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _testOne(path, checkUnignored) {
+      let ignored = false;
+      let unignored = false;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule.regex.test(path);
+        if (matched) {
+          ignored = !negative;
+          unignored = negative;
+        }
+      });
+      return {
+        ignored,
+        unignored
+      };
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path = originalPath && checkPath.convert(originalPath);
+      checkPath(path, originalPath, this._allowRelativePaths ? RETURN_FALSE : throwError);
+      return this._t(path, cache, checkUnignored, slices);
+    }
+    _t(path, cache, checkUnignored, slices) {
+      if (path in cache) {
+        return cache[path];
+      }
+      if (!slices) {
+        slices = path.split(SLASH);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path] = this._testOne(path, checkUnignored);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path] = parent.ignored ? parent : this._testOne(path, checkUnignored);
+    }
+    ignores(path) {
+      return this._test(path, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path) => !this.ignores(path);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path) {
+      return this._test(path, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
+  factory.isPathValid = isPathValid;
+  factory.default = factory;
+  module.exports = factory;
+  if (typeof process !== "undefined" && (process.env && process.env.IGNORE_TEST_WIN32 || process.platform === "win32")) {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
+  }
+});
 
 // generated/src/runtime.ts
 var BASE_PATH = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_".replace(/\/+$/, "");
@@ -326,7 +589,7 @@ var package_default = {
   name: "@uipath/solution-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0-preview.249",
+  version: "1.204.0-preview.254",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -382,6 +645,7 @@ var package_default = {
     "@uipath/studioweb-sdk": "workspace:*",
     "@types/node": "^25.5.2",
     fflate: "^0.8.2",
+    ignore: "^5.3.2",
     typescript: "^7.0.2"
   }
 };
@@ -4337,6 +4601,7 @@ function assertStudioWebCompatibleProjects(projects) {
 }
 
 // src/zip-utils.ts
+var import_ignore = __toESM(require_ignore(), 1);
 var DEFAULT_EXCLUDED_DIR_NAMES = new Set([
   ".venv",
   "node_modules",
@@ -4358,18 +4623,31 @@ function isDefaultExcludedFileName(name) {
 }
 var UIPIGNORE_FILENAME = ".uipignore";
 function parseUipignore(body) {
-  const names = new Set;
-  for (const rawLine of body.split(/\r?\n/)) {
-    const line = rawLine.split("#")[0]?.trim();
-    if (!line) {
+  return body.split(/\r?\n/).filter((line) => line.trim() !== "" && !line.startsWith("#"));
+}
+function createUipignoreRules(baseDir, patterns) {
+  const matcher = import_ignore.default().add([...patterns]);
+  return {
+    baseDir,
+    patterns,
+    ignores: (relativePath) => matcher.ignores(relativePath)
+  };
+}
+var UNMATCHABLE_RELATIVE_PATH = /^\.+$|^\.*\//;
+function isIgnoredByRules(fs, rules, fullPath, isDirectory) {
+  if (!rules) {
+    return false;
+  }
+  for (const rule of rules) {
+    const rel = fs.path.relative(rule.baseDir, fullPath).replace(/\\/g, "/");
+    if (!rel || UNMATCHABLE_RELATIVE_PATH.test(rel) || fs.path.isAbsolute(rel)) {
       continue;
     }
-    if (line.includes("/") || line.includes("\\")) {
-      continue;
+    if (rule.ignores(isDirectory ? `${rel}/` : rel)) {
+      return true;
     }
-    names.add(line);
   }
-  return names;
+  return false;
 }
 async function collectTree(fs, dir, options = {}) {
   const files = [];
@@ -4392,12 +4670,12 @@ async function collectTree(fs, dir, options = {}) {
       const fullPath = fs.path.join(current, entryName);
       const entryStat = await fs.stat(fullPath);
       if (entryStat?.isDirectory()) {
-        if (excluded.has(entryName)) {
+        if (excluded.has(entryName) || isIgnoredByRules(fs, options.ignoreRules, fullPath, true)) {
           continue;
         }
         await walk(fullPath, false);
       } else if (entryStat?.isFile()) {
-        if (isDefaultExcludedFileName(entryName)) {
+        if (isDefaultExcludedFileName(entryName) || isIgnoredByRules(fs, options.ignoreRules, fullPath, false)) {
           continue;
         }
         files.push(fullPath);
@@ -4500,38 +4778,43 @@ function countCentralDirectoryEntries(view, cdOffset, cdSize) {
 }
 
 // src/bundle-service.ts
+class UipignoreExcludesProjectError extends Error {
+  projectManifestPath;
+  constructor(projectManifestPath) {
+    super(`${UIPIGNORE_FILENAME} excludes ${projectManifestPath}, which the solution references. A project listed in the .uipx cannot be left out of the bundle.`);
+    this.projectManifestPath = projectManifestPath;
+    this.name = "UipignoreExcludesProjectError";
+  }
+}
 async function readUipignore(fs, dir) {
   const ignorePath = fs.path.join(dir, UIPIGNORE_FILENAME);
   if (!await fs.exists(ignorePath)) {
-    return new Set;
+    return;
   }
   try {
     const body = await fs.readFile(ignorePath, "utf-8");
-    if (!body) {
-      return new Set;
+    const patterns = body ? parseUipignore(body) : [];
+    if (patterns.length === 0) {
+      return;
     }
-    return parseUipignore(body);
+    return createUipignoreRules(dir, patterns);
   } catch (err) {
     logger.warn(`Could not read ${UIPIGNORE_FILENAME}; ignoring it: ${String(err)}`);
-    return new Set;
+    return;
   }
 }
-async function mergeProjectUipignore(fs, projectPath, projectLabel, solutionExcludeDirs) {
-  const projectExtra = await readUipignore(fs, projectPath);
-  if (projectExtra.size === 0) {
-    return solutionExcludeDirs;
+async function mergeProjectUipignore(fs, projectPath, projectLabel, solutionRules) {
+  const projectRules = await readUipignore(fs, projectPath);
+  if (!projectRules) {
+    return solutionRules;
   }
-  const merged = new Set(solutionExcludeDirs);
-  for (const name of projectExtra) {
-    merged.add(name);
-  }
-  logger.info(`[${projectLabel}] Applying ${projectExtra.size} extra exclude(s) from project ${UIPIGNORE_FILENAME}: ${[...projectExtra].join(", ")}`);
-  return merged;
+  logger.info(`[${projectLabel}] Applying ${projectRules.patterns.length} extra exclude(s) from project ${UIPIGNORE_FILENAME}: ${projectRules.patterns.join(", ")}`);
+  return [...solutionRules, projectRules];
 }
 var toForwardSlash = (p) => p.replace(/\\/g, "/");
-async function mirrorTree(fs, srcDir, relativeBase, destBaseDir, additionalExcludeDirs) {
+async function mirrorTree(fs, srcDir, relativeBase, destBaseDir, ignoreRules) {
   const { files, emptyDirs } = await collectTree(fs, srcDir, {
-    additionalExcludeDirs
+    ignoreRules
   });
   if (files.length === 0 && emptyDirs.length === 0) {
     const rootRel = fs.path.relative(relativeBase, srcDir);
@@ -4558,14 +4841,8 @@ async function mirrorTree(fs, srcDir, relativeBase, destBaseDir, additionalExclu
     await fs.mkdir(fs.path.join(destBaseDir, relPath));
   }
 }
-async function flattenProjectDir(fs, srcProjectDir, destProjectDir, additionalExcludeDirs) {
+async function flattenProjectDir(fs, srcProjectDir, destProjectDir, ignoreRules) {
   await fs.mkdir(destProjectDir);
-  const topLevelExclude = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
-  if (additionalExcludeDirs) {
-    for (const name of additionalExcludeDirs) {
-      topLevelExclude.add(name);
-    }
-  }
   const entries = await fs.readdir(srcProjectDir);
   for (const entryName of entries) {
     const srcPath = fs.path.join(srcProjectDir, entryName);
@@ -4574,7 +4851,7 @@ async function flattenProjectDir(fs, srcProjectDir, destProjectDir, additionalEx
       continue;
     }
     if (entryStat.isFile()) {
-      if (isDefaultExcludedFileName(entryName)) {
+      if (isDefaultExcludedFileName(entryName) || isIgnoredByRules(fs, ignoreRules, srcPath, false)) {
         continue;
       }
       const data = await fs.readFile(srcPath);
@@ -4582,13 +4859,13 @@ async function flattenProjectDir(fs, srcProjectDir, destProjectDir, additionalEx
         await fs.writeFile(fs.path.join(destProjectDir, entryName), data);
       }
     } else if (entryStat.isDirectory()) {
-      if (topLevelExclude.has(entryName)) {
+      if (DEFAULT_EXCLUDED_DIR_NAMES.has(entryName) || isIgnoredByRules(fs, ignoreRules, srcPath, true)) {
         continue;
       }
       if (entryName === "content" || entryName === "flow_files") {
-        await mirrorTree(fs, srcPath, srcPath, destProjectDir, additionalExcludeDirs);
+        await mirrorTree(fs, srcPath, srcPath, destProjectDir, ignoreRules);
       } else {
-        await mirrorTree(fs, srcPath, srcProjectDir, destProjectDir, additionalExcludeDirs);
+        await mirrorTree(fs, srcPath, srcProjectDir, destProjectDir, ignoreRules);
       }
     }
   }
@@ -4603,14 +4880,12 @@ async function bundleSolution(fs, solutionDir, outputDir, outputName) {
     throw new Error(`Not a directory: ${resolvedPath}. Provide the solution directory containing a .uipx file.`);
   }
   const { uipx, uipxFileName } = await readUipxFile(fs, resolvedPath);
-  const additionalExcludeDirs = await readUipignore(fs, resolvedPath);
-  if (additionalExcludeDirs.size > 0) {
-    logger.info(`Applying ${additionalExcludeDirs.size} extra exclude(s) from .uipignore: ${[...additionalExcludeDirs].join(", ")}`);
-  }
-  const effectiveExclude = new Set(DEFAULT_EXCLUDED_DIR_NAMES);
-  for (const name of additionalExcludeDirs) {
-    effectiveExclude.add(name);
+  const solutionUipignore = await readUipignore(fs, resolvedPath);
+  const solutionRules = solutionUipignore ? [solutionUipignore] : [];
+  if (solutionUipignore) {
+    logger.info(`Applying ${solutionUipignore.patterns.length} extra exclude(s) from ${UIPIGNORE_FILENAME}: ${solutionUipignore.patterns.join(", ")}`);
   }
+  const isTopLevelTreeExcluded = (treePath, name) => DEFAULT_EXCLUDED_DIR_NAMES.has(name) || isIgnoredByRules(fs, solutionRules, treePath, true);
   for (const project of uipx.Projects) {
     project.ProjectRelativePath = toForwardSlash(project.ProjectRelativePath);
   }
@@ -4635,16 +4910,20 @@ async function bundleSolution(fs, solutionDir, outputDir, outputName) {
       if (!projectStat) {
         throw new Error(`Project directory not found: ${srcProjectPath}`);
       }
-      const projectExcludeDirs = await mergeProjectUipignore(fs, srcProjectPath, projectDir, additionalExcludeDirs);
-      await flattenProjectDir(fs, srcProjectPath, fs.path.join(stagingDir, projectDir), projectExcludeDirs);
+      const projectRules = await mergeProjectUipignore(fs, srcProjectPath, projectDir, solutionRules);
+      const manifestPath = fs.path.join(resolvedPath, project.ProjectRelativePath);
+      if (isIgnoredByRules(fs, projectRules, manifestPath, false)) {
+        throw new UipignoreExcludesProjectError(project.ProjectRelativePath);
+      }
+      await flattenProjectDir(fs, srcProjectPath, fs.path.join(stagingDir, projectDir), projectRules);
     }
     const resourcesPath = fs.path.join(resolvedPath, "resources");
-    if (!effectiveExclude.has("resources") && await fs.exists(resourcesPath)) {
-      await mirrorTree(fs, resourcesPath, resolvedPath, stagingDir, additionalExcludeDirs);
+    if (!isTopLevelTreeExcluded(resourcesPath, "resources") && await fs.exists(resourcesPath)) {
+      await mirrorTree(fs, resourcesPath, resolvedPath, stagingDir, solutionRules);
     }
     const userProfilePath = fs.path.join(resolvedPath, "userProfile");
-    if (!effectiveExclude.has("userProfile") && await fs.exists(userProfilePath)) {
-      await mirrorTree(fs, userProfilePath, resolvedPath, stagingDir, additionalExcludeDirs);
+    if (!isTopLevelTreeExcluded(userProfilePath, "userProfile") && await fs.exists(userProfilePath)) {
+      await mirrorTree(fs, userProfilePath, resolvedPath, stagingDir, solutionRules);
     }
     const resolvedOutputDir = fs.path.resolve(outputDir);
     if (!await fs.exists(resolvedOutputDir)) {
@@ -5316,6 +5595,7 @@ export {
   SolutionUploadHttpError,
   StudioWebIncompatibleProjectError,
   TextApiResponse,
+  UipignoreExcludesProjectError,
   VoidApiResponse,
   WorkflowAction,
   WorkflowActionFromJSON,
@@ -5411,4 +5691,4 @@ export {
   uploadOrOverwriteSolution
 };
 
-//# debugId=14F18399CD557CE064756E2164756E21
+//# debugId=E7BE3615C046406164756E2164756E21

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

@@ -5,6 +5,15 @@
  */
 import type { IFileSystem } from "@uipath/filesystem";
 import type { BundleResult } from "./types";
+/**
+ * Thrown when a `.uipignore` pattern would drop a project the `.uipx` lists.
+ * `SolutionStorage.json` would still name that project, so the archive would
+ * be broken on import; refusing up front is the only honest outcome.
+ */
+export declare class UipignoreExcludesProjectError extends Error {
+    readonly projectManifestPath: string;
+    constructor(projectManifestPath: string);
+}
 /**
  * Bundle a solution directory into a .uis file.
  * Validates the .uipx file, flattens project directories, and zips everything.

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 import "./user-agent.js";
 export { getAvailablePublishLocationsV2, type PublishLocationType, type PublishLocationV2, } from "@uipath/studioweb-sdk";
 export * from "../generated/src/index.js";
-export { buildSolutionPackageFromDir, bundleSolution, resolveSolutionDir, } from "./bundle-service";
+export { buildSolutionPackageFromDir, bundleSolution, resolveSolutionDir, UipignoreExcludesProjectError, } from "./bundle-service";
 export { getProjectDebugStatus, isDebugProvisioningSucceeded, isDebugProvisioningTerminal, type ProjectDebugStatusClientConfig, type ProjectDebugStatusError, type ProjectDebugStatusResponse, } from "./project-debug-status";
 export { type PackageVersionSearchFilter, type PackageVersionSearchRow, type PackageVersionsClientConfig, searchPackageVersions, } from "./search-package-versions";
 export type { AutoCreatedSolution, ParentSolutionDiscovery, PrepareProjectLocationOptions, PrepareProjectLocationResult, ProjectSolutionRegistration, RegisterProjectOptions, SolutionManifestCreation, } from "./solution-file";

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

@@ -26,8 +26,9 @@ import type { IFileSystem } from "@uipath/filesystem";
  *                  `.project` (IDE state) and `.agent-builder` (inline agents)
  *                  must still ship.
  *
- * Callers can extend this set per-walk via the `additionalExcludeDirs` option
- * (sourced from a `.uipignore` file at the solution root by bundle-service).
+ * Callers can extend this set per-walk via the `additionalExcludeDirs` option.
+ * User-authored excludes come from `.uipignore` files and go through
+ * `ignoreRules` instead (see {@link UipignoreRules}).
  */
 export declare const DEFAULT_EXCLUDED_DIR_NAMES: ReadonlySet<string>;
 /**
@@ -46,13 +47,38 @@ export declare function isDefaultExcludedFileName(name: string): boolean;
 /** File name read by bundle-service to extend the default exclude set. */
 export declare const UIPIGNORE_FILENAME = ".uipignore";
 /**
- * Parse a `.uipignore` file body: one directory name per line, `#` for line
- * comments, blank lines ignored. Returns the names as a Set. The parser is
- * deliberately minimal — no globs, no negation, no path separators. Each
- * entry matches by exact directory name at any depth (same semantics as the
- * built-in defaults).
+ * Split a `.uipignore` file body into its patterns: one per line, skipping
+ * blank lines and lines that start with `#`. Nothing else is interpreted here.
+ * The patterns go to the `ignore` package as-is, so the syntax is plain
+ * gitignore: globs (`*.log`), anchored paths (`/dist`, `src/generated/`), a
+ * trailing `/` for directories only, `!` to re-include. `codedapp push` feeds
+ * the same file to `ignore` raw, so the two commands read it identically.
  */
-export declare function parseUipignore(body: string): Set<string>;
+export declare function parseUipignore(body: string): string[];
+/**
+ * Parsed `.uipignore` patterns, matched against paths relative to `baseDir`
+ * (the directory that holds the file). `ignores` takes a forward-slash path
+ * relative to `baseDir`, with a trailing `/` for a directory.
+ */
+export interface UipignoreRules {
+    baseDir: string;
+    patterns: readonly string[];
+    ignores: (relativePath: string) => boolean;
+}
+/** Build matchable rules from `.uipignore` patterns rooted at `baseDir`. */
+export declare function createUipignoreRules(baseDir: string, patterns: readonly string[]): UipignoreRules;
+/**
+ * True when any of `rules` ignores `fullPath`. Each rule set only sees paths
+ * under its own `baseDir`; paths outside it are never matched.
+ */
+export declare function isIgnoredByRules(fs: IFileSystem, rules: readonly UipignoreRules[] | undefined, fullPath: string, isDirectory: boolean): boolean;
+/** What {@link collectTree} skips on top of the built-in defaults. */
+export interface CollectTreeOptions {
+    /** Extra directory names to skip at any depth (caller-supplied). */
+    additionalExcludeDirs?: Iterable<string>;
+    /** Parsed `.uipignore` rules (gitignore syntax). */
+    ignoreRules?: readonly UipignoreRules[];
+}
 /**
  * Recursively walk `dir`, returning every file path and every empty directory
  * path beneath it. An empty directory is a directory whose `readdir` returns
@@ -63,20 +89,17 @@ export declare function parseUipignore(body: string): Set<string>;
  * caller provides. Directory exclusion is by exact directory name at any
  * depth. Files matching DEFAULT_EXCLUDED_FILE_PATTERNS (e.g. `.env`,
  * `.env.local`) are also skipped at any depth — they conventionally hold
- * credentials and must not be shipped in the bundle.
+ * credentials and must not be shipped in the bundle. Files and directories
+ * matched by `ignoreRules` (parsed `.uipignore` files) are skipped as well.
  */
-export declare function collectTree(fs: IFileSystem, dir: string, options?: {
-    additionalExcludeDirs?: Iterable<string>;
-}): Promise<{
+export declare function collectTree(fs: IFileSystem, dir: string, options?: CollectTreeOptions): Promise<{
     files: string[];
     emptyDirs: string[];
 }>;
 /**
  * Recursively collect all file paths under a directory.
  */
-export declare function collectFiles(fs: IFileSystem, dir: string, options?: {
-    additionalExcludeDirs?: Iterable<string>;
-}): Promise<string[]>;
+export declare function collectFiles(fs: IFileSystem, dir: string, options?: CollectTreeOptions): Promise<string[]>;
 /**
  * Collect all files (and empty directories) under `dir` and zip them using
  * fflate. Empty directories are written as standard zip directory records
@@ -85,9 +108,7 @@ export declare function collectFiles(fs: IFileSystem, dir: string, options?: {
  *
  * Returns the zip as a Uint8Array.
  */
-export declare function createZipFromDir(fs: IFileSystem, dir: string, options?: {
-    additionalExcludeDirs?: Iterable<string>;
-}): Promise<Uint8Array>;
+export declare function createZipFromDir(fs: IFileSystem, dir: string, options?: CollectTreeOptions): Promise<Uint8Array>;
 /**
  * Give an archive a zip64 tail once it holds more entries than the classic
  * end-of-central-directory record can count.

package/package.json

@@ -2,7 +2,7 @@
     "name": "@uipath/solution-sdk",
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.204.0-preview.249",
+    "version": "1.204.0-preview.254",
     "repository": {
         "type": "git",
         "url": "https://github.com/UiPath/cli.git",
@@ -40,5 +40,5 @@
         "dist"
     ],
     "private": false,
-    "gitHead": "a0ea4d79473cd8077d99d13c2644163be126b103"
+    "gitHead": "3ee79cdec05b36231a8da9e8de6bf0043585526a"
 }