@uipath/function-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/index-01pnwmwf.js

@@ -0,0 +1,1130 @@
+import {
+  catchError2,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  quoteForShell,
+  unsupportedSolutionProjectType
+} from "./packager-tool-cmtxbmhx.js";
+import {
+  __toESM,
+  __commonJS
+} from "./packager-tool-epsr41wx.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);
+  }
+});
+
+// ../solution-sdk/generated/src/runtime.ts
+var BASE_PATH = "https://alpha.uipath.com/uipattycyrhx/abizon_1/automationsolutions_".replace(/\/+$/, "");
+
+class Configuration {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig = new Configuration;
+
+class BaseAPI {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+// ../solution-sdk/package.json
+var package_default = {
+  name: "@uipath/solution-sdk",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.206.0-preview.282",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/solution-sdk"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  keywords: [
+    "uipath",
+    "solution",
+    "sdk"
+  ],
+  type: "module",
+  main: "./dist/index.js",
+  types: "./dist/src/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/src/index.d.ts",
+      default: "./dist/index.js"
+    },
+    "./resources": {
+      types: "./dist/src/resources/index.d.ts",
+      default: "./dist/resources/index.js"
+    },
+    "./auth": {
+      types: "./dist/src/solution-auth.d.ts",
+      default: "./dist/solution-auth.js"
+    },
+    "./deployments": {
+      types: "./dist/src/deployment-search.d.ts",
+      default: "./dist/deployment-search.js"
+    },
+    "./packages": {
+      types: "./dist/src/package-search.d.ts",
+      default: "./dist/package-search.js"
+    },
+    "./project-context": {
+      types: "./dist/src/project-context.d.ts",
+      default: "./dist/project-context.js"
+    }
+  },
+  bin: {
+    "generate-sdk": "./dist/scripts/generate-sdk.js"
+  },
+  files: [
+    "dist"
+  ],
+  private: false,
+  scripts: {
+    build: "bun build ./src/index.ts ./src/resources/index.ts ./src/solution-auth.ts ./src/deployment-search.ts ./src/package-search.ts ./src/project-context.ts --outdir dist --format esm --target node --splitting --sourcemap=linked && bun build ./src/scripts/generate-sdk.ts --outdir dist/scripts --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    generate: "bun run src/scripts/generate-sdk.ts",
+    lint: "biome check .",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    typecheck: "tsc --noEmit"
+  },
+  devDependencies: {
+    "@openapitools/openapi-generator-cli": "^2.31.1",
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/orchestrator-sdk": "workspace:*",
+    "@uipath/pipelines-sdk": "workspace:*",
+    "@uipath/resource-builder-sdk": "2025.11.0-alpha6584-4367",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/studioweb-sdk": "workspace:*",
+    "@types/node": "^25.5.2",
+    fflate: "^0.8.2",
+    ignore: "^5.3.2",
+    typescript: "^7.0.2"
+  }
+};
+
+// ../solution-sdk/src/user-agent.ts
+var SDK_USER_AGENT = getSdkUserAgentToken(package_default);
+installSdkUserAgentHeader(BaseAPI, SDK_USER_AGENT);
+
+// ../studioweb-sdk/generated/src/runtime.ts
+var BASE_PATH2 = "https://alpha.uipath.com/studio_/backend".replace(/\/+$/, "");
+
+class Configuration2 {
+  configuration;
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH2;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring2;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+var DefaultConfig2 = new Configuration2;
+
+class BaseAPI2 {
+  configuration;
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$", "i");
+  middleware;
+  constructor(configuration = DefaultConfig2) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI2.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError2(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === undefined ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData2(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob2(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = undefined;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : undefined
+          }) || response;
+        }
+      }
+      if (response === undefined) {
+        if (e instanceof Error) {
+          throw new FetchError2(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+function isBlob2(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData2(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+
+class ResponseError2 extends Error {
+  response;
+  name = "ResponseError";
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+}
+
+class FetchError2 extends Error {
+  cause;
+  name = "FetchError";
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+}
+function querystring2(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey2(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey2(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey2(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring2(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+// ../solution-sdk/src/solution-file.ts
+var STUDIO_WEB_PROJECT_TYPE_OVERRIDES = {
+  ProcessOrchestration: "processOrchestration"
+};
+function normalizeProjectType(projectType) {
+  return STUDIO_WEB_PROJECT_TYPE_OVERRIDES[projectType] ?? projectType;
+}
+function toPortableRelativePath(relativePath) {
+  return relativePath.replace(/\\/g, "/");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function tryRegisterProjectInParentSolution(fs, projectDir, options) {
+  if (options?.skipRegistration) {
+    return {
+      Status: "OptedOut",
+      Message: "Solution auto-registration skipped (--skip-solution-registration).",
+      Instructions: buildOptedOutInstructions(fs.path.resolve(projectDir))
+    };
+  }
+  const [registrationError, registration] = await catchError2(registerProjectInParentSolution(fs, projectDir));
+  if (registrationError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Instructions: buildRegistrationFailureInstructions(projectDir, registrationError.message)
+    };
+  }
+  return registration;
+}
+async function registerProjectInParentSolution(fs, projectDir) {
+  const resolvedProjectDir = fs.path.resolve(projectDir);
+  const discovery = await findNearestParentUipxFile(fs, resolvedProjectDir);
+  if (discovery.status === "notFound") {
+    return {
+      Status: "NotInSolution",
+      Message: "Project created in standalone mode; no parent .uipx solution found.",
+      Instructions: buildStandaloneInstructions(resolvedProjectDir)
+    };
+  }
+  if (discovery.status === "skipped") {
+    return discovery.registration;
+  }
+  const solutionFile = discovery.solutionFile;
+  const solutionDir = fs.path.dirname(solutionFile);
+  const relativeProjectDir = fs.path.relative(solutionDir, resolvedProjectDir);
+  if (relativeProjectDir === "" || relativeProjectDir.startsWith("..") || fs.path.isAbsolute(relativeProjectDir)) {
+    return {
+      Status: "Skipped",
+      Message: "Project registration skipped.",
+      Solution: solutionFile,
+      Instructions: `Project must reside within the solution folder.
+  Solution: ${solutionDir}
+  Project:  ${resolvedProjectDir}`
+    };
+  }
+  const [projectFileError, projectFile] = await findProjectFile(fs, resolvedProjectDir);
+  if (projectFileError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, projectFileError.message)
+    };
+  }
+  const [projectManifestError, projectManifest] = await readProjectManifest(fs, projectFile.filePath, projectFile.useProjectJson);
+  if (projectManifestError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, projectManifestError.message)
+    };
+  }
+  const unsupportedReason = unsupportedSolutionProjectType(projectManifest.projectType);
+  if (unsupportedReason) {
+    return {
+      Status: "Skipped",
+      Message: "Project registration skipped.",
+      Solution: solutionFile,
+      Instructions: unsupportedReason
+    };
+  }
+  const projectRelativePath = toPortableRelativePath(fs.path.join(relativeProjectDir, projectFile.fileName));
+  const [solutionError, solution] = await readSolutionManifest(fs, solutionFile);
+  if (solutionError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, solutionError.message)
+    };
+  }
+  const existingProject = solution.projects.find((project) => toPortableRelativePath(project.ProjectRelativePath) === projectRelativePath);
+  if (existingProject) {
+    return {
+      Status: "AlreadyRegistered",
+      Message: "Project already registered in solution.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      ProjectId: typeof existingProject.Id === "string" ? existingProject.Id : undefined,
+      Instructions: buildRegistrationSuccessInstructions(solutionDir)
+    };
+  }
+  const projectId = crypto.randomUUID();
+  solution.projects.push({
+    Type: normalizeProjectType(projectManifest.projectType),
+    ProjectRelativePath: projectRelativePath,
+    Id: projectId
+  });
+  solution.content.Projects = solution.projects;
+  const [writeError] = await catchError2(fs.writeFile(solutionFile, `${JSON.stringify(solution.content, null, 2)}
+`));
+  if (writeError) {
+    return {
+      Status: "Failed",
+      Message: "Project registration failed.",
+      Solution: solutionFile,
+      Project: projectRelativePath,
+      Instructions: buildRegistrationFailureInstructions(resolvedProjectDir, writeError.message)
+    };
+  }
+  return {
+    Status: "Registered",
+    Message: "Project registered in parent solution.",
+    Solution: solutionFile,
+    Project: projectRelativePath,
+    ProjectId: projectId,
+    Instructions: buildRegistrationSuccessInstructions(solutionDir)
+  };
+}
+async function findNearestParentUipxFile(fs, projectDir) {
+  let currentDir = fs.path.dirname(fs.path.resolve(projectDir));
+  while (true) {
+    const [readDirError, entries] = await catchError2(fs.readdir(currentDir));
+    if (readDirError) {
+      return {
+        status: "skipped",
+        registration: {
+          Status: "Failed",
+          Message: "Project registration failed.",
+          Instructions: buildRegistrationFailureInstructions(projectDir, `Could not inspect parent directory for a solution: ${currentDir}
+${readDirError.message}`)
+        }
+      };
+    }
+    const solutionFiles = entries.filter((entry) => entry.endsWith(".uipx"));
+    if (solutionFiles.length > 1) {
+      return {
+        status: "skipped",
+        registration: {
+          Status: "Skipped",
+          Message: "Project registration skipped.",
+          Instructions: `Found multiple .uipx files in ${currentDir}: ${solutionFiles.join(", ")}. Run 'uip solution projects add "${projectDir}" <solution.uipx>' to choose one.`
+        }
+      };
+    }
+    if (solutionFiles.length === 1) {
+      return {
+        status: "found",
+        solutionFile: fs.path.join(currentDir, solutionFiles[0])
+      };
+    }
+    const parentDir = fs.path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return { status: "notFound" };
+    }
+    currentDir = parentDir;
+  }
+}
+async function findProjectFile(fs, projectDir) {
+  const uiprojPath = fs.path.join(projectDir, "project.uiproj");
+  if (await fs.exists(uiprojPath)) {
+    return [
+      null,
+      {
+        filePath: uiprojPath,
+        fileName: "project.uiproj",
+        useProjectJson: false
+      }
+    ];
+  }
+  const jsonProjectPath = fs.path.join(projectDir, "project.json");
+  if (await fs.exists(jsonProjectPath)) {
+    return [
+      null,
+      {
+        filePath: jsonProjectPath,
+        fileName: "project.json",
+        useProjectJson: true
+      }
+    ];
+  }
+  return [
+    new Error(`No project file found in ${projectDir}. Expected project.uiproj or project.json.`),
+    null
+  ];
+}
+async function readProjectManifest(fs, filePath, useProjectJson) {
+  const [readError, rawContent] = await catchError2(fs.readFile(filePath, "utf-8"));
+  if (readError || !rawContent) {
+    return [readError ?? new Error(`Unable to read ${filePath}.`), null];
+  }
+  const [parseError, parsed] = catchError2(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in project file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!isRecord(parsed)) {
+    return [new Error(`Invalid project file: ${filePath}`), null];
+  }
+  const designOptions = parsed.designOptions;
+  const outputType = useProjectJson && isRecord(designOptions) ? readString(designOptions.outputType) : undefined;
+  const projectType = outputType ?? readString(parsed.ProjectType);
+  if (!projectType) {
+    return [new Error(`ProjectType not found in ${filePath}`), null];
+  }
+  return [
+    null,
+    {
+      projectType
+    }
+  ];
+}
+async function readSolutionManifest(fs, solutionFile) {
+  const [readError, rawContent] = await catchError2(fs.readFile(solutionFile, "utf-8"));
+  if (readError || !rawContent) {
+    return [
+      readError ?? new Error(`Unable to read solution file: ${solutionFile}`),
+      null
+    ];
+  }
+  const [parseError, parsed] = catchError2(() => JSON.parse(rawContent));
+  if (parseError) {
+    return [
+      new Error(`Invalid JSON in solution file: ${parseError.message}`),
+      null
+    ];
+  }
+  if (!isRecord(parsed)) {
+    return [
+      new Error(`Invalid solution file: ${solutionFile} must contain a JSON object.`),
+      null
+    ];
+  }
+  if (!Array.isArray(parsed.Projects)) {
+    return [
+      new Error(`Invalid solution file: ${solutionFile} must contain a Projects array.`),
+      null
+    ];
+  }
+  const projects = [];
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      return [
+        new Error(`Invalid solution file: Projects[${index}] must be an object.`),
+        null
+      ];
+    }
+    const projectRelativePath = readString(project.ProjectRelativePath);
+    if (!projectRelativePath) {
+      return [
+        new Error(`Invalid solution file: Projects[${index}] is missing ProjectRelativePath. Use 'uip solution projects add' to repair the manifest.`),
+        null
+      ];
+    }
+    projects.push({
+      ...project,
+      Type: readString(project.Type) ?? "",
+      ProjectRelativePath: projectRelativePath,
+      Id: readString(project.Id) ?? ""
+    });
+  }
+  return [null, { content: parsed, projects }];
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function buildRegistrationSuccessInstructions(solutionDir) {
+  return [
+    "The project is listed in the parent solution manifest.",
+    "Packing or uploading the solution will sync solution resources automatically.",
+    `To sync resources before packaging, run: uip solution resources refresh --solution-folder ${quoteForShell(solutionDir)}`
+  ].join(`
+`);
+}
+function buildRegistrationFailureInstructions(projectDir, details) {
+  return [
+    "Automatic solution registration could not complete.",
+    `Run 'uip solution projects add "${projectDir}" <solution.uipx>' after checking the project and solution files.`,
+    `Details: ${details}`
+  ].join(`
+`);
+}
+function buildStandaloneInstructions(projectDir) {
+  return [
+    "No parent solution was found by walking ancestor directories.",
+    "Studio Web upload, `flow debug`, and packaging require an enclosing solution.",
+    `To link this project to a solution, run 'uip solution init "<SolutionName>"' then 'uip solution projects add "${projectDir}" <SolutionName>.uipx'.`
+  ].join(`
+`);
+}
+function buildOptedOutInstructions(projectDir) {
+  return [
+    "Automatic solution registration was skipped because --skip-solution-registration was passed.",
+    `To register this project later, run 'uip solution projects add "${projectDir}" <SolutionName>.uipx' from within the solution.`
+  ].join(`
+`);
+}
+
+// ../solution-sdk/src/studio-web-compat.ts
+var API_PROJECT_TYPES = new Set(["api", "apiautomation"]);
+
+// ../solution-sdk/src/zip-utils.ts
+var import_ignore = __toESM(require_ignore(), 1);
+var DEFAULT_EXCLUDED_DIR_NAMES = new Set([
+  ".venv",
+  "node_modules",
+  "__pycache__",
+  ".git",
+  ".local",
+  ".flow-sdk",
+  ".flow-debug"
+]);
+// ../solution-sdk/src/project-debug-status.ts
+var SUCCEEDED = "creationsucceeded";
+var TERMINAL = new Set([SUCCEEDED, "creationfailed", "validationfailed"]);
+export {
+  tryRegisterProjectInParentSolution
+};
+
+//# debugId=90F2B2B756253CB864756E2164756E21