@uipath/solution-tool 1.204.0-preview.261 → 1.204.0-preview.264

package/dist/{packager-tool-yrz4mwfn.js → packager-tool-t21haejj.js}

@@ -2566,6 +2566,19 @@ class NullSecretsProvider {
   }
 }
 
+// ../../node_modules/@uipath/resource-builder-sdk/dist/providers/feature-flag-provider.js
+class NullFeatureFlagProvider {
+  getBool(_featureFlagName, defaultValue) {
+    return defaultValue ?? false;
+  }
+  getInt(_featureFlagName, defaultValue) {
+    return defaultValue ?? 0;
+  }
+  getString(_featureFlagName, defaultValue) {
+    return defaultValue ?? "";
+  }
+}
+
 // ../../node_modules/@uipath/resource-builder-sdk/dist/exceptions/timeout-exception.js
 class TimeoutException extends Error {
   constructor(message, timeoutMs) {
@@ -2720,10 +2733,12 @@ function withFileOperationTimeout2(provider, timeoutMs) {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/solution/solution-context-options.js
 var DEFAULT_SOLUTION_CONTEXT_OPTIONS = {
   lockTimeoutMs: 30000,
-  fileOperationTimeoutMs: 30000
+  fileOperationTimeoutMs: 30000,
+  maxDegreeOfParallelism: 1
 };
 var SOLUTION_CONTEXT_TIMEOUT_STORAGE_KEY = "SOL_RB_SOLUTION_CONTEXT_TIMEOUT_MS";
 var FILE_OPERATION_TIMEOUT_STORAGE_KEY = "SOL_RB_FILE_OPERATION_TIMEOUT_MS";
+var MAX_DEGREE_OF_PARALLELISM_STORAGE_KEY = "SOL_RB_MAX_DEGREE_OF_PARALLELISM";
 function resolveTimeoutMs(storageKey, configured, fallback) {
   const override = readTimeoutOverrideMs(storageKey);
   if (override !== undefined)
@@ -2736,10 +2751,33 @@ function resolveLockTimeoutMs(options) {
 function resolveFileOperationTimeoutMs(options) {
   return resolveTimeoutMs(FILE_OPERATION_TIMEOUT_STORAGE_KEY, options?.fileOperationTimeoutMs, DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs);
 }
+function isValidDegreeOfParallelism(value) {
+  return typeof value == "number" && Number.isInteger(value) && value > 0;
+}
+function resolveMaxDegreeOfParallelism(options) {
+  const override = readDegreeOfParallelismOverride(MAX_DEGREE_OF_PARALLELISM_STORAGE_KEY);
+  if (override !== undefined)
+    return override;
+  return isValidDegreeOfParallelism(options?.maxDegreeOfParallelism) ? options.maxDegreeOfParallelism : DEFAULT_SOLUTION_CONTEXT_OPTIONS.maxDegreeOfParallelism;
+}
+function readDegreeOfParallelismOverride(storageKey) {
+  try {
+    if ("u" < typeof localStorage)
+      return;
+    const raw = localStorage.getItem(storageKey);
+    if (raw === null || raw.trim() === "")
+      return;
+    const parsed = Number(raw);
+    return isValidDegreeOfParallelism(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
 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
+    fileOperationTimeoutMs: isValidTimeoutMs(options?.fileOperationTimeoutMs) ? options.fileOperationTimeoutMs : DEFAULT_SOLUTION_CONTEXT_OPTIONS.fileOperationTimeoutMs,
+    maxDegreeOfParallelism: isValidDegreeOfParallelism(options?.maxDegreeOfParallelism) ? options.maxDegreeOfParallelism : DEFAULT_SOLUTION_CONTEXT_OPTIONS.maxDegreeOfParallelism
   };
 }
 
@@ -3530,6 +3568,16 @@ function getRootFolder(solution) {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/solution/multi-file-solution-definition-provider.js
+function nowMs() {
+  return globalThis.performance?.now?.() ?? Date.now();
+}
+function round1(ms) {
+  return Math.round(10 * ms) / 10;
+}
+function cancellationError(signal) {
+  return signal?.reason instanceof OperationCancelledException ? signal.reason : new OperationCancelledException;
+}
+
 class MultiFileSolutionDefinitionProvider {
   get caseInsensitiveSerializer() {
     if (!this._caseInsensitiveSerializer)
@@ -3547,137 +3595,344 @@ class MultiFileSolutionDefinitionProvider {
   }
   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.getFileStorageProviderAsync(context, cancellationToken);
-    const resources = [];
-    const solutionFiles = [];
-    let hashes;
-    let paths;
-    const pathsByKind = this.getPathsByKind(context);
-    let tree;
-    pathsByKind.clear();
+    const loadStarted = nowMs();
+    let fileCount = 0;
+    let listMs = 0;
+    let readStarted = loadStarted;
+    let readWallMs = 0;
+    let readCompleted = false;
+    let ioMs = 0;
+    let maxFileIoMs = 0;
+    let parseMs = 0;
+    let hashMs = 0;
+    let chars = 0;
+    let loadedCount = 0;
     const parseErrors = [];
     const missingFiles = [];
     const invalidFiles = [];
-    context.items[SolutionContextKeys.PARSE_ERRORS_ITEM_KEY] = parseErrors;
-    if (!context.isReadOnly) {
-      hashes = this.getHashes(context);
-      paths = this.getPaths(context);
-      tree = this.getTree(context);
-      hashes.clear();
-      paths.clear();
-      tree.length = 0;
-    }
-    const resourceFiles = await fileStorageProvider.getFilesAsync(SolutionConstants.RESOURCE_FILES_FOLDER_NAME, "*.json", cancellationToken);
-    for (const resourceFile of resourceFiles)
-      try {
-        const stream = await fileStorageProvider.openFileAsync(resourceFile, cancellationToken);
-        const content = await this.streamToString(stream);
-        const wrapper = this.caseInsensitiveSerializer.deserialize(content);
-        if (wrapper?.resource) {
-          const rd = this.fromSerializable(wrapper.resource, solutionFiles);
-          const relPath = resourceFile.replace(/\\/g, "/");
-          const segments = relPath.split("/").filter((s) => s.length > 0);
-          const firstSegment = segments[0];
-          if (segments.length >= 3 && firstSegment && firstSegment.toLowerCase() === SolutionConstants.RESOURCE_FILES_FOLDER_NAME.toLowerCase()) {
-            const hasType = !!rd.type;
-            const folderSegmentCount = hasType ? segments.length - 3 : segments.length - 2;
-            if (folderSegmentCount < 1)
-              rd.folders = [
-                {
-                  fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
-                }
-              ];
-            else {
-              const segmentsToUse = segments.slice(1, folderSegmentCount);
-              const folderFqn = segmentsToUse.join("/");
-              rd.folders = [
-                {
-                  fullyQualifiedName: folderFqn
-                }
-              ];
+    let metricsLogged = false;
+    const logReadMetrics = (outcome) => {
+      metricsLogged = true;
+      const totalMs = nowMs() - loadStarted;
+      const mergeMs = readCompleted ? nowMs() - readStarted - readWallMs : 0;
+      const metrics = {
+        outcome,
+        path: context.path,
+        fileCount,
+        totalMs: round1(totalMs),
+        listMs: round1(listMs),
+        readWallMs: round1(readWallMs),
+        ioMs: round1(ioMs),
+        maxFileIoMs: round1(maxFileIoMs),
+        parseMs: round1(parseMs),
+        hashMs: round1(hashMs),
+        mergeMs: round1(mergeMs),
+        chars,
+        degreeOfParallelism: resolveMaxDegreeOfParallelism(this.options),
+        isReadOnly: context.isReadOnly,
+        loaded: loadedCount,
+        missing: missingFiles.length,
+        invalid: invalidFiles.length,
+        parseErrors: parseErrors.length
+      };
+      const message = `Solution read ${outcome} for solution ${context.path}: ${metrics.fileCount} files in ${metrics.totalMs} ms (list ${metrics.listMs} ms, read ${metrics.readWallMs} ms wall, io ${metrics.ioMs} ms summed, max file io ${metrics.maxFileIoMs} ms, parse ${metrics.parseMs} ms, hash ${metrics.hashMs} ms, merge ${metrics.mergeMs} ms); ${metrics.chars} chars; parallelism ${metrics.degreeOfParallelism}; readOnly ${metrics.isReadOnly}; loaded ${metrics.loaded}, missing ${metrics.missing}, invalid ${metrics.invalid}, parseErrors ${metrics.parseErrors}`;
+      if (outcome === "Success")
+        this.logger.info(message, metrics);
+      else
+        this.logger.warn(message, metrics);
+    };
+    const readCore = async () => {
+      const solutionKey = this.getSolutionKey(context);
+      const fileStorageProvider = await this.getFileStorageProviderAsync(context, cancellationToken);
+      const resources = [];
+      const solutionFiles = [];
+      let hashes;
+      let paths;
+      const pathsByKind = this.getPathsByKind(context);
+      let tree;
+      pathsByKind.clear();
+      context.items[SolutionContextKeys.PARSE_ERRORS_ITEM_KEY] = parseErrors;
+      if (!context.isReadOnly) {
+        hashes = this.getHashes(context);
+        paths = this.getPaths(context);
+        tree = this.getTree(context);
+        hashes.clear();
+        paths.clear();
+        tree.length = 0;
+      }
+      const listStarted = nowMs();
+      const resourceFiles = await fileStorageProvider.getFilesAsync(SolutionConstants.RESOURCE_FILES_FOLDER_NAME, "*.json", cancellationToken);
+      listMs = nowMs() - listStarted;
+      fileCount = resourceFiles.length;
+      readStarted = nowMs();
+      const readResults = await this.readResourceFilesAsync(context, fileStorageProvider, resourceFiles, cancellationToken);
+      readWallMs = nowMs() - readStarted;
+      readCompleted = true;
+      let fatal;
+      let hasFatal = false;
+      for (const result of readResults)
+        if (result !== undefined) {
+          if (result.timings) {
+            ioMs += result.timings.ioMs;
+            maxFileIoMs = Math.max(maxFileIoMs, result.timings.ioMs);
+            parseMs += result.timings.parseMs;
+            hashMs += result.timings.hashMs;
+            chars += result.timings.chars;
+          }
+          if (result.fatal !== undefined) {
+            if (!hasFatal) {
+              fatal = result.fatal;
+              hasFatal = true;
             }
-          } else
-            rd.folders = [
-              {
-                fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
+            continue;
+          }
+          if (!hasFatal)
+            switch (result.outcome) {
+              case "loaded": {
+                loadedCount++;
+                const rd = result.resource;
+                for (const file of result.files)
+                  if (!solutionFiles.some((sf) => sf.name === file.name && sf.kind === file.kind))
+                    solutionFiles.push(file);
+                resources.push(rd);
+                const resourceKey = rd.key;
+                const normalizedFullPath = result.normalizedPath;
+                if (!pathsByKind.has(rd.kind))
+                  pathsByKind.set(rd.kind, []);
+                const kindPaths = pathsByKind.get(rd.kind);
+                if (kindPaths)
+                  kindPaths.push({
+                    name: rd.name,
+                    key: rd.key,
+                    path: normalizedFullPath
+                  });
+                if (!context.isReadOnly && hashes && paths) {
+                  paths.set(resourceKey, normalizedFullPath);
+                  hashes.set(resourceKey, result.hash);
+                }
+                break;
               }
-            ];
-          resources.push(rd);
-          const resourceKey = rd.key;
-          const normalizedFullPath = this.getNormalizedPath(resourceFile);
-          if (!pathsByKind.has(rd.kind))
-            pathsByKind.set(rd.kind, []);
-          const kindPaths = pathsByKind.get(rd.kind);
-          if (kindPaths)
-            kindPaths.push({
-              name: rd.name,
-              key: rd.key,
-              path: normalizedFullPath
+              case "missing":
+                missingFiles.push(result.file);
+                break;
+              case "invalid":
+                invalidFiles.push(result.file);
+                break;
+              case "parseError":
+                parseErrors.push(result.file);
+                break;
+            }
+        }
+      if (hasFatal) {
+        logReadMetrics("Fatal");
+        throw fatal;
+      }
+      if (missingFiles.length > 0) {
+        logReadMetrics("MissingFiles");
+        throw new BadRequestException(ErrorCodes.Resources.MissingFileDependencies, `Solution has missing files: ${missingFiles.join(", ")}`);
+      }
+      if (invalidFiles.length > 0) {
+        logReadMetrics("InvalidFiles");
+        throw new BadRequestException(ErrorCodes.Resources.InvalidResourceFile, `Solution has resource files with invalid content: ${invalidFiles.join(", ")}`);
+      }
+      if (parseErrors.length > 0) {
+        logReadMetrics("ParseErrors");
+        throw new Error(`Failed to read resource files for solution ${context.path}: ${parseErrors.join(", ")}`);
+      }
+      const folderMap = new Map;
+      const rootFolder = this.buildRootFolder(solutionKey, SolutionConstants.ROOT_FOLDER_NAME);
+      folderMap.set(rootFolder.fullyQualifiedName.toLowerCase(), rootFolder);
+      for (const res of resources)
+        for (const fdep of res.folders ?? []) {
+          const fqnLower = fdep.fullyQualifiedName.toLowerCase();
+          if (!folderMap.has(fqnLower)) {
+            const folderKey = this.generateGuidFromString(fdep.fullyQualifiedName);
+            const pathSegments = fdep.fullyQualifiedName.split("/").filter((s) => s.length > 0).map((p) => {
+              if (p.toLowerCase() !== SolutionConstants.ROOT_FOLDER_NAME.toLowerCase())
+                return this.generateGuidFromString(SolutionConstants.ROOT_FOLDER_NAME);
+              return rootFolder.key;
+            });
+            const folderPath = pathSegments.join(".");
+            folderMap.set(fqnLower, {
+              key: folderKey,
+              fullyQualifiedName: fdep.fullyQualifiedName,
+              path: folderPath
             });
-          if (!context.isReadOnly && hashes && paths) {
-            paths.set(resourceKey, normalizedFullPath);
-            hashes.set(resourceKey, await this.computeHash(content));
           }
-        } else {
-          this.logger.error("Failed to read resource file %s for solution %s: invalid content", undefined, resourceFile, context.path);
-          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);
-        } else {
-          this.logger.error("Failed to read resource file %s for solution %s", ex, resourceFile, context.path);
-          parseErrors.push(resourceFile);
         }
+      const solution = {
+        key: solutionKey,
+        docVersion: SolutionConstants.CURRENT_DOC_VERSION,
+        folders: Array.from(folderMap.values()),
+        resources,
+        files: solutionFiles
+      };
+      await this.replaceDuplicateKeysAsync(solution, cancellationToken);
+      if (!context.isReadOnly && tree) {
+        const orderedResourceKeys = getTopologicalIdsOrdering(buildDependencyGraph(solution.resources));
+        tree.push(...orderedResourceKeys);
       }
-    if (missingFiles.length > 0)
-      throw new BadRequestException(ErrorCodes.Resources.MissingFileDependencies, `Solution has missing files: ${missingFiles.join(", ")}`);
-    if (invalidFiles.length > 0)
-      throw new BadRequestException(ErrorCodes.Resources.InvalidResourceFile, `Solution has resource files with invalid content: ${invalidFiles.join(", ")}`);
-    if (parseErrors.length > 0)
-      throw new Error(`Failed to read resource files for solution ${context.path}: ${parseErrors.join(", ")}`);
-    const folderMap = new Map;
-    const rootFolder = this.buildRootFolder(solutionKey, SolutionConstants.ROOT_FOLDER_NAME);
-    folderMap.set(rootFolder.fullyQualifiedName.toLowerCase(), rootFolder);
-    for (const res of resources)
-      for (const fdep of res.folders ?? []) {
-        const fqnLower = fdep.fullyQualifiedName.toLowerCase();
-        if (!folderMap.has(fqnLower)) {
-          const folderKey = this.generateGuidFromString(fdep.fullyQualifiedName);
-          const pathSegments = fdep.fullyQualifiedName.split("/").filter((s) => s.length > 0).map((p) => {
-            if (p.toLowerCase() !== SolutionConstants.ROOT_FOLDER_NAME.toLowerCase())
-              return this.generateGuidFromString(SolutionConstants.ROOT_FOLDER_NAME);
-            return rootFolder.key;
-          });
-          const folderPath = pathSegments.join(".");
-          folderMap.set(fqnLower, {
-            key: folderKey,
-            fullyQualifiedName: fdep.fullyQualifiedName,
-            path: folderPath
-          });
-        }
+      logReadMetrics("Success");
+      return solution;
+    };
+    try {
+      return await readCore();
+    } catch (ex) {
+      if (!metricsLogged)
+        logReadMetrics("Fatal");
+      throw ex;
+    }
+  }
+  async readResourceFilesAsync(context, fileStorageProvider, resourceFiles, cancellationToken) {
+    const results = Array.from({
+      length: resourceFiles.length
+    }, () => {
+      return;
+    });
+    if (resourceFiles.length === 0)
+      return results;
+    const computeHash = !context.isReadOnly;
+    const degreeOfParallelism = Math.min(resolveMaxDegreeOfParallelism(this.options), resourceFiles.length);
+    let nextIndex = 0;
+    let stopRequested = false;
+    const runWorkerAsync = async () => {
+      while (!stopRequested && nextIndex < resourceFiles.length) {
+        const index = nextIndex++;
+        const resourceFile = resourceFiles[index];
+        const result = await this.readResourceFileAsync(context, fileStorageProvider, resourceFile, computeHash, cancellationToken);
+        results[index] = result;
+        if (result.fatal !== undefined)
+          stopRequested = true;
       }
-    const solution = {
-      key: solutionKey,
-      docVersion: SolutionConstants.CURRENT_DOC_VERSION,
-      folders: Array.from(folderMap.values()),
-      resources,
-      files: solutionFiles
     };
-    await this.replaceDuplicateKeysAsync(solution, cancellationToken);
-    if (!context.isReadOnly && tree) {
-      const orderedResourceKeys = getTopologicalIdsOrdering(buildDependencyGraph(solution.resources));
-      tree.push(...orderedResourceKeys);
+    const workers = [];
+    for (let i = 0;i < degreeOfParallelism; i++)
+      workers.push(runWorkerAsync());
+    await Promise.all(workers);
+    if (cancellationToken?.aborted && !results.some((result) => result?.fatal !== undefined))
+      throw cancellationError(cancellationToken);
+    return results;
+  }
+  async readResourceFileAsync(context, fileStorageProvider, resourceFile, computeHash, cancellationToken) {
+    const started = nowMs();
+    let ioMs;
+    let content;
+    const failureTimings = () => {
+      const elapsed = nowMs() - started;
+      return ioMs === undefined ? {
+        ioMs: elapsed,
+        parseMs: 0,
+        hashMs: 0,
+        chars: 0
+      } : {
+        ioMs,
+        parseMs: elapsed - ioMs,
+        hashMs: 0,
+        chars: content?.length ?? 0
+      };
+    };
+    try {
+      if (cancellationToken?.aborted)
+        throw cancellationError(cancellationToken);
+      const stream = await fileStorageProvider.openFileAsync(resourceFile, cancellationToken);
+      content = await this.streamToString(stream);
+      ioMs = nowMs() - started;
+      const parseStarted = nowMs();
+      const wrapper = this.caseInsensitiveSerializer.deserialize(content);
+      if (!wrapper?.resource) {
+        this.logger.error("Failed to read resource file %s for solution %s: invalid content", undefined, resourceFile, context.path);
+        return {
+          file: resourceFile,
+          outcome: "invalid",
+          timings: failureTimings()
+        };
+      }
+      const files = [];
+      const rd = this.fromSerializable(wrapper.resource, files);
+      this.applyFolders(rd, resourceFile);
+      const parseMs = nowMs() - parseStarted;
+      let hash;
+      let hashMs = 0;
+      if (computeHash) {
+        const hashStarted = nowMs();
+        hash = await this.computeHash(content);
+        hashMs = nowMs() - hashStarted;
+      }
+      return {
+        file: resourceFile,
+        outcome: "loaded",
+        resource: rd,
+        files,
+        normalizedPath: this.getNormalizedPath(resourceFile),
+        hash,
+        timings: {
+          ioMs,
+          parseMs,
+          hashMs,
+          chars: content.length
+        }
+      };
+    } catch (ex) {
+      if (ex instanceof OperationCancelledException || cancellationToken?.aborted) {
+        this.logger.warn("Operation cancelled while reading file %s for solution %s", resourceFile, context.path);
+        return {
+          file: resourceFile,
+          outcome: "fatal",
+          fatal: ex instanceof OperationCancelledException ? ex : cancellationError(cancellationToken),
+          timings: failureTimings()
+        };
+      }
+      if (ex instanceof TimeoutException)
+        return {
+          file: resourceFile,
+          outcome: "fatal",
+          fatal: new TimeoutException(`Reading resource file ${resourceFile} for solution ${context.path} timed out: ${ex.message}`, ex.timeoutMs),
+          timings: failureTimings()
+        };
+      if (isFileNotFoundError(ex)) {
+        this.logger.warn("Resource file listed but missing in storage for solution %s: %s", resourceFile, context.path);
+        return {
+          file: resourceFile,
+          outcome: "missing",
+          timings: failureTimings()
+        };
+      }
+      this.logger.error("Failed to read resource file %s for solution %s", ex, resourceFile, context.path);
+      return {
+        file: resourceFile,
+        outcome: "parseError",
+        timings: failureTimings()
+      };
     }
-    return solution;
+  }
+  applyFolders(resource, resourceFile) {
+    const relPath = resourceFile.replace(/\\/g, "/");
+    const segments = relPath.split("/").filter((s) => s.length > 0);
+    const firstSegment = segments[0];
+    if (segments.length >= 3 && firstSegment && firstSegment.toLowerCase() === SolutionConstants.RESOURCE_FILES_FOLDER_NAME.toLowerCase()) {
+      const hasType = !!resource.type;
+      const folderSegmentCount = hasType ? segments.length - 3 : segments.length - 2;
+      if (folderSegmentCount < 1)
+        resource.folders = [
+          {
+            fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
+          }
+        ];
+      else {
+        const segmentsToUse = segments.slice(1, folderSegmentCount);
+        const folderFqn = segmentsToUse.join("/");
+        resource.folders = [
+          {
+            fullyQualifiedName: folderFqn
+          }
+        ];
+      }
+    } else
+      resource.folders = [
+        {
+          fullyQualifiedName: SolutionConstants.ROOT_FOLDER_NAME
+        }
+      ];
   }
   async writeAsync(context, solution, cancellationToken) {
     if (context.isReadOnly)
@@ -3982,7 +4237,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-rf2g1kfj.js"),
+    import("./embedded-file-reader-z4becc02.js"),
     import("./index-dqa169gp.js")
   ]);
   return new EmbeddedFileReader(new JsonSerializerFactory2);
@@ -4000,6 +4255,7 @@ var ServiceTokens = {
   SecretsProvider: "ISecretsProvider",
   FileStorageProviderFactory: "IFileStorageProviderFactory",
   IpRangeBypassSecretProvider: "IIpRangeBypassSecretProvider",
+  FeatureFlagProvider: "IFeatureFlagProvider",
   SolutionDefinitionProvider: "ISolutionDefinitionProvider",
   SolutionDefinitionFactory: "ISolutionDefinitionFactory",
   ArtifactResourceSpecEnhancer: "IArtifactResourceSpecEnhancer",
@@ -4350,6 +4606,9 @@ function getBindingType(resourceKind, resourceType) {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/bindings/bindings-metadata-serializer.js
+var SUPPORTED_SCHEMA_MAJOR_VERSION = 2;
+var INT32_MAX_VALUE = 2147483647;
+
 class BindingsMetadataSerializer {
   tryDeserialize(input) {
     if (!input)
@@ -4360,30 +4619,52 @@ class BindingsMetadataSerializer {
       let cleanInput = input.charCodeAt(0) === 65279 ? input.slice(1) : input;
       if (cleanInput.charCodeAt(cleanInput.length - 1) === 26)
         cleanInput = cleanInput.slice(0, -1);
-      const jsonObject = JSON.parse(cleanInput);
+      const root = JSON.parse(cleanInput);
+      if (root === null || typeof root != "object" || Array.isArray(root)) {
+        this.logger.warn("Invalid bindings: content is not a JSON object");
+        return {
+          success: false
+        };
+      }
+      const jsonObject = root;
       const versionValue = jsonObject[BindingsKnownKeys.Version];
-      if (!versionValue)
+      if (typeof versionValue != "string") {
+        this.logger.warn(`Invalid bindings: '${BindingsKnownKeys.Version}' is missing or not a string`);
         return {
           success: false
         };
-      const versionParts = versionValue.split(".").map(Number);
-      const majorVersion = versionParts[0];
-      if (majorVersion !== 2)
-        throw new Error("Unsupported bindings schema");
+      }
+      const majorVersion = BindingsMetadataSerializer.tryParseMajorVersion(versionValue);
+      if (majorVersion === undefined) {
+        this.logger.warn(`Invalid bindings: '${BindingsKnownKeys.Version}' is not a valid version`);
+        return {
+          success: false
+        };
+      }
+      if (majorVersion !== SUPPORTED_SCHEMA_MAJOR_VERSION) {
+        this.logger.warn(`Invalid bindings: unsupported schema major version ${majorVersion}`);
+        return {
+          success: false
+        };
+      }
+      const resources = jsonObject[BindingsKnownKeys.Resources];
+      if (!Array.isArray(resources)) {
+        this.logger.warn(`Invalid bindings: '${BindingsKnownKeys.Resources}' is missing or not an array`);
+        return {
+          success: false
+        };
+      }
       const metadata = {
         version: versionValue,
         resources: []
       };
-      const resources = jsonObject[BindingsKnownKeys.Resources];
-      if (Array.isArray(resources))
-        for (const resourceElement of resources) {
-          if (resourceElement == null) {
-            this.logger.warn("Skipping null bindings resource element");
-            continue;
-          }
-          const resource = this.getBindingsResourceV2(resourceElement);
-          metadata.resources.push(resource);
+      for (const resourceElement of resources) {
+        if (resourceElement == null) {
+          this.logger.warn("Skipping null bindings resource element");
+          continue;
         }
+        metadata.resources.push(this.getBindingsResourceV2(resourceElement));
+      }
       this.linkDependencies(metadata.resources);
       return {
         success: true,
@@ -4396,6 +4677,22 @@ class BindingsMetadataSerializer {
       };
     }
   }
+  static tryParseMajorVersion(value) {
+    const parts = value.split(".");
+    if (parts.length < 2 || parts.length > 4)
+      return;
+    let major;
+    for (const [index, part] of parts.entries()) {
+      if (!/^\s*[+-]?\d+\s*$/.test(part))
+        return;
+      const component = Number(part);
+      if (component < 0 || component > INT32_MAX_VALUE)
+        return;
+      if (index === 0)
+        major = component === 0 ? 0 : component;
+    }
+    return major;
+  }
   linkDependencies(resources) {
     for (const resource of resources) {
       const propertyMeta = resource.metadata;
@@ -4555,6 +4852,62 @@ class BindingOverwritesMappingRequest {
   }
 }
 
+// ../../node_modules/@uipath/resource-builder-sdk/dist/bindings/jit-debug-project-types.js
+var JIT_DEBUG_PROJECT_TYPES_FEATURE_FLAG = "FE.JitDebugProjectTypes";
+var PROCESS_KIND = "process";
+var BUSINESS_RULE_KIND = "businessrule";
+var APP_KIND = "app";
+var LOW_CODE_APP_PROJECT_TYPE = "webapp";
+var LOW_CODE_APP_TYPES = new Set([
+  "workflow action"
+]);
+var CODED_APP_PROJECT_TYPE = "appv2";
+var CODED_APP_TYPES = new Set([
+  "coded",
+  "codedaction"
+]);
+var DEFAULT_PROCESS_PROJECT_TYPE = "process";
+var KNOWN_PROCESS_PROJECT_TYPES = new Set([
+  DEFAULT_PROCESS_PROJECT_TYPE,
+  "processorchestration",
+  "agent",
+  "api",
+  "flow",
+  "function",
+  "casemanagement",
+  "webapp",
+  "businessrules"
+]);
+var BUSINESS_RULE_PROJECT_TYPE = "businessrules";
+function parseJitDebugProjectTypes(flagValue) {
+  if (!flagValue || !flagValue.trim())
+    return [];
+  return flagValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
+}
+function solutionSupportsJitDebug(solution, flagValue) {
+  const enabledProjectTypes = parseJitDebugProjectTypes(flagValue).map((t) => t.toLowerCase());
+  if (enabledProjectTypes.length === 0)
+    return false;
+  return (solution.resources ?? []).filter((r) => (r.projectKey != null || r.isArtefactResource === true) && isDecisionKind(r.kind)).every((r) => enabledProjectTypes.some((projectType) => matches(projectType, r)));
+}
+function isDecisionKind(kind) {
+  const normalized = (kind ?? "").toLowerCase();
+  return normalized === PROCESS_KIND || normalized === BUSINESS_RULE_KIND || normalized === APP_KIND;
+}
+function matches(projectType, resource) {
+  if ((resource.kind ?? "").toLowerCase() === BUSINESS_RULE_KIND)
+    return projectType === BUSINESS_RULE_PROJECT_TYPE;
+  if ((resource.kind ?? "").toLowerCase() === APP_KIND) {
+    const appType = (resource.type ?? "").toLowerCase();
+    if (appType === "" || LOW_CODE_APP_TYPES.has(appType))
+      return projectType === LOW_CODE_APP_PROJECT_TYPE;
+    return CODED_APP_TYPES.has(appType) && projectType === CODED_APP_PROJECT_TYPE;
+  }
+  const resourceType = (resource.type ?? "").toLowerCase();
+  const processType = resourceType === "" ? DEFAULT_PROCESS_PROJECT_TYPE : resourceType;
+  return !KNOWN_PROCESS_PROJECT_TYPES.has(processType) || projectType === processType;
+}
+
 // ../../node_modules/@uipath/resource-builder-sdk/dist/bindings/binding-overwrites-handler.js
 class BindingOverwritesHandler {
   async handleAsync(request, cancellationToken) {
@@ -4570,6 +4923,10 @@ class BindingOverwritesHandler {
     if (bindingResources.length === 0)
       return {};
     const result = {};
+    const solution = await request.context.loadAsync(cancellationToken);
+    const jitDebugProjectTypes = this.featureFlagProvider.getString(JIT_DEBUG_PROJECT_TYPES_FEATURE_FLAG, "");
+    const emptyFolderPathForArtefacts = solutionSupportsJitDebug(solution, jitDebugProjectTypes);
+    this.logger.info(`Binding overwrites for solution ${request.context.path}: JIT debug ${emptyFolderPathForArtefacts ? "on" : "off"} (FE.JitDebugProjectTypes = '${jitDebugProjectTypes}')`);
     const resourceOverwrites = await this.resourceOverwritesService.getResourceOverwritesAsync(request.context, cancellationToken);
     for (const bindingResource of bindingResources) {
       const resourceOverwrite = resourceOverwrites.get(bindingResource.resourceKey.toLowerCase());
@@ -4582,8 +4939,7 @@ class BindingOverwritesHandler {
           [BindingsKnownKeys.FolderKeyPropertyName]: resourceOverwrite.folderKey ?? ""
         };
       else {
-        const isBusinessRule = bindingResource.binding.resourceType === models_BindingsResourceType.BusinessRule;
-        const folderPath = bindingResource.isArtefactResource && !isBusinessRule ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
+        const folderPath = emptyFolderPathForArtefacts && bindingResource.isArtefactResource ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
         overwrite = {
           [BindingsKnownKeys.FolderPathPropertyName]: folderPath,
           [BindingsKnownKeys.NamePropertyName]: resourceOverwrite.resourceName
@@ -4605,9 +4961,10 @@ class BindingOverwritesHandler {
       throw new BadRequestException("Bindings.ValidationFailed", `Binding validation failed: ${failureMessages}`);
     }
   }
-  constructor(mediator, resourceOverwritesService, loggerFactory) {
+  constructor(mediator, resourceOverwritesService, loggerFactory, featureFlagProvider) {
     this.mediator = mediator;
     this.resourceOverwritesService = resourceOverwritesService;
+    this.featureFlagProvider = featureFlagProvider;
     this.logger = loggerFactory.create("BindingOverwritesHandler");
   }
 }
@@ -4616,6 +4973,11 @@ function removeTimeTriggerBindings(bindings) {
 }
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/bindings/binding-overwrites-mapping-handler.js
+function isCodedAppType(type) {
+  const normalized = type?.toLowerCase();
+  return normalized === "coded" || normalized === "codedaction";
+}
+
 class BindingOverwritesMappingRequestHandler {
   async handleAsync(request, cancellationToken) {
     const solutionBindings = request.bindings.resources.filter((x) => isSolutionResource(x.metadata));
@@ -4641,7 +5003,8 @@ class BindingOverwritesMappingRequestHandler {
           result.push({
             binding: bindingsResource,
             resourceKey: resource.key,
-            isArtefactResource: resource.projectKey != null
+            isArtefactResource: resource.projectKey != null,
+            isCodedApp: bindingsResource.resourceType === models_BindingsResourceType.App && isCodedAppType(resource.type)
           });
       } else {
         this.logger.error(`Solution does not contain binding resource of type ${models_BindingsResourceType[bindingsResource.resourceType]}.`);
@@ -5646,6 +6009,9 @@ class SolutionPublishLocationRequest {
 }
 
 class SolutionPublishLocationRequestV2 {
+  constructor(permissionType) {
+    this.permissionType = permissionType;
+  }
 }
 
 class SettingsRequest {
@@ -5810,12 +6176,13 @@ function _ts_param3(paramIndex, decorator) {
 }
 
 class SolutionPublishLocationRequestV2Handler {
-  async handleAsync(_request, cancellationToken) {
+  async handleAsync(request, cancellationToken) {
     try {
       const orchestratorClient = await this.orchestratorClientFactory.getClientAsync(cancellationToken);
       if (!orchestratorClient)
         throw new InvalidOperationException("Failed to create Orchestrator client");
-      return await orchestratorClient.getPublishLocationsAsync(cancellationToken);
+      const { permissionType } = request;
+      return permissionType == null ? await orchestratorClient.getPublishLocationsAsync(cancellationToken) : await orchestratorClient.getAccessiblePublishLocationsAsync(permissionType, cancellationToken);
     } catch (error) {
       this.logger.error("An unexpected error occurred while retrieving publish locations from Automation Solutions service.", error);
       throw error;
@@ -7255,8 +7622,8 @@ class SolutionDefinitionHelper {
         if (references.length === 0)
           continue;
         const referenceKind = refProp["referenceKind"];
-        const matches = (ref) => ref.name != null && invariantEquals(resource.name, ref.name) && referenceKind != null && invariantEquals(referenceKind, resource.kind);
-        const filtered = references.filter((r) => !matches(r));
+        const matches2 = (ref) => ref.name != null && invariantEquals(resource.name, ref.name) && referenceKind != null && invariantEquals(referenceKind, resource.kind);
+        const filtered = references.filter((r) => !matches2(r));
         if (filtered.length !== references.length)
           spec[refProp.property] = isSingleReferenceProperty(refProp) ? filtered[0] ?? null : filtered;
       }
@@ -7845,7 +8212,7 @@ class GetResourceKeyForProjectRequestHandler {
       projectKey: request.projectKey,
       solution: request.context.path
     });
-    const cacheKey = `prk:${request.projectKey}`;
+    const cacheKey = `prk:${request.context.path}:${request.projectKey}`;
     const cached = await this.cacheProvider.getAsync(cacheKey, cancellationToken);
     if (cached && typeof cached == "object" && "resourceKey" in cached) {
       this.logger.info("Cache hit for project {projectKey} resource key.", {
@@ -8673,7 +9040,11 @@ class UpdateResourceConfigurationCommandHandler {
     for (const prop of command.properties) {
       const propKey = prop.property.toLowerCase();
       const metadata = propertiesMetadata.get(propKey);
-      if (!(!metadata || isAnyReferenceProperty(metadata)) && metadata.readOnly !== true) {
+      if (metadata && metadata.readOnly !== true) {
+        if (isAnyReferenceProperty(metadata)) {
+          updated = this.setSolutionReference(solution, resource, currentConfiguration, propertiesMetadata, metadata, prop.configuredValue) || updated;
+          continue;
+        }
         if (isSecretProperty(metadata)) {
           const secretValue = prop.configuredValue?.toString() || "";
           const existingKey = currentConfiguration[metadata.property]?.toString();
@@ -8717,6 +9088,38 @@ class UpdateResourceConfigurationCommandHandler {
     await command.context.saveChangesAsync(cancellationToken);
     return resourceConfiguration;
   }
+  setSolutionReference(solution, resource, currentConfiguration, propertiesMetadata, metadata, configuredValue) {
+    const referenceKind = metadata["referenceKind"];
+    if (!isSingleReferenceProperty(metadata) || isFileReferenceProperty(metadata) || typeof referenceKind != "string" || !referenceKind)
+      return false;
+    const requested = asReference(configuredValue);
+    const target = requested?.key ? solution.resources.find((r) => invariantEquals(r.key, requested.key) && invariantEquals(r.kind, referenceKind)) : undefined;
+    if (!requested || !target || invariantEquals(target.key, resource.key))
+      return false;
+    const dependencies = resource.dependencies ??= [];
+    const previous = asReference(currentConfiguration[metadata.property]);
+    const previousKey = previous?.key;
+    const isReferencedElsewhere = (key) => [
+      ...propertiesMetadata.values()
+    ].some((p) => isAnyReferenceProperty(p) && !isFileReferenceProperty(p) && typeof p["referenceKind"] == "string" && invariantEquals(p["referenceKind"], target.kind) && !invariantEquals(p.property, metadata.property) && asReferences(currentConfiguration[p.property]).some((r) => r.key !== undefined && invariantEquals(r.key, key)));
+    if (previousKey && !invariantEquals(previousKey, target.key) && !isReferencedElsewhere(previousKey)) {
+      const previousName = solution.resources.find((r) => invariantEquals(r.key, previousKey) && invariantEquals(r.kind, target.kind))?.name ?? previous?.name ?? "";
+      resource.dependencies = dependencies.filter((d) => !(invariantEquals(d.kind, target.kind) && invariantEquals(d.name, previousName)));
+    }
+    if (!resource.dependencies.some((d) => invariantEquals(d.kind, target.kind) && invariantEquals(d.name, target.name)))
+      resource.dependencies.push({
+        kind: target.kind,
+        name: target.name
+      });
+    currentConfiguration[metadata.property] = {
+      name: target.name,
+      key: target.key,
+      folderKey: requested.folderKey ?? null,
+      lookupStrategy: null,
+      info: null
+    };
+    return true;
+  }
   async updateReferencesName(solutionDefinition, resource, oldName, cancellationToken) {
     const resourcesToBeChanged = solutionDefinition.resources.filter((r) => r.key !== resource.key && (r.dependencies ?? []).some((d) => invariantEquals(d.kind, resource.kind) && invariantEquals(d.name, oldName)));
     if (resourcesToBeChanged.length === 0)
@@ -9003,6 +9406,28 @@ class UpsertResourceSecretCommandHandler {
     this.secretsProvider = secretsProvider;
   }
 }
+function asReference(value) {
+  if (!value || typeof value != "object" || Array.isArray(value))
+    return;
+  const record = value;
+  const pick = (name) => {
+    const entry = Object.entries(record).find(([k]) => k.toLowerCase() === name.toLowerCase());
+    return typeof entry?.[1] == "string" ? entry[1] : undefined;
+  };
+  return {
+    key: pick("key"),
+    name: pick("name"),
+    folderKey: pick("folderKey")
+  };
+}
+function asReferences(value) {
+  if (Array.isArray(value))
+    return value.map(asReference).filter((r) => r !== undefined);
+  const single = asReference(value);
+  return single ? [
+    single
+  ] : [];
+}
 
 // ../../node_modules/@uipath/resource-builder-sdk/dist/handlers/solution-handlers.js
 var DUPLICATE_NAMES_SUPPORTED_KINDS = new Set([
@@ -12251,7 +12676,16 @@ class AutomationSolutionsClientProxy2 {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/clients/orchestrator/orchestrator-client.js
 class OrchestratorClient {
   async getPublishLocationsAsync(cancellationToken) {
-    const url = `${this.options.baseUrl}api/v2/AutomationSolutions/publish_locations`;
+    return this.getPublishLocationsFromAsync(this.publishLocationsUrl(), cancellationToken);
+  }
+  async getAccessiblePublishLocationsAsync(permissionType, cancellationToken) {
+    const url = `${this.publishLocationsUrl()}?permissionType=${encodeURIComponent(permissionType)}`;
+    return this.getPublishLocationsFromAsync(url, cancellationToken);
+  }
+  publishLocationsUrl() {
+    return `${this.options.baseUrl}api/v2/AutomationSolutions/publish_locations`;
+  }
+  async getPublishLocationsFromAsync(url, cancellationToken) {
     const headers = OrchestratorClientFactory.buildHeaders(this.options.securityData);
     const response = await fetch(url, {
       method: "GET",
@@ -12941,7 +13375,7 @@ class ReconcileProjectsCommandHandler {
     } : {
       resourceKey: undefined
     };
-    await this.cacheProvider.setAsync(`prk:${projectKey}`, result, cancellationToken);
+    await this.cacheProvider.setAsync(`prk:${context.path}:${projectKey}`, result, cancellationToken);
   }
   groupByProjectKey(artefactResources) {
     const map = new Map;
@@ -13815,6 +14249,11 @@ class ResourceBuilder {
     const request = new SolutionPublishLocationRequestV2;
     return this._mediator.sendAsync(request, cancellationToken);
   }
+  async getAccessiblePublishLocationsAsync(permissionType, cancellationToken) {
+    this.throwIfCancelled(cancellationToken);
+    const request = new SolutionPublishLocationRequestV2(permissionType);
+    return this._mediator.sendAsync(request, cancellationToken);
+  }
   async getSettingsAsync(cancellationToken) {
     this.throwIfCancelled(cancellationToken);
     const request = new SettingsRequest;
@@ -14374,9 +14813,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, solutionContextOptions) {
+function createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, embeddedFileReader, solutionContextOptions, featureFlagProvider) {
   const childContainer = import_tsyringe6.container.createChildContainer();
-  registerProviders(childContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions);
+  registerProviders(childContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions, featureFlagProvider);
   registerServices(childContainer, embeddedFileReader);
   registerHandlers(childContainer);
   childContainer.register(ServiceTokens.Mediator, {
@@ -14400,11 +14839,15 @@ function registerProvider(diContainer, token, provider) {
       break;
   }
 }
-function registerProviders(diContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions) {
+function registerProviders(diContainer, accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, httpReaderOptions, loggerFactory, solutionContextOptions, featureFlagProvider) {
   registerProvider(diContainer, ServiceTokens.AccessProvider, accessProvider);
   registerProvider(diContainer, ServiceTokens.CacheProvider, cacheProvider);
   registerProvider(diContainer, ServiceTokens.SecretsProvider, secretsProvider);
   registerProvider(diContainer, ServiceTokens.IpRangeBypassSecretProvider, ipRangeBypassSecretProvider);
+  registerProvider(diContainer, ServiceTokens.FeatureFlagProvider, featureFlagProvider ?? {
+    instance: new NullFeatureFlagProvider,
+    lifetime: service_tokens_ServiceLifetime.Singleton
+  });
   registerProvider(diContainer, ServiceTokens.FileStorageProviderFactory, fileStorageProviderFactory);
   registerProvider(diContainer, ServiceTokens.SolutionDefinitionProvider, solutionDefinitionProvider);
   registerProvider(diContainer, ServiceTokens.SolutionDefinitionFactory, solutionDefinitionFactory);
@@ -14841,7 +15284,8 @@ function registerHandlers(diContainer) {
       const mediator = c.resolve(ServiceTokens.Mediator);
       const resourceOverwritesService = c.resolve(Tokens.IResourceOverwritesService);
       const loggerFactory = c.resolve(ServiceTokens.LoggerFactory);
-      return new BindingOverwritesHandler(mediator, resourceOverwritesService, loggerFactory);
+      const featureFlagProvider = c.resolve(ServiceTokens.FeatureFlagProvider);
+      return new BindingOverwritesHandler(mediator, resourceOverwritesService, loggerFactory, featureFlagProvider);
     }
   });
   diContainer.register(createCommandHandlerToken(BindingOverwritesValidationCommand.name), {
@@ -14849,7 +15293,8 @@ function registerHandlers(diContainer) {
       const mediator = c.resolve(ServiceTokens.Mediator);
       const resourceOverwritesService = c.resolve(Tokens.IResourceOverwritesService);
       const loggerFactory = c.resolve(ServiceTokens.LoggerFactory);
-      return new BindingOverwritesHandler(mediator, resourceOverwritesService, loggerFactory);
+      const featureFlagProvider = c.resolve(ServiceTokens.FeatureFlagProvider);
+      return new BindingOverwritesHandler(mediator, resourceOverwritesService, loggerFactory, featureFlagProvider);
     }
   });
   diContainer.register(createRequestHandlerToken(BindingOverwritesMappingRequest.name), {
@@ -15131,6 +15576,11 @@ class ResourceBuilderConfiguration {
     this._ipRangeBypassSecretProviderLifetime = lifetime;
     return this;
   }
+  addFeatureFlagProvider(provider, lifetime = service_tokens_ServiceLifetime.Scoped) {
+    this._featureFlagProviderProvider = provider;
+    this._featureFlagProviderLifetime = lifetime;
+    return this;
+  }
   addSolutionDefinitionProvider(provider, lifetime = service_tokens_ServiceLifetime.Scoped) {
     this._solutionDefinitionProviderProvider = provider;
     this._solutionDefinitionProviderLifetime = lifetime;
@@ -15184,6 +15634,11 @@ class ResourceBuilderConfiguration {
       instance: ipRangeBypassSecretProviderInstance,
       lifetime: this._ipRangeBypassSecretProviderLifetime
     };
+    const featureFlagProviderInstance = this._featureFlagProviderProvider ? await resolveProvider(this._featureFlagProviderProvider) : new NullFeatureFlagProvider;
+    const featureFlagProvider = {
+      instance: featureFlagProviderInstance,
+      lifetime: this._featureFlagProviderLifetime
+    };
     const secretsProviderInstance = this._secretsProviderProvider ? await resolveProvider(this._secretsProviderProvider) : new NullSecretsProvider;
     const secretsProvider = {
       instance: secretsProviderInstance,
@@ -15227,7 +15682,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, this._solutionContextOptions);
+    const container3 = createContainer(accessProvider, cacheProvider, secretsProvider, fileStorageProviderFactory, ipRangeBypassSecretProvider, solutionDefinitionProvider, solutionDefinitionFactory, artifactResourceSpecEnhancer, this._httpReaderOptions, loggerFactory, embeddedFileReader, this._solutionContextOptions, featureFlagProvider);
     return new ResourceBuilderServices(container3);
   }
   async buildServices() {
@@ -15239,6 +15694,7 @@ class ResourceBuilderConfiguration {
     this._secretsProviderLifetime = service_tokens_ServiceLifetime.Scoped;
     this._fileStorageProviderFactoryLifetime = service_tokens_ServiceLifetime.Singleton;
     this._ipRangeBypassSecretProviderLifetime = service_tokens_ServiceLifetime.Scoped;
+    this._featureFlagProviderLifetime = service_tokens_ServiceLifetime.Scoped;
     this._solutionDefinitionProviderLifetime = service_tokens_ServiceLifetime.Scoped;
     this._solutionDefinitionFactoryLifetime = service_tokens_ServiceLifetime.Scoped;
     this._artifactResourceSpecEnhancerLifetime = service_tokens_ServiceLifetime.Scoped;
@@ -16384,12 +16840,12 @@ async function findResourceByKeyInRcs(builder, kind, expectedKey, folderPath, pr
   return;
 }
 async function searchRcsResources(builder, kind, name) {
-  const [searchError, matches] = await catchError(searchRcsResourcesStrict(builder, kind, name));
+  const [searchError, matches2] = await catchError(searchRcsResourcesStrict(builder, kind, name));
   if (searchError) {
     logger.warn(`Failed to search ${kind} resources in RCS: ${searchError.message}`);
     return [];
   }
-  return matches;
+  return matches2;
 }
 async function searchRcsResourcesStrict(builder, kind, name) {
   let pageCursor;
@@ -16397,8 +16853,8 @@ async function searchRcsResourcesStrict(builder, kind, name) {
   do {
     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) {
+      const matches2 = folderResources.resources.filter((r) => r.name.toLowerCase() === name.toLowerCase());
+      for (const match of matches2) {
         allMatches.push({
           key: match.key,
           name: match.name,
@@ -16970,4 +17426,4 @@ function sortKeysDeep(value) {
 }
 export { Tokens, models_BindingsResourceType, getResourceName, getFolderPathProperty, getResourceKindForBinding, assertSolutionManifest, computeEntryPointSpec, applyEntryPointEnhancementAsync, createResourceBuilderServices, findProjectFile, isProjectManifestError, isMissingProjectTypeError, readProjectFile, readSolutionFile, resolveSolutionFilePath, writeSolutionFile, restoreSolutionFile, createProjectInSolutionBuilder, normalizeFolderPath, findMatchingLocalResource, addProjectArtifactsToSolutionAsync, hasBareTemplateRow, hasAnyTemplateRow, getRemoteResourceClients, findCatalogEntityAsync, toResourceReference, exportResourceDefinitionAsync, readSpecProperty, saveCasingNormalized, normalizeResourceFileCasing, validateResourceName, formatResourceSubtypes, sameResourceSubtype, syncResourcesFromBindings, findResourceByKeyInRcs, searchRcsResources, findResourceInRcs, createResourceKindMetadataResolver, resolveResourceKindMetadata, createLocalResource, readUipxProjects, syncAndLog, resourceRefreshAsync, resourceRemoteSyncAsync };
 
-//# debugId=503E17628305A6E964756E2164756E21
+//# debugId=D75E94C9297A402C64756E2164756E21