@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/{packager-tool-2px5qqm4.js → packager-tool-kz3t4raw.js}

@@ -1,47 +1,45 @@
 import {
-  resolveMaestroRegistry
-} from "./packager-tool-dxgrhfq5.js";
-import {
-  searchWithFilters
-} from "./packager-tool-7hw344bt.js";
+  getLoginStatusAsync2,
+  getAuthContext2
+} from "./packager-tool-p123mtfx.js";
 import {
-  buildInSolutionNodes,
-  findSolutionFromCwd,
-  unknownContractWarning
-} from "./packager-tool-z21c6mbp.js";
-import {
-  listKnownSdkNodes
-} from "./packager-tool-409n51pv.js";
+  getFileSystem
+} from "./packager-tool-vgrswa8p.js";
 import {
-  getAuthContext,
-  getLoginStatusAsync
-} from "./packager-tool-kn86394c.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
-  isBrowser
-} from "./packager-tool-0gctz400.js";
+  httpStatusOf,
+  classifyThrownError,
+  extractErrorMessage,
+  logger,
+  UIPATH_HOME_DIR2,
+  hashContent,
+  getSdkUserAgentToken,
+  addSdkUserAgentHeader,
+  installSdkUserAgentHeader
+} from "./packager-tool-8ed52y5r.js";
 import {
   MANIFEST_FEATURE_FLAGS,
   ManifestClient
-} from "./packager-tool-9rmaeaww.js";
+} from "./packager-tool-gdpw0daf.js";
 import {
-  UIPATH_HOME_DIR,
-  addSdkUserAgentHeader,
-  extractErrorMessage,
-  getSdkUserAgentToken,
-  hashContent,
-  httpStatusOf,
-  installSdkUserAgentHeader,
-  logger
-} from "./packager-tool-apawc11t.js";
+  searchWithFilters2
+} from "./packager-tool-xb16e3tz.js";
 import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
+  listKnownSdkNodes2
+} from "./packager-tool-d07g2kpn.js";
 import {
-  getFileSystem
-} from "./packager-tool-myhbp761.js";
+  findSolutionFromCwd2,
+  buildInSolutionNodes2,
+  unknownContractWarning2
+} from "./packager-tool-a1h0q79w.js";
 import {
-  __require
-} from "./packager-tool-1yh8g550.js";
+  resolveMaestroRegistry
+} from "./packager-tool-64r7e4ek.js";
+import {
+  isBrowser2
+} from "./packager-tool-zdqbp34f.js";
 
 // ../integrationservice-sdk/generated/connections/src/runtime.ts
 var BASE_PATH = "https://alpha.uipath.com/entity/Azure/connections_".replace(/\/+$/, "");
