@uipath/flow-tool 1.204.0 → 1.205.0-preview.258

package/dist/{index-aaq9rwfv.js → index-1b2je9n2.js}

@@ -1,3 +1,6 @@
+import {
+  getSolutionAuthContext
+} from "./packager-tool-9era57c0.js";
 import {
   JsonSerializerFactory,
   JsonSerializerNames,
@@ -10,30 +13,31 @@ import {
 import {
   UsersApi,
   createApiClient
-} from "./packager-tool-n89vrpex.js";
+} from "./packager-tool-skcjythd.js";
 import {
-  getAuthContext,
   getLoginStatusAsync
-} from "./packager-tool-6h69pd2a.js";
-import"./packager-tool-qa9gftnj.js";
+} from "./packager-tool-kn86394c.js";
 import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
 import"./packager-tool-yc4kw997.js";
 import {
   findSolutionFileUpward,
   normalizeProjectType,
   toPortableRelativePath
-} from "./packager-tool-m8xtf5ej.js";
-import"./packager-tool-stq8800d.js";
+} from "./packager-tool-8g5931fz.js";
+import"./packager-tool-pacrqxv2.js";
 import"./packager-tool-nkrmjr3a.js";
 import {
-  catchError,
   extractErrorMessage,
   isGuid,
   logger
-} from "./packager-tool-02f63a08.js";
+} from "./packager-tool-apawc11t.js";
+import {
+  catchError
+} from "./packager-tool-t7ahhaer.js";
 import {
   getFileSystem
-} from "./packager-tool-3h2ktz6q.js";
+} from "./packager-tool-myhbp761.js";
 import {
   __commonJS,
   __require,
@@ -2472,6 +2476,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) {
@@ -2626,10 +2643,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)
@@ -2642,10 +2661,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
   };
 }
 
@@ -3436,6 +3478,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)
@@ -3453,137 +3505,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)
@@ -3888,7 +4147,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-v8c2yj2a.js"),
+    import("./embedded-file-reader-r66242ey.js"),
     import("./index-kmp9fmhb.js")
   ]);
   return new EmbeddedFileReader(new JsonSerializerFactory2);
@@ -3906,6 +4165,7 @@ var ServiceTokens = {
   SecretsProvider: "ISecretsProvider",
   FileStorageProviderFactory: "IFileStorageProviderFactory",
   IpRangeBypassSecretProvider: "IIpRangeBypassSecretProvider",
+  FeatureFlagProvider: "IFeatureFlagProvider",
   SolutionDefinitionProvider: "ISolutionDefinitionProvider",
   SolutionDefinitionFactory: "ISolutionDefinitionFactory",
   ArtifactResourceSpecEnhancer: "IArtifactResourceSpecEnhancer",
@@ -4256,6 +4516,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)
@@ -4266,30 +4529,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 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 versionParts = versionValue.split(".").map(Number);
-      const majorVersion = versionParts[0];
-      if (majorVersion !== 2)
-        throw new Error("Unsupported bindings schema");
+      }
       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,
