@uipath/flow-tool 1.204.0-preview.254 → 1.205.0-preview.256

package/dist/{packager-tool-fjcbc1bb.js → packager-tool-7wnxyvf9.js}

@@ -1,146 +1,48 @@
 import {
   resolveMaestroRegistry
-} from "./packager-tool-t605qewm.js";
+} from "./packager-tool-dxgrhfq5.js";
 import {
-  listKnownSdkNodes
-} from "./packager-tool-awkq26v0.js";
+  searchWithFilters
+} from "./packager-tool-7hw344bt.js";
+import {
+  buildInSolutionNodes,
+  findSolutionFromCwd,
+  unknownContractWarning
+} from "./packager-tool-phw8ydjx.js";
 import {
-  getAgentProjectMetadataReader
-} from "./packager-tool-8qp60s20.js";
+  listKnownSdkNodes
+} from "./packager-tool-e7kvq8hf.js";
 import {
   getAuthContext,
   getLoginStatusAsync
-} from "./packager-tool-6h69pd2a.js";
+} from "./packager-tool-kn86394c.js";
 import {
   isBrowser
 } from "./packager-tool-0gctz400.js";
 import {
   MANIFEST_FEATURE_FLAGS,
-  ManifestClient,
-  extractIOFromEntryPoints,
-  getServiceType,
-  taskDefinitionsToNodeManifests
-} from "./packager-tool-5nqhxb9e.js";
+  ManifestClient
+} from "./packager-tool-dwd6cc01.js";
 import {
   UIPATH_HOME_DIR,
   addSdkUserAgentHeader,
-  catchError,
+  extractErrorMessage,
   getSdkUserAgentToken,
   hashContent,
+  httpStatusOf,
   installSdkUserAgentHeader,
   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 {
   __require
 } from "./packager-tool-1yh8g550.js";
 
-// ../maestro-sdk/src/registry/filter-engine.ts
-function filterNodes(nodes, parsedFilters) {
-  if (!parsedFilters.filters || parsedFilters.filters.length === 0) {
-    return nodes;
-  }
-  return nodes.filter((node) => {
-    if (parsedFilters.logic === "AND") {
-      return parsedFilters.filters.every((condition) => matchesCondition(node, condition));
-    } else {
-      return parsedFilters.filters.some((condition) => matchesCondition(node, condition));
-    }
-  });
-}
-function matchesCondition(node, condition) {
-  const fieldValue = getFieldValue(node, condition.field);
-  if (fieldValue === null || fieldValue === undefined) {
-    return false;
-  }
-  const searchValue = condition.value.toString().toLowerCase();
-  if (Array.isArray(fieldValue)) {
-    return matchesArrayField(fieldValue, condition.operator, searchValue);
-  }
-  const fieldString = fieldValue.toString().toLowerCase();
-  switch (condition.operator) {
-    case "equals":
-      return fieldString === searchValue;
-    case "contains":
-      return fieldString.includes(searchValue);
-    case "startsWith":
-      return fieldString.startsWith(searchValue);
-    case "endsWith":
-      return fieldString.endsWith(searchValue);
-    case "in": {
-      const values = searchValue.split(",").map((v) => v.trim());
-      return values.includes(fieldString);
-    }
-    default:
-      return fieldString === searchValue;
-  }
-}
-function matchesArrayField(arrayValue, operator, searchValue) {
-  const lowerArray = arrayValue.map((v) => v.toLowerCase());
-  switch (operator) {
-    case "equals":
-      return lowerArray.includes(searchValue);
-    case "contains":
-      return lowerArray.some((tag) => tag.includes(searchValue));
-    case "in": {
-      const values = searchValue.split(",").map((v) => v.trim());
-      return lowerArray.some((tag) => values.includes(tag));
-    }
-    default:
-      return lowerArray.includes(searchValue);
-  }
-}
-function getFieldValue(node, field) {
-  switch (field) {
-    case "category":
-      return node.category;
-    case "type":
-    case "nodetype":
-      return node.nodeType;
-    case "tags":
-      return node.tags;
-    case "displayname":
-      return node.display?.label;
-    case "description":
-      return node.description ?? node.display?.description;
-    default:
-      return node[field];
-  }
-}
-function searchWithFilters(nodes, keyword, filters) {
-  let results = nodes;
-  if (filters && filters.filters.length > 0) {
-    results = filterNodes(results, filters);
-  }
-  if (keyword && keyword.trim() !== "") {
-    const lowerKeyword = keyword.toLowerCase();
-    results = results.filter((node) => {
-      if (node.nodeType?.toLowerCase().includes(lowerKeyword)) {
-        return true;
-      }
-      if (node.category?.toLowerCase().includes(lowerKeyword)) {
-        return true;
-      }
-      if (node.tags?.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
-        return true;
-      }
-      if (node.display?.label?.toLowerCase().includes(lowerKeyword)) {
-        return true;
-      }
-      if (node.description?.toString().toLowerCase().includes(lowerKeyword)) {
-        return true;
-      }
-      if (node.display?.description?.toLowerCase().includes(lowerKeyword)) {
-        return true;
-      }
-      return false;
-    });
-  }
-  return results;
-}
-
 // ../integrationservice-sdk/generated/connections/src/runtime.ts
 var BASE_PATH = "https://alpha.uipath.com/entity/Azure/connections_".replace(/\/+$/, "");
 
@@ -672,7 +574,7 @@ var package_default = {
   name: "@uipath/integrationservice-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0-preview.254",
+  version: "1.205.0-preview.256",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -708,12 +610,13 @@ var package_default = {
   devDependencies: {
     "@uipath/auth": "workspace:*",
     "@uipath/common": "workspace:*",
+    "@uipath/solution-sdk": "workspace:*",
     "@openapitools/openapi-generator-cli": "^2.31.1",
     "@types/node": "^25.5.2",
     typescript: "^7.0.2"
   },
   dependencies: {
-    "@uipath/integration-service-design-time": "1.41.2"
+    "@uipath/integration-service-design-time": "2.10.0"
   }
 };
 
@@ -6506,6 +6409,43 @@ var CONNECTION_STATE_NAMES = new Map([
   [ConnectionState.Expired, "Expired"],
   [ConnectionState.Failed, "Failed"]
 ]);
+// ../integrationservice-sdk/src/dap/activity-bindings.ts
+var DROPPED_RESOURCES = ["connection", "eventtrigger"];
+var isResourceType = (resource, types) => types.includes((resource ?? "").toLowerCase());
+function storedActivityBindings(bindings) {
+  return bindings.filter((binding) => !isResourceType(binding.resource, DROPPED_RESOURCES));
+}
+function planResourceBindings(stored, resolved) {
+  const plans = [];
+  for (const { field, companion, selection } of resolved) {
+    const entry = stored.find((binding) => binding.key?.toLowerCase() === selection.key.toLowerCase() && !isResourceType(binding.resource, ["property"]));
+    if (entry === undefined)
+      continue;
+    const displayName = entry.value?.name?.displayName ?? field;
+    const rows = [
+      {
+        field,
+        propertyAttribute: "name",
+        name: displayName,
+        default: selection.name
+      }
+    ];
+    if (entry.value?.folderKey && selection.folderKey) {
+      rows.push({
+        field: companion,
+        propertyAttribute: "folderKey",
+        name: `${displayName} folder`,
+        default: selection.folderKey
+      });
+    }
+    plans.push({
+      resource: entry.resource,
+      resourceKey: selection.key,
+      rows
+    });
+  }
+  return plans;
+}
 // ../integrationservice-sdk/src/dap/filter-builder/index.ts
 class FilterNotSupportedError extends Error {
   constructor(message) {
@@ -6643,6 +6583,177 @@ function createLiveConnectionsProvider() {
   };
 }
 
+// ../integrationservice-sdk/src/dap/resource-field-resolver.ts
+var FIELD_ARRAY_MARKER = "[*]";
+function resourceFolderKeyFieldName(fieldName) {
+  const base = fieldName.endsWith(FIELD_ARRAY_MARKER) ? fieldName.slice(0, -FIELD_ARRAY_MARKER.length) : fieldName;
+  return `${base}_folderKey`;
+}
+function isResourceSelection(value) {
+  return typeof value === "object" && value !== null && typeof value.key === "string" && typeof value.name === "string";
+}
+
+class ResourceFieldResolutionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ResourceFieldResolutionError";
+  }
+}
+async function resolveResourceFieldValues(fieldValues, resourceFields, solutionDir) {
+  let solution;
+  const openOnce = async () => {
+    solution ??= await openSolution(solutionDir);
+    return solution;
+  };
+  const [resolveError, resolved] = await catchError(resolveEach(fieldValues, resourceFields, openOnce));
+  const saveError = solution ? await saveSolution(solution, solutionDir) : null;
+  if (resolveError) {
+    if (saveError) {
+      resolveError.message += ` The solution at '${solutionDir}' also failed to save: ${saveError.message}`;
+    }
+    throw resolveError;
+  }
+  if (saveError) {
+    throw new ResourceFieldResolutionError(`The resource was referenced but the solution at '${solutionDir}' could not be saved: ${saveError.message}`);
+  }
+  return resolved;
+}
+async function resolveEach(fieldValues, resourceFields, openOnce) {
+  const resolved = [];
+  for (const field of resourceFields) {
+    const value = fieldValues[field.name];
+    if (value == null || value === "" || isResourceSelection(value) || typeof value === "string" && value.startsWith("=")) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      throw new ResourceFieldResolutionError(`'${field.name}' is a multi-select ${field.kind} picker, which the CLI cannot resolve yet — pick one ${field.kind} by name.`);
+    }
+    if (typeof value !== "string") {
+      throw new ResourceFieldResolutionError(`'${field.name}' is a ${field.kind} picker on this activity — pass the ${field.kind} name as a string.`);
+    }
+    const companion = resourceFolderKeyFieldName(field.name);
+    const folderHint = fieldValues[companion];
+    const selection = await referenceResource(await openOnce(), field, value, typeof folderHint === "string" && folderHint !== "" ? folderHint : undefined, companion);
+    fieldValues[field.name] = selection;
+    delete fieldValues[companion];
+    resolved.push({ field: field.name, companion, selection });
+  }
+  return resolved;
+}
+async function openSolution(solutionDir) {
+  const [error, solution] = await catchError((async () => {
+    const { getSolutionAuthContext } = await import("./solution-auth-8qz5pw7z.js");
+    await getSolutionAuthContext({});
+    const resources = await import("./index-1b2je9n2.js");
+    await resources.normalizeResourceFileCasing(solutionDir);
+    const services = await resources.createResourceBuilderServices();
+    return {
+      resources,
+      builder: await services.getSolutionBuilder(solutionDir)
+    };
+  })());
+  if (error) {
+    throw new ResourceFieldResolutionError(`A resource picker needs the solution the resource is referenced into, and '${solutionDir}' could not be opened: ${error.message}. ` + "Check the project sits in a solution and you are logged in (run 'uip login').");
+  }
+  return solution;
+}
+async function saveSolution({ resources, builder }, solutionDir) {
+  const error = await resources.saveCasingNormalized(builder);
+  if (!error)
+    await resources.normalizeResourceFileCasing(solutionDir);
+  return error;
+}
+async function referenceResource({ resources, builder }, field, name, folderHint, companion) {
+  const matches = await resources.searchRcsResources(builder, field.kind, name);
+  const candidates = matches.filter((match2) => match2.name.toLowerCase() === name.toLowerCase() && (folderHint === undefined || matchesFolder(resources, match2, folderHint)));
+  if (candidates.length === 0) {
+    throw new ResourceFieldResolutionError(`No ${field.kind} named '${name}'${folderHint ? ` in folder '${folderHint}'` : ""} was found. ` + "If a failed resource catalog lookup was logged above, check your login and retry. " + `Otherwise run 'uip solution resources list --source remote --kind ${field.kind} --search "${name}"' to discover candidates.`);
+  }
+  if (candidates.length > 1) {
+    const folders = candidates.map((match2) => `  - ${match2.folder?.fullyQualifiedName ?? "<tenant>"} (folder key ${match2.folder?.folderKey ?? "<none>"})`).join(`
+`);
+    throw new ResourceFieldResolutionError(`${candidates.length} ${field.kind} resources are named '${name}'. Pass the folder key or path as '${companion}' to pick one:
+${folders}`);
+  }
+  const [match] = candidates;
+  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  if (loadError) {
+    throw new ResourceFieldResolutionError(`Failed to read the solution before referencing ${field.kind} '${name}': ${loadError.message}`);
+  }
+  const existing = solution.resources.find((resource) => resource.key.toLowerCase() === match.key.toLowerCase());
+  if (existing) {
+    return {
+      key: existing.key,
+      name: match.name,
+      folderKey: match.folder?.folderKey,
+      folderPath: match.folder?.fullyQualifiedName
+    };
+  }
+  const [referenceError, response] = await catchError(builder.addOrUpdateResourceToSolutionAsync({
+    kind: field.kind,
+    type: match.type,
+    key: match.key,
+    name: match.name,
+    folder: match.folder
+  }, true));
+  if (referenceError) {
+    throw new ResourceFieldResolutionError(`Failed to reference ${field.kind} '${name}' into the solution: ${referenceError.message}`);
+  }
+  return {
+    key: response.resource.key,
+    name: match.name,
+    folderKey: match.folder?.folderKey,
+    folderPath: match.folder?.fullyQualifiedName
+  };
+}
+function matchesFolder({ normalizeFolderPath }, match, folderHint) {
+  const folder = match.folder;
+  if (!folder)
+    return false;
+  if (folder.folderKey.toLowerCase() === folderHint.toLowerCase())
+    return true;
+  const hint = normalizeFolderPath(folderHint);
+  return normalizeFolderPath(folder.fullyQualifiedName) === hint || folder.path !== undefined && normalizeFolderPath(folder.path) === hint;
+}
+
+// ../integrationservice-sdk/src/dap/solution-resource-configurations.ts
+var CATALOG_MISS = "was not found in the solution or in the resource catalog";
+function createSolutionResourceConfigurationsProvider(solutionDir, namesByKey = new Map, openedEngine) {
+  let engine = openedEngine ? Promise.resolve(openedEngine) : undefined;
+  const ensureEngine = () => {
+    engine ??= openEngine().catch((err) => {
+      engine = undefined;
+      throw err;
+    });
+    return engine;
+  };
+  const where = solutionDir ? `in ${solutionDir} or the resource catalog` : "in the resource catalog";
+  return {
+    async getAllConfigurations(resourceKey) {
+      const { resources, services } = await ensureEngine();
+      const builder = solutionDir ? await services.getSolutionBuilder(solutionDir, true) : undefined;
+      const [error, graph] = await catchError(resources.readResourceConfigurationsAsync(services, builder, resourceKey, { name: namesByKey.get(resourceKey) }));
+      await builder?.disposeAsync();
+      if (error) {
+        const status = httpStatusOf(error) ?? (error.message.endsWith(CATALOG_MISS) ? 404 : undefined);
+        throw Object.assign(new Error(`Failed to read configuration for solution resource '${resourceKey}' ${where}: ${await extractErrorMessage(error)}`, { cause: error }), { status });
+      }
+      return {
+        resources: graph.resources ?? []
+      };
+    }
+  };
+}
+async function openEngine() {
+  const { getSolutionAuthContext } = await import("./solution-auth-8qz5pw7z.js");
+  await getSolutionAuthContext({});
+  const resources = await import("./index-1b2je9n2.js");
+  return {
+    resources,
+    services: await resources.createResourceBuilderServices()
+  };
+}
+
 // ../integrationservice-sdk/src/dap/essential-config.ts
 var MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
 var MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
