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

package/dist/{packager-tool-b1nw50ev.js → packager-tool-265h946t.js}

@@ -1,322 +1,36 @@
 import {
-  resolveMaestroRegistry
-} from "./packager-tool-ezds6t5e.js";
-import {
-  ConnectionsApi,
-  ElementsApi,
-  createApiClient,
-  getConnectorActivityMetadataV4,
-  isV4ActivityConfiguration
-} from "./packager-tool-wr12ndwk.js";
-import {
-  searchWithFilters
-} from "./packager-tool-7hw344bt.js";
+  getLoginStatusAsync2
+} from "./packager-tool-dn9d4ywm.js";
 import {
-  listKnownSdkNodes
-} from "./packager-tool-tqn0j6f9.js";
+  getFileSystem2
+} from "./packager-tool-z070caqq.js";
 import {
-  buildInSolutionNodes,
-  findSolutionFromCwd,
-  unknownContractWarning
-} from "./packager-tool-d8e2mrkq.js";
+  catchError2,
+  classifyThrownError,
+  UIPATH_HOME_DIR2,
+  hashContent
+} from "./packager-tool-psmb758n.js";
 import {
   MANIFEST_FEATURE_FLAGS,
   ManifestClient
-} from "./packager-tool-8ftat1vn.js";
+} from "./packager-tool-17b466mr.js";
 import {
-  getLoginStatusAsync
-} from "./packager-tool-yn33pw57.js";
+  searchWithFilters2
+} from "./packager-tool-xb16e3tz.js";
 import {
-  UIPATH_HOME_DIR,
-  catchError,
-  hashContent,
-  logger
-} from "./packager-tool-83v804p7.js";
+  listKnownSdkNodes2
+} from "./packager-tool-v11fx4dk.js";
 import {
-  getFileSystem
-} from "./packager-tool-hdxtgckw.js";
-
-// ../maestro-sdk/src/registry/integration-service-fetcher.ts
-function parseContext(node) {
-  const context = node.model?.context;
-  if (!Array.isArray(context))
-    return null;
-  const connectorKey = context.find((c) => c.name === "connectorKey")?.value;
-  const objectName = context.find((c) => c.name === "objectName")?.value;
-  const method = context.find((c) => c.name === "method")?.value ?? "POST";
-  const operation = context.find((c) => c.name === "operation")?.value;
-  if (!connectorKey || !objectName)
-    return null;
-  return { connectorKey, objectName, method, operation };
-}
-function applyOptionalFieldProps(compact, field) {
-  if (field.enum?.length)
-    compact.enum = field.enum;
-  if (field.reference) {
-    compact.reference = {
-      objectName: field.reference.objectName,
-      lookupValue: field.reference.lookupValue,
-      lookupNames: field.reference.lookupNames,
-      path: field.reference.path,
-      childPath: field.reference.childPath,
-      scriptRef: field.reference.scriptRef
-    };
-  }
-}
-function extractFields(metadata, method, requestOnly) {
-  const fieldsObj = metadata?.fields ?? {};
-  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
-  return fields.filter((field) => {
-    const methodInfo = field.method?.[method];
-    if (!methodInfo)
-      return false;
-    return requestOnly ? methodInfo.request === true || methodInfo.requestCurated === true : methodInfo.response === true || methodInfo.responseCurated === true;
-  }).map((field) => {
-    const compact = {
-      name: field.name,
-      displayName: field.displayName,
-      type: field.type,
-      dataType: field.type,
-      required: requestOnly ? field.method?.[method]?.required === true : false,
-      description: field.description
-    };
-    if (!requestOnly)
-      compact.responseOnly = true;
-    applyOptionalFieldProps(compact, field);
-    return compact;
-  });
-}
-function isConnectorNode(node) {
-  const nodeType = node.nodeType;
-  return nodeType?.startsWith("uipath.connector") || false;
-}
-function isConnectorTriggerNode(node) {
-  const nodeType = node.nodeType;
-  return nodeType?.startsWith("uipath.connector.trigger") || false;
-}
-function toCompactField(field, required) {
-  const compact = {
-    name: field.name,
-    displayName: field.displayName,
-    type: field.type,
-    dataType: field.type,
-    required,
-    description: field.description
-  };
-  applyOptionalFieldProps(compact, field);
-  return compact;
-}
-function extractTriggerEventParameters(metadata, operationName) {
-  const fields = Object.values(metadata?.fields ?? {});
-  return fields.filter((field) => !!field.events?.[operationName]).map((field) => toCompactField(field, field.events?.[operationName]?.required === true));
-}
-function extractTriggerFilterFields(metadata) {
-  const fields = Object.values(metadata?.fields ?? {});
-  return fields.filter((field) => field.order === 1).map((field) => toCompactField(field, false));
-}
-function extractActivityFilterFields(metadata, _method) {
-  const fieldsObj = metadata?.fields ?? {};
-  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
-  return fields.filter((field) => field.searchable === true).map((field) => {
-    const compact = {
-      name: field.name,
-      displayName: field.displayName,
-      type: field.type,
-      dataType: field.type,
-      required: false,
-      description: field.description
-    };
-    if (field.searchableOperators?.length) {
-      compact.searchableOperators = [...field.searchableOperators];
-    }
-    if (field.searchableNames?.length) {
-      compact.searchableNames = [...field.searchableNames];
-    }
-    applyOptionalFieldProps(compact, field);
-    return compact;
-  });
-}
-function extractTriggerOutputFields(metadata) {
-  const fields = Object.values(metadata?.fields ?? {});
-  return fields.map((field) => {
-    const compact = toCompactField(field, false);
-    compact.responseOnly = true;
-    return compact;
-  });
-}
-async function fetchConnectorTriggerMetadata(connectorKey, operationName, objectName, connectionId) {
-  const api = await createApiClient(ElementsApi);
-  const triggerMetadata = await api.getInstanceEventObjectMetadata({
-    connectionOrInstanceId: connectionId,
-    elementKey: connectorKey,
-    operationName,
-    objectName,
-    allFields: true
-  });
-  return triggerMetadata;
-}
-function getConfigurationString(node) {
-  const modelConfig = node.model?.configuration;
-  if (modelConfig)
-    return modelConfig;
-  const form = node.form;
-  for (const section of form?.sections ?? []) {
-    for (const field of section.fields ?? []) {
-      const config = field.componentProps?.connectorDetail?.configuration;
-      if (config)
-        return config;
-    }
-  }
-  return;
-}
-function getConnectorConfiguration(node) {
-  const configStr = getConfigurationString(node);
-  if (!configStr)
-    return null;
-  const [err, parsed] = catchError(() => JSON.parse(configStr));
-  return err ? null : parsed;
-}
-function getConnectorInfo(node) {
-  const context = parseContext(node);
-  const config = getConnectorConfiguration(node);
-  if (!context && !config)
-    return null;
-  const connectorKey = config?.connectorKey ?? context?.connectorKey ?? "";
-  const objectName = config?.objectName ?? context?.objectName ?? "";
-  if (!connectorKey || !objectName)
-    return null;
-  return {
-    connectorKey,
-    objectName,
-    method: config?.httpMethod ?? context?.method ?? "POST",
-    activityType: config?.activityType ?? ""
-  };
-}
-async function fetchConnectionInfo(connectionId) {
-  const api = await createApiClient(ConnectionsApi);
-  const response = await api.apiV1ConnectionsConnectionIdGet({
-    connectionId
-  });
-  const connector = response.connector;
-  return {
-    id: response.id ?? connectionId,
-    name: response.name ?? connectionId,
-    connectorKey: connector?.key ?? "",
-    connectorName: connector?.name ?? "",
-    connectorVersion: response.elementVersion ?? null,
-    pollingInterval: response.pollingIntervalInMinutes ?? null,
-    byoaConnection: response.byoaConnection === true,
-    elementInstanceId: response.elementInstanceId ?? null,
-    folderKey: response.folder?.key ?? null
-  };
-}
-async function fetchConnectorMetadata(connectorKey, objectName, connectionId) {
-  const api = await createApiClient(ElementsApi);
-  if (connectionId) {
-    const response2 = await api.getInstanceObjectMetadataRaw({
-      connectionOrInstanceId: connectionId,
-      elementKey: connectorKey,
-      objectName,
-      includeParentArray: true
-    });
-    return await response2.raw.json();
-  }
-  const response = await api.getObjectMetadataRaw({
-    elementKey: connectorKey,
-    objectName,
-    includeParentArray: true
-  });
-  return await response.raw.json();
-}
-async function fetchConnectorActivityMetadataV4(connectorKey, objectName) {
-  return await getConnectorActivityMetadataV4(undefined, connectorKey, objectName);
-}
-function buildEnrichedActivityNode(node, metadata, method) {
-  const connectorMethodInfo = metadata?.metadata?.method?.[method];
-  const inputFields = extractFields(metadata, method, true);
-  const outputFields = extractFields(metadata, method, false);
-  const filterFields = extractActivityFilterFields(metadata, method);
-  return {
-    ...node,
-    ...connectorMethodInfo && { connectorMethodInfo },
-    inputDefinition: node.inputDefinition && Object.keys(node.inputDefinition).length > 0 ? node.inputDefinition : { fields: inputFields },
-    outputResponseDefinition: { fields: outputFields },
-    ...filterFields.length > 0 && {
-      filterFields: { fields: filterFields }
-    }
-  };
-}
-async function enrichConnectorActivityNode(node, connectionId) {
-  const parsed = parseContext(node);
-  const config = getConnectorConfiguration(node);
-  if (isV4ActivityConfiguration(config)) {
-    return enrichV4ConnectorActivityNode(node, connectionId, config);
-  }
-  if (!parsed)
-    return node;
-  const { connectorKey, objectName, method } = parsed;
-  const [error, metadata] = await catchError(fetchConnectorMetadata(connectorKey, objectName, connectionId));
-  if (error) {
-    return node;
-  }
-  return buildEnrichedActivityNode(node, metadata, method);
-}
-async function enrichV4ConnectorActivityNode(node, connectionId, config) {
-  const connectorKey = config?.connectorKey;
-  const objectName = config?.objectName;
-  const method = config?.httpMethod;
-  if (!connectorKey || !objectName || !method) {
-    logger.warn("v4 IS enrichment skipped: node configuration carries no connectorKey/objectName/httpMethod.");
-    return node;
-  }
-  if (connectionId) {
-    logger.warn("v4 metadata endpoints are not connection-scoped — --connection-id is ignored for 4.0.0 enrichment.");
-  }
-  const [error, metadata] = await catchError(fetchConnectorActivityMetadataV4(connectorKey, objectName));
-  if (error) {
-    logger.warn(`IS v4 enrichment failed: ${error.message}`);
-    return node;
-  }
-  return buildEnrichedActivityNode(node, metadata, method);
-}
-async function enrichConnectorNode(node, connectionId) {
-  if (!isConnectorNode(node))
-    return node;
-  return isConnectorTriggerNode(node) ? enrichConnectorTriggerNode(node, connectionId) : enrichConnectorActivityNode(node, connectionId);
-}
-async function enrichConnectorTriggerNode(node, connectionId) {
-  if (!connectionId) {
-    throw new Error("Trigger nodes require --connection-id for IS enrichment. Provide it with --connection-id <id>.");
-  }
-  const parsed = parseContext(node);
-  if (!parsed?.operation)
-    return node;
-  const { connectorKey, objectName, operation } = parsed;
-  const metadata = await fetchConnectorTriggerMetadata(connectorKey, operation, objectName, connectionId);
-  const eventParameters = extractTriggerEventParameters(metadata, operation);
-  const filterFields = extractTriggerFilterFields(metadata);
-  const outputFields = extractTriggerOutputFields(metadata);
-  let byoaConnection = false;
-  let elementInstanceId = null;
-  if (connectionId) {
-    const [connErr, connInfo] = await catchError(fetchConnectionInfo(connectionId));
-    if (!connErr) {
-      byoaConnection = connInfo.byoaConnection;
-      elementInstanceId = connInfo.elementInstanceId;
-    } else {
-      logger.warn(`Failed to fetch connection info for ${connectionId}: ${connErr.message}`);
-    }
-  }
-  return {
-    ...node,
-    eventMode: metadata.eventMode,
-    byoaConnection,
-    elementInstanceId,
-    eventParameters: { fields: eventParameters },
-    filterFields: { fields: filterFields },
-    outputResponseDefinition: { fields: outputFields }
-  };
-}
+  findSolutionFromCwd2,
+  buildInSolutionNodes2,
+  unknownContractWarning2
+} from "./packager-tool-tgehy324.js";
+import {
+  resolveMaestroRegistry
+} from "./packager-tool-s12s1dp6.js";
+import {
+  enrichConnectorNode
+} from "./packager-tool-k0ar6cn7.js";
 
 // ../maestro-sdk/src/registry/is-precache.ts
 async function resolveLibraryJsonDir() {
@@ -324,15 +38,15 @@ async function resolveLibraryJsonDir() {
   return snapshot?.libraryJson ?? null;
 }
 async function readIndex() {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const dir = await resolveLibraryJsonDir();
   if (!dir)
     return null;
   const indexPath = fs.path.join(dir, "index.json");
-  const [readError, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(indexPath, "utf-8"));
   if (readError || content === null)
     return null;
-  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  const [parseError, parsed] = catchError2(() => JSON.parse(content));
   if (parseError || !parsed || !Array.isArray(parsed.entries))
     return null;
   return parsed.entries;
@@ -342,15 +56,15 @@ async function listPrecacheEntries() {
   return entries ?? [];
 }
 async function getPrecacheNode(nodeType, options) {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const dir = await resolveLibraryJsonDir();
   if (!dir)
     return null;
   const indexPath = fs.path.join(dir, "index.json");
-  const [indexReadError, indexContent] = await catchError(fs.readFile(indexPath, "utf-8"));
+  const [indexReadError, indexContent] = await catchError2(fs.readFile(indexPath, "utf-8"));
   if (indexReadError || indexContent === null)
     return null;
-  const [indexParseError, parsed] = catchError(() => JSON.parse(indexContent));
+  const [indexParseError, parsed] = catchError2(() => JSON.parse(indexContent));
   if (indexParseError || !parsed || !Array.isArray(parsed.entries))
     return null;
   const lowerNodeType = nodeType.toLowerCase();
@@ -363,17 +77,17 @@ async function getPrecacheNode(nodeType, options) {
     return null;
   const entry = matches[0];
   const v1defPath = fs.path.join(dir, entry.path.replace(/\.json$/, ".v1def.json"));
-  const [readError, content] = await catchError(fs.readFile(v1defPath, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(v1defPath, "utf-8"));
   if (readError || content === null)
     return null;
-  const [parseError, manifest] = catchError(() => JSON.parse(content));
+  const [parseError, manifest] = catchError2(() => JSON.parse(content));
   if (parseError || !manifest)
     return null;
   return manifest;
 }
 
 // ../maestro-sdk/src/registry/node-storage.ts
-var CACHE_FORMAT_VERSION = 6;
+var CACHE_FORMAT_VERSION = 7;
 var INDEX_FILE = "index.json";
 var METADATA_FILE = "index.meta.json";
 var SEARCH_INDEX_FILE = "search-index.json";
@@ -388,8 +102,8 @@ function nodeCacheScope(login) {
   return [baseUrl, organizationId, tenantId].join("|").toLowerCase();
 }
 async function resolveNodeStorageDir() {
-  const fs = getFileSystem();
-  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, "nodes");
+  const fs = getFileSystem2();
+  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR2, "nodes");
 }
 function buildSearchIndex(nodes) {
   return nodes.map((node) => ({
@@ -455,74 +169,75 @@ async function writeNodeArtifacts(fs, dir, nodes, scope, missingSources) {
   await writeTempAndRename(fs, metaPath, metadataContent);
   return nodes.length;
 }
-async function saveNodeIndex(nodes, scope, missingSources) {
-  const fs = getFileSystem();
-  const dir = await resolveNodeStorageDir();
-  await fs.mkdir(dir);
-  const lockPath = fs.path.join(dir, WRITE_LOCK_FILE);
-  const releaseLock = await fs.acquireLock(lockPath);
-  let result;
-  let writeError;
-  try {
-    result = await writeNodeArtifacts(fs, dir, nodes, scope, missingSources);
-  } catch (error) {
-    writeError = error;
-  }
-  const [releaseError] = await catchError(releaseLock());
-  if (writeError)
-    throw writeError;
-  if (releaseError)
-    throw releaseError;
-  if (result === undefined) {
-    throw new Error("Node index write did not complete.");
-  }
-  return result;
-}
-async function commitNodeIndex(nodes, scope, missingSources) {
-  const fs = getFileSystem();
+async function commitNodeIndexUnderLock(nodes, scope, missingSources, protectExistingSources = false) {
+  const fs = getFileSystem2();
   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 [writeError, result] = await catchError2((async () => {
     const current = await loadIndexMetadata();
+    const scopedSnapshot = scope !== undefined && current?.scope === scope ? await loadScopedNodeIndex(scope) : null;
+    if (protectExistingSources && scopedSnapshot !== null) {
+      const previouslyMissing = new Set(scopedSnapshot.metadata.missingSources?.map((failure) => failure.source) ?? []);
+      const newlyMissingSources = missingSources?.filter((failure) => !previouslyMissing.has(failure.source)) ?? [];
+      if (newlyMissingSources.length > 0) {
+        return { committed: false, newlyMissingSources };
+      }
+    }
     const hash = await hashContent(JSON.stringify(nodes));
-    if (current && current.cacheVersion === CACHE_FORMAT_VERSION && current.hash === hash && current.scope === scope && await areDerivedArtifactsCurrent()) {
+    if (current && current.cacheVersion === CACHE_FORMAT_VERSION && current.hash === hash && current.scope === scope && (scope === undefined || scopedSnapshot !== null) && await areDerivedArtifactsCurrent()) {
       const { missingSources: _previous, ...rest } = current;
       await writeTempAndRename(fs, fs.path.join(dir, METADATA_FILE), JSON.stringify({
         ...rest,
+        cacheVersion: CACHE_FORMAT_VERSION,
         lastSync: Date.now(),
         ...missingSources?.length && { missingSources }
       }));
-      return current.nodeCount;
+      return {
+        committed: true,
+        nodeCount: current.nodeCount
+      };
     }
-    return writeNodeArtifacts(fs, dir, nodes, scope, missingSources);
+    return {
+      committed: true,
+      nodeCount: await writeNodeArtifacts(fs, dir, nodes, scope, missingSources)
+    };
   })());
-  const [releaseError] = await catchError(releaseLock());
+  const [releaseError] = await catchError2(releaseLock());
   if (writeError)
     throw writeError;
   if (releaseError)
     throw releaseError;
-  return count;
+  return result;
+}
+async function commitNodeIndex(nodes, scope, missingSources) {
+  const result = await commitNodeIndexUnderLock(nodes, scope, missingSources);
+  if (!result.committed)
+    throw new Error("Unexpected refused node index commit");
+  return result.nodeCount;
+}
+async function commitNodeIndexForReader(nodes, scope, missingSources) {
+  return commitNodeIndexUnderLock(nodes, scope, missingSources, true);
 }
 async function loadScopedNodeIndex(scope) {
   const metadata = await loadIndexMetadata();
   if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION || metadata.scope !== scope) {
     return null;
   }
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const indexPath = fs.path.join(await resolveNodeStorageDir(), INDEX_FILE);
-  const [readError, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  const [readError, content] = await catchError2(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));
+  const [parseError, nodes] = catchError2(() => JSON.parse(content));
   if (parseError || !Array.isArray(nodes))
     return null;
   return { nodes, metadata };
 }
 async function loadNodeIndex() {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   const dir = await resolveNodeStorageDir();
   const indexPath = fs.path.join(dir, INDEX_FILE);
   if (!await fs.exists(indexPath)) {
@@ -532,41 +247,31 @@ async function loadNodeIndex() {
   if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION) {
     throw new Error("Node index is outdated. Please run 'uip [flow|maestro] registry pull' to sync nodes first.");
   }
-  const [error, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  const [error, content] = await catchError2(fs.readFile(indexPath, "utf-8"));
   if (error) {
     throw new Error(`Failed to load node index: ${error.message}`);
   }
   if (content === null) {
     throw new Error("No node index found. Please run 'uip [flow|maestro] registry pull' to sync nodes first.");
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  const [parseError, parsed] = catchError2(() => JSON.parse(content));
   if (parseError) {
     throw new Error(`Failed to load node index: ${parseError.message}`);
   }
   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 fs = getFileSystem2();
   const dir = await resolveNodeStorageDir();
   const metaPath = fs.path.join(dir, METADATA_FILE);
   if (!await fs.exists(metaPath)) {
     return null;
   }
-  const [error, content] = await catchError(fs.readFile(metaPath, "utf-8"));
+  const [error, content] = await catchError2(fs.readFile(metaPath, "utf-8"));
   if (error || content === null) {
     return null;
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  const [parseError, parsed] = catchError2(() => JSON.parse(content));
   if (parseError || parsed === null) {
     return null;
   }
@@ -578,36 +283,42 @@ function isDerivedArtifact(value) {
   const artifact = value;
   return typeof artifact.cacheVersion === "number" && typeof artifact.sourceHash === "string" && typeof artifact.generatedAt === "number" && Array.isArray(artifact.nodes);
 }
-async function loadValidDerivedArtifact(fileName) {
-  const fs = getFileSystem();
+async function loadValidDerivedArtifact(fileName, scope) {
+  const fs = getFileSystem2();
   const dir = await resolveNodeStorageDir();
   const indexPath = fs.path.join(dir, INDEX_FILE);
   if (!await fs.exists(indexPath)) {
     return null;
   }
   const metadata = await loadIndexMetadata();
-  if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION || typeof metadata.hash !== "string") {
+  if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION || typeof metadata.hash !== "string" || scope !== undefined && metadata.scope !== scope) {
     return null;
   }
   const artifactPath = fs.path.join(dir, fileName);
-  const [readError, content] = await catchError(fs.readFile(artifactPath, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(artifactPath, "utf-8"));
   if (readError || content === null) {
     return null;
   }
-  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  const [parseError, parsed] = catchError2(() => JSON.parse(content));
   if (parseError || !isDerivedArtifact(parsed)) {
     return null;
   }
   if (parsed.cacheVersion !== CACHE_FORMAT_VERSION || parsed.sourceHash !== metadata.hash) {
     return null;
   }
-  return parsed.nodes;
+  return { nodes: parsed.nodes, metadata };
 }
 async function loadValidSearchIndex() {
-  return loadValidDerivedArtifact(SEARCH_INDEX_FILE);
+  return (await loadValidDerivedArtifact(SEARCH_INDEX_FILE))?.nodes ?? null;
 }
 async function loadValidEssentialsIndex() {
-  return loadValidDerivedArtifact(ESSENTIALS_INDEX_FILE);
+  return (await loadValidDerivedArtifact(ESSENTIALS_INDEX_FILE))?.nodes ?? null;
+}
+async function loadScopedSearchIndex(scope) {
+  return loadValidDerivedArtifact(SEARCH_INDEX_FILE, scope);
+}
+async function loadScopedEssentialsIndex(scope) {
+  return loadValidDerivedArtifact(ESSENTIALS_INDEX_FILE, scope);
 }
 async function areDerivedArtifactsCurrent() {
   const searchIndex = await loadValidSearchIndex();
@@ -617,11 +328,11 @@ async function areDerivedArtifactsCurrent() {
   return essentialsIndex !== null;
 }
 async function rederiveNodeIndexArtifacts() {
-  const fs = getFileSystem();
+  const fs = getFileSystem2();
   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 [rederiveError, count] = await catchError2((async () => {
     const nodes = await loadNodeIndex();
     const metadata = await loadIndexMetadata();
     const hash = await hashContent(JSON.stringify(nodes));
@@ -629,7 +340,7 @@ async function rederiveNodeIndexArtifacts() {
     const scope = sameNodes ? metadata.scope : undefined;
     return writeNodeArtifacts(fs, dir, nodes, scope, sameNodes ? metadata.missingSources : undefined);
   })());
-  const [releaseError] = await catchError(releaseLock());
+  const [releaseError] = await catchError2(releaseLock());
   if (rederiveError)
     throw rederiveError;
   if (releaseError)
@@ -639,21 +350,62 @@ async function rederiveNodeIndexArtifacts() {
 
 // ../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 MANIFEST_VALIDATION_NEXT_STEP2 = "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 {
+class TenantManifestInvalidError2 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}`);
+    super(`The tenant manifest failed validation, so only OOTB nodes are available (${failures.map((f) => `${f.source}: ${f.reason}`).join("; ")}). ${MANIFEST_VALIDATION_NEXT_STEP2}`);
     this.name = "TenantManifestInvalidError";
     this.ootbNodes = ootbNodes;
   }
 }
-function isTenantManifestInvalidError(error) {
+function isTenantManifestInvalidError2(error) {
   return error instanceof Error && error.code === TENANT_MANIFEST_INVALID;
 }
+var TENANT_MANIFEST_UNAVAILABLE = "TenantManifestUnavailable";
+
+class PartialNodeSourcesError extends Error {
+  errorCode;
+  retry;
+  constructor(failures) {
+    super(`Unavailable node sources: ${failures.map((failure) => `${failure.source}: ${failure.reason}`).join("; ")}`);
+    this.name = "PartialNodeSourcesError";
+    this.errorCode = failures.some((failure) => /(?:\bHTTP\s+|\bfetch failed:\s*)401\b/i.test(failure.reason)) ? "authentication_required" : failures.some((failure) => /(?:\bHTTP\s+|\bfetch failed:\s*)403\b/i.test(failure.reason)) ? "permission_denied" : undefined;
+    this.retry = this.errorCode ? "RetryWillNotFix" : "RetryLater";
+  }
+}
+
+class TenantManifestUnavailableError2 extends Error {
+  code = TENANT_MANIFEST_UNAVAILABLE;
+  errorCode;
+  retry;
+  ootbNodes;
+  constructor(cause, ootbNodes = []) {
+    const inferred = classifyThrownError(cause);
+    const nextStep = inferred.errorCode === "authentication_required" ? "Run 'uip login', then run the command again." : inferred.errorCode === "permission_denied" ? "Ask for access to the missing node sources, then run the command again." : "Check your connection and run the command again; if your session expired, run 'uip login' first.";
+    const partialCacheStep = cause instanceof PartialNodeSourcesError ? " If this persists, run 'uip maestro flow registry pull --force' to cache the nodes that are available." : "";
+    super(`Could not refresh this tenant's nodes (${describeFailureReason(cause)}), so only OOTB nodes are available. ${nextStep}${partialCacheStep}`, { cause });
+    this.name = "TenantManifestUnavailableError";
+    this.ootbNodes = ootbNodes;
+    this.errorCode = inferred.errorCode;
+    this.retry = inferred.errorCode === "unknown_error" ? "RetryLater" : inferred.retry;
+  }
+}
+function isTenantManifestUnavailableError2(error) {
+  return error instanceof Error && error.code === TENANT_MANIFEST_UNAVAILABLE;
+}
+
+class SessionExpiredError extends Error {
+  errorCode = "authentication_required";
+  retry = "RetryWillNotFix";
+  constructor(loginStatus) {
+    super(loginStatus === "Refresh Failed" ? "your session could not be refreshed" : "your session expired");
+    this.name = "SessionExpiredError";
+  }
+}
 var MAX_FAILURE_REASON_LENGTH = 500;
 function stringifyReason(reason) {
   if (reason instanceof Error)
@@ -677,6 +429,10 @@ function toPullFailures(failures) {
   }));
 }
 var CACHE_EXPIRATION = 30 * 60 * 1000;
+async function readLoginStatus() {
+  const [loginError, loginStatus] = await catchError2(getLoginStatusAsync2());
+  return loginError ? { loginStatus: "Not logged in" } : loginStatus;
+}
 function loginScope(loginStatus) {
   if (loginStatus.loginStatus !== "Logged in" || !loginStatus.accessToken) {
     return;
@@ -689,20 +445,20 @@ function isFreshFor(meta, scope) {
 function isMissingIndexError(error) {
   return error.message.includes("No node index found") || error.message.includes("Node index is outdated");
 }
-async function pullNodes(options = {}) {
+async function pullNodes2(options = {}) {
   const { force = false } = options;
-  const loginStatus = await getLoginStatusAsync();
+  const loginStatus = await getLoginStatusAsync2();
   if (force) {
-    const refreshResult2 = await refreshNodes(loginStatus);
-    const meta2 = await loadIndexMetadata();
+    const refreshResult = await refreshNodes(loginStatus);
+    const meta = await loadIndexMetadata();
     return {
-      syncedCount: refreshResult2.nodeCount || meta2?.nodeCount || 0,
+      syncedCount: refreshResult.nodeCount || meta?.nodeCount || 0,
       fromCache: false,
-      source: refreshResult2.source,
-      cacheWritten: refreshResult2.cacheWritten,
-      info: refreshResult2.info,
-      failures: refreshResult2.failures,
-      missingSources: refreshResult2.missingSources
+      source: refreshResult.source,
+      cacheWritten: refreshResult.cacheWritten,
+      info: refreshResult.info,
+      failures: refreshResult.failures,
+      missingSources: refreshResult.missingSources
     };
   }
   const meta = await loadIndexMetadata();
@@ -713,7 +469,7 @@ async function pullNodes(options = {}) {
     if (isFreshFor(meta, scope)) {
       let syncedCount = meta.nodeCount;
       if (!await areDerivedArtifactsCurrent()) {
-        const [rederiveError, nodeCount] = await catchError(rederiveNodeIndexArtifacts());
+        const [rederiveError, nodeCount] = await catchError2(rederiveNodeIndexArtifacts());
         if (rederiveError) {
           if (!isMissingIndexError(rederiveError)) {
             throw rederiveError;
@@ -747,7 +503,7 @@ async function pullNodes(options = {}) {
   };
 }
 async function refreshNodes(loginStatus) {
-  const pullResult = await pullRemoteNodes(loginStatus);
+  const pullResult = await pullRemoteNodes2(loginStatus);
   if (!pullResult.cacheable) {
     return {
       cacheWritten: false,
@@ -766,30 +522,37 @@ async function refreshNodes(loginStatus) {
   };
 }
 var ENABLED_MANIFEST_FLAGS = new Set([
-  MANIFEST_FEATURE_FLAGS.CONNECTOR_NODES,
   MANIFEST_FEATURE_FLAGS.EXTRACT_DOCUMENT,
-  MANIFEST_FEATURE_FLAGS.HITL,
-  MANIFEST_FEATURE_FLAGS.LOOP_CONTAINER,
-  MANIFEST_FEATURE_FLAGS.BATCH_TRANSFORM,
-  MANIFEST_FEATURE_FLAGS.SUMMARIZE,
   MANIFEST_FEATURE_FLAGS.CONVERSATION_TRIGGER,
   MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_WAIT_FOR_MESSAGE,
   MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_SEND_MESSAGE,
   MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_GET_CONVERSATION_CONTEXT,
-  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_VOICE_INCOMING_CALL_TRIGGER,
-  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_VOICE_CREATE_OUTGOING_CALL,
-  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_VOICE_END_CALL,
   MANIFEST_FEATURE_FLAGS.READ_ENTITY,
   MANIFEST_FEATURE_FLAGS.CREATE_ENTITY,
   MANIFEST_FEATURE_FLAGS.UPDATE_ENTITY,
-  MANIFEST_FEATURE_FLAGS.DELETE_ENTITY
+  MANIFEST_FEATURE_FLAGS.DELETE_ENTITY,
+  MANIFEST_FEATURE_FLAGS.READ_FILE,
+  MANIFEST_FEATURE_FLAGS.CREATE_FILE
 ]);
-async function pullRemoteNodes(loginStatus) {
-  loginStatus ??= await getLoginStatusAsync();
+async function pullRemoteNodes2(loginStatus) {
+  loginStatus ??= await getLoginStatusAsync2();
   const client = new ManifestClient({
     baseUrl: loginStatus.baseUrl || "localhost",
     getFeatureFlag: (flag) => ENABLED_MANIFEST_FLAGS.has(flag)
   });
+  if (loginStatus.loginStatus === "Expired" || loginStatus.loginStatus === "Refresh Failed") {
+    const sessionError = new SessionExpiredError(loginStatus.loginStatus);
+    const manifest = await client.getManifest({
+      inlineAgentNodes: true
+    });
+    return {
+      nodes: manifest.nodes || [],
+      source: "ootb",
+      cacheable: false,
+      info: `Using OOTB nodes because ${sessionError.message}. Run 'uip login' to get this tenant's nodes. Cache was not updated.`,
+      refreshError: sessionError
+    };
+  }
   if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.accessToken || !loginStatus.tenantId || !loginStatus.organizationId) {
     const manifest = await client.getManifest({
       inlineAgentNodes: true
@@ -806,7 +569,7 @@ async function pullRemoteNodes(loginStatus) {
     tenantId: loginStatus.tenantId,
     organizationId: loginStatus.organizationId
   };
-  const [manifestError, diagnostics] = await catchError(client.getManifestWithDiagnostics({
+  const [manifestError, diagnostics] = await catchError2(client.getManifestWithDiagnostics({
     auth: authContext,
     includeIntegrationTriggers: true,
     inlineAgentNodes: true,
@@ -849,62 +612,87 @@ async function pullRemoteNodes(loginStatus) {
     nodes: fallbackManifest.nodes || [],
     source: "ootb",
     cacheable: false,
-    info: `Failed to refresh authenticated nodes with error: ${manifestError}. Using OOTB nodes without updating cache.`
+    info: `Failed to refresh authenticated nodes with error: ${manifestError}. Using OOTB nodes without updating cache.`,
+    refreshError: manifestError
   };
 }
 async function getNodesWithCacheFallback() {
-  const [error, nodes] = await catchError(loadNodeIndex());
-  if (error) {
-    if (!isMissingIndexError(error)) {
-      throw error;
-    }
-    const pullResult = await pullRemoteNodes();
-    if (pullResult.failures?.length) {
-      throw new TenantManifestInvalidError(pullResult.failures, pullResult.nodes);
-    }
-    if (pullResult.cacheable) {
-      await saveNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources);
-    }
-    return pullResult.nodes;
+  const { nodes, failures, refreshError } = await loadCurrentTenantNodes2();
+  if (failures?.length) {
+    throw new TenantManifestInvalidError2(failures, nodes);
+  }
+  if (refreshError) {
+    throw new TenantManifestUnavailableError2(refreshError, nodes);
   }
   return nodes;
 }
-async function loadCurrentTenantNodes(options = {}) {
-  const [loginError, readStatus] = await catchError(getLoginStatusAsync());
-  const loginStatus = loginError ? { loginStatus: "Not logged in" } : readStatus;
+async function loadFreshDerivedIndex(load) {
+  const scope = loginScope(await readLoginStatus());
+  if (scope === undefined)
+    return null;
+  const [, cached] = await catchError2(load(scope));
+  return cached && isFreshFor(cached.metadata, scope) ? cached.nodes : null;
+}
+async function loadCurrentTenantNodes2(options = {}) {
+  const loginStatus = await readLoginStatus();
   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" };
+  if (scope !== undefined) {
+    const [, scoped] = await catchError2(loadScopedNodeIndex(scope));
+    if (!options.force && scoped && isFreshFor(scoped.metadata, scope)) {
+      return { nodes: scoped.nodes, fromCache: true, source: "cache" };
     }
   }
-  const pullResult = await pullRemoteNodes(loginStatus);
+  const pullResult = await pullRemoteNodes2(loginStatus);
   if (pullResult.cacheable) {
-    await catchError(commitNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources));
+    const [commitError, commit] = await catchError2(commitNodeIndexForReader(pullResult.nodes, pullResult.scope, pullResult.missingSources));
+    const unavailableSources = commit && !commit.committed ? commit.newlyMissingSources : commitError ? pullResult.missingSources : undefined;
+    if (unavailableSources?.length) {
+      if (commit && !commit.committed && scope !== undefined) {
+        const [, latest] = await catchError2(loadScopedNodeIndex(scope));
+        if (latest && isFreshFor(latest.metadata, scope) && !latest.metadata.missingSources?.length) {
+          return {
+            nodes: latest.nodes,
+            fromCache: true,
+            source: "cache"
+          };
+        }
+      }
+      const fallback = await pullRemoteNodes2({
+        loginStatus: "Not logged in"
+      });
+      const refreshError = new PartialNodeSourcesError(unavailableSources);
+      return {
+        nodes: fallback.nodes,
+        fromCache: false,
+        source: "ootb",
+        refreshError
+      };
+    }
   }
   return {
     nodes: pullResult.nodes,
     fromCache: false,
     source: pullResult.source,
-    info: pullResult.info
+    info: pullResult.info,
+    failures: pullResult.failures,
+    refreshError: pullResult.refreshError
   };
 }
-async function getLocalSolutionSnapshot() {
-  const ctx = await findSolutionFromCwd();
+async function getLocalSolutionSnapshot2() {
+  const ctx = await findSolutionFromCwd2();
   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 buildInSolutionNodes(ctx);
+  return buildInSolutionNodes2(ctx);
 }
 async function getLocalSolutionNodes() {
-  return (await getLocalSolutionSnapshot()).manifests;
+  return (await getLocalSolutionSnapshot2()).manifests;
 }
-function localContractWarning(snapshot, shown) {
+function localContractWarning2(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()))));
+  return unknownContractWarning2(snapshot.unknownContracts.filter((p) => p.nodeTypes.some((t) => types.has(t.toLowerCase()))));
 }
-function filterNodesByKeyword(nodes, keyword) {
+function filterNodesByKeyword2(nodes, keyword) {
   const lowerKeyword = keyword.toLowerCase();
   return nodes.filter((node) => {
     if (node.nodeType?.toLowerCase().includes(lowerKeyword)) {
@@ -928,11 +716,11 @@ function filterNodesByKeyword(nodes, keyword) {
     return false;
   });
 }
-function findNodeByType(nodes, nodeType) {
+function findNodeByType2(nodes, nodeType) {
   const lowerNodeType = nodeType.toLowerCase();
   return nodes.find((node) => node.nodeType?.toLowerCase() === lowerNodeType) ?? null;
 }
-async function listNodes(options) {
+async function listNodes2(options) {
   if (options?.local)
     return getLocalSolutionNodes();
   const precacheEntries = await listPrecacheEntries();
@@ -977,7 +765,7 @@ function unionWithKnownSdkNodes(tenantNodes) {
     }
     result.push(node);
   }
-  for (const known of listKnownSdkNodes()) {
+  for (const known of listKnownSdkNodes2()) {
     const type = typeof known.nodeType === "string" ? known.nodeType.toLowerCase() : null;
     if (type === null || seen.has(type))
       continue;
@@ -987,34 +775,16 @@ function unionWithKnownSdkNodes(tenantNodes) {
   return result;
 }
 async function loadSearchSummariesWithCacheFallback() {
-  const validSearchIndex = await loadValidSearchIndex();
-  if (validSearchIndex)
-    return validSearchIndex;
-  const [repairError] = await catchError(rederiveNodeIndexArtifacts());
-  if (!repairError) {
-    const repairedSearchIndex = await loadValidSearchIndex();
-    if (repairedSearchIndex)
-      return repairedSearchIndex;
-  }
-  return buildSearchIndex(await getNodesWithCacheFallback());
-}
-async function loadEssentialsIndexWithRepair() {
-  const validEssentialsIndex = await loadValidEssentialsIndex();
-  if (validEssentialsIndex)
-    return validEssentialsIndex;
-  const [repairError] = await catchError(rederiveNodeIndexArtifacts());
-  if (repairError)
-    return null;
-  return loadValidEssentialsIndex();
+  return await loadFreshDerivedIndex(loadScopedSearchIndex) ?? buildSearchIndex(await getNodesWithCacheFallback());
 }
-async function searchNodeSummariesWithAvailability(keyword, filters) {
+async function searchNodeSummariesWithAvailability2(keyword, filters) {
   const tenantNodes = await loadSearchSummariesWithCacheFallback();
   const tenantTypes = new Set(tenantNodes.map((node) => node.nodeType?.toLowerCase()).filter((type) => typeof type === "string"));
   const merged = tenantNodes.map((node) => ({
     node,
     availableOnTenant: true
   }));
-  for (const knownNode of listKnownSdkNodes()) {
+  for (const knownNode of listKnownSdkNodes2()) {
     const type = knownNode.nodeType?.toLowerCase();
     if (typeof type !== "string" || tenantTypes.has(type))
       continue;
@@ -1028,12 +798,12 @@ async function searchNodeSummariesWithAvailability(keyword, filters) {
     entry.node.nodeType.toLowerCase(),
     entry.availableOnTenant
   ] : null).filter((entry) => entry !== null));
-  return searchWithFilters(merged.map((entry) => entry.node), keyword, filters).map((node) => ({
+  return searchWithFilters2(merged.map((entry) => entry.node), keyword, filters).map((node) => ({
     node,
     availableOnTenant: typeof node.nodeType === "string" ? availabilityByType.get(node.nodeType.toLowerCase()) ?? true : true
   }));
 }
-async function searchNodes(keyword, options) {
+async function searchNodes2(keyword, options) {
   let nodes;
   if (options?.local) {
     nodes = await getLocalSolutionNodes();
@@ -1041,9 +811,9 @@ async function searchNodes(keyword, options) {
     const tenantNodes = await getNodesWithCacheFallback();
     nodes = unionWithKnownSdkNodes(tenantNodes);
   }
-  return filterNodesByKeyword(nodes, keyword);
+  return filterNodesByKeyword2(nodes, keyword);
 }
-async function getNode(nodeType, options) {
+async function getNode2(nodeType, options) {
   const lowerNodeType = nodeType.toLowerCase();
   if (!options?.local && lowerNodeType.startsWith("uipath.connector.")) {
     const precached = await getPrecacheNode(nodeType);
@@ -1051,43 +821,43 @@ async function getNode(nodeType, options) {
       return precached;
   }
   if (!options?.local && isEssentialNodeType(nodeType)) {
-    const essentials = await loadEssentialsIndexWithRepair();
-    const node = essentials?.find((node2) => node2.nodeType?.toLowerCase() === lowerNodeType) ?? null;
+    const essentials = await loadFreshDerivedIndex(loadScopedEssentialsIndex);
+    const node = essentials?.find((node) => node.nodeType?.toLowerCase() === lowerNodeType) ?? null;
     if (node)
       return node;
   }
   if (options?.local) {
-    return findNodeByType(await getLocalSolutionNodes(), nodeType);
+    return findNodeByType2(await getLocalSolutionNodes(), nodeType);
   }
-  const [error, nodes] = await catchError(getNodesWithCacheFallback());
+  const [error, nodes] = await catchError2(getNodesWithCacheFallback());
   if (error) {
-    if (error instanceof TenantManifestInvalidError) {
-      const ootbNode = findNodeByType(error.ootbNodes, nodeType);
+    if (error instanceof TenantManifestInvalidError2 || error instanceof TenantManifestUnavailableError2) {
+      const ootbNode = findNodeByType2(error.ootbNodes, nodeType);
       if (ootbNode)
         return ootbNode;
     }
     throw error;
   }
-  return findNodeByType(nodes, nodeType);
+  return findNodeByType2(nodes, nodeType);
 }
-async function getNodeEnriched(nodeType, connectionId, options) {
-  const node = await getNode(nodeType, options);
+async function getNodeEnriched2(nodeType, connectionId, options) {
+  const node = await getNode2(nodeType, options);
   if (!node) {
     return null;
   }
   return await enrichConnectorNode(node, connectionId);
 }
-async function getLocalNodeEnriched(nodeType, connectionId) {
-  const snapshot = await getLocalSolutionSnapshot();
-  const node = findNodeByType(snapshot.manifests, nodeType);
+async function getLocalNodeEnriched2(nodeType, connectionId) {
+  const snapshot = await getLocalSolutionSnapshot2();
+  const node = findNodeByType2(snapshot.manifests, nodeType);
   if (!node)
     return { node: null };
   return {
     node: await enrichConnectorNode(node, connectionId),
-    warning: localContractWarning(snapshot, [node])
+    warning: localContractWarning2(snapshot, [node])
   };
 }
-async function searchNodesWithFilters(keyword, filters, options) {
+async function searchNodesWithFilters2(keyword, filters, options) {
   let nodes;
   if (options?.local) {
     nodes = await getLocalSolutionNodes();
@@ -1095,9 +865,9 @@ async function searchNodesWithFilters(keyword, filters, options) {
     const tenantNodes = await getNodesWithCacheFallback();
     nodes = unionWithKnownSdkNodes(tenantNodes);
   }
-  return searchWithFilters(nodes, keyword, filters);
+  return searchWithFilters2(nodes, keyword, filters);
 }
 
-export { isConnectorNode, isConnectorTriggerNode, extractTriggerEventParameters, extractTriggerFilterFields, extractActivityFilterFields, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorActivityMetadataV4, enrichConnectorNode, resolveNodeStorageDir, saveNodeIndex, loadNodeIndex, saveIndexMetadata, loadIndexMetadata, MANIFEST_VALIDATION_NEXT_STEP, TenantManifestInvalidError, isTenantManifestInvalidError, pullNodes, pullRemoteNodes, loadCurrentTenantNodes, getLocalSolutionSnapshot, localContractWarning, filterNodesByKeyword, findNodeByType, listNodes, searchNodeSummariesWithAvailability, searchNodes, getNode, getNodeEnriched, getLocalNodeEnriched, searchNodesWithFilters };
+export { MANIFEST_VALIDATION_NEXT_STEP2, TenantManifestInvalidError2, isTenantManifestInvalidError2, TenantManifestUnavailableError2, isTenantManifestUnavailableError2, pullNodes2, pullRemoteNodes2, loadCurrentTenantNodes2, getLocalSolutionSnapshot2, localContractWarning2, filterNodesByKeyword2, findNodeByType2, listNodes2, searchNodeSummariesWithAvailability2, searchNodes2, getNode2, getNodeEnriched2, getLocalNodeEnriched2, searchNodesWithFilters2 };
 
-//# debugId=84A6547C9B12968064756E2164756E21
+//# debugId=BBA240B067D0BDAA64756E2164756E21