@@ -4302,6 +4587,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;
@@ -4488,8 +4789,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 = bindingResource.isArtefactResource && !bindingResource.isCodedApp ? "" : resourceOverwrite.folderFullyQualifiedName ?? "";
         overwrite = {
           [BindingsKnownKeys.FolderPathPropertyName]: folderPath,
           [BindingsKnownKeys.NamePropertyName]: resourceOverwrite.resourceName
@@ -4522,6 +4822,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));
@@ -4547,7 +4852,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]}.`);
@@ -5552,6 +5858,9 @@ class SolutionPublishLocationRequest {
 }
 
 class SolutionPublishLocationRequestV2 {
+  constructor(permissionType) {
+    this.permissionType = permissionType;
+  }
 }
 
 class SettingsRequest {
@@ -5716,12 +6025,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;
@@ -7751,7 +8061,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.", {
@@ -8579,7 +8889,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();
@@ -8623,6 +8937,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)
@@ -8909,6 +9255,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([
@@ -9880,6 +10248,9 @@ class ResourceCatalogApi extends HttpClient {
 // ../../node_modules/@uipath/resource-builder-sdk/dist/clients/resource-catalog/resource-catalog-client.factory.js
 var RESOURCE_CATALOG_SCOPE = "RCS.FolderAuthorization";
 var RESOURCE_CATALOG_SERVICE_NAME = "resourcecatalog";
+function trimTrailingSlashes(url) {
+  return url.replace(/\/+$/, "");
+}
 
 class ResourceCatalogClientFactory {
   async getClientAsync(cancellationToken) {
@@ -9893,9 +10264,8 @@ class ResourceCatalogClientFactory {
     ], true, cancellationToken);
     const ipRangeBypassSecret = await this.ipRangeBypassSecretProvider?.getIpRangeBypassSecretAsync(cancellationToken);
     const gatewayIntegrationEnabled = this.resourceBuilderAccessProvider.isGatewayIntegrationEnabled();
-    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : baseUrl + "/";
     const client = new ResourceCatalogApi({
-      baseUrl: normalizedBaseUrl,
+      baseUrl: trimTrailingSlashes(baseUrl),
       securityWorker: (securityData) => {
         if (!securityData)
           return {};
@@ -9938,7 +10308,7 @@ class ResourceCatalogClientFactory {
     if (!accountKey)
       throw new Error("Unable to obtain account key");
     const client = new ResourceCatalogApi({
-      baseUrl,
+      baseUrl: trimTrailingSlashes(baseUrl),
       securityWorker: (securityData) => {
         if (!securityData)
           return {};
@@ -12157,7 +12527,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",
@@ -12847,7 +13226,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;
@@ -13721,6 +14100,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;
@@ -14280,9 +14664,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, {
@@ -14306,11 +14690,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);
@@ -15037,6 +15425,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;
@@ -15090,6 +15483,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,
@@ -15133,7 +15531,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() {
@@ -15145,6 +15543,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;
@@ -15256,8 +15655,59 @@ var ARTEFACT_KIND_APP = "app";
 var ARTEFACT_KIND_APP_VERSION = "appversion";
 var ARTEFACT_KIND_PACKAGE = "package";
 var SPEC_KEY_PACKAGE = "package";
+var RESOURCE_FILES_FOLDER_NAME = "resources";
+var RESOURCE_FILE_PATTERN = "*.json";
+var FIX_SHARED_KEY = "Delete all but one file for each key, then retry.";
+var FIX_KEYLESS = 'Give each file without a key its own unique "key", then retry.';
+
+class DuplicateKeysError extends Error {
+  keys;
+  constructor(keys) {
+    super(`Duplicate resource keys: ${keys.map(describeKey).join(", ")}`);
+    this.keys = keys;
+  }
+}
 
 class ArtefactPairBindingProvider extends MultiFileSolutionDefinitionProvider {
+  async readAsync(context, cancellationToken) {
+    const [readError, solution] = await catchError(super.readAsync(context, cancellationToken));
+    if (!readError)
+      return solution;
+    if (!(readError instanceof DuplicateKeysError))
+      throw readError;
+    const [describeError, message] = await catchError(this.describeDuplicateKeys(context, readError.keys, cancellationToken));
+    throw describeError ? readError : new Error(message);
+  }
+  async replaceDuplicateKeysAsync(solution) {
+    const keys = findDuplicateKeys(solution);
+    if (keys.length > 0)
+      throw new DuplicateKeysError(keys);
+  }
+  async describeDuplicateKeys(context, keys, cancellationToken) {
+    const storage = await this.getFileStorageProviderAsync(context, cancellationToken);
+    const files = await storage.getFilesAsync(RESOURCE_FILES_FOLDER_NAME, RESOURCE_FILE_PATTERN, cancellationToken);
+    const pathsByKey = new Map(keys.map((key) => [key, []]));
+    for (const file of [...files].sort()) {
+      const [readError, key] = await catchError(this.readResourceKey(storage, file, cancellationToken));
+      if (readError)
+        continue;
+      pathsByKey.get(key)?.push(toPortableRelativePath(file));
+    }
+    const lines = [...pathsByKey].map(([key, paths]) => `Resource key ${describeKey(key)} is used by: ${paths.join(", ")}`);
+    const fixes = [
+      keys.some((key) => !isKeyless(key)) && FIX_SHARED_KEY,
+      keys.some(isKeyless) && FIX_KEYLESS
+    ].filter(Boolean);
+    return [...lines, ...fixes].join(`
+`);
+  }
+  async readResourceKey(storage, file, cancellationToken) {
+    const content = await storage.readFileToEndAsync(file, cancellationToken);
+    const wrapper = this.caseInsensitiveSerializer.deserialize(content);
+    if (!wrapper?.resource)
+      throw new Error(`No resource in ${file}`);
+    return wrapper.resource.key;
+  }
   async writeAsync(context, solution, cancellationToken) {
     patchAppPackageLinkage(solution);
     return super.writeAsync(context, solution, cancellationToken);
@@ -15269,6 +15719,22 @@ class ArtefactPairBindingSolutionDefinitionFactory extends MultiFileSolutionDefi
     return new ArtefactPairBindingProvider(this.fileStorageProviderFactory, this.jsonSerializerFactory, this.loggerFactory);
   }
 }
+function findDuplicateKeys(solution) {
+  const counts = new Map;
+  for (const resource of solution.resources ?? []) {
+    const key = resource.key;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return [...counts].filter(([, count]) => count > 1).map(([key]) => key);
+}
+function isKeyless(key) {
+  return typeof key !== "string" || !key;
+}
+function describeKey(key) {
+  if (typeof key === "string" && key)
+    return key;
+  return key === undefined ? "(missing)" : JSON.stringify(key);
+}
 function patchAppPackageLinkage(solution) {
   const resources = solution.resources ?? [];
   const projectKeys = new Set;
@@ -15740,6 +16206,108 @@ async function createProjectInSolutionBuilder(solutionDir, projectId, projectNam
   await catchError(solutionBuilder.disposeAsync());
   return createError;
 }
+// ../solution-sdk/src/resources/services/catalog-lookup-failure.ts
+var NO_CLIENT_MESSAGE = "Unable to create Resource Catalog client";
+function classifyCatalogFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes(NO_CLIENT_MESSAGE)) {
+    return { message, kind: "no_session" };
+  }
+  const match = /\bHTTP (\d{3})\b/.exec(message);
+  const status = match ? Number(match[1]) : undefined;
+  if (status === 401 || status === 403) {
+    return { message, kind: "refused", status };
+  }
+  return { message, kind: "failed", ...status ? { status } : {} };
+}
+function stopsCatalogLookups(failure) {
+  return failure.kind !== "failed";
+}
+function describeBindings(bindings) {
+  return bindings.map((b) => `${b.kind} "${b.name}"`).join(", ");
+}
+function describeCause(failure) {
+  switch (failure.kind) {
+    case "no_session":
+      return "There is no login, so the Resource Catalog could not be searched";
+    case "refused":
+      return `The Resource Catalog refused this login (${failure.message})`;
+    default:
+      return `A Resource Catalog call failed (${failure.message})`;
+  }
+}
+function classify(failure) {
+  const refreshAndCommit = "or run 'uip solution resources refresh' under a login the Resource Catalog accepts and commit the solution's resources. The resources already in the solution are used as they are.";
+  if (failure.kind === "no_session") {
+    return {
+      errorCode: "authentication_required",
+      retry: "RetryWillNotFix",
+      instructions: `Run 'uip login', then re-run; ${refreshAndCommit}`
+    };
+  }
+  if (failure.kind === "refused") {
+    return {
+      errorCode: "permission_denied",
+      retry: "RetryWillNotFix",
+      instructions: `Use a login the Resource Catalog accepts (a user login: 'uip login'), ${refreshAndCommit}`
+    };
+  }
+  const status = failure.status;
+  if (status === 429) {
+    return {
+      errorCode: "rate_limited",
+      retry: "RetryLater",
+      instructions: `Wait, then re-run; ${refreshAndCommit}`
+    };
+  }
+  if (status !== undefined && status >= 500) {
+    return {
+      errorCode: "server_error",
+      retry: "RetryLater",
+      instructions: `Retry once the Resource Catalog is back; ${refreshAndCommit}`
+    };
+  }
+  if (status !== undefined && status >= 400) {
+    return {
+      errorCode: "unknown_error",
+      retry: "RetryWillNotFix",
+      instructions: `The Resource Catalog rejected the lookup for these bindings, so a retry gets the same answer. Check them in the project's bindings, ${refreshAndCommit}`
+    };
+  }
+  return {
+    errorCode: "unknown_error",
+    retry: "RetryLater",
+    instructions: `Retry; if it keeps failing, ${refreshAndCommit}`
+  };
+}
+function catalogLookupWarning(failure, kept, unresolved) {
+  const parts = [
+    `${describeCause(failure)}, so ${kept + unresolved.length} binding(s) were not checked against the cloud.`
+  ];
+  if (kept > 0) {
+    parts.push(`${kept} already in the solution were kept as they are.`);
+  }
+  if (unresolved.length > 0) {
+    parts.push(`Not added to the solution: ${describeBindings(unresolved)}.`);
+  }
+  return parts.join(" ");
+}
+
+class CatalogLookupError extends Error {
+  errorCode;
+  retry;
+  instructions;
+  unresolved;
+  constructor(failure, unresolved) {
+    super(`${describeCause(failure)}, so these bindings could not be resolved and are not in the solution: ${describeBindings(unresolved)}.`);
+    this.name = "CatalogLookupError";
+    const { errorCode, retry, instructions } = classify(failure);
+    this.errorCode = errorCode;
+    this.retry = retry;
+    this.instructions = instructions;
+    this.unresolved = unresolved;
+  }
+}
 // ../solution-sdk/src/resources/services/local-resource-matcher.ts
 function normalizeFolderPath(path) {
   if (!path)
@@ -15845,6 +16413,20 @@ async function findCatalogEntityAsync(catalog, query, match) {
   } while (pageCursor);
   return;
 }