@@ -6677,26 +6788,41 @@ function computeSavedJitInputFieldId(operation, parameters, objectName) {
     return;
   return `in_${objectName}`;
 }
-async function createConfiguredActivityClient({
+async function configureActivityClient({
   instanceParameters,
   connectionId,
   savedFilterTrees = null,
   customFieldsRequestDetails = null,
-  fieldValues = null
+  fieldValues = null,
+  solutionDir = null
 }) {
   if (savedFilterTrees) {
     for (const tree of Object.values(savedFilterTrees)) {
       assertFilterTreeSupported(tree);
     }
   }
-  const { DesignTimeActivityClient } = await import("./index-ng2f77my.js");
-  const client = await DesignTimeActivityClient.initiate({ instanceParameters, uiPathActivityTypeId: "" }, { connectionsProvider: createLiveConnectionsProvider() });
+  const { DesignTimeActivityClient } = await import("./index-fyc0k5dd.js");
+  const initiateOptions = {
+    connectionsProvider: createLiveConnectionsProvider(),
+    ...solutionDir ? {
+      solutionResourceConfigurationsProvider: createSolutionResourceConfigurationsProvider(solutionDir)
+    } : {}
+  };
+  const client = await DesignTimeActivityClient.initiate({ instanceParameters, uiPathActivityTypeId: "" }, initiateOptions);
   await client.updateConnection({ connectionId });
+  const resourceFields = fieldValues && (solutionDir || customFieldsRequestDetails) ? await client.getResourceFields() : [];
+  const pickerNames = new Set(resourceFields.map((field) => field.name));
+  const resolvedResources = solutionDir && fieldValues ? await resolveResourceFieldValues(fieldValues, resourceFields, solutionDir) : [];
   if (customFieldsRequestDetails) {
     for (const [
       fieldId,
       value
     ] of customFieldsRequestDetails.parameterValues) {
+      const selection = fieldValues?.[fieldId];
+      if (pickerNames.has(fieldId) && isResourceSelection(selection)) {
+        await client.setFieldValues({ [fieldId]: selection });
+        continue;
+      }
       await client.updateProperty({
         propertyName: fieldId,
         valueType: "widget",
@@ -6715,7 +6841,7 @@ async function createConfiguredActivityClient({
       await applySavedFilterTree(client, filterParam, tree);
     }
   }
-  return client;
+  return { client, resolvedResources };
 }
 async function applySavedFilterTree(client, propertyName, tree) {
   await client.updateProperty({
@@ -6946,7 +7072,7 @@ function validateEventType(context) {
 function validateConfiguration(context) {
   if (!context.configuration?.trim()) {
     return [
-      issue(context, "configuration", "Error", 'Configuration is missing or empty. Expected `=jsonString:` prefix wrapping a JSON string with shape `{"essentialConfiguration": {"objectName": "...", "connectionId": "...", ...}}`. Re-run `uip maestro flow node configure` to populate this field correctly.')
+      issue(context, "configuration", "Error", 'Configuration is missing or empty. Expected `=jsonString:` prefix wrapping a JSON string with shape `{"essentialConfiguration": {"objectName": "...", "connectionId": "...", ...}}`. Re-run `uip maestro flow nodes configure` to populate this field correctly.')
     ];
   }
   const jsonStr = context.configuration.startsWith("=jsonString:") ? context.configuration.slice("=jsonString:".length) : context.configuration;
@@ -6954,12 +7080,12 @@ function validateConfiguration(context) {
     const parsed = JSON.parse(jsonStr);
     if (!parsed.essentialConfiguration) {
       return [
-        issue(context, "configuration", "Error", "Configuration is missing the essentialConfiguration envelope. The decoded `=jsonString:` value must be an object whose only top-level key is `essentialConfiguration` (which itself carries `objectName`, `connectionId`, `instanceParameters`, etc.). Re-run `uip maestro flow node configure` rather than hand-editing.")
+        issue(context, "configuration", "Error", "Configuration is missing the essentialConfiguration envelope. The decoded `=jsonString:` value must be an object whose only top-level key is `essentialConfiguration` (which itself carries `objectName`, `connectionId`, `instanceParameters`, etc.). Re-run `uip maestro flow nodes configure` rather than hand-editing.")
       ];
     }
   } catch {
     return [
-      issue(context, "configuration", "Error", 'Configuration contains invalid JSON. The `=jsonString:` prefix must be followed by a single JSON-encoded string (one level of quoting), e.g. `"=jsonString:{\\"essentialConfiguration\\":{...}}"`. Re-run `uip maestro flow node configure` to regenerate.')
+      issue(context, "configuration", "Error", 'Configuration contains invalid JSON. The `=jsonString:` prefix must be followed by a single JSON-encoded string (one level of quoting), e.g. `"=jsonString:{\\"essentialConfiguration\\":{...}}"`. Re-run `uip maestro flow nodes configure` to regenerate.')
     ];
   }
   return [];
@@ -7423,12 +7549,20 @@ async function getPrecacheNode(nodeType, options) {
 }
 
 // ../maestro-sdk/src/registry/node-storage.ts
-var CACHE_FORMAT_VERSION = 5;
+var CACHE_FORMAT_VERSION = 6;
 var INDEX_FILE = "index.json";
 var METADATA_FILE = "index.meta.json";
 var SEARCH_INDEX_FILE = "search-index.json";
 var ESSENTIALS_INDEX_FILE = "get-essentials.json";
 var WRITE_LOCK_FILE = ".index-write.lock";
+function nodeCacheScope(login) {
+  const baseUrl = login.baseUrl?.trim().replace(/\/+$/, "");
+  const organizationId = login.organizationId?.trim();
+  const tenantId = login.tenantId?.trim();
+  if (!baseUrl || !organizationId || !tenantId)
+    return;
+  return [baseUrl, organizationId, tenantId].join("|").toLowerCase();
+}
 async function resolveNodeStorageDir() {
   const fs = getFileSystem();
   return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, "nodes");
@@ -7474,7 +7608,7 @@ async function writeTempAndRename(fs, targetPath, content) {
   await fs.writeFile(tempPath, content);
   await fs.rename(tempPath, targetPath);
 }
-async function writeNodeArtifacts(fs, dir, nodes) {
+async function writeNodeArtifacts(fs, dir, nodes, scope, missingSources) {
   const indexPath = fs.path.join(dir, INDEX_FILE);
   const searchIndexPath = fs.path.join(dir, SEARCH_INDEX_FILE);
   const essentialsIndexPath = fs.path.join(dir, ESSENTIALS_INDEX_FILE);
@@ -7487,7 +7621,9 @@ async function writeNodeArtifacts(fs, dir, nodes) {
     lastSync: Date.now(),
     nodeCount: nodes.length,
     hash,
-    cacheVersion: CACHE_FORMAT_VERSION
+    cacheVersion: CACHE_FORMAT_VERSION,
+    ...scope && { scope },
+    ...missingSources?.length && { missingSources }
   });
   await writeTempAndRename(fs, searchIndexPath, searchContent);
   await writeTempAndRename(fs, essentialsIndexPath, essentialsContent);
@@ -7495,7 +7631,7 @@ async function writeNodeArtifacts(fs, dir, nodes) {
   await writeTempAndRename(fs, metaPath, metadataContent);
   return nodes.length;
 }
-async function saveNodeIndex(nodes) {
+async function saveNodeIndex(nodes, scope, missingSources) {
   const fs = getFileSystem();
   const dir = await resolveNodeStorageDir();
   await fs.mkdir(dir);
@@ -7504,7 +7640,7 @@ async function saveNodeIndex(nodes) {
   let result;
   let writeError;
   try {
-    result = await writeNodeArtifacts(fs, dir, nodes);
+    result = await writeNodeArtifacts(fs, dir, nodes, scope, missingSources);
   } catch (error) {
     writeError = error;
   }
@@ -7518,6 +7654,49 @@ async function saveNodeIndex(nodes) {
   }
   return result;
 }
+async function commitNodeIndex(nodes, scope, missingSources) {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  await fs.mkdir(dir);
+  const releaseLock = await fs.acquireLock(fs.path.join(dir, WRITE_LOCK_FILE));
+  const [writeError, count] = await catchError((async () => {
+    const current = await loadIndexMetadata();
+    const hash = await hashContent(JSON.stringify(nodes));
+    if (current && current.cacheVersion === CACHE_FORMAT_VERSION && current.hash === hash && current.scope === scope && await areDerivedArtifactsCurrent()) {
+      const { missingSources: _previous, ...rest } = current;
+      await writeTempAndRename(fs, fs.path.join(dir, METADATA_FILE), JSON.stringify({
+        ...rest,
+        lastSync: Date.now(),
+        ...missingSources?.length && { missingSources }
+      }));
+      return current.nodeCount;
+    }
+    return writeNodeArtifacts(fs, dir, nodes, scope, missingSources);
+  })());
+  const [releaseError] = await catchError(releaseLock());
+  if (writeError)
+    throw writeError;
+  if (releaseError)
+    throw releaseError;
+  return count;
+}
+async function loadScopedNodeIndex(scope) {
+  const metadata = await loadIndexMetadata();
+  if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION || metadata.scope !== scope) {
+    return null;
+  }
+  const fs = getFileSystem();
+  const indexPath = fs.path.join(await resolveNodeStorageDir(), INDEX_FILE);
+  const [readError, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  if (readError || content === null)
+    return null;
+  if (await hashContent(content) !== metadata.hash)
+    return null;
+  const [parseError, nodes] = catchError(() => JSON.parse(content));
+  if (parseError || !Array.isArray(nodes))
+    return null;
+  return { nodes, metadata };
+}
 async function loadNodeIndex() {
   const fs = getFileSystem();
   const dir = await resolveNodeStorageDir();
@@ -7542,16 +7721,6 @@ async function loadNodeIndex() {
   }
   return parsed;
 }
-async function saveIndexMetadata(metadata) {
-  const fs = getFileSystem();
-  const dir = await resolveNodeStorageDir();
-  await fs.mkdir(dir);
-  const metaPath = fs.path.join(dir, METADATA_FILE);
-  await fs.writeFile(metaPath, JSON.stringify({
-    ...metadata,
-    cacheVersion: metadata.cacheVersion ?? CACHE_FORMAT_VERSION
-  }));
-}
 async function loadIndexMetadata() {
   const fs = getFileSystem();
   const dir = await resolveNodeStorageDir();
@@ -7614,246 +7783,101 @@ async function areDerivedArtifactsCurrent() {
   return essentialsIndex !== null;
 }
 async function rederiveNodeIndexArtifacts() {
-  const nodes = await loadNodeIndex();
-  return saveNodeIndex(nodes);
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  await fs.mkdir(dir);
+  const releaseLock = await fs.acquireLock(fs.path.join(dir, WRITE_LOCK_FILE));
+  const [rederiveError, count] = await catchError((async () => {
+    const nodes = await loadNodeIndex();
+    const metadata = await loadIndexMetadata();
+    const hash = await hashContent(JSON.stringify(nodes));
+    const sameNodes = metadata !== null && metadata.hash === hash;
+    const scope = sameNodes ? metadata.scope : undefined;
+    return writeNodeArtifacts(fs, dir, nodes, scope, sameNodes ? metadata.missingSources : undefined);
+  })());
+  const [releaseError] = await catchError(releaseLock());
+  if (rederiveError)
+    throw rederiveError;
+  if (releaseError)
+    throw releaseError;
+  return count;
 }
 
-// ../maestro-sdk/src/registry/solution-discovery.ts
-var EMPTY_IO = {
-  inputs: {},
-  outputs: {}
-};
-function findEnclosingProjectId(solutionDir, projects, cwd) {
-  const fs = getFileSystem();
-  for (const p of projects) {
-    const projDir = fs.path.resolve(solutionDir, fs.path.dirname(p.ProjectRelativePath));
-    if (cwd === projDir)
-      return p.Id;
-    const rel = fs.path.relative(projDir, cwd);
-    if (rel !== "" && !rel.startsWith("..") && !fs.path.isAbsolute(rel)) {
-      return p.Id;
-    }
+// ../maestro-sdk/src/registry/node-sync-service.ts
+var MANIFEST_VALIDATION_SOURCE = "manifest validation";
+var MANIFEST_VALIDATION_NEXT_STEP = "Fix or remove the tenant resource named in the validation error, then run 'registry pull' again.";
+var TENANT_MANIFEST_INVALID = "TenantManifestInvalid";
+
+class TenantManifestInvalidError extends Error {
+  code = TENANT_MANIFEST_INVALID;
+  ootbNodes;
+  constructor(failures, ootbNodes = []) {
+    super(`The tenant manifest failed validation, so only OOTB nodes are available (${failures.map((f) => `${f.source}: ${f.reason}`).join("; ")}). ${MANIFEST_VALIDATION_NEXT_STEP}`);
+    this.name = "TenantManifestInvalidError";
+    this.ootbNodes = ootbNodes;
+  }
+}
+function isTenantManifestInvalidError(error) {
+  return error instanceof Error && error.code === TENANT_MANIFEST_INVALID;
+}
+var MAX_FAILURE_REASON_LENGTH = 500;
+function stringifyReason(reason) {
+  if (reason instanceof Error)
+    return reason.message;
+  if (typeof reason === "string")
+    return reason;
+  try {
+    return JSON.stringify(reason) ?? String(reason);
+  } catch {
+    return String(reason);
   }
-  return;
 }
-async function findSolutionFromCwd() {
-  const fs = getFileSystem();
-  const cwd = fs.env.cwd();
-  const dirsToCheck = [
-    cwd,
-    fs.path.resolve(cwd, ".."),
-    fs.path.resolve(cwd, "../..")
-  ];
-  for (const dir of dirsToCheck) {
-    const [readErr, entries] = await catchError(fs.readdir(dir));
-    if (readErr)
-      continue;
-    const uipxName = entries.find((e) => e.endsWith(".uipx"));
-    if (!uipxName)
-      continue;
-    const uipxPath = fs.path.join(dir, uipxName);
-    const [fileErr, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
-    if (fileErr || !content)
-      continue;
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
-    if (parseErr || !parsed.SolutionId)
-      continue;
-    const projects = parsed.Projects ?? [];
-    return {
-      solutionId: parsed.SolutionId,
-      solutionDir: dir,
-      projects,
-      currentProjectId: findEnclosingProjectId(dir, projects, cwd)
-    };
-  }
-  return null;
+function describeFailureReason(reason) {
+  const text = stringifyReason(reason);
+  return text.length > MAX_FAILURE_REASON_LENGTH ? `${text.slice(0, MAX_FAILURE_REASON_LENGTH)}...` : text;
 }
-async function readProjectEntryPointIO(projectDir) {
-  const fs = getFileSystem();
-  const fromSource = await readEntryPointsFile(fs.path.join(projectDir, "entry-points.json"), fs.path.join(projectDir, "content", "entry-points.json"));
-  if (fromSource)
-    return fromSource;
-  const fromFlow = await readProjectIOFromFlowVariables(projectDir);
-  if (fromFlow)
-    return fromFlow;
-  const fromBuild = await readEntryPointsFile(fs.path.join(projectDir, ".local", "content", "entry-points.json"));
-  if (fromBuild)
-    return fromBuild;
-  return EMPTY_IO;
-}
-async function readEntryPointsFile(...candidates) {
-  const fs = getFileSystem();
-  for (const filePath of candidates) {
-    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
-    if (err || !content)
-      continue;
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
-    if (parseErr || !parsed.entryPoints?.length)
-      continue;
-    return extractIOFromEntryPoints(parsed);
-  }
-  return;
+function toPullFailures(failures) {
+  return failures.map((failure) => ({
+    source: failure.source,
+    reason: describeFailureReason(failure.reason)
+  }));
 }
-async function readProjectIOFromFlowVariables(projectDir) {
-  const fs = getFileSystem();
-  const [readErr, entries] = await catchError(fs.readdir(projectDir));
-  if (readErr || !Array.isArray(entries))
-    return;
-  const flowFileName = entries.find((entry) => entry.endsWith(".flow"));
-  if (!flowFileName)
-    return;
-  const flowPath = fs.path.join(projectDir, flowFileName);
-  const [readFileErr, content] = await catchError(fs.readFile(flowPath, "utf-8"));
-  if (readFileErr || !content)
-    return;
-  const [parseErr, parsed] = catchError(() => JSON.parse(content));
-  if (parseErr)
-    return;
-  const globals = parsed.variables?.globals;
-  if (!Array.isArray(globals) || globals.length === 0)
-    return;
-  const inputProps = {};
-  const outputProps = {};
-  for (const variable of globals) {
-    if (!variable?.id || !variable.direction)
-      continue;
-    const schema = {
-      type: variable.type ?? "string"
-    };
-    if (variable.description) {
-      schema.description = variable.description;
-    }
-    if (variable.direction === "in" || variable.direction === "inout") {
-      inputProps[variable.id] = schema;
-    }
-    if (variable.direction === "out" || variable.direction === "inout") {
-      outputProps[variable.id] = schema;
-    }
-  }
-  const hasInputs = Object.keys(inputProps).length > 0;
-  const hasOutputs = Object.keys(outputProps).length > 0;
-  if (!hasInputs && !hasOutputs)
+var CACHE_EXPIRATION = 30 * 60 * 1000;
+function loginScope(loginStatus) {
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.accessToken) {
     return;
-  const synthetic = {
-    entryPoints: [
-      {
-        filePath: flowFileName,
-        input: hasInputs ? { type: "object", properties: inputProps } : undefined,
-        output: hasOutputs ? { type: "object", properties: outputProps } : undefined
-      }
-    ]
-  };
-  return extractIOFromEntryPoints(synthetic);
-}
-async function readProjectName(projectDir) {
-  const fs = getFileSystem();
-  const uiprojPath = fs.path.join(projectDir, "project.uiproj");
-  const [err, content] = await catchError(fs.readFile(uiprojPath, "utf-8"));
-  if (!err && content) {
-    const [parseErr, parsed] = catchError(() => JSON.parse(content));
-    if (!parseErr && parsed.Name)
-      return parsed.Name;
   }
-  return fs.path.basename(projectDir);
+  return nodeCacheScope(loginStatus);
 }
-async function loadResourceKeyMap(solutionDir) {
-  const fs = getFileSystem();
-  const map = new Map;
-  const processDir = fs.path.join(solutionDir, "resources", "solution_folder", "process");
-  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
-  if (dirErr)
-    return map;
-  for (const typeDir of typeDirs) {
-    const typePath = fs.path.join(processDir, typeDir);
-    const [filesErr, files] = await catchError(fs.readdir(typePath));
-    if (filesErr)
-      continue;
-    for (const file of files) {
-      if (!file.endsWith(".json"))
-        continue;
-      const filePath = fs.path.join(typePath, file);
-      const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
-      if (readErr || !content)
-        continue;
-      const [parseErr, parsed] = catchError(() => JSON.parse(content));
-      if (parseErr)
-        continue;
-      const projectKey = parsed.resource?.projectKey;
-      const resourceKey = parsed.resource?.key;
-      if (projectKey && resourceKey) {
-        map.set(projectKey, resourceKey);
-      }
-    }
-  }
-  return map;
+function isFreshFor(meta, scope) {
+  return meta !== null && scope !== undefined && meta.scope === scope && Date.now() - meta.lastSync < CACHE_EXPIRATION;
 }
-async function buildInSolutionNodeManifests(ctx) {
-  const fs = getFileSystem();
-  const manifests = [];
-  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
-  for (const project of ctx.projects) {
-    if (ctx.currentProjectId && project.Id === ctx.currentProjectId)
-      continue;
-    const serviceType = getServiceType(project.Type);
-    if (!serviceType)
-      continue;
-    const projectDir = fs.path.resolve(ctx.solutionDir, fs.path.dirname(project.ProjectRelativePath));
-    const reader = getAgentProjectMetadataReader();
-    const [name, io, projectMetadata] = await Promise.all([
-      readProjectName(projectDir),
-      readProjectEntryPointIO(projectDir),
-      reader ? reader(projectDir, project.Type).catch((err) => {
-        logger.debug(`Agent metadata reader failed for ${projectDir}: ${String(err)}`);
-        return {};
-      }) : Promise.resolve({})
-    ]);
-    const resourceKey = resourceKeyMap.get(project.Id) ?? project.Id;
-    const task = {
-      name,
-      type: serviceType,
-      resourceKey,
-      inputs: io.inputs,
-      outputs: io.outputs,
-      metadata: {
-        ...projectMetadata,
-        description: `(In-solution) ${name}`,
-        key: resourceKey,
-        name,
-        tags: ["in-solution", "local"],
-        projectId: project.Id,
-        entryPointUniqueId: io.entryPointUniqueId,
-        inputProperties: io.inputProperties
-      }
-    };
-    const nodes = taskDefinitionsToNodeManifests({ [resourceKey]: task }, project.Type);
-    manifests.push(...nodes);
-  }
-  return manifests;
-}
-
-// ../maestro-sdk/src/registry/node-sync-service.ts
-var CACHE_EXPIRATION = 30 * 60 * 1000;
 function isMissingIndexError(error) {
   return error.message.includes("No node index found") || error.message.includes("Node index is outdated");
 }
 async function pullNodes(options = {}) {
   const { force = false } = options;
+  const loginStatus = await getLoginStatusAsync();
   if (force) {
-    const refreshResult2 = await refreshNodes();
+    const refreshResult2 = await refreshNodes(loginStatus);
     const meta2 = await loadIndexMetadata();
     return {
       syncedCount: refreshResult2.nodeCount || meta2?.nodeCount || 0,
       fromCache: false,
       source: refreshResult2.source,
       cacheWritten: refreshResult2.cacheWritten,
-      info: refreshResult2.info
+      info: refreshResult2.info,
+      failures: refreshResult2.failures,
+      missingSources: refreshResult2.missingSources
     };
   }
   const meta = await loadIndexMetadata();
+  const scope = loginScope(loginStatus);
   if (meta) {
     const ageMs = Date.now() - meta.lastSync;
     let needsRefresh = false;
-    if (ageMs < CACHE_EXPIRATION) {
+    if (isFreshFor(meta, scope)) {
+      let syncedCount = meta.nodeCount;
       if (!await areDerivedArtifactsCurrent()) {
         const [rederiveError, nodeCount] = await catchError(rederiveNodeIndexArtifacts());
         if (rederiveError) {
@@ -7862,71 +7886,49 @@ async function pullNodes(options = {}) {
           }
           needsRefresh = true;
         } else {
-          return {
-            syncedCount: nodeCount,
-            fromCache: true,
-            ageMinutes: Math.round(ageMs / 60000)
-          };
+          syncedCount = nodeCount;
         }
       }
-      if (!needsRefresh) {
+      const current = await loadIndexMetadata();
+      if (!needsRefresh && isFreshFor(current, scope)) {
         return {
-          syncedCount: meta.nodeCount,
+          syncedCount,
           fromCache: true,
-          ageMinutes: Math.round(ageMs / 60000)
+          ageMinutes: Math.round(ageMs / 60000),
+          missingSources: current.missingSources
         };
       }
     }
   }
-  const refreshResult = await refreshNodes();
+  const refreshResult = await refreshNodes(loginStatus);
   const refreshedMeta = await loadIndexMetadata();
   return {
     syncedCount: refreshResult.nodeCount || refreshedMeta?.nodeCount || 0,
     fromCache: false,
     source: refreshResult.source,
     cacheWritten: refreshResult.cacheWritten,
-    info: refreshResult.info
+    info: refreshResult.info,
+    failures: refreshResult.failures,
+    missingSources: refreshResult.missingSources
   };
 }
-async function refreshNodes() {
-  const oldMeta = await loadIndexMetadata();
-  const pullResult = await pullRemoteNodes();
-  const allNodes = pullResult.nodes;
+async function refreshNodes(loginStatus) {
+  const pullResult = await pullRemoteNodes(loginStatus);
   if (!pullResult.cacheable) {
     return {
       cacheWritten: false,
-      nodeCount: allNodes.length,
+      nodeCount: pullResult.nodes.length,
       source: pullResult.source,
-      info: pullResult.info
-    };
-  }
-  const content = JSON.stringify(allNodes);
-  const newHash = await hashContent(content);
-  if (oldMeta && oldMeta.hash === newHash) {
-    if (!await areDerivedArtifactsCurrent()) {
-      await saveNodeIndex(allNodes);
-      return {
-        cacheWritten: true,
-        nodeCount: allNodes.length,
-        source: pullResult.source
-      };
-    }
-    await saveIndexMetadata({
-      lastSync: Date.now(),
-      nodeCount: oldMeta.nodeCount,
-      hash: oldMeta.hash
-    });
-    return {
-      cacheWritten: true,
-      nodeCount: oldMeta.nodeCount,
-      source: pullResult.source
+      info: pullResult.info,
+      failures: pullResult.failures
     };
   }
-  await saveNodeIndex(allNodes);
+  const nodeCount = await commitNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources);
   return {
     cacheWritten: true,
-    nodeCount: allNodes.length,
-    source: pullResult.source
+    nodeCount,
+    source: pullResult.source,
+    missingSources: pullResult.missingSources
   };
 }
 var ENABLED_MANIFEST_FLAGS = new Set([
@@ -7948,18 +7950,18 @@ var ENABLED_MANIFEST_FLAGS = new Set([
   MANIFEST_FEATURE_FLAGS.UPDATE_ENTITY,
   MANIFEST_FEATURE_FLAGS.DELETE_ENTITY
 ]);
-async function pullRemoteNodes() {
-  const loginStatus = await getLoginStatusAsync();
+async function pullRemoteNodes(loginStatus) {
+  loginStatus ??= await getLoginStatusAsync();
   const client = new ManifestClient({
     baseUrl: loginStatus.baseUrl || "localhost",
     getFeatureFlag: (flag) => ENABLED_MANIFEST_FLAGS.has(flag)
   });
   if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.accessToken || !loginStatus.tenantId || !loginStatus.organizationId) {
-    const manifest2 = await client.getManifest({
+    const manifest = await client.getManifest({
       inlineAgentNodes: true
     });
     return {
-      nodes: manifest2.nodes || [],
+      nodes: manifest.nodes || [],
       source: "ootb",
       cacheable: false,
       info: "Using OOTB nodes because you are not logged in. Cache was not updated."
@@ -7970,7 +7972,7 @@ async function pullRemoteNodes() {
     tenantId: loginStatus.tenantId,
     organizationId: loginStatus.organizationId
   };
-  const [manifestError, manifest] = await catchError(client.getManifest({
+  const [manifestError, diagnostics] = await catchError(client.getManifestWithDiagnostics({
     auth: authContext,
     includeIntegrationTriggers: true,
     inlineAgentNodes: true,
@@ -7978,10 +7980,32 @@ async function pullRemoteNodes() {
     excludeIntsvcConnectorHttpRequest: true
   }));
   if (!manifestError) {
+    const nodes = diagnostics.manifest.nodes || [];
+    if (diagnostics.failures.length === 0) {
+      return {
+        nodes,
+        source: "authenticated",
+        cacheable: true,
+        scope: nodeCacheScope(loginStatus)
+      };
+    }
+    const failures = toPullFailures(diagnostics.failures);
+    const ootbOnly = failures.some((failure) => failure.source === MANIFEST_VALIDATION_SOURCE);
+    if (!ootbOnly) {
+      return {
+        nodes,
+        source: "authenticated",
+        cacheable: true,
+        scope: nodeCacheScope(loginStatus),
+        missingSources: failures
+      };
+    }
     return {
-      nodes: manifest.nodes || [],
-      source: "authenticated",
-      cacheable: true
+      nodes,
+      source: "ootb",
+      cacheable: false,
+      failures,
+      info: "The tenant manifest failed validation; using OOTB nodes without updating cache."
     };
   }
   const fallbackManifest = await client.getManifest({
@@ -8001,19 +8025,78 @@ async function getNodesWithCacheFallback() {
       throw error;
     }
     const pullResult = await pullRemoteNodes();
+    if (pullResult.failures?.length) {
+      throw new TenantManifestInvalidError(pullResult.failures, pullResult.nodes);
+    }
     if (pullResult.cacheable) {
-      await saveNodeIndex(pullResult.nodes);
+      await saveNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources);
     }
     return pullResult.nodes;
   }
   return nodes;
 }
-async function getLocalSolutionNodes() {
+async function loadCurrentTenantNodes(options = {}) {
+  const [loginError, readStatus] = await catchError(getLoginStatusAsync());
+  const loginStatus = loginError ? { loginStatus: "Not logged in" } : readStatus;
+  const scope = loginScope(loginStatus);
+  if (!options.force && scope !== undefined) {
+    const [, cached] = await catchError(loadScopedNodeIndex(scope));
+    if (cached && isFreshFor(cached.metadata, scope)) {
+      return { nodes: cached.nodes, fromCache: true, source: "cache" };
+    }
+  }
+  const pullResult = await pullRemoteNodes(loginStatus);
+  if (pullResult.cacheable) {
+    await catchError(commitNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources));
+  }
+  return {
+    nodes: pullResult.nodes,
+    fromCache: false,
+    source: pullResult.source,
+    info: pullResult.info
+  };
+}
+async function getLocalSolutionSnapshot() {
   const ctx = await findSolutionFromCwd();
   if (!ctx) {
     throw new Error("No .uipx solution file found in current directory, its parent, or its grandparent. " + "Run this command from inside a solution project directory.");
   }
-  return buildInSolutionNodeManifests(ctx);
+  return buildInSolutionNodes(ctx);
+}
+async function getLocalSolutionNodes() {
+  return (await getLocalSolutionSnapshot()).manifests;
+}
+function localContractWarning(snapshot, shown) {
+  const types = new Set(shown.map((n) => n.nodeType).filter((t) => typeof t === "string").map((t) => t.toLowerCase()));
+  return unknownContractWarning(snapshot.unknownContracts.filter((p) => p.nodeTypes.some((t) => types.has(t.toLowerCase()))));
+}
+function filterNodesByKeyword(nodes, keyword) {
+  const lowerKeyword = keyword.toLowerCase();
+  return nodes.filter((node) => {
+    if (node.nodeType?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.category?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.tags?.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
+      return true;
+    }
+    if (node.display?.label?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.description?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.display?.description?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    return false;
+  });
+}
+function findNodeByType(nodes, nodeType) {
+  const lowerNodeType = nodeType.toLowerCase();
+  return nodes.find((node) => node.nodeType?.toLowerCase() === lowerNodeType) ?? null;
 }
 async function listNodes(options) {
   if (options?.local)
@@ -8124,28 +8207,7 @@ async function searchNodes(keyword, options) {
     const tenantNodes = await getNodesWithCacheFallback();
     nodes = unionWithKnownSdkNodes(tenantNodes);
   }
-  const lowerKeyword = keyword.toLowerCase();
-  return nodes.filter((node) => {
-    if (node.nodeType?.toLowerCase().includes(lowerKeyword)) {
-      return true;
-    }
-    if (node.category?.toLowerCase().includes(lowerKeyword)) {
-      return true;
-    }
-    if (node.tags?.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
-      return true;
-    }
-    if (node.display?.label?.toLowerCase().includes(lowerKeyword)) {
-      return true;
-    }
-    if (node.description?.toLowerCase().includes(lowerKeyword)) {
-      return true;
-    }
-    if (node.display?.description?.toLowerCase().includes(lowerKeyword)) {
-      return true;
-    }
-    return false;
-  });
+  return filterNodesByKeyword(nodes, keyword);
 }
 async function getNode(nodeType, options) {
   const lowerNodeType = nodeType.toLowerCase();
@@ -8156,13 +8218,23 @@ async function getNode(nodeType, options) {
   }
   if (!options?.local && isEssentialNodeType(nodeType)) {
     const essentials = await loadEssentialsIndexWithRepair();
-    const node2 = essentials?.find((node3) => node3.nodeType?.toLowerCase() === lowerNodeType) ?? null;
-    if (node2)
-      return node2;
+    const node = essentials?.find((node2) => node2.nodeType?.toLowerCase() === lowerNodeType) ?? null;
+    if (node)
+      return node;
   }
-  const nodes = options?.local ? await getLocalSolutionNodes() : await getNodesWithCacheFallback();
-  const node = nodes.find((node2) => node2.nodeType?.toLowerCase() === lowerNodeType) ?? null;
-  return node;
+  if (options?.local) {
+    return findNodeByType(await getLocalSolutionNodes(), nodeType);
+  }
+  const [error, nodes] = await catchError(getNodesWithCacheFallback());
+  if (error) {
+    if (error instanceof TenantManifestInvalidError) {
+      const ootbNode = findNodeByType(error.ootbNodes, nodeType);
+      if (ootbNode)
+        return ootbNode;
+    }
+    throw error;
+  }
+  return findNodeByType(nodes, nodeType);
 }
 async function getNodeEnriched(nodeType, connectionId, options) {
   const node = await getNode(nodeType, options);
@@ -8171,6 +8243,16 @@ async function getNodeEnriched(nodeType, connectionId, options) {
   }
   return await enrichConnectorNode(node, connectionId);
 }
+async function getLocalNodeEnriched(nodeType, connectionId) {
+  const snapshot = await getLocalSolutionSnapshot();
+  const node = findNodeByType(snapshot.manifests, nodeType);
+  if (!node)
+    return { node: null };
+  return {
+    node: await enrichConnectorNode(node, connectionId),
+    warning: localContractWarning(snapshot, [node])
+  };
+}
 async function searchNodesWithFilters(keyword, filters, options) {
   let nodes;
   if (options?.local) {
@@ -8182,6 +8264,6 @@ async function searchNodesWithFilters(keyword, filters, options) {
   return searchWithFilters(nodes, keyword, filters);
 }
 
-export { ACTIVITY_VERSION_V4, isV4ActivityConfiguration, FilterNotSupportedError, substituteFilterVariables, MANAGED_HTTP_CONNECTOR_KEY, buildActivityEssentialConfiguration, createConfiguredActivityClient, applySavedFilterTree, assertActivityMetadataResolved, buildManagedHttpEssentialConfiguration, extractMultipartParameters, inlineMultipartFileValues, isListOperation, buildInputMetadata, normalizeHttpMethod, validateIntSvcNode, isConnectorNode, getConnectorInfo, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorActivityMetadataV4, pullNodes, pullRemoteNodes, listNodes, searchNodeSummariesWithAvailability, searchNodes, getNode, getNodeEnriched, searchNodesWithFilters };
+export { ACTIVITY_VERSION_V4, isV4ActivityConfiguration, storedActivityBindings, planResourceBindings, FilterNotSupportedError, substituteFilterVariables, MANAGED_HTTP_CONNECTOR_KEY, buildActivityEssentialConfiguration, configureActivityClient, applySavedFilterTree, assertActivityMetadataResolved, buildManagedHttpEssentialConfiguration, extractMultipartParameters, inlineMultipartFileValues, isListOperation, buildInputMetadata, normalizeHttpMethod, validateIntSvcNode, isConnectorNode, getConnectorInfo, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorActivityMetadataV4, MANIFEST_VALIDATION_NEXT_STEP, TenantManifestInvalidError, isTenantManifestInvalidError, pullNodes, pullRemoteNodes, loadCurrentTenantNodes, getLocalSolutionSnapshot, localContractWarning, filterNodesByKeyword, findNodeByType, listNodes, searchNodeSummariesWithAvailability, searchNodes, getNode, getNodeEnriched, getLocalNodeEnriched, searchNodesWithFilters };
 
-//# debugId=EB973E50DAA1B0BD64756E2164756E21
+//# debugId=E08A55B7C74E5E3864756E2164756E21