@uipath/solution-sdk 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/resources/index.js

@@ -18,12 +18,12 @@ import {
   logger,
   normalizeProjectType,
   toPortableRelativePath
-} from "../index-4zqv4bn2.js";
+} from "../index-bdpp6dsk.js";
 import {
   getAuthContext,
   getLoginStatusAsync,
   getSolutionAuthContext
-} from "../index-y8tgscfm.js";
+} from "../index-6gp5j7j5.js";
 import {
   getFileSystem
 } from "../index-g0hcxnae.js";
@@ -3314,7 +3314,6 @@ class InMemoryCacheProvider {
     this._defaultTtlMs = defaultTtlMs;
   }
 }
-
 // ../../node_modules/@uipath/resource-builder-sdk/dist/providers/ip-range-bypass-secret-provider.js
 class NullIpRangeBypassSecretProvider {
   async getIpRangeBypassSecretAsync(_cancellationToken) {
@@ -3335,6 +3334,183 @@ class NullSecretsProvider {
   }
 }
 
+// ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/timeout-exception.js
+class TimeoutException extends Error {
+  constructor(message, timeoutMs) {
+    super(message);
+    this.name = "TimeoutException";
+    this.timeoutMs = timeoutMs;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, TimeoutException);
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/helpers/timeout.js
+function createTimeoutSignal(timeoutMs, description, linkedSignal) {
+  const controller = new AbortController;
+  let timeoutId;
+  const dispose = () => {
+    if (timeoutId !== undefined) {
+      clearTimeout(timeoutId);
+      timeoutId = undefined;
+    }
+    linkedSignal?.removeEventListener("abort", onLinkedAbort);
+  };
+  const onLinkedAbort = () => {
+    dispose();
+    controller.abort(linkedSignal?.reason);
+  };
+  if (linkedSignal?.aborted) {
+    controller.abort(linkedSignal.reason);
+    return {
+      signal: controller.signal,
+      dispose
+    };
+  }
+  timeoutId = setTimeout(() => {
+    dispose();
+    controller.abort(new TimeoutException(`${description} timed out after ${timeoutMs}ms`, timeoutMs));
+  }, timeoutMs);
+  linkedSignal?.addEventListener("abort", onLinkedAbort, {
+    once: true
+  });
+  return {
+    signal: controller.signal,
+    dispose
+  };
+}
+var MAX_TIMEOUT_MS = 2147483647;
+function isValidTimeoutMs(value) {
+  return typeof value == "number" && Number.isFinite(value) && value > 0 && value <= MAX_TIMEOUT_MS;
+}
+function readTimeoutOverrideMs(storageKey) {
+  try {
+    if ("u" < typeof localStorage)
+      return;
+    const raw = localStorage.getItem(storageKey);
+    if (raw === null || raw.trim() === "")
+      return;
+    const parsed = Number(raw);
+    return isValidTimeoutMs(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/operation-cancelled-exception.js
+class OperationCancelledException extends Error {
+  constructor(message, operationName) {
+    super(message ?? "The operation was cancelled");
+    this.name = "OperationCancelledException";
+    this.operationName = operationName;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, OperationCancelledException);
+  }
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/providers/timeout-file-storage-provider.js
+class TimeoutFileStorageProvider2 {
+  fileExistsAsync(path, cancellationToken) {
+    return this.guard(`fileExists(${path})`, cancellationToken, (signal) => this.inner.fileExistsAsync(path, signal));
+  }
+  async openFileAsync(path, cancellationToken) {
+    const stream = await this.guard(`openFile(${path})`, cancellationToken, (signal) => this.inner.openFileAsync(path, signal));
+    return this.bindReadsToTimeout(stream, `read(${path})`, cancellationToken);
+  }
+  bindReadsToTimeout(stream, description, cancellationToken) {
+    const reader = stream.getReader();
+    return new ReadableStream({
+      pull: async (controller) => {
+        let result;
+        try {
+          result = await this.guard(description, cancellationToken, () => reader.read());
+        } catch (error) {
+          reader.cancel(error).catch(() => {});
+          throw error;
+        }
+        if (result.done)
+          controller.close();
+        else
+          controller.enqueue(result.value);
+      },
+      cancel: (reason) => reader.cancel(reason)
+    });
+  }
+  readFileToEndAsync(path, cancellationToken) {
+    return this.guard(`readFileToEnd(${path})`, cancellationToken, (signal) => this.inner.readFileToEndAsync(path, signal));
+  }
+  writeFileAsync(path, content, cancellationToken) {
+    return this.guard(`writeFile(${path})`, cancellationToken, (signal) => this.inner.writeFileAsync(path, content, signal));
+  }
+  deleteFileAsync(path, cancellationToken) {
+    return this.guard(`deleteFile(${path})`, cancellationToken, (signal) => this.inner.deleteFileAsync(path, signal));
+  }
+  getFilesAsync(path, searchPattern, cancellationToken) {
+    return this.guard(`getFiles(${path ?? ""}, ${searchPattern ?? ""})`, cancellationToken, (signal) => this.inner.getFilesAsync(path, searchPattern, signal));
+  }
+  async guard(description, cancellationToken, operation) {
+    const timeout = createTimeoutSignal(this.timeoutMs, `File storage operation ${description}`, cancellationToken);
+    try {
+      return await Promise.race([
+        operation(timeout.signal),
+        rejectOnAbort(timeout.signal)
+      ]);
+    } catch (error) {
+      if (cancellationToken?.aborted)
+        throw cancellationToken.reason instanceof OperationCancelledException ? cancellationToken.reason : new OperationCancelledException(undefined, description);
+      if (timeout.signal.aborted && timeout.signal.reason instanceof TimeoutException)
+        throw timeout.signal.reason;
+      throw error;
+    } finally {
+      timeout.dispose();
+    }
+  }
+  constructor(inner, timeoutMs) {
+    this.inner = inner;
+    this.timeoutMs = timeoutMs;
+  }
+}
+function rejectOnAbort(signal) {
+  return new Promise((_, reject) => {
+    if (signal.aborted)
+      return void reject(signal.reason);
+    signal.addEventListener("abort", () => reject(signal.reason), {
+      once: true
+    });
+  });
+}
+function withFileOperationTimeout2(provider, timeoutMs) {
+  if (!isValidTimeoutMs(timeoutMs) || provider instanceof TimeoutFileStorageProvider2)
+    return provider;
+  return new TimeoutFileStorageProvider2(provider, timeoutMs);
+}
+
+// ../../node_modules/@uipath/resource-builder-sdk/dist/solution/solution-context-options.js
+var DEFAULT_SOLUTION_CONTEXT_OPTIONS = {
+  lockTimeoutMs: 30000,
+  fileOperationTimeoutMs: 30000
+};
+var SOLUTION_CONTEXT_TIMEOUT_STORAGE_KEY = "SOL_RB_SOLUTION_CONTEXT_TIMEOUT_MS";
+var FILE_OPERATION_TIMEOUT_STORAGE_KEY = "SOL_RB_FILE_OPERATION_TIMEOUT_MS";
+function resolveTimeoutMs(storageKey, configured, fallback) {
+  const override = readTimeoutOverrideMs(storageKey);
+  if (override !== undefined)
+    return override;
+  return isValidTimeoutMs(configured) ? configured : fallback;
+}
+function resolveLockTimeoutMs(options) {
+  return resolveTimeoutMs(SOLUTION_CONTEXT_TIMEOUT_STORAGE_KEY, options?.lockTimeoutMs, DEFAULT_SOLUTION_CONTEXT_OPTIONS.lockTimeoutMs);
+}
+function resolveFileOperationTimeoutMs(options) {
+  return resolveTimeoutMs(FILE_OPERATION_TIMEOUT_STORAGE_KEY, options?.fileOperationTimeoutMs, DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs);
+}
+function mergeSolutionContextOptions(options) {
+  return {
+    lockTimeoutMs: isValidTimeoutMs(options?.lockTimeoutMs) ? options.lockTimeoutMs : DEFAULT_SOLUTION_CONTEXT_OPTIONS.lockTimeoutMs,
+    fileOperationTimeoutMs: isValidTimeoutMs(options?.fileOperationTimeoutMs) ? options.fileOperationTimeoutMs : DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs
+  };
+}
+
 // ../../node_modules/@uipath/resource-builder-sdk/dist/solution/models.js
 var SolutionConstants = {
   RESOURCE_FILES_FOLDER_NAME: "resources",
@@ -3469,17 +3645,6 @@ class DisconnectedException extends Error {
   }
 }
 
-// ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/operation-cancelled-exception.js
-class OperationCancelledException extends Error {
-  constructor(message, operationName) {
-    super(message ?? "The operation was cancelled");
-    this.name = "OperationCancelledException";
-    this.operationName = operationName;
-    if (Error.captureStackTrace)
-      Error.captureStackTrace(this, OperationCancelledException);
-  }
-}
-
 // ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/invalid-operation-exception.js
 class InvalidOperationException extends Error {
   constructor(message) {
@@ -4144,10 +4309,14 @@ class MultiFileSolutionDefinitionProvider {
       this._jsonSerializer = this.jsonSerializerFactory.getByName(JsonSerializerNames.CamelCaseIndented);
     return this._jsonSerializer;
   }
+  async getFileStorageProviderAsync(context, cancellationToken) {
+    const provider = await this.fileStorageProviderFactory.getProviderAsync(context, cancellationToken);
+    return withFileOperationTimeout2(provider, resolveFileOperationTimeoutMs(this.options));
+  }
   async readAsync(context, cancellationToken) {
     this.logger.info("Reading multi-file solution definition for solution %s", context.path);
     const solutionKey = this.getSolutionKey(context);
-    const fileStorageProvider = await this.fileStorageProviderFactory.getProviderAsync(context, cancellationToken);
+    const fileStorageProvider = await this.getFileStorageProviderAsync(context, cancellationToken);
     const resources = [];
     const solutionFiles = [];
     let hashes;
@@ -4223,6 +4392,12 @@ class MultiFileSolutionDefinitionProvider {
           invalidFiles.push(resourceFile);
         }
       } catch (ex) {
+        if (ex instanceof OperationCancelledException || cancellationToken?.aborted) {
+          this.logger.warn("Operation cancelled while reading file %s for solution %s", resourceFile, context.path);
+          throw ex instanceof OperationCancelledException ? ex : new OperationCancelledException;
+        }
+        if (ex instanceof TimeoutException)
+          throw new TimeoutException(`Reading resource file ${resourceFile} for solution ${context.path} timed out: ${ex.message}`, ex.timeoutMs);
         if (isFileNotFoundError(ex)) {
           this.logger.warn("Resource file listed but missing in storage for solution %s: %s", resourceFile, context.path);
           missingFiles.push(resourceFile);
@@ -4275,7 +4450,7 @@ class MultiFileSolutionDefinitionProvider {
   async writeAsync(context, solution, cancellationToken) {
     if (context.isReadOnly)
       return;
-    const fileStorageProvider = await this.fileStorageProviderFactory.getProviderAsync(context, cancellationToken);
+    const fileStorageProvider = await this.getFileStorageProviderAsync(context, cancellationToken);
     const existingHashes = this.getHashes(context);
     const existingPaths = this.getPaths(context);
     const existingTree = this.getTree(context);
@@ -4350,7 +4525,7 @@ class MultiFileSolutionDefinitionProvider {
   async deleteFilesAsync(context, filesToDelete, cancellationToken) {
     if (!filesToDelete || filesToDelete.length === 0 || context.isReadOnly)
       return;
-    const fileStorageProvider = await this.fileStorageProviderFactory.getProviderAsync(context, cancellationToken);
+    const fileStorageProvider = await this.getFileStorageProviderAsync(context, cancellationToken);
     for (const file of filesToDelete)
       try {
         const outputPath = this.joinPath("resourceFiles", file.name);
@@ -4547,7 +4722,8 @@ class MultiFileSolutionDefinitionProvider {
     const hex = Math.abs(hash).toString(16).padStart(8, "0");
     return `${hex.slice(0, 8)}-${hex.slice(0, 4)}-4${hex.slice(1, 4)}-8${hex.slice(1, 4)}-${hex.slice(0, 12).padEnd(12, "0")}`;
   }
-  constructor(fileStorageProviderFactory, jsonSerializerFactory, loggerFactory) {
+  constructor(fileStorageProviderFactory, jsonSerializerFactory, loggerFactory, options) {
+    this.options = options;
     this._caseInsensitiveSerializer = null;
     this._jsonSerializer = null;
     this.fileStorageProviderFactory = fileStorageProviderFactory;
@@ -4560,12 +4736,13 @@ MultiFileSolutionDefinitionProvider.INVALID_FILE_NAME_CHARS = /[<>:"/\\|?*\x00-\
 // ../../node_modules/@uipath/resource-builder-sdk/dist/solution/multi-file-solution-definition-factory.js
 class MultiFileSolutionDefinitionFactory {
   async getProviderAsync(cancellationToken) {
-    return new MultiFileSolutionDefinitionProvider(this.fileStorageProviderFactory, this.jsonSerializerFactory, this.loggerFactory);
+    return new MultiFileSolutionDefinitionProvider(this.fileStorageProviderFactory, this.jsonSerializerFactory, this.loggerFactory, this.options);
   }
-  constructor(fileStorageProviderFactory, jsonSerializerFactory, loggerFactory) {
+  constructor(fileStorageProviderFactory, jsonSerializerFactory, loggerFactory, options) {
     this.fileStorageProviderFactory = fileStorageProviderFactory;
     this.jsonSerializerFactory = jsonSerializerFactory;
     this.loggerFactory = loggerFactory;
+    this.options = options;
     this.logger = loggerFactory.create("MultiFileSolutionDefinitionFactory");
   }
 }
@@ -4573,7 +4750,7 @@ class MultiFileSolutionDefinitionFactory {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/embedded-files-default.js
 async function createDefaultEmbeddedFileReaderAsync() {
   const [{ EmbeddedFileReader }, { JsonSerializerFactory: JsonSerializerFactory2 }] = await Promise.all([
-    import("../embedded-file-reader-xxqe8vs8.js"),
+    import("../embedded-file-reader-rf2g1kfj.js"),
     import("../index-dqa169gp.js")
   ]);
   return new EmbeddedFileReader(new JsonSerializerFactory2);
@@ -4606,7 +4783,8 @@ var ServiceTokens = {
   JsonSerializerFactory: "IJsonSerializerFactory",
   SerializerProxy: "ISerializerProxy",
   StreamSerializer: "IStreamSerializer",
-  HttpReaderOptions: "HttpReaderOptions"
+  HttpReaderOptions: "HttpReaderOptions",
+  SolutionContextOptions: "SolutionContextOptions"
 };
 var Tokens = {
   IMediator: "IMediator",
@@ -5172,7 +5350,8 @@ class BindingOverwritesHandler {
           [BindingsKnownKeys.FolderKeyPropertyName]: resourceOverwrite.folderKey ?? ""
         };
       else {
-        const folderPath = bindingResource.isArtefactResource ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
+        const isBusinessRule = bindingResource.binding.resourceType === models_BindingsResourceType.BusinessRule;
+        const folderPath = bindingResource.isArtefactResource && !isBusinessRule ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
         overwrite = {
           [BindingsKnownKeys.FolderPathPropertyName]: folderPath,
           [BindingsKnownKeys.NamePropertyName]: resourceOverwrite.resourceName
@@ -5330,42 +5509,6 @@ class AsyncSemaphore {
     this._permits = permits;
   }
 }
-function createTimeoutSignal(timeoutMs, linkedSignal) {
-  const controller = new AbortController;
-  const timeoutId = setTimeout(() => {
-    controller.abort(new Error(`Operation timed out after ${timeoutMs}ms`));
-  }, timeoutMs);
-  if (linkedSignal)
-    if (linkedSignal.aborted) {
-      clearTimeout(timeoutId);
-      controller.abort(linkedSignal.reason);
-    } else
-      linkedSignal.addEventListener("abort", () => {
-        clearTimeout(timeoutId);
-        controller.abort(linkedSignal.reason);
-      }, {
-        signal: controller.signal
-      });
-  controller.signal.addEventListener("abort", () => {
-    clearTimeout(timeoutId);
-  });
-  return controller.signal;
-}
-var DEFAULT_TIMEOUT_MS = 5000;
-var SOLUTION_CONTEXT_TIMEOUT_STORAGE_KEY = "SOL_RB_SOLUTION_CONTEXT_TIMEOUT_MS";
-function getLockTimeoutMs() {
-  try {
-    if ("u" < typeof localStorage)
-      return DEFAULT_TIMEOUT_MS;
-    const raw = localStorage.getItem(SOLUTION_CONTEXT_TIMEOUT_STORAGE_KEY);
-    if (raw === null || raw.trim() === "")
-      return DEFAULT_TIMEOUT_MS;
-    const parsed = Number(raw);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_TIMEOUT_MS;
-  } catch {
-    return DEFAULT_TIMEOUT_MS;
-  }
-}
 
 class SolutionContext {
   get isLoaded() {
@@ -5493,30 +5636,42 @@ class SolutionContext {
       throw new FileDependencyNotFoundException(missingFileDependencies);
   }
   async doWithLockAsync(doWork, cancellationToken) {
-    const timeoutSignal = createTimeoutSignal(getLockTimeoutMs(), cancellationToken);
-    await this._semaphore.acquire(timeoutSignal);
+    const lockTimeoutMs = resolveLockTimeoutMs(this._options);
+    const lockTimeout = createTimeoutSignal(lockTimeoutMs, `Waiting for the lock on solution ${this.path}`, cancellationToken);
     try {
-      return await doWork(timeoutSignal);
+      await this._semaphore.acquire(lockTimeout.signal);
+    } catch (error) {
+      if (!cancellationToken?.aborted && lockTimeout.signal.reason instanceof TimeoutException)
+        throw lockTimeout.signal.reason;
+      throw error;
+    } finally {
+      lockTimeout.dispose();
+    }
+    try {
+      return await doWork(cancellationToken);
     } finally {
       this._semaphore.release();
     }
   }
-  constructor(path, isReadOnlyOrProvider, definitionProvider) {
+  constructor(path, isReadOnlyOrProvider, definitionProviderOrOptions, options) {
     this._definition = null;
     this._semaphore = new AsyncSemaphore(1);
     this._items = {};
     this._persistChanges = true;
     ArgumentException.throwIfNullOrEmpty(path, "path");
     if (typeof isReadOnlyOrProvider == "boolean") {
+      const definitionProvider = definitionProviderOrOptions;
       ArgumentException.throwIfNull(definitionProvider, "definitionProvider");
       this.path = path;
       this.isReadOnly = isReadOnlyOrProvider;
       this._definitionProvider = definitionProvider;
+      this._options = options;
     } else {
       ArgumentException.throwIfNull(isReadOnlyOrProvider, "definitionProvider");
       this.path = path;
       this.isReadOnly = false;
       this._definitionProvider = isReadOnlyOrProvider;
+      this._options = definitionProviderOrOptions;
     }
   }
 }
@@ -5527,7 +5682,8 @@ class SolutionContextFactory {
     ArgumentException.throwIfNullOrEmpty(path, "path");
     const solutionDefinitionFactory = this._container.resolve(Tokens.ISolutionDefinitionFactory);
     const solutionDefinitionProvider = await solutionDefinitionFactory.getProviderAsync(cancellationToken);
-    return new SolutionContext(path, isReadOnly, solutionDefinitionProvider);
+    const options = this._container.isRegistered(ServiceTokens.SolutionContextOptions, true) ? this._container.resolve(ServiceTokens.SolutionContextOptions) : undefined;
+    return new SolutionContext(path, isReadOnly, solutionDefinitionProvider, options);
   }
   constructor(_container) {
     this._container = _container;
@@ -6549,7 +6705,13 @@ var solutionsSubtypesMap = {
   Api: "api",
   Function: "function",
   McpServer: "mcpserver",
-  BusinessRule: "businessRule"
+  BusinessRule: "businessRule",
+  Native: "native",
+  Federated: "federated",
+  Case: "case",
+  CaseMain: "caseMain",
+  CaseComment: "caseComment",
+  CaseDocument: "caseDocument"
 };
 function mapResourceToSolutionSubtype(entitySubtype) {
   if (!entitySubtype)
@@ -14980,9 +15142,9 @@ class UnconfiguredEmbeddedFileReader {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/container.js
-function createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, embeddedFileReader) {
+function createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, embeddedFileReader, solutionContextOptions) {
   const childContainer = import_tsyringe6.container.createChildContainer();
-  registerProviders(childContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory);
+  registerProviders(childContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions);
   registerServices(childContainer, embeddedFileReader);
   registerHandlers(childContainer);
   childContainer.register(ServiceTokens.Mediator, {
@@ -15006,7 +15168,7 @@ function registerProvider(diContainer, token, provider) {
       break;
   }
 }
-function registerProviders(diContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory) {
+function registerProviders(diContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions) {
   registerProvider(diContainer, ServiceTokens.AccessProvider, accessProvider);
   registerProvider(diContainer, ServiceTokens.CacheProvider, cacheProvider);
   registerProvider(diContainer, ServiceTokens.SecretsProvider, secretsProvider);
@@ -15021,6 +15183,7 @@ function registerProviders(diContainer, accessProvider, cacheProvider, secretsPr
     ...httpReaderOptions
   };
   diContainer.registerInstance(ServiceTokens.HttpReaderOptions, mergedOptions);
+  diContainer.registerInstance(ServiceTokens.SolutionContextOptions, mergeSolutionContextOptions(solutionContextOptions));
 }
 function registerServices(diContainer, embeddedFileReader) {
   diContainer.register(ServiceTokens.AutomationSolutionsClientProxy, {
@@ -15755,6 +15918,10 @@ class ResourceBuilderConfiguration {
     this._httpReaderOptions = options;
     return this;
   }
+  addSolutionContextOptions(options) {
+    this._solutionContextOptions = options;
+    return this;
+  }
   addLoggerFactory(factoryProvider, lifetime = service_tokens_ServiceLifetime.Singleton) {
     this._loggerFactoryProvider = factoryProvider;
     this._loggerFactoryLifetime = lifetime;
@@ -15819,7 +15986,7 @@ class ResourceBuilderConfiguration {
       };
     } else if (!solutionDefinitionProvider && fileStorageProviderFactory)
       solutionDefinitionFactory = {
-        instance: new MultiFileSolutionDefinitionFactory(fileStorageProviderFactory.instance, new JsonSerializerFactory, loggerFactoryInstance),
+        instance: new MultiFileSolutionDefinitionFactory(fileStorageProviderFactory.instance, new JsonSerializerFactory, loggerFactoryInstance, this._solutionContextOptions),
         lifetime: service_tokens_ServiceLifetime.Scoped
       };
     const artifactResourceSpecEnhancerInstance = this._artifactResourceSpecEnhancerProvider ? await this.resolveGenericProvider(this._artifactResourceSpecEnhancerProvider) : new DefaultArtifactResourceSpecEnhancer;
@@ -15828,7 +15995,7 @@ class ResourceBuilderConfiguration {
       lifetime: this._artifactResourceSpecEnhancerLifetime
     };
     const embeddedFileReader = await createDefaultEmbeddedFileReaderAsync();
-    const container3 = createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, this._httpReaderOptions, loggerFactory, embeddedFileReader);
+    const container3 = createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, this._httpReaderOptions, loggerFactory, embeddedFileReader, this._solutionContextOptions);
     return new ResourceBuilderServices(container3);
   }
   async buildServices() {
@@ -15849,7 +16016,6 @@ class ResourceBuilderConfiguration {
 function createResourceBuilderConfiguration() {
   return new ResourceBuilderConfiguration;
 }
-
 // src/resources/services/solution-manifest.ts
 async function assertSolutionManifest(dir) {
   const fs = getFileSystem();
@@ -16205,7 +16371,7 @@ class CliResourceBuilderLoggerFactory {
 }
 
 // ../orchestrator-sdk/generated/src/runtime.ts
-var BASE_PATH = "https://alpha.uipath.com/uipattycyrhx/abizon_1/orchestrator_".replace(/\/+$/, "");
+var BASE_PATH = "https://alpha.uipath.com/Ada/byoa/orchestrator_".replace(/\/+$/, "");
 
 class Configuration {
   configuration;
@@ -16458,7 +16624,7 @@ var package_default = {
   name: "@uipath/orchestrator-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.203.0",
+  version: "1.204.0",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -18010,6 +18176,12 @@ async function createApiClient(ApiClass, options) {
   const config = await createOrchestratorConfig(options);
   return new ApiClass(config);
 }
+// ../orchestrator-sdk/src/knowledge-bundles.ts
+var KB_INLINE_LIMITS = {
+  maxObjectBytes: 16 * 1024 * 1024,
+  maxBodyBytes: 100 * 1024 * 1024,
+  maxParts: 1e4
+};
 // src/resources/providers/solution-access-provider.ts
 var ORG_SCOPED_SERVICES = new Set(["apps", "authz"]);
 
@@ -18324,6 +18496,81 @@ function hasAnyTemplateRow(projectType) {
     return key === wanted || key.startsWith(`${wanted}_`);
   });
 }
+// src/resources/services/remote-resources.ts
+function getRemoteResourceClients(services2) {
+  return {
+    catalog: services2.container.resolve(Tokens.IResourceCatalogClientProxy),
+    importer: services2.container.resolve(Tokens.IImportResourceHelper)
+  };
+}
+async function findCatalogEntityAsync(catalog, query, match) {
+  let pageCursor;
+  do {
+    const page = await catalog.searchFolderEntities({
+      ...query,
+      pageSize: 100,
+      pageCursor
+    });
+    const found = (page.items ?? []).find(match);
+    if (found) {
+      return found;
+    }
+    pageCursor = page.nextPage ?? undefined;
+  } while (pageCursor);
+  return;
+}
+function toResourceReference(entity) {
+  return toCatalogReference({
+    kind: entity.entityType ?? "",
+    type: entity.entitySubType ?? undefined,
+    key: entity.entityKey ?? "",
+    name: entity.entityName ?? undefined,
+    folderPath: entity.fullyQualifiedName ?? undefined,
+    folderKey: entity.folderKey ?? undefined
+  });
+}
+function toCatalogReference(reference) {
+  const { folderPath, folderKey, ...rest } = reference;
+  return {
+    ...rest,
+    folder: folderPath ? { fullyQualifiedName: folderPath, folderKey } : undefined
+  };
+}
+async function exportResourceDefinitionAsync(importer, reference) {
+  const payload = await importer.exportResourceAsync(reference);
+  return payload.resourceDefinitions.find((d) => d.key === reference.key);
+}
+function readSpecProperty(spec, name) {
+  if (!spec) {
+    return;
+  }
+  if (spec[name] !== undefined) {
+    return spec[name];
+  }
+  const lower = name.toLowerCase();
+  const key = Object.keys(spec).find((k) => k.toLowerCase() === lower);
+  return key === undefined ? undefined : spec[key];
+}
+function readSpecEntryPoints(spec) {
+  const entryPoints = parseJsonString(readSpecProperty(spec, "entryPoints"));
+  if (!Array.isArray(entryPoints) || !entryPoints.every((entry) => entry !== null && typeof entry === "object")) {
+    return;
+  }
+  return entryPoints.map((entry) => ({
+    UniqueId: String(readSpecProperty(entry, "uniqueId") ?? ""),
+    Path: String(readSpecProperty(entry, "path") ?? ""),
+    DisplayName: String(readSpecProperty(entry, "displayName") ?? ""),
+    InputArguments: readSpecProperty(entry, "inputArguments"),
+    OutputArguments: readSpecProperty(entry, "outputArguments")
+  }));
+}
+function parseJsonString(raw) {
+  if (typeof raw !== "string") {
+    return raw;
+  }
+  const [error, parsed] = catchError(() => JSON.parse(raw));
+  return error ? undefined : parsed;
+}
 // src/resources/services/resource-casing.ts
 var RESOURCE_FILES_FOLDER_NAME = "resources";
 function lowerFirstChar(value) {
@@ -18481,7 +18728,52 @@ function parseResourceHeader(content) {
     return null;
   }
 }
+// src/resources/services/resource-name.ts
+var MAX_RESOURCE_NAME_LENGTH = 256;
+var UNSAFE_NAME_CHARS = /[\\/:*?"<>|]/;
+function hasControlChar(value) {
+  for (let i = 0;i < value.length; i++) {
+    if (value.charCodeAt(i) < 32)
+      return true;
+  }
+  return false;
+}
+function validateResourceName(name, options = {}) {
+  const optionName = options.optionName ?? "--name";
+  if (name.trim() === "") {
+    return {
+      ok: false,
+      message: `${optionName} must not be blank`,
+      instructions: "Pass a non-empty resource name."
+    };
+  }
+  if (name.length > MAX_RESOURCE_NAME_LENGTH) {
+    return {
+      ok: false,
+      message: `${optionName} exceeds the ${MAX_RESOURCE_NAME_LENGTH}-character limit (got ${name.length})`,
+      instructions: "Shorten the resource name. Orchestrator name limits are kind-specific (queues cap at 50, assets at 256)."
+    };
+  }
+  if (UNSAFE_NAME_CHARS.test(name) || hasControlChar(name)) {
+    return {
+      ok: false,
+      message: `${optionName} contains unsafe characters`,
+      instructions: 'Resource names cannot contain path separators (/, \\), control characters, or any of: : * ? " < > |'
+    };
+  }
+  return { ok: true };
+}
+function assertValidResourceName(name, options = {}) {
+  const result = validateResourceName(name, options);
+  if (!result.ok) {
+    throw new Error(`${result.message}. ${result.instructions}`);
+  }
+}
 // src/resources/services/sync-resources-from-bindings.ts
+var TYPE_IS_IDENTITY_REPLACE_OPTIONS = new Set([
+  "SameType",
+  "SameNameAndType"
+]);
 var BINDINGS_JSON_FALLBACK_TYPES = new Set(["agent", "function"]);
 function placeholderForType(type) {
   switch ((type ?? "string").toLowerCase()) {
@@ -18511,7 +18803,7 @@ async function buildKindResolver(metadataReader) {
     byKind.set(key, list);
   }
   return async (kind, type) => {
-    const cacheKey = `${kind}|${type ?? ""}`.toLowerCase();
+    const cacheKey = (type === undefined ? kind : `${kind}|${type}`).toLowerCase();
     if (cache.has(cacheKey))
       return cache.get(cacheKey);
     const list = byKind.get(kind.toLowerCase());
@@ -18519,7 +18811,9 @@ async function buildKindResolver(metadataReader) {
       cache.set(cacheKey, undefined);
       return;
     }
-    const entry = type ? list.find((r) => (r.type ?? "").toLowerCase() === type.toLowerCase()) ?? list[0] : list[0];
+    const subtypes = list.flatMap((r) => r.type ? [r.type] : []);
+    const matched = type === undefined ? undefined : findSubtypeEntry(list, type);
+    const entry = matched ?? list[0];
     const version = entry.versions?.[0];
     const requiredDefaults = [];
     for (const prop of version?.spec ?? []) {
@@ -18538,16 +18832,35 @@ async function buildKindResolver(metadataReader) {
         }
       }
     }
+    const takesFreeFormType = type !== undefined && type.trim() !== "" && subtypes.length === 0 && TYPE_IS_IDENTITY_REPLACE_OPTIONS.has(String(version?.replaceOption));
     const resolved = {
       type: entry.type,
       virtualizable: version?.supportsInLineCreation ?? false,
       requiredDefaults,
-      specProperties
+      specProperties,
+      subtypes,
+      typeMatched: type === undefined || matched !== undefined || takesFreeFormType
     };
     cache.set(cacheKey, resolved);
     return resolved;
   };
 }
+function formatResourceSubtypes(subtypes) {
+  return subtypes.map((subtype) => {
+    const alias = mapSolutionToResourceSubtype(subtype);
+    return alias && alias.toLowerCase() !== subtype.toLowerCase() ? `${subtype} (${alias})` : subtype;
+  }).join(", ");
+}
+function sameResourceSubtype(a, b) {
+  if (a === undefined || b === undefined)
+    return false;
+  if (a.toLowerCase() === b.toLowerCase())
+    return true;
+  return mapSolutionToResourceSubtype(a)?.toLowerCase() === mapSolutionToResourceSubtype(b)?.toLowerCase();
+}
+function findSubtypeEntry(list, type) {
+  return list.find((r) => !!r.type && sameResourceSubtype(r.type, type));
+}
 function resolveBindingResourceIdentity(binding) {
   switch (binding.resourceType) {
     case models_BindingsResourceType.TimeTrigger:
@@ -18860,14 +19173,18 @@ async function findResourceByKeyInRcs(builder, kind, expectedKey, folderPath, pr
   return;
 }
 async function searchRcsResources(builder, kind, name) {
+  const [searchError, matches] = await catchError(searchRcsResourcesStrict(builder, kind, name));
+  if (searchError) {
+    logger.warn(`Failed to search ${kind} resources in RCS: ${searchError.message}`);
+    return [];
+  }
+  return matches;
+}
+async function searchRcsResourcesStrict(builder, kind, name) {
   let pageCursor;
   const allMatches = [];
   do {
-    const [searchError, result] = await catchError(builder.searchResourcesAsync(kind, undefined, name, pageCursor, 50, undefined, false));
-    if (searchError) {
-      logger.warn(`Failed to search ${kind} resources in RCS: ${searchError.message}`);
-      return [];
-    }
+    const result = await builder.searchResourcesAsync(kind, undefined, name, pageCursor, 50, undefined, false);
     for (const folderResources of result.availableResources) {
       const matches = folderResources.resources.filter((r) => r.name.toLowerCase() === name.toLowerCase());
       for (const match of matches) {
@@ -18921,7 +19238,13 @@ async function resolveResourceKindMetadata(services2, kind, type) {
 }
 async function createLocalResource(params) {
   const { builder, services: services2, kind, type, name } = params;
+  if (type !== undefined && type.trim() === "") {
+    throw new Error(`Type for kind ${kind} is empty.`);
+  }
   const metadata = await resolveResourceKindMetadata(services2, kind, type);
+  if (type !== undefined && metadata && !metadata.typeMatched) {
+    throw new Error(metadata.subtypes.length > 0 ? `Unknown type "${type}" for kind ${kind}. Use one of: ${formatResourceSubtypes(metadata.subtypes)}` : `Kind ${kind} has no subtypes, so type "${type}" does not apply.`);
+  }
   const minted = await mintVirtualResource(builder, kind, metadata?.type ?? type, name, metadata);
   if (!minted?.resource)
     return;
@@ -19346,21 +19669,27 @@ function sortKeysDeep(value) {
 }
 export {
   EntryPointSpecEnhancer,
+  MAX_RESOURCE_NAME_LENGTH,
   ProjectManifestError,
   addProjectArtifactsToSolutionAsync,
   applyEntryPointEnhancementAsync,
   assertSolutionManifest,
+  assertValidResourceName,
   computeEntryPointSpec,
   createLocalResource,
   createProjectInSolutionBuilder,
   createResourceBuilderServices,
   createResourceKindMetadataResolver,
+  exportResourceDefinitionAsync,
+  findCatalogEntityAsync,
   findMatchingLocalResource,
   findMatchingMemberResource,
   findMemberCloneResources,
   findProjectFile,
   findResourceByKeyInRcs,
   findResourceInRcs,
+  formatResourceSubtypes,
+  getRemoteResourceClients,
   hasAnyTemplateRow,
   hasBareTemplateRow,
   isMissingProjectTypeError,
@@ -19371,6 +19700,8 @@ export {
   readProjectFile,
   readSolutionFile,
   readSolutionManifest,
+  readSpecEntryPoints,
+  readSpecProperty,
   readUipxProjects,
   resolveProjectDirFromManifest,
   resolveResourceKindMetadata,
@@ -19378,12 +19709,17 @@ export {
   resourceRefreshAsync,
   resourceRemoteSyncAsync,
   restoreSolutionFile,
+  sameResourceSubtype,
   saveCasingNormalized,
   searchRcsResources,
+  searchRcsResourcesStrict,
   syncAndLog,
   syncResourcesFromBindings,
+  toCatalogReference,
+  toResourceReference,
   uniqueNameForResource,
+  validateResourceName,
   writeSolutionFile
 };
 
-//# debugId=A05FBBF114C0206364756E2164756E21
+//# debugId=67B9891A0091029064756E2164756E21