+async function findCatalogEntitiesAsync(catalog, query, match) {
+  const found = [];
+  let pageCursor;
+  do {
+    const page = await catalog.searchFolderEntities({
+      ...query,
+      pageSize: 100,
+      pageCursor
+    });
+    found.push(...(page.items ?? []).filter(match));
+    pageCursor = page.nextPage ?? undefined;
+  } while (pageCursor);
+  return found;
+}
 function toResourceReference(entity) {
   return toCatalogReference({
     kind: entity.entityType ?? "",
@@ -15898,7 +16480,7 @@ function parseJsonString(raw) {
   return error ? undefined : parsed;
 }
 // ../solution-sdk/src/resources/services/resource-casing.ts
-var RESOURCE_FILES_FOLDER_NAME = "resources";
+var RESOURCE_FILES_FOLDER_NAME2 = "resources";
 function lowerFirstChar(value) {
   return value ? value.charAt(0).toLowerCase() + value.slice(1) : value;
 }
@@ -15927,7 +16509,7 @@ async function saveCasingNormalized(builder) {
 }
 async function normalizeResourceFileCasing(solutionDir) {
   const fs = getFileSystem();
-  const root = fs.path.join(solutionDir, RESOURCE_FILES_FOLDER_NAME);
+  const root = fs.path.join(solutionDir, RESOURCE_FILES_FOLDER_NAME2);
   if (!await fs.exists(root))
     return [];
   const byTarget = new Map;
@@ -15975,13 +16557,17 @@ function targetSegments(segments, kind, type) {
   const kindIndex = type ? target.length - 3 : target.length - 2;
   if (kindIndex < 0)
     return target;
-  if (target[kindIndex] === kind)
+  if (sameIgnoringCase(target[kindIndex], kind)) {
     target[kindIndex] = lowerFirstChar(kind);
-  if (type && target[kindIndex + 1] === type) {
+  }
+  if (type && sameIgnoringCase(target[kindIndex + 1], type)) {
     target[kindIndex + 1] = lowerFirstChar(type);
   }
   return target;
 }
+function sameIgnoringCase(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
 async function collectResourceFiles(root, segments) {
   const fs = getFileSystem();
   const [readError, names] = await catchError(fs.readdir(fs.path.join(root, ...segments)));
@@ -16054,6 +16640,118 @@ function parseResourceHeader(content) {
     return null;
   }
 }
+// ../solution-sdk/src/resources/services/resource-configurations.ts
+var ROOT_RESOURCE_TYPES = new Set(["resource", "solutionresource"]);
+var KEY_NOT_FOUND = /^(?:Solution)?Resource with key '([^']+)' was not found$/i;
+function isResourceKeyNotFound(error, resourceKey) {
+  if (!(error instanceof Error))
+    return false;
+  const typed = error;
+  const sameKey = (key) => key !== undefined && key.toLowerCase() === resourceKey.toLowerCase();
+  if (typeof typed.resourceType === "string" && typeof typed.resourceKey === "string") {
+    return ROOT_RESOURCE_TYPES.has(typed.resourceType.toLowerCase()) && sameKey(typed.resourceKey);
+  }
+  return sameKey(KEY_NOT_FOUND.exec(error.message.trim())?.[1]);
+}
+async function refreshArtefactSpecsAsync(builder, configurations) {
+  const resources = new Map;
+  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  if (loadError || !solution)
+    return resources;
+  for (const configuration of configurations) {
+    const resource = solution.resources.find((r) => r.key === configuration?.key);
+    if (!resource)
+      continue;
+    resources.set(resource.key, resource);
+    if (!resource.projectKey)
+      continue;
+    configuration.spec = await applyEntryPointEnhancementAsync(builder.context, resource, configuration.spec ?? {});
+  }
+  return resources;
+}
+async function exportResourceConfigurationsAsync(services, resourceKey, hint = {}) {
+  const { catalog, importer } = getRemoteResourceClients(services);
+  const byKey = (item) => item.entityKey === resourceKey;
+  const entity = (hint.name ? await findCatalogEntityAsync(catalog, { name: hint.name }, byKey) : undefined) ?? await findCatalogEntityAsync(catalog, {}, byKey);
+  if (!entity) {
+    throw new Error(`Resource '${resourceKey}' was not found in the solution or in the resource catalog`);
+  }
+  const payload = await importer.exportResourceAsync(toResourceReference(entity));
+  const definitions = payload.resourceDefinitions ?? [];
+  if (definitions.length === 0) {
+    throw new Error(`FPS export for '${resourceKey}' returned no resource definitions`);
+  }
+  return {
+    resources: definitions.map((d) => ({
+      key: d.key ?? "",
+      spec: d.spec ?? {},
+      locks: d.locks ?? [],
+      apiVersion: d.apiVersion,
+      isOverridable: d.isOverridable,
+      name: d.name ?? "",
+      kind: d.kind ?? "",
+      dependencies: (d.dependencies ?? []).map((dep) => ({
+        kind: dep.kind ?? "",
+        name: dep.name ?? ""
+      }))
+    }))
+  };
+}
+async function readLocalAsync(builder, resourceKey, read) {
+  if (!builder)
+    return;
+  const [error, value] = await catchError(read(builder));
+  if (!error)
+    return { builder, value };
+  if (isResourceKeyNotFound(error, resourceKey))
+    return;
+  throw error;
+}
+async function readResourceConfigurationsAsync(services, builder, resourceKey, hint = {}) {
+  const local = await readLocalAsync(builder, resourceKey, (b) => b.getAllConfigurationsAsync(resourceKey));
+  if (!local) {
+    return exportResourceConfigurationsAsync(services, resourceKey, hint);
+  }
+  await refreshArtefactSpecsAsync(local.builder, local.value?.resources ?? []);
+  return local.value;
+}
+async function readResourceConfigurationAsync(services, builder, resourceKey) {
+  const local = await readLocalAsync(builder, resourceKey, (b) => b.getConfigurationAsync(resourceKey));
+  if (local) {
+    const configuration = local.value;
+    const resources2 = await refreshArtefactSpecsAsync(local.builder, [
+      configuration
+    ]);
+    return { configuration, resource: resources2.get(configuration.key) };
+  }
+  const { resources } = await exportResourceConfigurationsAsync(services, resourceKey);
+  const primary = resources.find((r) => r.key === resourceKey) ?? resources[0];
+  const { key, spec, locks, apiVersion, isOverridable } = primary;
+  return { configuration: { key, spec, locks, apiVersion, isOverridable } };
+}
+// ../solution-sdk/src/resources/services/resource-lookup.ts
+async function findResourcesByNameAsync(services, builder, { kind, name, subTypes, folderKey }) {
+  const same = (a, b) => (a ?? "").toLowerCase() === b.toLowerCase();
+  const ofSubType = (type) => subTypes === undefined || subTypes.some((t) => same(type, t));
+  if (builder) {
+    const solution = await builder.context.loadAsync();
+    const local = solution.resources.filter((r) => same(r.kind, kind) && same(r.name, name) && ofSubType(r.type)).map((r) => ({
+      key: r.key,
+      local: true,
+      folderPath: r.folders?.[0]?.fullyQualifiedName
+    }));
+    if (local.length > 0)
+      return local;
+  }
+  const { catalog } = getRemoteResourceClients(services);
+  const rows = await findCatalogEntitiesAsync(catalog, { name, entityTypes: [kind] }, (row) => same(row.entityType, kind) && same(row.entityName, name) && ofSubType(row.entitySubType) && (folderKey === undefined || same(row.folderKey, folderKey)));
+  return rows.map((row) => ({
+    key: row.entityKey ?? "",
+    local: false,
+    folderPath: row.fullyQualifiedName ?? undefined,
+    folderKey: row.folderKey ?? undefined
+  }));
+}
 // ../solution-sdk/src/resources/services/resource-name.ts
 var MAX_RESOURCE_NAME_LENGTH = 256;
 var UNSAFE_NAME_CHARS = /[\\/:*?"<>|]/;
@@ -16095,32 +16793,15 @@ function assertValidResourceName(name, options = {}) {
     throw new Error(`${result.message}. ${result.instructions}`);
   }
 }
-// ../solution-sdk/src/solution-auth.ts
-async function getSolutionAuthContext(options) {
-  const ctx = await getAuthContext({
-    tenant: options.tenant,
-    ensureTokenValidityMinutes: options.loginValidity ?? 10,
-    envFilePath: options.envFilePath,
-    requireOrganizationId: true,
-    requireTenantName: true
-  });
-  const organizationId = ctx.organizationId;
-  const tenantName = ctx.tenantName;
-  const basePath = `${ctx.baseUrl}/${organizationId}/${tenantName}/automationsolutions_`;
-  return {
-    accessToken: ctx.accessToken,
-    basePath,
-    organizationId,
-    tenantName,
-    identity: ctx.identity
-  };
-}
 // ../solution-sdk/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"]);
+
+class OverwriteRefreshError extends Error {
+}
 function placeholderForType(type) {
   switch ((type ?? "string").toLowerCase()) {
     case "boolean":
@@ -16221,13 +16902,15 @@ function resolveBindingResourceIdentity(binding) {
       };
   }
 }
-async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTypes) {
+async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTypes, projectBindings) {
   const result = {
     created: 0,
     imported: 0,
     skipped: 0,
     pruned: 0,
-    warnings: []
+    projectResourcesCreated: 0,
+    warnings: [],
+    unresolved: []
   };
   const uipxProjects = await readUipxProjects(solutionDir);
   const paths = projectPaths ?? uipxProjects.map((p) => p.path);
@@ -16241,7 +16924,7 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     return result;
   }
   const serializer = services.container.resolve(Tokens.IBindingsMetadataSerializer);
-  const { bindings: allBindings, parseErrors } = await collectBindings(solutionDir, paths, bindingsJsonFallbackDirs, serializer);
+  const { bindings: allBindings, parseErrors } = await collectBindings(bindingsJsonFallbackDirs, serializer, bindingSources(solutionDir, paths, uipxProjects, projectBindings));
   if (parseErrors.length > 0) {
     const detail = parseErrors.map((e) => `${e.path}: ${e.reason}`).join("; ");
     throw new Error(`Invalid bindings file — ${detail}`);
@@ -16255,7 +16938,8 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     logger.warn(`Failed to get solution builder: ${builderError.message}`);
     return result;
   }
-  await reconcileSolutionProjects(builder, solutionDir, projectSubTypes);
+  const reconcileOutcome = await reconcileSolutionProjects(builder, solutionDir, projectSubTypes);
+  result.projectResourcesCreated = reconcileOutcome.resourcesAdded;
   const memberProjectKeys = new Set(uipxProjects.map((project) => project.id.toLowerCase()));
   await pruneMemberClones(builder, memberProjectKeys, result);
   if (allBindings.length === 0) {
@@ -16270,6 +16954,28 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
   const resolveKindMetadata = await buildKindResolver(metadataReader);
   const solution = await builder.context.loadAsync();
   const knownResourceKeys = new Set((solution.resources ?? []).map((r) => r.key?.toLowerCase()).filter((k) => !!k));
+  let keptUnchecked = 0;
+  const resolvedKeys = new Set;
+  const overwrittenKeys = new Set;
+  const bindingKey = (kind, name) => `${kind}:${name ?? ""}`.toLowerCase();
+  const recordUnchecked = async (error, kind, name, directCloudKey) => {
+    if (error) {
+      const failure = classifyCatalogFailure(error);
+      if (!result.catalogLookupFailure || stopsCatalogLookups(failure) && !stopsCatalogLookups(result.catalogLookupFailure)) {
+        result.catalogLookupFailure = failure;
+      }
+    }
+    const covered = await isUncheckedBindingCovered(builder, knownResourceKeys, kind, name, directCloudKey);
+    if (covered) {
+      keptUnchecked++;
+      result.skipped++;
+      return;
+    }
+    result.unresolved.push({
+      kind,
+      name: directCloudKey ?? name
+    });
+  };
   const virtualCandidates = [];
   for (const binding of allBindings) {
     const identity = resolveBindingResourceIdentity(binding);
@@ -16299,7 +17005,12 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
       logger.info(`Skipping ${kind} "${name}" — the solution provisions this project itself; its member declaration covers the binding`);
       continue;
     }
-    const rcsMatch = directCloudKey ? await findResourceByKeyInRcs(builder, kind, directCloudKey, folderPath) : await findResourceInRcs(builder, kind, name, folderPath);
+    const lookupsStopped = !!result.catalogLookupFailure && stopsCatalogLookups(result.catalogLookupFailure);
+    const [lookupError, rcsMatch] = lookupsStopped ? [undefined, undefined] : await catchError(directCloudKey ? findResourceByKeyInRcs(builder, kind, directCloudKey, folderPath, true) : findResourceInRcs(builder, kind, name, folderPath, true));
+    if (lookupsStopped || lookupError) {
+      await recordUnchecked(lookupError, kind, name, directCloudKey);
+      continue;
+    }
     const resolvedType = identity.type ?? rcsMatch?.type ?? metadata?.type;
     if (!rcsMatch) {
       if (isConnection) {
@@ -16318,30 +17029,48 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     }
     if (!isConnection && rcsMatch.key && knownResourceKeys.has(rcsMatch.key.toLowerCase())) {
       result.skipped++;
+      resolvedKeys.add(bindingKey(kind, name));
       continue;
     }
     const callType = isConnection ? binding.metadata?.connector : resolvedType;
-    const [importError] = await catchError(builder.addOrUpdateResourceToSolutionAsync({
+    const wasKnown = !!rcsMatch.key && knownResourceKeys.has(rcsMatch.key.toLowerCase());
+    const reference = {
       kind,
       type: callType,
       key: rcsMatch.key,
       name: rcsMatch.name,
       folder: rcsMatch.folder
-    }, true));
+    };
+    const [importError] = await catchError(wasKnown ? refreshKnownResource(services, builder, reference, overwrittenKeys) : builder.addOrUpdateResourceToSolutionAsync(reference, true));
     if (!importError) {
+      resolvedKeys.add(bindingKey(kind, directCloudKey ?? name));
+      if (wasKnown) {
+        result.skipped++;
+        logger.info(`Refreshed ${kind} "${rcsMatch.name}" (key: ${rcsMatch.key}), already in solution`);
+        continue;
+      }
       if (rcsMatch.key) {
         knownResourceKeys.add(rcsMatch.key.toLowerCase());
+        overwrittenKeys.add(rcsMatch.key.toLowerCase());
       }
       result.imported++;
       logger.info(`Imported ${kind} "${rcsMatch.name}" (key: ${rcsMatch.key}) into solution`);
       continue;
     }
+    if (stopsCatalogLookups(classifyCatalogFailure(importError))) {
+      await recordUnchecked(importError, kind, name, directCloudKey);
+      continue;
+    }
     if (isConnection) {
-      result.warnings.push(`Failed to import connection ${directCloudKey}: ${importError.message}`);
-      logger.warn(`Failed to import connection ${directCloudKey}: ${importError.message}`);
+      const failedStep = importError instanceof OverwriteRefreshError ? "refresh the debug overwrite for" : "import";
+      const warning = `Failed to ${failedStep} connection ${directCloudKey}: ${importError.message}`;
+      result.warnings.push(warning);
+      logger.warn(warning);
       continue;
     }
-    logger.warn(`Failed to import ${kind} "${name}" from Orchestrator: ${importError.message}. Will create locally instead.`);
+    const importWarning = `Failed to import ${kind} "${name}" from Orchestrator: ${importError.message}. Created it locally instead; link it before deploy if it must point at the cloud resource.`;
+    result.warnings.push(importWarning);
+    logger.warn(importWarning);
     virtualCandidates.push({
       binding,
       kind,
@@ -16360,11 +17089,29 @@ async function syncResourcesFromBindings(solutionDir, projectPaths, projectSubTy
     return true;
   });
   for (const candidate of dedupedVirtuals) {
-    const [syncError] = await catchError(createVirtualForBinding(builder, candidate.binding, candidate.kind, candidate.type, candidate.metadata, candidate.name, candidate.folderPath, result));
+    const [syncError, created] = await catchError(createVirtualForBinding(builder, candidate.binding, candidate.kind, candidate.type, candidate.metadata, candidate.name, candidate.folderPath, result));
     if (syncError) {
       logger.warn(`Failed to create virtual ${candidate.kind}/${candidate.name}: ${syncError.message}`);
+    } else if (created) {
+      resolvedKeys.add(bindingKey(candidate.kind, candidate.name));
     }
   }
+  if (result.catalogLookupFailure) {
+    const seen = new Set;
+    result.unresolved = result.unresolved.filter((b) => {
+      const key = bindingKey(b.kind, b.name);
+      if (resolvedKeys.has(key)) {
+        keptUnchecked++;
+        result.skipped++;
+        return false;
+      }
+      if (seen.has(key))
+        return false;
+      seen.add(key);
+      return true;
+    });
+    result.warnings.push(catalogLookupWarning(result.catalogLookupFailure, keptUnchecked, result.unresolved));
+  }
   const saveError = await saveAndDisposeBuilder(builder, solutionDir);
   if (saveError) {
     throw new Error(`Failed to save solution changes: ${saveError.message}`);
@@ -16392,6 +17139,43 @@ async function pruneMemberClones(builder, memberProjectKeys, result) {
     logger.info(`Removed duplicate ${clone.kind} "${clone.name}" (key: ${clone.key}) — the solution provisions this project itself`);
   }
 }
+async function isUncheckedBindingCovered(builder, knownResourceKeys, kind, name, directCloudKey) {
+  if (directCloudKey) {
+    return knownResourceKeys.has(directCloudKey.toLowerCase());
+  }
+  const solution = await builder.context.loadAsync();
+  return !!findMatchingLocalResource(solution.resources ?? [], kind, name, undefined);
+}
+async function refreshKnownResource(services, builder, reference, overwrittenKeys) {
+  const solution = await builder.context.loadAsync();
+  const referenceKey = reference.key.toLowerCase();
+  const existing = (solution.resources ?? []).find((resource) => resource.key?.toLowerCase() === referenceKey);
+  const mediator = services.container.resolve(Tokens.IMediator);
+  const response = await mediator.sendCommandAsync(new AddOrUpdateResourceToSolutionCommand(builder.context, reference, true, existing?.key));
+  const sdkWroteOverwrite = response.saved && existing?.key === reference.key;
+  if (!existing || sdkWroteOverwrite || overwrittenKeys.has(referenceKey)) {
+    overwrittenKeys.add(referenceKey);
+    return response;
+  }
+  const [overwriteError] = await catchError(refreshOverwrite(services, builder, reference, existing.key));
+  if (overwriteError)
+    throw new OverwriteRefreshError(overwriteError.message);
+  overwrittenKeys.add(referenceKey);
+  return response;
+}
+async function refreshOverwrite(services, builder, reference, solutionResourceKey) {
+  const importer = services.container.resolve(Tokens.IImportResourceHelper);
+  const payload = await importer.exportResourceAsync(reference);
+  const referenceKey = reference.key.toLowerCase();
+  const overwrite = [...payload.overwrites].find(([key]) => key.toLowerCase() === referenceKey)?.[1];
+  if (!overwrite) {
+    throw new Error(`Overwrite not found for resource key '${reference.key}' in exported payload`);
+  }
+  const overwrites = services.container.resolve(Tokens.IResourceOverwritesService);
+  await overwrites.manageSolutionOverwritesAsync(builder.context, [
+    { solutionResourceKey, overwrite }
+  ]);
+}
 async function saveAndDisposeBuilder(builder, solutionDir) {
   const context = builder.context;
   if (!context?.forceSaveChangesAsync) {
@@ -16461,11 +17245,11 @@ async function createVirtualForBinding(builder, _binding, kind, type, metadata,
   if (alreadyVirtualized) {
     result.skipped++;
     logger.info(`Skipping virtual ${kind} "${name}" — existing resource "${alreadyVirtualized.name}" in solution_folder already covers this binding (requested folder "${folderPath}")`);
-    return;
+    return true;
   }
   const minted = await mintVirtualResource(builder, kind, type, name, metadata);
   if (!minted)
-    return;
+    return false;
   result.created++;
   logger.info(`Created ${kind} "${name}" in solution`);
   if (!virtualizable) {
@@ -16473,6 +17257,7 @@ async function createVirtualForBinding(builder, _binding, kind, type, metadata,
     result.warnings.push(warning);
     logger.warn(warning);
   }
+  return true;
 }
 async function findResourceByKeyInRcs(builder, kind, expectedKey, folderPath, propagateErrors = false) {
   const expectedLower = expectedKey.toLowerCase();
@@ -16550,8 +17335,8 @@ async function searchRcsResourcesStrict(builder, kind, name) {
   } while (pageCursor);
   return allMatches;
 }
-async function findResourceInRcs(builder, kind, name, folderPath) {
-  const allMatches = await searchRcsResources(builder, kind, name);
+async function findResourceInRcs(builder, kind, name, folderPath, propagateErrors = false) {
+  const allMatches = propagateErrors ? await searchRcsResourcesStrict(builder, kind, name) : await searchRcsResources(builder, kind, name);
   if (allMatches.length === 0) {
     return;
   }
@@ -16649,9 +17434,15 @@ async function readUiprojName(uiprojPath) {
     return;
   }
 }
+async function snapshotResourceIdentities(builder) {
+  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  if (loadError || !solution)
+    return;
+  return new Set((solution.resources ?? []).map((resource) => resource.key ? resource.key.toLowerCase() : `${resource.kind}:${resource.name}`.toLowerCase()));
+}
 async function reconcileSolutionProjects(builder, solutionDir, projectSubTypes) {
   const fs = getFileSystem();
-  const outcome = { projectsCount: 0 };
+  const outcome = { projectsCount: 0, resourcesAdded: 0 };
   const uipxProjects = await readUipxProjects(solutionDir);
   const projectDetails = uipxProjects.flatMap((project) => {
     const reconcileType = mapUipxTypeToReconcileType(project.type);
@@ -16669,6 +17460,7 @@ async function reconcileSolutionProjects(builder, solutionDir, projectSubTypes)
   if (projectDetails.length === 0)
     return outcome;
   const solutionName = fs.path.basename(solutionDir);
+  const before = await snapshotResourceIdentities(builder);
   const [reconcileError] = await catchError(builder.reconcileProjectsAsync({
     solutionName,
     projects: projectDetails
@@ -16678,6 +17470,10 @@ async function reconcileSolutionProjects(builder, solutionDir, projectSubTypes)
     return outcome;
   }
   outcome.projectsCount = projectDetails.length;
+  const after = before && await snapshotResourceIdentities(builder);
+  if (before && after) {
+    outcome.resourcesAdded = [...after].filter((identity) => !before.has(identity)).length;
+  }
   logger.info(`Reconciled ${projectDetails.length} .uipx project(s) in solution ${solutionName}`);
   return outcome;
 }
@@ -16719,12 +17515,48 @@ function findBindingsSchemaError(content) {
   }
   return null;
 }
-async function collectBindings(solutionDir, projectPaths, bindingsJsonFallbackDirs, serializer) {
+function bindingSources(solutionDir, projectPaths, projects, projectBindings) {
+  const sources = [{ directory: solutionDir }];
+  const fileDirectories = new Set([solutionDir]);
+  const contributedIds = new Set;
+  for (const directory of new Set(projectPaths)) {
+    const owners = projects.filter((project) => project.path === directory);
+    for (const project of owners) {
+      const bindings = projectBindings?.get(project.id);
+      if (bindings === undefined || contributedIds.has(project.id))
+        continue;
+      contributedIds.add(project.id);
+      sources.push({
+        directory,
+        contribution: { projectId: project.id, bindings }
+      });
+    }
+    const needsFile = owners.length === 0 || owners.some((project) => !projectBindings?.has(project.id));
+    if (needsFile && !fileDirectories.has(directory)) {
+      fileDirectories.add(directory);
+      sources.push({ directory });
+    }
+  }
+  return sources;
+}
+async function collectBindings(bindingsJsonFallbackDirs, serializer, sources) {
   const fs = getFileSystem();
   const allBindings = [];
   const parseErrors = [];
-  const candidateDirs = [solutionDir, ...projectPaths];
-  for (const dir of candidateDirs) {
+  for (const { directory: dir, contribution } of sources) {
+    if (contribution) {
+      if (contribution.bindings.length === 0)
+        continue;
+      const parsed2 = deserializeBindings(JSON.stringify({
+        version: "2.0",
+        resources: contribution.bindings
+      }), `${dir} (bindings contributed by the project's tool; project ${contribution.projectId})`, serializer);
+      if ("error" in parsed2)
+        parseErrors.push(parsed2.error);
+      else
+        allBindings.push(...parsed2.resources);
+      continue;
+    }
     const v2Path = fs.path.join(dir, "bindings_v2.json");
     let bindingsPath = v2Path;
     let exists = await fs.exists(v2Path);
@@ -16743,37 +17575,44 @@ async function collectBindings(solutionDir, projectPaths, bindingsJsonFallbackDi
       });
       continue;
     }
-    const decoded = new TextDecoder().decode(content);
-    let success;
-    let metadata;
-    try {
-      const result = serializer.tryDeserialize(decoded);
-      success = result.success;
-      metadata = result.metadata;
-    } catch (err) {
-      parseErrors.push({
-        path: bindingsPath,
+    const parsed = deserializeBindings(new TextDecoder().decode(content), bindingsPath, serializer);
+    if ("error" in parsed)
+      parseErrors.push(parsed.error);
+    else
+      allBindings.push(...parsed.resources);
+  }
+  return { bindings: allBindings, parseErrors };
+}
+function deserializeBindings(decoded, source, serializer) {
+  let success;
+  let metadata;
+  try {
+    const result = serializer.tryDeserialize(decoded);
+    success = result.success;
+    metadata = result.metadata;
+  } catch (err) {
+    return {
+      error: {
+        path: source,
         reason: findBindingsSchemaError(decoded) ?? `does not match the expected v2 bindings schema — check each resource's 'kind' and required fields${err instanceof Error ? ` (${err.message})` : ""}`
-      });
-      continue;
-    }
-    if (!success) {
-      parseErrors.push({
-        path: bindingsPath,
+      }
+    };
+  }
+  if (!success) {
+    return {
+      error: {
+        path: source,
         reason: findBindingsSchemaError(decoded) ?? "does not match the expected v2 bindings schema (the serializer rejected it)"
-      });
-      continue;
-    }
-    if (!metadata?.resources?.length) {
-      continue;
-    }
-    allBindings.push(...metadata.resources);
+      }
+    };
   }
-  return { bindings: allBindings, parseErrors };
+  return { resources: metadata?.resources ?? [] };
 }
-async function syncAndLog(solutionDir, projectSubTypes) {
-  const [syncError, syncResult] = await catchError(syncResourcesFromBindings(solutionDir, undefined, projectSubTypes));
+async function syncAndLog(solutionDir, projectSubTypes, options) {
+  const [syncError, syncResult] = await catchError(syncResourcesFromBindings(solutionDir, undefined, projectSubTypes, options?.projectBindings));
   if (syncError) {
+    if (options?.failOnUnresolved)
+      throw syncError;
     logger.warn(`Resource sync failed: ${syncError.message}. Continuing.`);
     return;
   }
@@ -16783,6 +17622,9 @@ async function syncAndLog(solutionDir, projectSubTypes) {
   for (const warning of syncResult.warnings) {
     logger.warn(warning);
   }
+  if (options?.failOnUnresolved && syncResult.catalogLookupFailure && syncResult.unresolved.length > 0) {
+    throw new CatalogLookupError(syncResult.catalogLookupFailure, syncResult.unresolved);
+  }
 }
 
 // ../solution-sdk/src/resources/services/resource-refresh-service.ts
@@ -16819,7 +17661,11 @@ async function resourceRefreshAsync(solutionPath = ".", options = {}) {
   const resolverWarnings = subTypesError ? [
     `Could not resolve project subTypes: ${subTypesError.message}. Project artefacts for types that need a variant were left as they are; fix the tool install and re-run 'uip solution resources refresh'.`
   ] : [];
-  const [syncError, result] = await catchError(syncResourcesFromBindings(resolvedPath, undefined, projectSubTypes ?? new Map));
+  const [bindingsError, projectBindings] = await catchError(options.resolveProjectBindingsAsync?.() ?? Promise.resolve(new Map));
+  if (bindingsError) {
+    resolverWarnings.push(`Could not read the bindings projects contribute: ${bindingsError.message}. Those projects were synced from any bindings_v2.json on disk instead; fix the tool install and re-run 'uip solution resources refresh'.`);
+  }
+  const [syncError, result] = await catchError(syncResourcesFromBindings(resolvedPath, undefined, projectSubTypes ?? new Map, projectBindings ?? new Map));
   if (syncError) {
     return {
       ok: false,
@@ -16833,6 +17679,7 @@ async function resourceRefreshAsync(solutionPath = ".", options = {}) {
     imported: result.imported,
     skipped: result.skipped,
     pruned: result.pruned,
+    projectResourcesCreated: result.projectResourcesCreated,
     warnings: [...resolverWarnings, ...result.warnings]
   };
 }
@@ -17014,6 +17861,7 @@ function sortKeysDeep(value) {
   return sorted;
 }
 export {
+  CatalogLookupError,
   EntryPointSpecEnhancer,
   MAX_RESOURCE_NAME_LENGTH,
   ProjectManifestError,
@@ -17026,7 +17874,9 @@ export {
   createProjectInSolutionBuilder,
   createResourceBuilderServices,
   createResourceKindMetadataResolver,
+  exportResourceConfigurationsAsync,
   exportResourceDefinitionAsync,
+  findCatalogEntitiesAsync,
   findCatalogEntityAsync,
   findMatchingLocalResource,
   findMatchingMemberResource,
@@ -17034,21 +17884,26 @@ export {
   findProjectFile,
   findResourceByKeyInRcs,
   findResourceInRcs,
+  findResourcesByNameAsync,
   formatResourceSubtypes,
   getRemoteResourceClients,
   hasAnyTemplateRow,
   hasBareTemplateRow,
   isMissingProjectTypeError,
   isProjectManifestError,
+  isResourceKeyNotFound,
   normalizeFolderPath,
   normalizeResourceCasing,
   normalizeResourceFileCasing,
   readProjectFile,
+  readResourceConfigurationAsync,
+  readResourceConfigurationsAsync,
   readSolutionFile,
   readSolutionManifest,
   readSpecEntryPoints,
   readSpecProperty,
   readUipxProjects,
+  refreshArtefactSpecsAsync,
   resolveProjectDirFromManifest,
   resolveResourceKindMetadata,
   resolveSolutionFilePath,
@@ -17068,4 +17923,4 @@ export {
   writeSolutionFile
 };
 
-//# debugId=DD659B11A166BFC064756E2164756E21
+//# debugId=EF208697C79EBB8D64756E2164756E21