@@ -574,7 +572,7 @@ var package_default = {
   name: "@uipath/integrationservice-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.205.0-preview.276",
+  version: "1.206.0-preview.279",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -595,17 +593,26 @@ var package_default = {
     ".": {
       types: "./dist/src/index.d.ts",
       default: "./dist/index.js"
+    },
+    "./bindings": {
+      types: "./dist/src/bindings.d.ts",
+      default: "./dist/bindings.js"
+    },
+    "./connections": {
+      types: "./dist/src/connections.d.ts",
+      default: "./dist/connections.js"
     }
   },
   files: [
     "dist"
   ],
   scripts: {
-    build: "bun build ./src/index.ts --outdir dist --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
+    build: "bun build ./src/index.ts ./src/bindings.ts ./src/connections.ts --outdir dist --root ./src --format esm --target node --sourcemap=linked && tsc -p tsconfig.build.json --noCheck",
     generate: "bun run src/scripts/generate-sdk.ts",
     lint: "biome check .",
     test: "vitest run",
-    "test:coverage": "vitest run --coverage"
+    "test:coverage": "vitest run --coverage",
+    typecheck: "tsc --noEmit"
   },
   devDependencies: {
     "@uipath/auth": "workspace:*",
@@ -616,7 +623,7 @@ var package_default = {
     typescript: "^7.0.2"
   },
   dependencies: {
-    "@uipath/integration-service-design-time": "2.10.0"
+    "@uipath/integration-service-design-time": "3.3.0"
   }
 };
 
@@ -6338,7 +6345,7 @@ function resolveApiDomain(ApiClass) {
   return API_DOMAIN_MAP.get(ApiClass) ?? API_DOMAIN_BY_NAME.get(baseApiClassName(ApiClass.name));
 }
 async function getValidatedAuthContext(options) {
-  const ctx = await getAuthContext({
+  const ctx = await getAuthContext2({
     tenant: options?.tenant,
     ensureTokenValidityMinutes: options?.loginValidity,
     requireOrganizationId: true,
@@ -6352,10 +6359,13 @@ async function getValidatedAuthContext(options) {
     tenantName: ctx.tenantName
   };
 }
+function tenantServiceRoot(baseUrl, organizationId, tenantName) {
+  return `${baseUrl}/${encodeURIComponent(organizationId)}/${encodeURIComponent(tenantName)}`;
+}
 async function createConnectionsConfig(options) {
   const { baseUrl, accessToken, organizationId, tenantName } = await getValidatedAuthContext(options);
   return new Configuration({
-    basePath: `${baseUrl}/${organizationId}/${tenantName}/connections_`,
+    basePath: `${tenantServiceRoot(baseUrl, organizationId, tenantName)}/connections_`,
     accessToken: async () => accessToken,
     headers: addSdkUserAgentHeader({
       "x-uipath-source": "UiPath.CodingAgent"
@@ -6365,7 +6375,7 @@ async function createConnectionsConfig(options) {
 async function createElementsConfig(options) {
   const { baseUrl, accessToken, organizationId, tenantName } = await getValidatedAuthContext(options);
   return new Configuration2({
-    basePath: `${baseUrl}/${organizationId}/${tenantName}/elements_/v3/element`,
+    basePath: `${tenantServiceRoot(baseUrl, organizationId, tenantName)}/elements_/v3/element`,
     accessToken: async () => accessToken,
     headers: addSdkUserAgentHeader({
       "x-uipath-source": "UiPath.CodingAgent"
@@ -6377,18 +6387,22 @@ async function createApiClient(ApiClass, options) {
   if (!domain) {
     throw new Error(`Unknown API class: ${ApiClass.name}`);
   }
-  const config = domain === "connections" ? await createConnectionsConfig(options) : await createElementsConfig(options);
+  if (domain === "connections") {
+    const config = await createConnectionsConfig(options);
+    return new ApiClass(config);
+  }
+  const config = await createElementsConfig(options);
   return new ApiClass(config);
 }
-var ACTIVITY_VERSION_V4 = "4.0.0";
-function isV4ActivityConfiguration(instanceParameters) {
+var ACTIVITY_VERSION_V42 = "4.0.0";
+function isV4ActivityConfiguration2(instanceParameters) {
   if (!instanceParameters)
     return false;
-  return instanceParameters.version === ACTIVITY_VERSION_V4;
+  return instanceParameters.version === ACTIVITY_VERSION_V42;
 }
 async function getConnectorActivityMetadataV4(options, connectorKey, objectName) {
   const { baseUrl, accessToken, organizationId, tenantName } = await getValidatedAuthContext(options);
-  const url = `${baseUrl}/${organizationId}/${tenantName}/elements_/v4/element/connectors/${encodeURIComponent(connectorKey)}/objects/${encodeURIComponent(objectName)}/metadata`;
+  const url = `${tenantServiceRoot(baseUrl, organizationId, tenantName)}/elements_/v4/element/connectors/${encodeURIComponent(connectorKey)}/objects/${encodeURIComponent(objectName)}/metadata`;
   const response = await fetch(url, {
     headers: addSdkUserAgentHeader({
       Authorization: `Bearer ${accessToken}`,
@@ -6548,7 +6562,7 @@ function shortHash(input) {
 // ../integrationservice-sdk/src/dap/live-connection-provider.ts
 var _locationShimmed = false;
 function ensureLocationShim(origin) {
-  if (_locationShimmed || isBrowser()) {
+  if (_locationShimmed || isBrowser2()) {
     return;
   }
   const url = new URL(origin);
@@ -6566,7 +6580,7 @@ function ensureLocationShim(origin) {
 function createLiveConnectionsProvider() {
   return {
     getConnectionInfo: async (connectionId) => {
-      const ctx = await getAuthContext({
+      const ctx = await getAuthContext2({
         requireOrganizationId: true,
         requireTenantName: true,
         requireTenantId: true
@@ -6583,6 +6597,98 @@ function createLiveConnectionsProvider() {
   };
 }
 
+// ../integrationservice-sdk/src/dap/managed-http.ts
+var MANAGED_HTTP_CONNECTOR_KEY2 = "uipath-uipath-http";
+var MANAGED_HTTP_OBJECT_NAME = "http-request";
+var MANAGED_HTTP_ENDPOINT = "/http-request";
+var IMPLICIT_CONNECTION = "ImplicitConnection";
+var MANAGED_HTTP_METHODS = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+var MANAGED_HTTP_KEYS = new Set([
+  "authentication",
+  "method",
+  "url",
+  "connectionId",
+  "folderKey",
+  "targetConnector",
+  "headers",
+  "query",
+  "body"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function managedHttpDetailErrors(config) {
+  const errors = [];
+  const auth = config.authentication;
+  if (auth !== "connector" && auth !== "manual") {
+    errors.push('authentication is required ("connector" or "manual")');
+  }
+  if (typeof config.method !== "string" || !MANAGED_HTTP_METHODS.has(config.method)) {
+    errors.push(`method must be one of: ${[...MANAGED_HTTP_METHODS].join(", ")}`);
+  }
+  if (auth === "connector") {
+    for (const key of ["connectionId", "folderKey", "targetConnector"]) {
+      if (typeof config[key] !== "string" || !config[key]) {
+        errors.push(`${key} is required for connector mode`);
+      }
+    }
+    if (config.url !== undefined && typeof config.url !== "string") {
+      errors.push("url must be a string");
+    }
+  } else if (auth === "manual") {
+    if (typeof config.url !== "string" || !config.url) {
+      errors.push("url is required for manual mode");
+    }
+  }
+  for (const key of ["headers", "query"]) {
+    if (config[key] !== undefined && !isRecord(config[key])) {
+      errors.push(`${key} must be a JSON object`);
+    }
+  }
+  const unknownKeys = Object.keys(config).filter((key) => !MANAGED_HTTP_KEYS.has(key));
+  if (unknownKeys.length > 0) {
+    errors.push(`Unknown keys: ${unknownKeys.join(", ")}. Valid keys: ${[...MANAGED_HTTP_KEYS].join(", ")}`);
+  }
+  return errors;
+}
+function buildManagedHttpBodyParameters(detail) {
+  const body = {
+    authentication: detail.authentication,
+    method: detail.method
+  };
+  if (detail.authentication === "connector") {
+    body.targetConnector = detail.targetConnector;
+    body.connection = detail.connectionId;
+    if (detail.url !== undefined) {
+      body.path = detail.url;
+      body.url = detail.url;
+    }
+  } else {
+    body.url = detail.url;
+  }
+  if (detail.headers !== undefined)
+    body.headers = detail.headers;
+  if (detail.query !== undefined)
+    body.query = detail.query;
+  if (detail.body !== undefined)
+    body.body = detail.body;
+  return body;
+}
+var MANAGED_HTTP_TELEMETRY = {
+  connectorKey: MANAGED_HTTP_CONNECTOR_KEY2,
+  connectorName: "HTTP",
+  operationType: "create",
+  objectName: MANAGED_HTTP_OBJECT_NAME,
+  objectDisplayName: "HTTP Request",
+  primaryKeyName: ""
+};
+
 // ../integrationservice-sdk/src/dap/resource-field-resolver.ts
 var FIELD_ARRAY_MARKER = "[*]";
 function resourceFolderKeyFieldName(fieldName) {
@@ -6594,8 +6700,10 @@ function isResourceSelection(value) {
 }
 
 class ResourceFieldResolutionError extends Error {
-  constructor(message) {
+  fromInput;
+  constructor(message, fromInput = false) {
     super(message);
+    this.fromInput = fromInput;
     this.name = "ResourceFieldResolutionError";
   }
 }
@@ -6605,7 +6713,7 @@ async function resolveResourceFieldValues(fieldValues, resourceFields, solutionD
     solution ??= await openSolution(solutionDir);
     return solution;
   };
-  const [resolveError, resolved] = await catchError(resolveEach(fieldValues, resourceFields, openOnce));
+  const [resolveError, resolved] = await catchError2(resolveEach(fieldValues, resourceFields, openOnce));
   const saveError = solution ? await saveSolution(solution, solutionDir) : null;
   if (resolveError) {
     if (saveError) {
@@ -6626,10 +6734,10 @@ async function resolveEach(fieldValues, resourceFields, openOnce) {
       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.`);
+      throw new ResourceFieldResolutionError(`'${field.name}' is a multi-select ${field.kind} picker, which the CLI cannot resolve yet — pick one ${field.kind} by name.`, true);
     }
     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.`);
+      throw new ResourceFieldResolutionError(`'${field.name}' is a ${field.kind} picker on this activity — pass the ${field.kind} name as a string.`, true);
     }
     const companion = resourceFolderKeyFieldName(field.name);
     const folderHint = fieldValues[companion];
@@ -6641,10 +6749,10 @@ async function resolveEach(fieldValues, resourceFields, openOnce) {
   return resolved;
 }
 async function openSolution(solutionDir) {
-  const [error, solution] = await catchError((async () => {
-    const { getSolutionAuthContext } = await import("./solution-auth-8qz5pw7z.js");
+  const [error, solution] = await catchError2((async () => {
+    const { getSolutionAuthContext } = await import("./solution-auth-j8x84n5z.js");
     await getSolutionAuthContext({});
-    const resources = await import("./index-1b2je9n2.js");
+    const resources = await import("./index-px95xmkg.js");
     await resources.normalizeResourceFileCasing(solutionDir);
     const services = await resources.createResourceBuilderServices();
     return {
@@ -6665,18 +6773,18 @@ async function saveSolution({ resources, builder }, solutionDir) {
 }
 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)));
+  const candidates = matches.filter((match) => match.name.toLowerCase() === name.toLowerCase() && (folderHint === undefined || matchesFolder(resources, match, 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(`
+    const folders = candidates.map((match) => `  - ${match.folder?.fullyQualifiedName ?? "<tenant>"} (folder key ${match.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}`);
+${folders}`, true);
   }
   const [match] = candidates;
-  const [loadError, solution] = await catchError(builder.context.loadAsync());
+  const [loadError, solution] = await catchError2(builder.context.loadAsync());
   if (loadError) {
     throw new ResourceFieldResolutionError(`Failed to read the solution before referencing ${field.kind} '${name}': ${loadError.message}`);
   }
@@ -6689,7 +6797,7 @@ ${folders}`);
       folderPath: match.folder?.fullyQualifiedName
     };
   }
-  const [referenceError, response] = await catchError(builder.addOrUpdateResourceToSolutionAsync({
+  const [referenceError, response] = await catchError2(builder.addOrUpdateResourceToSolutionAsync({
     kind: field.kind,
     type: match.type,
     key: match.key,
@@ -6732,7 +6840,7 @@ function createSolutionResourceConfigurationsProvider(solutionDir, namesByKey =
     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) }));
+      const [error, graph] = await catchError2(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);
@@ -6745,9 +6853,9 @@ function createSolutionResourceConfigurationsProvider(solutionDir, namesByKey =
   };
 }
 async function openEngine() {
-  const { getSolutionAuthContext } = await import("./solution-auth-8qz5pw7z.js");
+  const { getSolutionAuthContext } = await import("./solution-auth-j8x84n5z.js");
   await getSolutionAuthContext({});
-  const resources = await import("./index-1b2je9n2.js");
+  const resources = await import("./index-px95xmkg.js");
   return {
     resources,
     services: await resources.createResourceBuilderServices()
@@ -6755,9 +6863,8 @@ async function openEngine() {
 }
 
 // ../integrationservice-sdk/src/dap/essential-config.ts
-var MANAGED_HTTP_CONNECTOR_KEY = "uipath-uipath-http";
 var MANAGED_HTTP_CONNECTOR_VERSION = "1.4.50";
-function buildActivityEssentialConfiguration(instanceParameters, methodInfo, savedFilterTrees = null, customFieldsRequestDetails = null) {
+function buildActivityEssentialConfiguration2(instanceParameters, methodInfo, savedFilterTrees = null, customFieldsRequestDetails = null) {
   const operation = methodInfo.operation.toLowerCase();
   const savedJitInputFieldId = computeSavedJitInputFieldId(operation, methodInfo.parameters, instanceParameters.objectName);
   const essentialConfiguration = {
@@ -6801,7 +6908,7 @@ async function configureActivityClient({
       assertFilterTreeSupported(tree);
     }
   }
-  const { DesignTimeActivityClient } = await import("./index-fyc0k5dd.js");
+  const { DesignTimeActivityClient } = await import("./index-5pzp2qeb.js");
   const initiateOptions = {
     connectionsProvider: createLiveConnectionsProvider(),
     ...solutionDir ? {
@@ -6838,30 +6945,30 @@ async function configureActivityClient({
   }
   if (savedFilterTrees) {
     for (const [filterParam, tree] of Object.entries(savedFilterTrees)) {
-      await applySavedFilterTree(client, filterParam, tree);
+      await applySavedFilterTree2(client, filterParam, tree);
     }
   }
   return { client, resolvedResources };
 }
-async function applySavedFilterTree(client, propertyName, tree) {
+async function applySavedFilterTree2(client, propertyName, tree) {
   await client.updateProperty({
     propertyName,
     valueType: "widget",
     widget: { type: "filter", widgetValue: tree }
   });
 }
-function assertActivityMetadataResolved(essentialConfiguration, connectionId) {
+function assertActivityMetadataResolved2(essentialConfiguration, connectionId) {
   if (essentialConfiguration.connectorVersion == null) {
     throw new Error(`Connector activity metadata was not resolved for connection '${connectionId}' (no connectorVersion). Check the connection is enabled and you are logged in (run 'uip login').`);
   }
 }
-function buildManagedHttpEssentialConfiguration() {
+function buildManagedHttpEssentialConfiguration2() {
   const essentialConfiguration = {
     connectorVersion: MANAGED_HTTP_CONNECTOR_VERSION,
     executionType: null,
     customFieldsRequestDetails: null,
     instanceParameters: {
-      connectorKey: MANAGED_HTTP_CONNECTOR_KEY,
+      connectorKey: MANAGED_HTTP_CONNECTOR_KEY2,
       objectName: "http-request",
       httpMethod: "POST",
       activityType: "Curated",
@@ -6877,14 +6984,44 @@ function buildManagedHttpEssentialConfiguration() {
   };
   return { essentialConfiguration };
 }
+// ../integrationservice-sdk/src/dap/external-execution.ts
+function externalExecutionOf(metadata) {
+  if (typeof metadata !== "object" || metadata === null)
+    return;
+  const record = metadata;
+  const executionType = record.executionType;
+  if (typeof executionType !== "string" || executionType === "") {
+    return;
+  }
+  if (executionType !== "async" && executionType !== "hybrid") {
+    return { executionType };
+  }
+  const events = record.metadata?.events;
+  const eventMode = Array.isArray(events?.eventMode) ? String(events.eventMode[0] ?? "") : undefined;
+  const source = eventMode === "webhooks" ? events?.webhook : eventMode === "polling" ? events?.polling : undefined;
+  const eventTypes = source?.eventTypes;
+  return {
+    executionType,
+    ...eventMode && { eventMode },
+    ...eventTypes?.[0]?.operation && {
+      eventType: eventTypes[0].operation
+    }
+  };
+}
+function externalExecutionWarning(external, target) {
+  const { executionType, eventType } = external;
+  if (executionType === "sync" || eventType)
+    return;
+  return executionType === "async" || executionType === "hybrid" ? `"${target}" runs ${executionType}, but its metadata names no event it answers with, so the node has nothing to wait on and may never finish.` : `"${target}" has execution type "${executionType}", which is neither sync nor async, so it is saved as is and may not run.`;
+}
 // ../integrationservice-sdk/src/dap/input-metadata.ts
 function findMultipartBodyField(params) {
   return params.find((param) => param.dataType === "string")?.name;
 }
-function extractMultipartParameters(params) {
+function extractMultipartParameters2(params) {
   return params.filter((p) => p.type === "multipart").map((p) => ({ name: p.name, dataType: p.dataType }));
 }
-function inlineMultipartFileValues(multipartParams, bodyParameters) {
+function inlineMultipartFileValues2(multipartParams, bodyParameters) {
   if (!bodyParameters || multipartParams.length === 0) {
     return { multipartParams, bodyParameters };
   }
@@ -6907,7 +7044,7 @@ var DEFAULT_MAX_PAGE_SIZE = 1000;
 function isListOperation(operation) {
   return typeof operation === "string" && operation.toLowerCase() === "list";
 }
-function buildInputMetadata(multipartParams, operation, maxPageSize, expressionResolutionFields) {
+function buildInputMetadata2(multipartParams, operation, maxPageSize, expressionResolutionFields) {
   const metadata = {};
   let hasContent = false;
   if (multipartParams.length > 0) {
@@ -6930,6 +7067,32 @@ function buildInputMetadata(multipartParams, operation, maxPageSize, expressionR
   }
   return hasContent ? metadata : undefined;
 }
+// ../integrationservice-sdk/src/dap/bindings-v2.ts
+var JSON_STRING_PREFIX = "=jsonString:";
+var guardJsonString = (json) => `${JSON_STRING_PREFIX}${json}`;
+var stripJsonStringGuard = (value) => value.startsWith(JSON_STRING_PREFIX) ? value.slice(JSON_STRING_PREFIX.length) : value;
+function upsertResourceBinding(bindings, row, mintId) {
+  const existing = bindings.find((binding) => binding.resource === row.resource && binding.resourceKey === row.resourceKey && binding.propertyAttribute === row.propertyAttribute);
+  if (existing) {
+    if (typeof existing.id !== "string" || existing.id === "") {
+      existing.id = mintId();
+    }
+    existing.name = row.name;
+    existing.default = row.default;
+    return { binding: existing, created: false };
+  }
+  const binding = {
+    id: mintId(),
+    name: row.name,
+    type: "string",
+    resource: row.resource,
+    resourceKey: row.resourceKey,
+    ...row.default ? { default: row.default } : {},
+    propertyAttribute: row.propertyAttribute
+  };
+  return { binding, created: true };
+}
+
 // ../integrationservice-sdk/src/dap/validation/rules.ts
 var counter = 0;
 function uid() {
@@ -7001,12 +7164,12 @@ function validateMethodMatchesOperation(context) {
     return [];
   if (!VALID_HTTP_METHODS.has(context.httpMethod.toUpperCase()))
     return [];
-  const jsonStr = context.configuration.startsWith("=jsonString:") ? context.configuration.slice("=jsonString:".length) : context.configuration;
+  const jsonStr = stripJsonStringGuard(context.configuration);
   let operation;
   try {
     const parsed = JSON.parse(jsonStr);
     const instanceParameters = parsed?.essentialConfiguration?.instanceParameters;
-    if (isV4ActivityConfiguration(instanceParameters)) {
+    if (isV4ActivityConfiguration2(instanceParameters)) {
       return [];
     }
     operation = instanceParameters?.operation;
@@ -7075,7 +7238,7 @@ function validateConfiguration(context) {
       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;
+  const jsonStr = stripJsonStringGuard(context.configuration);
   try {
     const parsed = JSON.parse(jsonStr);
     if (!parsed.essentialConfiguration) {
@@ -7262,7 +7425,7 @@ function extractFields(metadata, method, requestOnly) {
     return compact;
   });
 }
-function isConnectorNode(node) {
+function isConnectorNode2(node) {
   const nodeType = node.nodeType;
   return nodeType?.startsWith("uipath.connector") || false;
 }
@@ -7349,10 +7512,10 @@ function getConnectorConfiguration(node) {
   const configStr = getConfigurationString(node);
   if (!configStr)
     return null;
-  const [err, parsed] = catchError(() => JSON.parse(configStr));
+  const [err, parsed] = catchError2(() => JSON.parse(configStr));
   return err ? null : parsed;
 }
-function getConnectorInfo(node) {
+function getConnectorInfo2(node) {
   const context = parseContext(node);
   const config = getConnectorConfiguration(node);
   if (!context && !config)
@@ -7368,7 +7531,22 @@ function getConnectorInfo(node) {
     activityType: config?.activityType ?? ""
   };
 }
-async function fetchConnectionInfo(connectionId) {
+
+class ConnectionConnectorMismatchError2 extends Error {
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+    this.name = "ConnectionConnectorMismatchError";
+  }
+}
+function assertConnectionConnector2(connectionId, info, connectorKey, subject) {
+  if (!info.connectorKey || !connectorKey || info.connectorKey.toLowerCase() === connectorKey.toLowerCase()) {
+    return;
+  }
+  throw new ConnectionConnectorMismatchError2(`Connection "${connectionId}" is a ${info.connectorKey} connection, but ${subject} runs on ${connectorKey}.`, `Pass a ${connectorKey} connection: 'uip is connections list ${connectorKey} --all-folders'.`);
+}
+async function fetchConnectionInfo2(connectionId) {
   const api = await createApiClient(ConnectionsApi);
   const response = await api.apiV1ConnectionsConnectionIdGet({
     connectionId
@@ -7386,16 +7564,16 @@ async function fetchConnectionInfo(connectionId) {
     folderKey: response.folder?.key ?? null
   };
 }
-async function fetchConnectorMetadata(connectorKey, objectName, connectionId) {
+async function fetchConnectorMetadata2(connectorKey, objectName, connectionId) {
   const api = await createApiClient(ElementsApi);
   if (connectionId) {
-    const response2 = await api.getInstanceObjectMetadataRaw({
+    const response = await api.getInstanceObjectMetadataRaw({
       connectionOrInstanceId: connectionId,
       elementKey: connectorKey,
       objectName,
       includeParentArray: true
     });
-    return await response2.raw.json();
+    return await response.raw.json();
   }
   const response = await api.getObjectMetadataRaw({
     elementKey: connectorKey,
@@ -7404,7 +7582,7 @@ async function fetchConnectorMetadata(connectorKey, objectName, connectionId) {
   });
   return await response.raw.json();
 }
-async function fetchConnectorActivityMetadataV4(connectorKey, objectName) {
+async function fetchConnectorActivityMetadataV42(connectorKey, objectName) {
   return await getConnectorActivityMetadataV4(undefined, connectorKey, objectName);
 }
 function buildEnrichedActivityNode(node, metadata, method) {
@@ -7425,13 +7603,13 @@ function buildEnrichedActivityNode(node, metadata, method) {
 async function enrichConnectorActivityNode(node, connectionId) {
   const parsed = parseContext(node);
   const config = getConnectorConfiguration(node);
-  if (isV4ActivityConfiguration(config)) {
+  if (isV4ActivityConfiguration2(config)) {
     return enrichV4ConnectorActivityNode(node, connectionId, config);
   }
   if (!parsed)
     return node;
   const { connectorKey, objectName, method } = parsed;
-  const [error, metadata] = await catchError(fetchConnectorMetadata(connectorKey, objectName, connectionId));
+  const [error, metadata] = await catchError2(fetchConnectorMetadata2(connectorKey, objectName, connectionId));
   if (error) {
     return node;
   }
@@ -7448,7 +7626,7 @@ async function enrichV4ConnectorActivityNode(node, connectionId, config) {
   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));
+  const [error, metadata] = await catchError2(fetchConnectorActivityMetadataV42(connectorKey, objectName));
   if (error) {
     logger.warn(`IS v4 enrichment failed: ${error.message}`);
     return node;
@@ -7456,7 +7634,7 @@ async function enrichV4ConnectorActivityNode(node, connectionId, config) {
   return buildEnrichedActivityNode(node, metadata, method);
 }
 async function enrichConnectorNode(node, connectionId) {
-  if (!isConnectorNode(node))
+  if (!isConnectorNode2(node))
     return node;
   return isConnectorTriggerNode(node) ? enrichConnectorTriggerNode(node, connectionId) : enrichConnectorActivityNode(node, connectionId);
 }
@@ -7475,7 +7653,7 @@ async function enrichConnectorTriggerNode(node, connectionId) {
   let byoaConnection = false;
   let elementInstanceId = null;
   if (connectionId) {
-    const [connErr, connInfo] = await catchError(fetchConnectionInfo(connectionId));
+    const [connErr, connInfo] = await catchError2(fetchConnectionInfo2(connectionId));
     if (!connErr) {
       byoaConnection = connInfo.byoaConnection;
       elementInstanceId = connInfo.elementInstanceId;
@@ -7505,10 +7683,10 @@ async function readIndex() {
   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;
@@ -7523,10 +7701,10 @@ async function getPrecacheNode(nodeType, options) {
   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();
@@ -7539,17 +7717,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";
@@ -7565,7 +7743,7 @@ function nodeCacheScope(login) {
 }
 async function resolveNodeStorageDir() {
   const fs = getFileSystem();
-  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, "nodes");
+  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR2, "nodes");
 }
 function buildSearchIndex(nodes) {
   return nodes.map((node) => ({
@@ -7631,54 +7809,55 @@ 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) {
+async function commitNodeIndexUnderLock(nodes, scope, missingSources, protectExistingSources = false) {
   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 [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();
@@ -7687,12 +7866,12 @@ async function loadScopedNodeIndex(scope) {
   }
   const fs = getFileSystem();
   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 };
@@ -7708,14 +7887,14 @@ 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}`);
   }
@@ -7728,11 +7907,11 @@ async function loadIndexMetadata() {
   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;
   }
@@ -7744,7 +7923,7 @@ 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) {
+async function loadValidDerivedArtifact(fileName, scope) {
   const fs = getFileSystem();
   const dir = await resolveNodeStorageDir();
   const indexPath = fs.path.join(dir, INDEX_FILE);
@@ -7752,28 +7931,34 @@ async function loadValidDerivedArtifact(fileName) {
     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();
@@ -7787,7 +7972,7 @@ async function rederiveNodeIndexArtifacts() {
   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));
@@ -7795,7 +7980,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)
@@ -7805,21 +7990,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)
@@ -7843,6 +8069,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;
@@ -7855,20 +8085,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();
@@ -7879,7 +8109,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;
@@ -7913,7 +8143,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,
@@ -7932,30 +8162,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
@@ -7972,7 +8209,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,
@@ -8015,62 +8252,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)) {
@@ -8094,11 +8356,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();
@@ -8143,7 +8405,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;
@@ -8153,34 +8415,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;
@@ -8194,12 +8438,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();
@@ -8207,9 +8451,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);
@@ -8217,43 +8461,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();
@@ -8261,9 +8505,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 { 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 };
+export { storedActivityBindings, planResourceBindings, guardJsonString, stripJsonStringGuard, upsertResourceBinding, externalExecutionOf, externalExecutionWarning, MANAGED_HTTP_CONNECTOR_KEY2, MANAGED_HTTP_ENDPOINT, IMPLICIT_CONNECTION, managedHttpDetailErrors, buildManagedHttpBodyParameters, MANAGED_HTTP_TELEMETRY, ACTIVITY_VERSION_V42, isV4ActivityConfiguration2, FilterNotSupportedError, substituteFilterVariables, buildActivityEssentialConfiguration2, configureActivityClient, applySavedFilterTree2, assertActivityMetadataResolved2, buildManagedHttpEssentialConfiguration2, extractMultipartParameters2, inlineMultipartFileValues2, isListOperation, buildInputMetadata2, normalizeHttpMethod, validateIntSvcNode, isConnectorNode2, getConnectorInfo2, ConnectionConnectorMismatchError2, assertConnectionConnector2, fetchConnectionInfo2, fetchConnectorMetadata2, fetchConnectorActivityMetadataV42, MANIFEST_VALIDATION_NEXT_STEP2, TenantManifestInvalidError2, isTenantManifestInvalidError2, TenantManifestUnavailableError2, isTenantManifestUnavailableError2, pullNodes2, pullRemoteNodes2, loadCurrentTenantNodes2, getLocalSolutionSnapshot2, localContractWarning2, filterNodesByKeyword2, findNodeByType2, listNodes2, searchNodeSummariesWithAvailability2, searchNodes2, getNode2, getNodeEnriched2, getLocalNodeEnriched2, searchNodesWithFilters2 };
 
-//# debugId=C1B5CAA88495D05664756E2164756E21
+//# debugId=7D41A254E4F48E4464756E2164756E21