@uipath/maestro-tool 1.202.2 → 1.203.0-preview.180

package/dist/packager-tool-dz506qqq.js

@@ -1,2120 +0,0 @@
-import {
-  ConnectionsApi,
-  ElementsApi,
-  buildResourceCompactSummary,
-  buildTriggerCompactSummary,
-  createApiClient,
-  fetchRawMetadata,
-  fetchTriggerMetadata,
-  normalizeConnectionStatus
-} from "./packager-tool-1zpm7wts.js";
-import {
-  BPMN_SPEC,
-  SUPPORTED_UIPATH_EXTENSION_TAGS
-} from "./packager-tool-jfv7t0c8.js";
-import {
-  ReleasesApi,
-  createOrchestratorConfig
-} from "./packager-tool-d5mjdpbf.js";
-import {
-  getLoginStatusAsync
-} from "./packager-tool-f0kd5kq4.js";
-import {
-  OutputFormatter,
-  RESULTS,
-  UIPATH_HOME_DIR,
-  catchError,
-  hashContent,
-  isGuid,
-  logger,
-  processContext
-} from "./packager-tool-79gws1zn.js";
-import {
-  getFileSystem
-} from "./packager-tool-0v3s8r01.js";
-import {
-  __require
-} from "./packager-tool-1yh8g550.js";
-
-// ../maestro-sdk/src/bpmn-validation/project-validator.ts
-var KNOWN_UIPATH_TAGS = new Set(SUPPORTED_UIPATH_EXTENSION_TAGS);
-var CALL_ACTIVITY_TYPES = Object.entries(BPMN_SPEC.extensionTypes).filter(([, contract]) => contract.bpmnElement === "bpmn:CallActivity").map(([type]) => type).sort((a, b) => a.localeCompare(b));
-var CALL_ACTIVITY_PAYLOAD_TAGS = new Set(Object.values(BPMN_SPEC.extensionTypes).filter((contract) => contract.bpmnElement === "bpmn:CallActivity").map((contract) => contract.extensionTag).filter((tag) => typeof tag === "string"));
-var SEMANTIC_VALIDATION_ERROR = "BPMN_VALIDATION_ERROR";
-var BPMN_MODEL_NAMESPACE = "http://www.omg.org/spec/BPMN/20100524/MODEL";
-var ACTIVITY_CONFIGURATION_VERSION = "activityConfigurationVersion";
-var ACTIVITY_CONFIGURATION_V1 = "v1";
-
-class BpmnValidateService {
-  fileSystem;
-  options;
-  constructor(fileSystem, options = {}) {
-    this.fileSystem = fileSystem;
-    this.options = options;
-  }
-  async validateProject(projectPath) {
-    if (!projectPath) {
-      return this.createFailure([
-        {
-          file: ".",
-          message: "Project path is required.",
-          instruction: "Provide a ProcessOrchestration project path."
-        }
-      ]);
-    }
-    const files = await this.fileSystem.readdir(projectPath);
-    const bpmnFiles = files.filter((file) => file.endsWith(".bpmn"));
-    const diagnostics = [];
-    if (bpmnFiles.length === 0) {
-      diagnostics.push({
-        file: ".",
-        message: "No BPMN files were found.",
-        instruction: "Add at least one .bpmn process file."
-      });
-    }
-    const bindings = await this.loadBindings(projectPath, diagnostics);
-    for (const file of bpmnFiles) {
-      const filePath = this.fileSystem.joinPath(projectPath, file);
-      const content = await this.fileSystem.readFile(filePath);
-      if (content === null || content.byteLength === 0) {
-        diagnostics.push({
-          file,
-          message: "BPMN file could not be read or is empty.",
-          instruction: "Ensure the file exists and contains BPMN XML."
-        });
-        continue;
-      }
-      const xml = decodeFileContent(content);
-      this.validateBpmnFile(file, xml, bindings, diagnostics);
-      await this.runFileValidators({ projectPath, file, xml, fileSystem: this.fileSystem }, diagnostics);
-    }
-    await this.runProjectValidators({ projectPath, bpmnFiles, fileSystem: this.fileSystem }, diagnostics);
-    const errors = diagnostics.filter(isErrorDiagnostic);
-    if (errors.length > 0) {
-      return this.createFailure(errors);
-    }
-    const warnings = diagnostics.filter(isWarningDiagnostic);
-    if (warnings.length > 0) {
-      return {
-        isValid: true,
-        diagnostics,
-        message: this.createWarningMessage(warnings)
-      };
-    }
-    return {
-      isValid: true,
-      diagnostics: []
-    };
-  }
-  validateBpmnFile(file, xml, bindings, diagnostics) {
-    const parseResult = parseXml(xml);
-    diagnostics.push(...parseResult.diagnostics.map((message) => ({
-      file,
-      message,
-      instruction: "Fix the BPMN XML so tags are well-formed."
-    })));
-    if (!parseResult.root) {
-      diagnostics.push({
-        file,
-        message: "BPMN XML does not contain a root element.",
-        instruction: "Export a valid BPMN definitions document."
-      });
-      return;
-    }
-    const definitions = findFirst(parseResult.root, (node) => hasLocalName(node, "definitions"));
-    if (!definitions) {
-      diagnostics.push({
-        file,
-        message: "BPMN definitions element is missing.",
-        instruction: "Use a BPMN document rooted at bpmn:definitions."
-      });
-      return;
-    }
-    const processes = findChildren(definitions, (node) => hasLocalName(node, "process"));
-    if (processes.length === 0) {
-      diagnostics.push({
-        file,
-        message: "BPMN process element is missing.",
-        instruction: "Add a bpmn:process element to the BPMN file."
-      });
-    }
-    for (const process of processes) {
-      if (findDescendants(process, (node) => hasLocalName(node, "startEvent")).length === 0) {
-        diagnostics.push({
-          file,
-          element: describeElement(process),
-          message: "BPMN process has no start event.",
-          instruction: "Add a bpmn:StartEvent to each process."
-        });
-      }
-      this.validateRootEntryPointIds(file, process, diagnostics);
-    }
-    const availableBindings = new Map(bindings);
-    collectInlineBindings(definitions, availableBindings);
-    this.validateUiPathTags(file, definitions, availableBindings, diagnostics);
-    this.validateUnassignedVariables(file, definitions, diagnostics);
-    this.validateCallActivityReferences(file, definitions, diagnostics);
-  }
-  validateUnassignedVariables(file, definitions, diagnostics) {
-    for (const process of findChildren(definitions, (node) => hasLocalName(node, "process"))) {
-      this.reportUnassignedVariables(file, process, diagnostics);
-    }
-  }
-  reportUnassignedVariables(file, process, diagnostics) {
-    const startEventIds = new Set(findChildren(process, (node) => hasLocalName(node, "startEvent")).filter(isManualStartEvent).map((node) => node.attributes.id).filter((id) => Boolean(id)));
-    const declaredById = new Map;
-    for (const block of findDescendants(process, (node) => hasLocalName(node, "variables"))) {
-      for (const decl of block.children) {
-        const declKind = getLocalName(decl.name);
-        if (declKind !== "input" && declKind !== "inputoutput" && declKind !== "output") {
-          continue;
-        }
-        const id = decl.attributes.id;
-        if (!id) {
-          continue;
-        }
-        const elementId = decl.attributes.elementId?.trim() ?? "";
-        const callerCanSupply = declKind === "input" && !!decl.attributes.name?.trim() && startEventIds.has(elementId);
-        declaredById.set(id, {
-          hasValueSource: !!decl.attributes.default?.trim() || callerCanSupply,
-          declKind,
-          element: describeElement(decl)
-        });
-      }
-    }
-    if (declaredById.size === 0) {
-      return;
-    }
-    const assigned = new Set;
-    for (const output of findDescendants(process, (node) => hasLocalName(node, "output"))) {
-      const target = output.attributes.var;
-      const isDeclaration = output.parent !== undefined && hasLocalName(output.parent, "variables");
-      if (target && !isDeclaration) {
-        assigned.add(target);
-      }
-    }
-    for (const id of collectVariableReads(process)) {
-      const declared = declaredById.get(id);
-      if (!declared || declared.hasValueSource || assigned.has(id)) {
-        continue;
-      }
-      diagnostics.push({
-        file,
-        element: declared.element,
-        message: `Variable "vars.${id}" is read but never assigned; it will be empty at run time.`,
-        instruction: declared.declKind === "input" ? "Give the variable a default, assign it through a uipath:output mapping, or bind it to an entry-point start event by giving it both a name and an elementId." : "Give the variable a default, or assign it through a uipath:output mapping before it is read.",
-        severity: "warning"
-      });
-    }
-  }
-  validateCallActivityReferences(file, definitions, diagnostics) {
-    for (const callActivity of findDescendants(definitions, (node) => hasLocalName(node, "callActivity"))) {
-      const hasUiPathPayload = findDescendants(callActivity, (node) => CALL_ACTIVITY_PAYLOAD_TAGS.has(node.name)).length > 0;
-      const calledElement = callActivity.attributes.calledElement?.trim() ?? "";
-      if (!hasUiPathPayload) {
-        diagnostics.push({
-          file,
-          element: describeElement(callActivity),
-          message: "Call activity has no uipath:activity payload, so it invokes nothing at run time.",
-          instruction: `Add a payload naming one of the call-activity types (${CALL_ACTIVITY_TYPES.join(", ")}), with a process resource binding.`
-        });
-        continue;
-      }
-      if (calledElement) {
-        diagnostics.push({
-          file,
-          element: describeElement(callActivity),
-          message: `Call activity attribute calledElement="${calledElement}" is ignored; the invoked process comes from the uipath:activity payload and its process binding.`,
-          instruction: "Remove calledElement, or ensure the uipath:activity payload names the process you intend to invoke.",
-          severity: "warning"
-        });
-      }
-    }
-  }
-  validateRootEntryPointIds(file, process, diagnostics) {
-    const rootStartEvents = findChildren(process, (node) => hasLocalName(node, "startEvent"));
-    for (const startEvent of rootStartEvents) {
-      const entryPointIds = findDescendants(startEvent, (node) => node.name === "uipath:entryPointId");
-      for (const entryPointId of entryPointIds) {
-        const value = entryPointId.attributes.value ?? "";
-        if (isGuid(value)) {
-          continue;
-        }
-        diagnostics.push({
-          file,
-          element: describeElement(startEvent),
-          message: `Root start event uipath:entryPointId value "${value}" must be a GUID.`,
-          instruction: "Set uipath:entryPointId value to a GUID and use the same value for the matching entry-points.json uniqueId."
-        });
-      }
-    }
-  }
-  validateUiPathTags(file, root, bindings, diagnostics) {
-    const uipathNodes = findDescendants(root, (node) => node.name.startsWith("uipath:"));
-    for (const node of uipathNodes) {
-      if (!KNOWN_UIPATH_TAGS.has(node.name)) {
-        diagnostics.push({
-          file,
-          element: describeElement(node),
-          message: `Unsupported UiPath extension tag "${node.name}".`,
-          instruction: `Use a supported UiPath extension tag: ${SUPPORTED_UIPATH_EXTENSION_TAGS.join(", ")}.`,
-          severity: "warning"
-        });
-      }
-    }
-    for (const loopCharacteristics of uipathNodes.filter((node) => node.name === "uipath:loopCharacteristics")) {
-      const extensionElements = loopCharacteristics.parent;
-      const owner = extensionElements && hasLocalName(extensionElements, "extensionElements") ? extensionElements.parent : undefined;
-      if (owner && hasLocalName(owner, "multiInstanceLoopCharacteristics")) {
-        continue;
-      }
-      diagnostics.push({
-        file,
-        element: describeElement(loopCharacteristics),
-        message: "uipath:loopCharacteristics must be nested under bpmn:multiInstanceLoopCharacteristics.",
-        instruction: "Move it into bpmn:multiInstanceLoopCharacteristics/bpmn:extensionElements and remove any copy from the activity's extensionElements."
-      });
-    }
-    const payloads = uipathNodes.filter((node) => ["uipath:activity", "uipath:event", "uipath:mapping"].includes(node.name));
-    for (const payload of payloads) {
-      this.validatePayload(file, payload, bindings, getOwningProcessActivityConfigurationVersion(payload), diagnostics);
-    }
-  }
-  validatePayload(file, payload, bindings, workflowActivityConfigurationVersion, diagnostics) {
-    const owner = findBpmnOwner(payload);
-    if (!owner) {
-      diagnostics.push({
-        file,
-        element: describeElement(payload),
-        message: `${payload.name} must be inside bpmn:extensionElements on a BPMN element.`,
-        instruction: "Move the UiPath extension payload under the owning BPMN element's extensionElements."
-      });
-      return;
-    }
-    const typeNodes = childElements(payload, "uipath:type");
-    if (payload.attributes.type && typeNodes.length > 0) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: `${payload.name} must not mix a type attribute with legacy uipath:type child elements.`,
-        instruction: "Use either the payload type attribute or one uipath:type child, not both."
-      });
-      return;
-    }
-    if (!payload.attributes.type && typeNodes.length === 0 && !isImplicitVariablesMapping(payload, owner)) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: `${payload.name} must contain exactly one uipath:type child or a type attribute.`,
-        instruction: "Add one uipath:type element with a supported value attribute, or set the payload type attribute."
-      });
-      return;
-    }
-    if (!payload.attributes.type && typeNodes.length > 1) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: `${payload.name} must contain exactly one uipath:type child or a type attribute.`,
-        instruction: "Add one uipath:type element with a supported value attribute, or set the payload type attribute."
-      });
-      return;
-    }
-    const typeNode = typeNodes[0];
-    const extensionType = payload.attributes.type ?? typeNode?.attributes.value ?? inferImplicitExtensionType(payload, owner);
-    if (!extensionType) {
-      diagnostics.push({
-        file,
-        element: describeElement(typeNode ?? payload),
-        message: "UiPath extension type is missing.",
-        instruction: "Set uipath:activity type or uipath:type value to a supported UiPath BPMN extension type."
-      });
-      return;
-    }
-    const contract = BPMN_SPEC.extensionTypes[extensionType];
-    if (!contract) {
-      const severity = this.options.unsupportedExtensionTypeSeverity ?? "warning";
-      diagnostics.push({
-        file,
-        element: describeElement(typeNode ?? payload),
-        message: `Unsupported UiPath extension type "${extensionType}".`,
-        instruction: severity === "error" ? `"${extensionType}" is not in this CLI's BPMN contract, so Orchestrator will reject the package at deploy (Error 1654). Use a supported extension type, remove the node, or upgrade the CLI to a version whose contract includes it.` : "Use an extension type present in the UiPath BPMN contract, or update the contract before packaging this project.",
-        severity
-      });
-      return;
-    }
-    this.validateContractPlacement(file, payload, owner, contract, diagnostics);
-    const isActivityExecutionV1 = extensionType === "Intsvc.ActivityExecution" && isIntsvcActivityExecutionV1(getContextInputs(payload).find((input) => input.attributes.name === ACTIVITY_CONFIGURATION_VERSION)?.attributes.value, workflowActivityConfigurationVersion);
-    this.validateContext(file, payload, owner, contract, isActivityExecutionV1, diagnostics);
-    if (isActivityExecutionV1) {
-      this.validateActivityExecutionV1Bindings(file, payload, owner, bindings, diagnostics);
-    }
-    if (contract.extensionType === "Orchestrator.StartAgentJob") {
-      this.validateStartAgentJobBindings(file, payload, owner, bindings, diagnostics);
-    }
-    if (contract.extensionType === "Intsvc.EventTrigger" || contract.extensionType === "Intsvc.WaitForEvent") {
-      this.validateTriggerConnectionBinding(file, payload, owner, bindings, contract.extensionType === "Intsvc.WaitForEvent" ? "wait" : "trigger", diagnostics);
-    }
-    this.validateInputs(file, payload, owner, contract, diagnostics);
-    this.validateOutput(file, payload, owner, contract, diagnostics);
-    this.validateBindingReferences(file, payload, bindings, diagnostics);
-  }
-  validateContractPlacement(file, payload, owner, contract, diagnostics) {
-    if (payload.name !== contract.extensionTag) {
-      diagnostics.push({
-        file,
-        element: describeElement(payload),
-        message: `${contract.extensionType} must use ${contract.extensionTag}, not ${payload.name}.`,
-        instruction: `Change the extension tag to ${contract.extensionTag}.`
-      });
-    }
-    const allowedOwners = getAllowedOwnerTypes(contract);
-    if (!allowedOwners.some((allowedOwner) => getLocalName(allowedOwner) === getLocalName(owner.name) && resolveNamespace(owner) === BPMN_MODEL_NAMESPACE)) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: `${contract.extensionType} cannot be attached to ${owner.name}.`,
-        instruction: `Attach it to one of: ${allowedOwners.join(", ")}.`
-      });
-    }
-  }
-  validateContext(file, payload, owner, contract, isActivityExecutionV1, diagnostics) {
-    const contextInputs = getContextInputs(payload);
-    const actual = new Map(contextInputs.map((input) => [input.attributes.name, input]));
-    const fields = contract.contextFields ?? [];
-    const allowDynamicPayloadShape = usesCanvasOwnedDynamicPayload(contract);
-    const allowed = new Set(fields.map((field) => field.name));
-    const requireDeclaredFields = !allowDynamicPayloadShape || isActivityExecutionV1;
-    const contractLabel = isActivityExecutionV1 ? "Integration Service activity" : contract.extensionType;
-    for (const field of fields) {
-      const input = actual.get(field.name);
-      if (requireDeclaredFields && field.required && !hasAttributeValue(input, "value")) {
-        diagnostics.push({
-          file,
-          element: describeElement(owner),
-          message: `${contractLabel} is missing required context input "${field.name}".`,
-          instruction: `Add <uipath:input name="${field.name}" value="..." /> inside uipath:context.`
-        });
-      }
-      if (input) {
-        if (isActivityExecutionV1 && field.type === "string" && input.attributes.type !== "string") {
-          diagnostics.push({
-            file,
-            element: describeElement(input),
-            message: `${contractLabel} context input "${field.name}" must use type="string".`,
-            instruction: 'Add type="string" to this context input.'
-          });
-        }
-        validateTypedValue(file, input, field.type, input.attributes.value, `context input "${field.name}"`, diagnostics);
-      }
-    }
-    for (const input of contextInputs) {
-      const name = input.attributes.name;
-      if (!name) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: "uipath:context input is missing a name attribute.",
-          instruction: "Set name to a context field from the UiPath BPMN contract."
-        });
-      } else if (!allowDynamicPayloadShape && allowed.size > 0 && !allowed.has(name)) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: `${contract.extensionType} does not support context input "${name}".`,
-          instruction: `Use one of: ${[...allowed].join(", ")}.`
-        });
-      }
-    }
-  }
-  validateActivityExecutionV1Bindings(file, payload, owner, bindings, diagnostics) {
-    const resourceKeys = this.validateConnectionBindings(file, payload, owner, bindings, diagnostics, "activity", [
-      {
-        contextName: "connection",
-        propertyAttribute: "ConnectionId"
-      },
-      { contextName: "folderKey", propertyAttribute: "folderKey" }
-    ]);
-    const connectionResourceKey = resourceKeys.get("connection");
-    const folderResourceKey = resourceKeys.get("folderKey");
-    if (connectionResourceKey && folderResourceKey && connectionResourceKey !== folderResourceKey) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: "Integration Service activity connection and folder bindings refer to different connection resources.",
-        instruction: "Set the same resourceKey on both root bindings."
-      });
-    }
-  }
-  validateTriggerConnectionBinding(file, payload, owner, bindings, nodeLabel, diagnostics) {
-    this.validateConnectionBindings(file, payload, owner, bindings, diagnostics, nodeLabel, [
-      {
-        contextName: "connection",
-        propertyAttribute: "ConnectionId"
-      },
-      {
-        contextName: "connectionId",
-        propertyAttribute: "ConnectionId"
-      }
-    ]);
-  }
-  validateConnectionBindings(file, payload, owner, bindings, diagnostics, nodeLabel, bindingFields) {
-    const inputByName = new Map(getConnectorInputs(payload).map((input) => [
-      input.attributes.name,
-      input
-    ]));
-    const resourceKeys = new Map;
-    for (const field of bindingFields) {
-      const contextInput = inputByName.get(field.contextName);
-      if (!contextInput) {
-        continue;
-      }
-      const value = contextInput.attributes.value?.trim() ?? "";
-      if (!value) {
-        continue;
-      }
-      if (!value.startsWith("=bindings.")) {
-        diagnostics.push({
-          file,
-          element: describeElement(owner),
-          message: `Integration Service ${nodeLabel} context input "${field.contextName}" must reference a root binding.`,
-          instruction: `Set ${field.contextName} to =bindings.<bindingId> and declare that binding with resource="Connection" and propertyAttribute="${field.propertyAttribute}".`
-        });
-        continue;
-      }
-      const bindingId = value.slice("=bindings.".length);
-      const binding = bindings.get(bindingId);
-      if (!binding) {
-        continue;
-      }
-      const hasInvalidBindingShape = binding.resource !== "Connection" || binding.propertyAttribute !== field.propertyAttribute;
-      if (hasInvalidBindingShape) {
-        diagnostics.push({
-          file,
-          element: describeElement(owner),
-          message: `Integration Service ${nodeLabel} ${field.contextName} binding "${bindingId}" must use resource="Connection" and propertyAttribute="${field.propertyAttribute}".`,
-          instruction: `Set resource="Connection" and propertyAttribute="${field.propertyAttribute}" on that binding.`
-        });
-      }
-      const resourceKey = binding.resourceKey?.trim();
-      if (!resourceKey) {
-        diagnostics.push({
-          file,
-          element: describeElement(owner),
-          message: `Integration Service ${nodeLabel} ${field.contextName} binding "${bindingId}" is missing resourceKey.`,
-          instruction: "Set resourceKey on that root binding."
-        });
-      } else if (!hasInvalidBindingShape) {
-        resourceKeys.set(field.contextName, resourceKey);
-      }
-    }
-    return resourceKeys;
-  }
-  validateInputs(file, payload, owner, contract, diagnostics) {
-    const directInputs = childElements(payload, "uipath:input");
-    const actual = new Map(directInputs.map((input) => [input.attributes.name, input]));
-    if (usesCanvasOwnedDynamicPayload(contract)) {
-      this.validateDynamicDirectInputs(file, directInputs, diagnostics);
-      return;
-    }
-    if (contract.inputPattern === "none") {
-      if (contract.extensionType === "BPMN.Variables") {
-        this.validateVariableMappingInputs(file, directInputs, diagnostics);
-        return;
-      }
-      for (const input of directInputs) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: `${contract.extensionType} does not support direct input payload "${input.attributes.name ?? ""}".`,
-          instruction: "Remove the direct uipath:input payload."
-        });
-      }
-      return;
-    }
-    if (["mergedBody", "splitInputsItemData", "scriptArgs"].includes(contract.inputPattern)) {
-      const expectedName = getExpectedInputName(contract);
-      const input = actual.get(expectedName);
-      if (!input) {
-        diagnostics.push({
-          file,
-          element: describeElement(owner),
-          message: `${contract.extensionType} is missing required input payload "${expectedName}".`,
-          instruction: `Add <uipath:input name="${expectedName}" type="json" target="${getExpectedInputTarget(contract)}">...</uipath:input>.`
-        });
-        return;
-      }
-      validateInputShape(file, input, expectedName, contract, diagnostics);
-      for (const extraInput of directInputs) {
-        if (extraInput.attributes.name !== expectedName) {
-          diagnostics.push({
-            file,
-            element: describeElement(extraInput),
-            message: `${contract.extensionType} does not support input payload "${extraInput.attributes.name ?? ""}".`,
-            instruction: `Use only the "${expectedName}" input payload for ${contract.inputPattern}.`
-          });
-        }
-      }
-      return;
-    }
-    const fields = contract.inputFields ?? [];
-    const allowed = new Set(fields.map((field) => field.name));
-    for (const field of fields) {
-      const input = actual.get(field.name);
-      if (field.required && !input) {
-        diagnostics.push({
-          file,
-          element: describeElement(owner),
-          message: `${contract.extensionType} is missing required input payload "${field.name}".`,
-          instruction: `Add a direct uipath:input named "${field.name}".`
-        });
-      }
-      if (input) {
-        validateTypedValue(file, input, field.type, input.text || input.attributes.value, `input payload "${field.name}"`, diagnostics);
-      }
-    }
-    for (const input of directInputs) {
-      const name = input.attributes.name;
-      if (!name) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: "uipath:input is missing a name attribute.",
-          instruction: "Set name to an input field from the UiPath BPMN contract."
-        });
-      } else if (allowed.size > 0 && !allowed.has(name)) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: `${contract.extensionType} does not support input payload "${name}".`,
-          instruction: `Use one of: ${[...allowed].join(", ")}.`
-        });
-      }
-    }
-  }
-  validateDynamicDirectInputs(file, directInputs, diagnostics) {
-    for (const input of directInputs) {
-      if (!hasAttributeValue(input, "name")) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: "uipath:input is missing a name attribute.",
-          instruction: "Set name to the Integration Service payload field."
-        });
-      }
-      if (input.attributes.type === "json") {
-        validateJsonPayload(file, input, `input payload "${input.attributes.name ?? ""}"`, diagnostics);
-      }
-    }
-  }
-  validateVariableMappingInputs(file, directInputs, diagnostics) {
-    for (const input of directInputs) {
-      if (!hasAttributeValue(input, "name")) {
-        diagnostics.push({
-          file,
-          element: describeElement(input),
-          message: "BPMN.Variables mapping input is missing its name attribute.",
-          instruction: "Set name to the process variable being mapped."
-        });
-      }
-      if (input.attributes.type === "json") {
-        validateJsonPayload(file, input, `mapping input "${input.attributes.name ?? ""}"`, diagnostics);
-      }
-    }
-  }
-  validateOutput(file, payload, owner, contract, diagnostics) {
-    if (usesCanvasOwnedDynamicPayload(contract)) {
-      for (const output of childElements(payload, "uipath:output")) {
-        if (!hasAttributeValue(output, "var")) {
-          diagnostics.push({
-            file,
-            element: describeElement(output),
-            message: `${contract.extensionType} output is missing its var attribute.`,
-            instruction: "Set var to the variable that receives the output."
-          });
-        }
-      }
-      return;
-    }
-    if (!contract.outputName && !contract.outputType) {
-      return;
-    }
-    const outputs = childElements(payload, "uipath:output");
-    if (outputs.length === 0) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: `${contract.extensionType} is missing an output payload.`,
-        instruction: "Add a uipath:output matching the UiPath BPMN contract."
-      });
-      return;
-    }
-    for (const output of outputs) {
-      if (contract.outputName && output.attributes.name !== contract.outputName) {
-        diagnostics.push({
-          file,
-          element: describeElement(output),
-          message: `${contract.extensionType} output name must be "${contract.outputName}".`,
-          instruction: `Set the uipath:output name attribute to "${contract.outputName}".`
-        });
-      }
-      if (contract.outputType && output.attributes.type !== contract.outputType) {
-        diagnostics.push({
-          file,
-          element: describeElement(output),
-          message: `${contract.extensionType} output type must be "${contract.outputType}".`,
-          instruction: `Set the uipath:output type attribute to "${contract.outputType}".`
-        });
-      }
-      if (contract.outputSource && output.attributes.source !== contract.outputSource) {
-        diagnostics.push({
-          file,
-          element: describeElement(output),
-          message: `${contract.extensionType} output source must be "${contract.outputSource}".`,
-          instruction: `Set the uipath:output source attribute to "${contract.outputSource}".`
-        });
-      }
-      if (!hasAttributeValue(output, "var")) {
-        diagnostics.push({
-          file,
-          element: describeElement(output),
-          message: `${contract.extensionType} output is missing its var attribute.`,
-          instruction: "Set var to the variable that receives the output."
-        });
-      }
-    }
-  }
-  validateBindingReferences(file, payload, bindings, diagnostics) {
-    const bindingReferences = findDescendants(payload, (node) => {
-      const value = node.attributes.value;
-      return value?.startsWith("=bindings.") === true;
-    });
-    for (const node of bindingReferences) {
-      const bindingId = node.attributes.value.slice("=bindings.".length);
-      if (!bindingId) {
-        diagnostics.push({
-          file,
-          element: describeElement(node),
-          message: "Binding reference is missing a binding id.",
-          instruction: 'Use a binding expression such as value="=bindings.<bindingId>".'
-        });
-        continue;
-      }
-      if (!bindings.has(bindingId)) {
-        diagnostics.push({
-          file,
-          element: describeElement(node),
-          message: `Binding reference "${bindingId}" was not found in project bindings.`,
-          instruction: "Add the binding to BPMN uipath:bindings or bindings_v2.json, or update the BPMN binding reference."
-        });
-      }
-    }
-  }
-  validateStartAgentJobBindings(file, payload, owner, bindings, diagnostics) {
-    const contexts = childElements(payload, "uipath:context");
-    const contextInputs = contexts.flatMap((context) => childElements(context, "uipath:input"));
-    const inputs = new Map(contextInputs.map((input) => [input.attributes.name, input]));
-    if (inputs.has("releaseKey") || inputs.has("folderId")) {
-      diagnostics.push({
-        file,
-        element: describeElement(owner),
-        message: "Orchestrator.StartAgentJob must use binding-backed name and folderPath context inputs, not releaseKey or folderId.",
-        instruction: 'Replace releaseKey/folderId with value="=bindings.<agentNameBindingId>" and value="=bindings.<agentFolderPathBindingId>".'
-      });
-    }
-    for (const expected of ["name", "folderPath"]) {
-      const input = inputs.get(expected);
-      const value = input?.attributes.value;
-      if (!value?.startsWith("=bindings.")) {
-        diagnostics.push({
-          file,
-          element: describeElement(input ?? owner),
-          message: `Orchestrator.StartAgentJob context input "${expected}" must reference project bindings.`,
-          instruction: `Set "${expected}" to a binding expression such as value="=bindings.<${expected}BindingId>".`
-        });
-        continue;
-      }
-      const bindingId = value.slice("=bindings.".length);
-      const binding = bindings.get(bindingId);
-      if (!binding) {
-        diagnostics.push({
-          file,
-          element: describeElement(input ?? owner),
-          message: `Orchestrator.StartAgentJob binding reference "${bindingId}" was not found in project bindings.`,
-          instruction: "Add agent name and folderPath bindings to BPMN uipath:bindings or bindings_v2.json before packaging this BPMN project."
-        });
-        continue;
-      }
-      if (binding.resource !== "process" || binding.resourceSubType !== "Agent" || binding.propertyAttribute !== expected) {
-        diagnostics.push({
-          file,
-          element: describeElement(input ?? owner),
-          message: `Orchestrator.StartAgentJob binding "${bindingId}" must target Agent ${expected}.`,
-          instruction: `Use a process binding with resourceSubType "Agent" and propertyAttribute "${expected}".`
-        });
-      }
-    }
-  }
-  async loadBindings(projectPath, diagnostics) {
-    const bindingsPath = this.fileSystem.joinPath(projectPath, "bindings_v2.json");
-    if (!await this.fileSystem.exists(bindingsPath)) {
-      return new Map;
-    }
-    const content = await this.fileSystem.readFile(bindingsPath);
-    if (content === null || content.byteLength === 0) {
-      diagnostics.push({
-        file: "bindings_v2.json",
-        message: "bindings_v2.json could not be read or is empty.",
-        instruction: "Write a valid bindings_v2.json file or remove malformed binding references from BPMN."
-      });
-      return new Map;
-    }
-    try {
-      const parsed = JSON.parse(decodeFileContent(content));
-      return collectBindings(parsed);
-    } catch (error) {
-      diagnostics.push({
-        file: "bindings_v2.json",
-        message: `bindings_v2.json is not valid JSON: ${String(error)}`,
-        instruction: "Fix bindings_v2.json so it contains valid JSON."
-      });
-      return new Map;
-    }
-  }
-  async runFileValidators(context, diagnostics) {
-    for (const validator of this.options.fileValidators ?? []) {
-      diagnostics.push(...await validator.validate(context));
-    }
-  }
-  async runProjectValidators(context, diagnostics) {
-    for (const validator of this.options.projectValidators ?? []) {
-      diagnostics.push(...await validator.validate(context));
-    }
-  }
-  createFailure(diagnostics) {
-    const message = diagnostics.map(formatDiagnostic).slice(0, 25).join(`
-`);
-    const suffix = diagnostics.length > 25 ? `
-...and ${diagnostics.length - 25} more BPMN validation error(s).` : "";
-    return {
-      isValid: false,
-      errorCode: SEMANTIC_VALIDATION_ERROR,
-      diagnostics,
-      message: `${message}${suffix}`
-    };
-  }
-  createWarningMessage(diagnostics) {
-    const message = diagnostics.map(formatDiagnostic).slice(0, 25).join(`
-`);
-    const suffix = diagnostics.length > 25 ? `
-...and ${diagnostics.length - 25} more BPMN validation warning(s).` : "";
-    return `${message}${suffix}`;
-  }
-}
-function decodeFileContent(content) {
-  return new TextDecoder().decode(content);
-}
-function parseXml(xml) {
-  const root = {
-    name: "#document",
-    attributes: {},
-    children: [],
-    text: ""
-  };
-  const stack = [root];
-  const diagnostics = [];
-  const tokenPattern = /<!\[CDATA\[([\s\S]*?)\]\]>|<!--[\s\S]*?-->|<\?[\s\S]*?\?>|<![^>]*>|<\/?[^>]+>/g;
-  let lastIndex = 0;
-  let match;
-  match = tokenPattern.exec(xml);
-  while (match !== null) {
-    const text = xml.slice(lastIndex, match.index);
-    if (text.trim()) {
-      stack[stack.length - 1].text += decodeXmlEntities(text.trim());
-    }
-    const token = match[0];
-    if (token.startsWith("<![CDATA[")) {
-      stack[stack.length - 1].text += match[1] ?? "";
-    } else if (token.startsWith("</")) {
-      const closeName = token.slice(2, -1).trim();
-      if (stack.length <= 1) {
-        diagnostics.push(`Unexpected closing tag "${closeName}".`);
-      } else if (stack[stack.length - 1].name !== closeName) {
-        let matchingOpenIndex = -1;
-        for (let i = stack.length - 1;i > 0; i -= 1) {
-          if (stack[i].name === closeName) {
-            matchingOpenIndex = i;
-            break;
-          }
-        }
-        if (matchingOpenIndex <= 0) {
-          diagnostics.push(`Unexpected closing tag "${closeName}".`);
-        } else {
-          diagnostics.push(`Mismatched closing tag "${closeName}".`);
-          while (stack.length > matchingOpenIndex) {
-            stack.pop();
-          }
-        }
-      } else {
-        stack.pop();
-      }
-    } else if (!token.startsWith("<!--") && !token.startsWith("<?") && !token.startsWith("<!")) {
-      const selfClosing = token.endsWith("/>");
-      const node = parseStartTag(token, selfClosing);
-      node.parent = stack[stack.length - 1];
-      stack[stack.length - 1].children.push(node);
-      if (!selfClosing) {
-        stack.push(node);
-      }
-    }
-    lastIndex = tokenPattern.lastIndex;
-    match = tokenPattern.exec(xml);
-  }
-  const trailing = xml.slice(lastIndex).trim();
-  if (trailing) {
-    stack[stack.length - 1].text += decodeXmlEntities(trailing);
-  }
-  if (stack.length > 1) {
-    diagnostics.push(`Unclosed tag "${stack[stack.length - 1].name}" in BPMN XML.`);
-  }
-  return {
-    root: root.children[0],
-    diagnostics
-  };
-}
-function parseStartTag(token, selfClosing) {
-  const body = token.slice(1, selfClosing ? -2 : -1).trim();
-  const nameMatch = /^([^\s/>]+)/.exec(body);
-  const name = nameMatch?.[1] ?? "";
-  const attributes = {};
-  const attributePattern = /([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
-  let match;
-  match = attributePattern.exec(body);
-  while (match !== null) {
-    attributes[match[1]] = decodeXmlEntities(match[2] ?? match[3] ?? "");
-    match = attributePattern.exec(body);
-  }
-  return {
-    name,
-    attributes,
-    children: [],
-    text: ""
-  };
-}
-function childElements(node, name) {
-  return node.children.filter((child) => child.name === name);
-}
-function findChildren(node, predicate) {
-  return node.children.filter(predicate);
-}
-function findDescendants(node, predicate) {
-  const matches = [];
-  for (const child of node.children) {
-    if (predicate(child)) {
-      matches.push(child);
-    }
-    matches.push(...findDescendants(child, predicate));
-  }
-  return matches;
-}
-function findFirst(node, predicate) {
-  if (predicate(node)) {
-    return node;
-  }
-  for (const child of node.children) {
-    const match = findFirst(child, predicate);
-    if (match) {
-      return match;
-    }
-  }
-  return;
-}
-function isManualStartEvent(startEvent) {
-  const hasEventDefinition = startEvent.children.some((child) => getLocalName(child.name).endsWith("eventdefinition"));
-  const hasUiPathEvent = findDescendants(startEvent, (node) => hasLocalName(node, "event")).length > 0;
-  return !hasEventDefinition && !hasUiPathEvent;
-}
-var VARIABLE_READ = /vars(?:\.([A-Za-z_$][\w$]*)|\[\s*["']([^"']+)["']\s*\])/g;
-var FREE_TEXT_ELEMENTS = new Set(["documentation", "text"]);
-function collectVariableReads(node, into = new Set) {
-  for (const value of Object.values(node.attributes)) {
-    if (!value.trimStart().startsWith("=")) {
-      continue;
-    }
-    for (const match of value.matchAll(VARIABLE_READ)) {
-      const id = match[1] ?? match[2];
-      if (id) {
-        into.add(id);
-      }
-    }
-  }
-  if (node.text && !FREE_TEXT_ELEMENTS.has(getLocalName(node.name))) {
-    for (const match of node.text.matchAll(VARIABLE_READ)) {
-      const id = match[1] ?? match[2];
-      if (id) {
-        into.add(id);
-      }
-    }
-  }
-  for (const child of node.children) {
-    collectVariableReads(child, into);
-  }
-  return into;
-}
-function hasLocalName(node, localName) {
-  return getLocalName(node.name) === localName.toLowerCase();
-}
-function getLocalName(name) {
-  return name.slice(name.lastIndexOf(":") + 1).toLowerCase();
-}
-function resolveNamespace(node) {
-  const separator = node.name.indexOf(":");
-  const prefix = separator === -1 ? "" : node.name.slice(0, separator);
-  const declaration = prefix ? `xmlns:${prefix}` : "xmlns";
-  let current = node;
-  while (current) {
-    if (Object.hasOwn(current.attributes, declaration)) {
-      return current.attributes[declaration];
-    }
-    current = current.parent;
-  }
-  return;
-}
-function findBpmnOwner(payload) {
-  const extensionElements = payload.parent;
-  if (extensionElements && hasLocalName(extensionElements, "extensionElements")) {
-    return extensionElements.parent;
-  }
-  if (payload.parent?.name.startsWith("bpmn:")) {
-    return payload.parent;
-  }
-  return;
-}
-function getContextInputs(payload) {
-  return childElements(payload, "uipath:context").flatMap((context) => childElements(context, "uipath:input"));
-}
-function getConnectorInputs(payload) {
-  return [
-    ...getContextInputs(payload),
-    ...childElements(payload, "uipath:input")
-  ];
-}
-function isIntsvcActivityExecutionV1(nodeVersion, workflowVersion) {
-  const version = nodeVersion ?? workflowVersion;
-  return version === undefined || version === ACTIVITY_CONFIGURATION_V1;
-}
-function getOwningProcessActivityConfigurationVersion(payload) {
-  let current = payload.parent;
-  while (current && !hasLocalName(current, "process")) {
-    current = current.parent;
-  }
-  if (!current) {
-    return;
-  }
-  const extensionElements = findChildren(current, (node) => hasLocalName(node, "extensionElements"));
-  return extensionElements.flatMap((node) => childElements(node, "uipath:intsvcActivityConfig")).at(0)?.attributes.version;
-}
-function describeElement(node) {
-  const id = node.attributes.id ? `#${node.attributes.id}` : "";
-  const name = node.attributes.name ? ` "${node.attributes.name}"` : "";
-  return `${node.name}${id}${name}`;
-}
-function hasAttributeValue(node, attribute) {
-  return Boolean(node?.attributes[attribute]?.trim());
-}
-function usesCanvasOwnedDynamicPayload(contract) {
-  return contract.isDynamic === true || contract.extensionType.startsWith("Intsvc.") && contract.requiresDiscovery;
-}
-function getAllowedOwnerTypes(contract) {
-  if (contract.extensionType === "BPMN.Variables") {
-    return [
-      "bpmn:StartEvent",
-      "bpmn:EndEvent",
-      "bpmn:Task",
-      "bpmn:ScriptTask",
-      "bpmn:SubProcess"
-    ];
-  }
-  const placementTypes = Object.values(contract.placements).map((placement) => placement.type);
-  return placementTypes.length > 0 ? placementTypes : [contract.bpmnElement];
-}
-function inferImplicitExtensionType(payload, owner) {
-  return isImplicitVariablesMapping(payload, owner) ? "BPMN.Variables" : undefined;
-}
-function isImplicitVariablesMapping(payload, owner) {
-  return payload.name === "uipath:mapping" && !payload.attributes.type && childElements(payload, "uipath:type").length === 0 && hasLocalName(owner, "task");
-}
-function getExpectedInputName(contract) {
-  if (contract.inputPattern === "splitInputsItemData") {
-    return "ItemData";
-  }
-  if (contract.inputPattern === "scriptArgs") {
-    return "args";
-  }
-  return contract.inputName ?? "body";
-}
-function getExpectedInputTarget(contract) {
-  if (contract.inputPattern === "scriptArgs") {
-    return "bodyField";
-  }
-  return contract.inputTarget ?? "body";
-}
-function validateInputShape(file, input, expectedName, contract, diagnostics) {
-  if (input.attributes.type !== "json") {
-    diagnostics.push({
-      file,
-      element: describeElement(input),
-      message: `Input payload "${expectedName}" must declare type="json".`,
-      instruction: 'Set the uipath:input type attribute to "json".'
-    });
-  }
-  const expectedTarget = getExpectedInputTarget(contract);
-  if (input.attributes.target !== expectedTarget) {
-    diagnostics.push({
-      file,
-      element: describeElement(input),
-      message: `Input payload "${expectedName}" must target "${expectedTarget}".`,
-      instruction: `Set the uipath:input target attribute to "${expectedTarget}".`
-    });
-  }
-  validateJsonPayload(file, input, `input payload "${expectedName}"`, diagnostics);
-}
-function validateTypedValue(file, node, type, value, label, diagnostics) {
-  if (value === undefined || value === "") {
-    return;
-  }
-  if (value.startsWith("=")) {
-    return;
-  }
-  if (type === "number" && !Number.isFinite(Number(value))) {
-    diagnostics.push({
-      file,
-      element: describeElement(node),
-      message: `${label} must be a number.`,
-      instruction: "Set the value to a numeric literal."
-    });
-  }
-  if (type === "boolean" && !["true", "false"].includes(value)) {
-    diagnostics.push({
-      file,
-      element: describeElement(node),
-      message: `${label} must be a boolean.`,
-      instruction: 'Set the value to "true" or "false".'
-    });
-  }
-  if (["json", "object"].includes(type)) {
-    validateJsonText(file, node, value, label, diagnostics);
-  }
-}
-function validateJsonPayload(file, input, label, diagnostics) {
-  const value = input.text.trim();
-  if (!value || value.startsWith("=")) {
-    return;
-  }
-  validateJsonText(file, input, value, label, diagnostics);
-}
-function validateJsonText(file, node, value, label, diagnostics) {
-  try {
-    JSON.parse(value);
-  } catch (error) {
-    diagnostics.push({
-      file,
-      element: describeElement(node),
-      message: `${label} contains malformed JSON: ${String(error)}`,
-      instruction: "Replace the payload with valid JSON.",
-      severity: "error"
-    });
-  }
-}
-function collectInlineBindings(root, bindings) {
-  for (const binding of findDescendants(root, (node) => node.name === "uipath:binding")) {
-    const id = binding.attributes.id;
-    if (!id) {
-      continue;
-    }
-    bindings.set(id, {
-      id,
-      resource: binding.attributes.resource,
-      resourceKey: binding.attributes.resourceKey,
-      resourceSubType: binding.attributes.resourceSubType,
-      propertyAttribute: binding.attributes.propertyAttribute
-    });
-  }
-}
-function collectBindings(parsed) {
-  const bindings = new Map;
-  collectBindingRecords(parsed, bindings);
-  return bindings;
-}
-function collectBindingRecords(value, bindings) {
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      collectBindingRecords(item, bindings);
-    }
-    return;
-  }
-  if (!isRecord(value)) {
-    return;
-  }
-  const id = getStringField(value, "bindingId") ?? getStringField(value, "bindingKey") ?? getStringField(value, "id");
-  if (id) {
-    bindings.set(id, {
-      id,
-      resource: getStringField(value, "resource"),
-      resourceKey: getStringField(value, "resourceKey"),
-      resourceSubType: getStringField(value, "resourceSubType"),
-      propertyAttribute: getStringField(value, "propertyAttribute")
-    });
-  }
-  for (const nested of Object.values(value)) {
-    collectBindingRecords(nested, bindings);
-  }
-}
-function getStringField(value, field) {
-  const fieldValue = value[field];
-  return typeof fieldValue === "string" && fieldValue ? fieldValue : undefined;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function formatDiagnostic(diagnostic) {
-  const element = diagnostic.element ? ` ${diagnostic.element}` : "";
-  return `${diagnostic.file}${element}: ${diagnostic.message} ${diagnostic.instruction}`;
-}
-function isErrorDiagnostic(diagnostic) {
-  return diagnostic.severity !== "warning";
-}
-function isWarningDiagnostic(diagnostic) {
-  return diagnostic.severity === "warning";
-}
-function decodeXmlEntities(value) {
-  return value.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-}
-// ../maestro-sdk/src/registry/filter-parser.ts
-class FilterParseError extends Error {
-  code;
-  token;
-  constructor(message, code, token) {
-    super(message);
-    this.code = code;
-    this.token = token;
-    this.name = "FilterParseError";
-  }
-}
-function parseFilterString(filterString) {
-  if (!filterString || filterString.trim() === "") {
-    return { filters: [], logic: "AND" };
-  }
-  const parts = filterString.split(/,(?=[a-zA-Z_][a-zA-Z0-9_]*(?::[a-zA-Z]+)?=)/);
-  const conditions = [];
-  for (const part of parts) {
-    const condition = parseFilterCondition(part.trim());
-    conditions.push(condition);
-  }
-  return {
-    filters: conditions,
-    logic: "AND"
-  };
-}
-function parseFilterCondition(conditionString) {
-  const match = conditionString.match(/^([^:=]+)(?::([^=]+))?=(.+)$/);
-  if (!match) {
-    throw new FilterParseError(`Invalid filter format: '${conditionString}'. Expected 'field=value' or 'field:operator=value'.`, "INVALID_FORMAT", conditionString);
-  }
-  const [, fieldStr, operatorStr, valueStr] = match;
-  const field = normalizeField(fieldStr.trim());
-  const operator = operatorStr?.trim() || "equals";
-  const value = valueStr.trim();
-  if (!isValidField(field)) {
-    throw new FilterParseError(`Invalid filter field: '${field}'. Supported fields: category, type, tags, displayname, nodetype, description.`, "INVALID_FIELD", field);
-  }
-  if (!isValidOperator(operator)) {
-    throw new FilterParseError(`Invalid filter operator: '${operator}'. Supported operators: equals, contains, in, startsWith, endsWith.`, "INVALID_OPERATOR", operator);
-  }
-  return {
-    field,
-    operator,
-    value
-  };
-}
-function normalizeField(field) {
-  const fieldMap = {
-    category: "category",
-    cat: "category",
-    type: "type",
-    nodetype: "nodetype",
-    node_type: "nodetype",
-    tags: "tags",
-    tag: "tags",
-    displayname: "displayname",
-    display_name: "displayname",
-    displayName: "displayname",
-    name: "displayname",
-    label: "displayname"
-  };
-  const normalized = field.toLowerCase().replace(/[-_\s]/g, "");
-  return fieldMap[normalized] || field;
-}
-function isValidField(field) {
-  const validFields = [
-    "category",
-    "type",
-    "tags",
-    "displayname",
-    "nodetype",
-    "description"
-  ];
-  return validFields.includes(field);
-}
-function isValidOperator(operator) {
-  const validOperators = [
-    "equals",
-    "contains",
-    "in",
-    "startsWith",
-    "endsWith"
-  ];
-  return validOperators.includes(operator);
-}
-
-// ../maestro-sdk/src/registry/command.ts
-function flattenNodeForDisplay(n) {
-  return {
-    NodeType: n.nodeType,
-    Category: n.category ?? "",
-    DisplayName: n.display?.label ?? "",
-    Description: n.description ?? n.display?.description ?? "",
-    Version: n.version ?? "",
-    Tags: (n.tags ?? []).join(", ")
-  };
-}
-function flattenNodeWithAvailability(n, availableOnTenant) {
-  return {
-    ...flattenNodeForDisplay(n),
-    AvailableOnTenant: availableOnTenant
-  };
-}
-async function mergeWithKnownSdkNodes(tenantNodes) {
-  const { listKnownSdkNodes } = await import("./known-types-eq32py2n.js");
-  const tenantTypes = new Set(tenantNodes.map((n) => n.nodeType?.toLowerCase()).filter((t) => typeof t === "string"));
-  const merged = tenantNodes.map((node) => ({ node, availableOnTenant: true }));
-  for (const known of listKnownSdkNodes()) {
-    const type = known.nodeType?.toLowerCase();
-    if (typeof type !== "string")
-      continue;
-    if (tenantTypes.has(type))
-      continue;
-    merged.push({ node: known, availableOnTenant: false });
-  }
-  return merged;
-}
-var registerRegistryCommand = (program, commandPrefix) => {
-  const cmd = `uip ${commandPrefix} registry`;
-  const registry = program.command("registry").description(`Browse and search the ${commandPrefix} node registry to discover available activities and connectors (OOTB + authenticated). Use 'pull' to sync, 'search' to find nodes, 'get' to inspect a node's full input/output schema.`).addHelpText("after", `
-Typical workflow:
-  0. Login for full registry (optional, OOTB nodes available without login):
-                          uip login
-  1. Sync the registry:   ${cmd} pull
-  2. Search for a node:   ${cmd} search slack
-  3. Inspect its schema:  ${cmd} get <node-type>
-  4. Extract input fields: ${cmd} get <node-type> --output-filter "Node.inputDefinition.fields"
-
-Note: Without login, only built-in (OOTB) nodes are available. Login to access the full node registry including custom connectors.
-
-In-solution discovery (--local):
-  Run from inside a solution project directory (with a .uipx file in CWD, parent, or grandparent).
-  Shows sibling projects (Agent, Process, Flow, Api) as invokable nodes.
-  cd MySolution/MyFlow && ${cmd} list --local
-
-Subcommands:
-  pull    Fetch and cache the full node registry (run once per session)
-  list    List cached nodes (default: first 20, --limit -1 for everything)
-  search  Find nodes by keyword and/or field filters  ← start here
-  get     Get full schema for a single node (with connector input/output enrichment)`);
-  const pullExamples = [
-    {
-      Description: "Sync the node registry",
-      Command: `${cmd} pull`,
-      Output: {
-        Code: "NodePullSuccess",
-        Data: {
-          NodesCount: 184,
-          FromCache: false,
-          Source: "authenticated",
-          CacheWritten: true,
-          Message: "Synced fresh nodes"
-        }
-      }
-    }
-  ];
-  const listExamples = [
-    {
-      Description: "List cached nodes (every row carries AvailableOnTenant; FF-gated SDK-known nodes are included)",
-      Command: `${cmd} list --limit 2`,
-      Output: {
-        Code: "NodeListSuccess",
-        Data: [
-          {
-            NodeType: "uipath.slack.connector.send-message",
-            Category: "connector",
-            DisplayName: "Send Message",
-            Description: "Post a message to a Slack channel",
-            Version: "1.0.0",
-            Tags: "slack, messaging",
-            AvailableOnTenant: true
-          },
-          {
-            NodeType: "uipath.human-in-the-loop",
-            Category: "human-task",
-            DisplayName: "Human in the Loop",
-            Description: "Assign a task to a human and wait for completion",
-            Version: "1.0.0",
-            Tags: "human-task, hitl, human-in-the-loop, approval",
-            AvailableOnTenant: false
-          }
-        ]
-      }
-    }
-  ];
-  const searchExamples = [
-    {
-      Description: "Search nodes by keyword (every row carries AvailableOnTenant; FF-gated SDK-known nodes are included)",
-      Command: `${cmd} search slack`,
-      Output: {
-        Code: "NodeSearchSuccess",
-        Data: [
-          {
-            NodeType: "uipath.slack.connector.send-message",
-            Category: "connector",
-            DisplayName: "Send Message",
-            Description: "Post a message to a Slack channel",
-            Version: "1.0.0",
-            Tags: "slack, messaging",
-            AvailableOnTenant: true
-          }
-        ]
-      }
-    }
-  ];
-  const getExamples = [
-    {
-      Description: "Get the full schema for a node",
-      Command: `${cmd} get uipath.slack.connector.send-message`,
-      Output: {
-        Code: "NodeGetSuccess",
-        Data: {
-          Node: {
-            nodeType: "uipath.slack.connector.send-message",
-            category: "connector",
-            display: { label: "Send Message" },
-            inputDefinition: {
-              fields: [{ name: "channel", required: true }]
-            }
-          }
-        }
-      }
-    }
-  ];
-  registry.command("pull").description(`Pull and sync node data from ${commandPrefix} registry (login first for full registry)`).option("-f, --force", "Force refresh, ignore cache").examples(pullExamples).trackedAction(processContext, async (options) => {
-    const { pullNodes } = await import("./node-sync-service-zwvm30qg.js");
-    const [error, result] = await catchError(pullNodes({
-      force: options.force
-    }));
-    if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error pulling nodes",
-        Instructions: error.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    const message = result.fromCache ? `Using cached nodes (age: ${result.ageMinutes}m)` : "Synced fresh nodes";
-    const finalMessage = result.info ? `${message}. ${result.info}` : message;
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "NodePullSuccess",
-      Data: {
-        NodesCount: result.syncedCount,
-        FromCache: result.fromCache,
-        AgeMinutes: result.ageMinutes,
-        Source: result.source,
-        CacheWritten: result.cacheWritten,
-        Message: finalMessage,
-        Info: result.info
-      }
-    });
-  });
-  registry.command("list").description("Sample cached nodes to inspect their config structure (default: first 20). Output merges tenant nodes with the SDK-known catalog; every row carries `AvailableOnTenant` so callers can filter FF-gated rows. Use 'search' to find nodes — use --limit -1 only if you need the full list (the result can be huge and unreadable).").addHelpText("after", `
-Examples:
-  ${cmd} list
-  ${cmd} list --limit 200
-  ${cmd} list --limit -1
-
-In-solution (--local):
-  cd MySolution/MyFlow && ${cmd} list --local`).option("-l, --limit <n>", "Number of nodes to return (default: 20, -1 for all)", (v) => Number.parseInt(v, 10), 20).option("--local", "Show only in-solution project nodes (requires .uipx in CWD, parent, or grandparent). Omits `AvailableOnTenant` (no tenant lookup).").examples(listExamples).trackedAction(processContext, async (options) => {
-    if (Number.isNaN(options.limit) || options.limit < 1 && options.limit !== -1) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Invalid --limit value",
-        Instructions: "Provide a positive integer (e.g. --limit 100) or -1 for all nodes"
-      });
-      processContext.exit(1);
-      return;
-    }
-    const { listNodes } = await import("./node-sync-service-zwvm30qg.js");
-    const [error, tenantNodes] = await catchError(listNodes({ local: options.local }));
-    if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error listing nodes",
-        Instructions: error.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    const showAll = options.limit === -1;
-    if (options.local) {
-      const totalCount2 = tenantNodes.length;
-      const effectiveLimit2 = showAll ? totalCount2 : options.limit;
-      const nodes = tenantNodes.slice(0, effectiveLimit2);
-      const truncated2 = nodes.length < totalCount2;
-      OutputFormatter.success({
-        Result: RESULTS.Success,
-        Code: "NodeListSuccess",
-        Data: nodes.map(flattenNodeForDisplay)
-      });
-      if (truncated2) {
-        logger.info(`Showing first ${nodes.length} of ${totalCount2}. Use --limit or --limit -1 to get more, or use 'search' to filter.`);
-      }
-      return;
-    }
-    const merged = await mergeWithKnownSdkNodes(tenantNodes);
-    const totalCount = merged.length;
-    const effectiveLimit = showAll ? totalCount : options.limit;
-    const slice = merged.slice(0, effectiveLimit);
-    const truncated = slice.length < totalCount;
-    const gatedCount = merged.filter((m) => !m.availableOnTenant).length;
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "NodeListSuccess",
-      Data: slice.map((m) => flattenNodeWithAvailability(m.node, m.availableOnTenant))
-    });
-    if (truncated) {
-      logger.info(`Showing first ${slice.length} of ${totalCount} (${gatedCount} not enabled on this tenant). Use --limit or --limit -1 to get more.`);
-    } else if (gatedCount > 0) {
-      logger.info(`${gatedCount} of ${totalCount} node type(s) are not enabled on this tenant (AvailableOnTenant=false).`);
-    }
-  });
-  registry.command("search").description("Find nodes by keyword and/or field filters").addHelpText("after", `
-Filter syntax:
-  field=value                    equality (default operator)
-  field:contains=value           field contains value
-  field:startsWith=value         field starts with value
-  field:endsWith=value           field ends with value
-  field:in=value1,value2         field matches any of the values
-  field1=v1,field2=v2            multiple conditions (AND logic)
-
-Filterable fields:
-  category / cat                 e.g. "connector", "agent"
-  type / nodetype                node type identifier
-  tags / tag                     node tags
-  displayname / name / label     human-readable display name
-
-Examples:
-  ${cmd} search slack
-  ${cmd} search --filter "category=connector"
-  ${cmd} search --filter "displayname:contains=send message"
-  ${cmd} search slack --filter "category=connector"
-  ${cmd} search --filter "tags:in=ai,automation"
-  ${cmd} search --filter "category=connector,displayname:contains=slack"
-
-Tip: pipe through --output-filter to extract just the nodeType values:
-  ${cmd} search slack --output-filter "[*].NodeType"
-
-In-solution (--local):
-  cd MySolution/MyFlow && ${cmd} search agent --local`).argument("[keyword]", "Search term matched against nodeType, category, tags, display name, and description").option("-f, --filter <filter>", "Structured field filter: field=value or field:operator=value. Comma-separated = AND. Fields: category, type, tags, displayname, description.").option("--local", "Search only in-solution project nodes (requires .uipx in CWD, parent, or grandparent). Omits `AvailableOnTenant` (no tenant lookup).").examples(searchExamples).trackedAction(processContext, async (keyword, options) => {
-    let parsedFilters;
-    if (options.filter) {
-      const [parseError, parsed] = catchError(() => parseFilterString(options.filter));
-      if (parseError) {
-        if (parseError instanceof FilterParseError) {
-          OutputFormatter.error({
-            Result: RESULTS.Failure,
-            Message: "Invalid filter syntax",
-            Instructions: `${parseError.message} Examples: category=agent, displayname:contains=http, tags:in=ai,automation.`
-          });
-          processContext.exit(1);
-          return;
-        }
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: "Error searching nodes",
-          Instructions: parseError.message
-        });
-        processContext.exit(1);
-        return;
-      }
-      parsedFilters = parsed;
-    }
-    if (!keyword && !parsedFilters) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Search requires either a keyword or filters",
-        Instructions: "Provide a keyword or use --filter flag"
-      });
-      processContext.exit(1);
-      return;
-    }
-    const {
-      searchNodeSummariesWithAvailability,
-      searchNodes,
-      searchNodesWithFilters
-    } = await import("./node-sync-service-zwvm30qg.js");
-    if (options.local) {
-      const [searchError2, results2] = await catchError(parsedFilters ? searchNodesWithFilters(keyword, parsedFilters, {
-        local: true
-      }) : searchNodes(keyword, { local: true }));
-      if (searchError2) {
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: "Error searching nodes",
-          Instructions: searchError2.message
-        });
-        processContext.exit(1);
-        return;
-      }
-      OutputFormatter.success({
-        Result: RESULTS.Success,
-        Code: "NodeSearchSuccess",
-        Data: results2.map(flattenNodeForDisplay)
-      });
-      return;
-    }
-    const [searchError, results] = await catchError(searchNodeSummariesWithAvailability(keyword, parsedFilters));
-    if (searchError) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error searching nodes",
-        Instructions: searchError.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "NodeSearchSuccess",
-      Data: results.map((result) => flattenNodeWithAvailability(result.node, result.availableOnTenant))
-    });
-  });
-  registry.command("get").description("Get the full schema for a single node. For connector nodes (uipath.connector.*), the base manifest is automatically enriched with live metadata from Integration Service.").addHelpText("after", `
-IS-enriched fields (connector nodes only, fetched live from Integration Service):
-
-  Activity nodes (uipath.connector.*, not trigger):
-    inputDefinition.fields    Fields to configure. Each field has: name, displayName, type, required, and optionally reference (lookup: objectName, path, lookupValue, lookupNames, childPath) or enum.
-    outputResponseDefinition  Fields produced after the node runs.
-    connectorMethodInfo       HTTP details (method, path, operationId).
-    --connection-id optional — adds custom fields specific to that account.
-
-  Trigger nodes (uipath.connector.trigger.*):
-    eventParameters           Fields that configure the trigger (e.g. which folder to watch).
-    filterFields              Fields used to filter which events fire the trigger.
-    outputResponseDefinition  Fields produced by the trigger event payload.
-    eventMode                 "webhooks" or "polling".
-    login + --connection-id required — without both, no enrichment is returned.
-
-Examples:
-  ${cmd} get uipath.slack.connector.send-message
-  ${cmd} get uipath.connector.uipath-salesforce-slack.send-message --connection-id <id>
-  ${cmd} get uipath.connector.trigger.uipath-microsoft-outlook365.email-received --connection-id <id>
-
-In-solution (--local):
-  cd MySolution/MyFlow && ${cmd} get <node-type> --local`).argument("<node-type>", `Node type identifier — get it from '${cmd} search'`).option("--connection-id <id>", "Connection ID for Integration Service connector node enrichment. Required for connector trigger nodes; optional for connector activity nodes.").option("--local", "Get node from in-solution projects only (requires .uipx in CWD, parent, or grandparent)").examples(getExamples).trackedAction(processContext, async (nodeType, options) => {
-    const { getNodeEnriched } = await import("./node-sync-service-zwvm30qg.js");
-    const [error, result] = await catchError(getNodeEnriched(nodeType, options.connectionId, {
-      local: options.local
-    }));
-    if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error retrieving node",
-        Instructions: error.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    if (!result) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Node not found",
-        Instructions: `No node found with node type: ${nodeType}`
-      });
-      processContext.exit(1);
-      return;
-    }
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "NodeGetSuccess",
-      Data: {
-        Node: result
-      }
-    }, { preserveDataKeys: true });
-  });
-};
-// ../maestro-sdk/src/registry/storage.ts
-var MAESTRO_REGISTRY_DIR = "maestro";
-var REGISTRY_FILE = "registry.json";
-var REGISTRY_META_FILE = "registry.meta.json";
-var CACHE_EXPIRATION_MS = 30 * 60 * 1000;
-async function resolveStorageDir() {
-  const fs = getFileSystem();
-  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, MAESTRO_REGISTRY_DIR);
-}
-async function saveRegistry(registry, processCountsByType) {
-  const fs = getFileSystem();
-  const dir = await resolveStorageDir();
-  await fs.mkdir(dir);
-  const content = JSON.stringify(registry, null, 2);
-  const hash = await hashContent(content);
-  const registryPath = fs.path.join(dir, REGISTRY_FILE);
-  await fs.writeFile(registryPath, content);
-  const meta = {
-    lastSync: registry.lastSync,
-    hash,
-    extensionTypeCount: Object.keys(registry.static.extensionTypes).length,
-    connectorCount: registry.discovered.connectors.length,
-    processCount: registry.discovered.processes.length,
-    processCountsByType
-  };
-  const metaPath = fs.path.join(dir, REGISTRY_META_FILE);
-  await fs.writeFile(metaPath, JSON.stringify(meta, null, 2));
-}
-async function loadRegistry() {
-  const fs = getFileSystem();
-  const dir = await resolveStorageDir();
-  const registryPath = fs.path.join(dir, REGISTRY_FILE);
-  if (!await fs.exists(registryPath)) {
-    return null;
-  }
-  const [readErr, content] = await catchError(fs.readFile(registryPath, "utf-8"));
-  if (readErr || content === null) {
-    return null;
-  }
-  const [parseErr, parsed] = catchError(() => JSON.parse(content));
-  if (parseErr) {
-    return null;
-  }
-  return parsed;
-}
-async function loadRegistryMetadata() {
-  const fs = getFileSystem();
-  const dir = await resolveStorageDir();
-  const metaPath = fs.path.join(dir, REGISTRY_META_FILE);
-  if (!await fs.exists(metaPath)) {
-    return null;
-  }
-  const [readErr, content] = await catchError(fs.readFile(metaPath, "utf-8"));
-  if (readErr || content === null) {
-    return null;
-  }
-  const [parseErr, parsed] = catchError(() => JSON.parse(content));
-  if (parseErr) {
-    return null;
-  }
-  return parsed;
-}
-
-// ../maestro-sdk/src/registry/registry-service.ts
-var ORCHESTRATOR_RESOURCE_TYPES = [
-  "Process",
-  "ProcessOrchestration",
-  "Agent",
-  "Flow",
-  "Api",
-  "Function",
-  "CaseManagement",
-  "BusinessRules"
-];
-function countProcessesByType(processes) {
-  const counts = {};
-  for (const type of ORCHESTRATOR_RESOURCE_TYPES) {
-    counts[type] = 0;
-  }
-  for (const p of processes) {
-    counts[p.type] = (counts[p.type] ?? 0) + 1;
-  }
-  return counts;
-}
-async function pullRegistry(options = {}) {
-  const { force = false } = options;
-  if (!force) {
-    const meta = await loadRegistryMetadata();
-    if (meta) {
-      const ageMs = Date.now() - meta.lastSync;
-      if (ageMs < CACHE_EXPIRATION_MS) {
-        return {
-          extensionTypeCount: meta.extensionTypeCount,
-          connectorCount: meta.connectorCount,
-          processCount: meta.processCount,
-          processCountsByType: meta.processCountsByType ?? {},
-          fromCache: true,
-          ageMinutes: Math.round(ageMs / 60000),
-          cacheWritten: false
-        };
-      }
-    }
-  }
-  const { registry, authenticated, connectorDiscovery } = await buildRegistry();
-  const processCountsByType = countProcessesByType(registry.discovered.processes);
-  await saveRegistry(registry, processCountsByType);
-  const connectorCount = registry.discovered.connectors.length;
-  const processCount = registry.discovered.processes.length;
-  return {
-    extensionTypeCount: Object.keys(registry.static.extensionTypes).length,
-    connectorCount,
-    processCount,
-    processCountsByType,
-    fromCache: false,
-    cacheWritten: true,
-    info: getRegistryPullInfo(authenticated, connectorCount, processCount, connectorDiscovery)
-  };
-}
-async function getRegistry() {
-  const cached = await loadRegistry();
-  if (cached) {
-    return cached;
-  }
-  const { registry } = await buildRegistry();
-  await saveRegistry(registry, countProcessesByType(registry.discovered.processes));
-  return registry;
-}
-async function searchRegistry(keyword) {
-  const registry = await getRegistry();
-  const lower = keyword.toLowerCase();
-  const extensionTypes = Object.values(registry.static.extensionTypes).filter((et) => et.extensionType.toLowerCase().includes(lower) || et.label.toLowerCase().includes(lower) || et.bpmnElement.toLowerCase().includes(lower) || et.extensionTag.toLowerCase().includes(lower) || (et.discoveryNotes ?? "").toLowerCase().includes(lower));
-  const connectors = registry.discovered.connectors.filter((c) => c.key.toLowerCase().includes(lower) || c.name.toLowerCase().includes(lower) || c.activities.some((a) => a.displayName.toLowerCase().includes(lower) || a.name.toLowerCase().includes(lower)) || c.triggers.some((t) => t.displayName.toLowerCase().includes(lower) || t.name.toLowerCase().includes(lower)));
-  const processes = registry.discovered.processes.filter((p) => p.name.toLowerCase().includes(lower) || p.processKey.toLowerCase().includes(lower) || (p.processVersion ?? "").toLowerCase().includes(lower) || p.key.toLowerCase().includes(lower) || p.type.toLowerCase().includes(lower) || p.folderKey.toLowerCase().includes(lower) || (p.feedId ?? "").toLowerCase().includes(lower));
-  return { extensionTypes, connectors, processes };
-}
-async function getExtensionType(extensionType) {
-  const registry = await getRegistry();
-  const lower = extensionType.toLowerCase();
-  const match = Object.entries(registry.static.extensionTypes).find(([key]) => key.toLowerCase() === lower);
-  return match ? match[1] : null;
-}
-async function resolveConnectorKey(connectionId) {
-  const [regErr, registry] = await catchError(getRegistry());
-  if (!regErr && registry) {
-    const cached = registry.discovered.connectors.find((connector) => connector.connections.some((conn) => conn.id === connectionId))?.key;
-    if (cached) {
-      return cached;
-    }
-  }
-  const [apiErr, api] = await catchError(createApiClient(ConnectionsApi));
-  if (apiErr) {
-    return null;
-  }
-  const [connErr, connection] = await catchError(api.apiV1ConnectionsConnectionIdGet({ connectionId, allFolders: true }));
-  if (connErr || !connection) {
-    return null;
-  }
-  return connection.connector?.key ?? null;
-}
-async function getEnrichedActivityMetadata(objectName, connectionId, options = {}) {
-  const [loginErr, loginStatus] = await catchError(getLoginStatusAsync());
-  if (loginErr || loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.accessToken || !loginStatus.organizationId || !loginStatus.tenantName) {
-    logger.warn("Not logged in — cannot enrich from IS.");
-    return null;
-  }
-  const connectorKey = await resolveConnectorKey(connectionId);
-  if (!connectorKey) {
-    logger.warn(`Cannot enrich: no connector found for connection ${connectionId}. Verify the connection id (and that you can access it).`);
-    return null;
-  }
-  const [apiErr, api] = await catchError(createApiClient(ElementsApi));
-  if (apiErr) {
-    logger.warn(`IS enrichment failed: ${apiErr.message}`);
-    return null;
-  }
-  if (options.isEvent) {
-    if (!options.operation) {
-      logger.warn("Event enrichment requires an operation — pass --operation (e.g. INCIDENT_CREATED).");
-      return null;
-    }
-    const operation2 = options.operation.toUpperCase();
-    const [err2, metadata2] = await fetchTriggerMetadata(api, connectorKey, operation2, objectName, connectionId);
-    const isEmpty = !err2 && metadata2 !== null && metadata2 !== undefined && Object.keys(metadata2).length === 0;
-    if (err2 || !metadata2 || isEmpty) {
-      const message = err2?.message ?? (isEmpty ? "no event metadata returned (empty)" : "no event metadata returned");
-      logger.warn(`IS event enrichment failed: ${message}`);
-      return {
-        error: `Event operation '${operation2}' on '${objectName}' could not be enriched: ${message}`
-      };
-    }
-    return buildTriggerCompactSummary(metadata2, operation2);
-  }
-  const [err, metadata] = await catchError(fetchRawMetadata(api, connectorKey, objectName, connectionId));
-  if (err || !metadata) {
-    logger.warn(`IS enrichment failed: ${err?.message ?? "no metadata returned"}`);
-    return null;
-  }
-  const operation = options.operation ?? soleOperation(metadata);
-  return buildResourceCompactSummary(metadata, operation);
-}
-function soleOperation(metadata) {
-  const inner = metadata.metadata;
-  const methods = inner?.method ?? {};
-  const keys = Object.keys(methods);
-  return keys.length === 1 ? keys[0] : undefined;
-}
-function getRegistryPullInfo(authenticated, connectorCount, processCount, connectorDiscovery) {
-  if (connectorCount > 0) {
-    return;
-  }
-  if (!authenticated) {
-    return "Only built-in (OOTB) extension types synced. Run 'uip login' to discover connectors and processes.";
-  }
-  if (connectorDiscovery === "failed") {
-    return "Connector/action metadata could not be refreshed; synced built-in extension types and any available processes. Check Integration Service access or connectivity and retry with --force.";
-  }
-  if (processCount > 0) {
-    return "No Integration Service connectors with connections were discovered; synced built-in extension types and discovered processes.";
-  }
-  return "No connector/action metadata or processes were discovered; synced built-in extension types. Check Integration Service and Orchestrator access if you expected tenant resources.";
-}
-async function buildRegistry() {
-  const extensionTypes = BPMN_SPEC.extensionTypes;
-  let connectors = [];
-  let processes = [];
-  let authenticated = false;
-  let connectorDiscovery = "not-run";
-  const auth = await getAuthContext();
-  if (auth) {
-    authenticated = true;
-    const [discoverErr, discovered] = await catchError(discoverResources(auth));
-    if (discoverErr) {
-      logger.warn(`Resource discovery failed, using static only: ${discoverErr.message}`);
-      connectorDiscovery = "failed";
-    } else {
-      connectors = discovered.connectors;
-      processes = discovered.processes;
-      connectorDiscovery = discovered.connectorDiscovery;
-    }
-  } else {
-    logger.info("Not logged in — syncing OOTB extension types only.");
-  }
-  const registry = {
-    version: BPMN_SPEC.version,
-    lastSync: Date.now(),
-    hash: "",
-    static: {
-      extensionTypes,
-      bpmnElements: BPMN_SPEC.bpmnElements,
-      serializationRules: BPMN_SPEC.serializationRules
-    },
-    discovered: { connectors, processes }
-  };
-  registry.hash = await hashContent(JSON.stringify(registry));
-  return { registry, authenticated, connectorDiscovery };
-}
-async function getAuthContext() {
-  const [err, status] = await catchError(getLoginStatusAsync());
-  if (err || status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken || !status.organizationId || !status.tenantName) {
-    return null;
-  }
-  return {
-    baseUrl: status.baseUrl,
-    accessToken: status.accessToken,
-    organizationId: status.organizationId.toString(),
-    tenantName: status.tenantName
-  };
-}
-async function discoverResources(auth) {
-  const [connectorsResult, processesResult] = await Promise.allSettled([
-    discoverConnectors(auth),
-    discoverProcesses(auth)
-  ]);
-  const connectorDiscovery = connectorsResult.status === "fulfilled" ? "succeeded" : "failed";
-  const connectors = connectorsResult.status === "fulfilled" ? connectorsResult.value : [];
-  const processes = processesResult.status === "fulfilled" ? processesResult.value : [];
-  if (connectorsResult.status === "rejected") {
-    logger.warn(`Connector discovery failed: ${String(connectorsResult.reason)}`);
-  }
-  if (processesResult.status === "rejected") {
-    logger.warn(`Process discovery failed: ${String(processesResult.reason)}`);
-  }
-  return { connectors, processes, connectorDiscovery };
-}
-async function isGet(auth, path) {
-  const url = `${auth.baseUrl}/${auth.organizationId}/${auth.tenantName}/connections_/api/v1/${path}`;
-  logger.debug(`IS GET: ${url}`);
-  const response = await fetch(url, {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${auth.accessToken}`,
-      Accept: "application/json"
-    }
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    throw new Error(`IS ${path} failed: ${response.status} — ${text.substring(0, 300)}`);
-  }
-  return await response.json();
-}
-async function discoverConnectors(auth) {
-  const allConnections = await fetchAllConnections();
-  const connectors = new Map;
-  for (const connection of allConnections) {
-    const key = connection.connector?.key;
-    if (!key) {
-      continue;
-    }
-    const connector = connectors.get(key) ?? {
-      key,
-      name: connection.connector?.name ?? key,
-      connections: []
-    };
-    connector.connections.push({
-      id: connection.id ?? "",
-      name: connection.name ?? "",
-      state: normalizeConnectionStatus(connection.state),
-      folder: connection.folder?.path ?? "",
-      folderKey: connection.folder?.key ?? ""
-    });
-    connectors.set(key, connector);
-  }
-  logger.debug(`Found ${connectors.size} connectors across ${allConnections.length} connections`);
-  const results = await Promise.allSettled([...connectors.values()].map(async (connector) => {
-    const [activities, triggers] = await Promise.all([
-      fetchActivities(auth, connector.key),
-      fetchTriggers(auth, connector.key)
-    ]);
-    return {
-      ...connector,
-      activities,
-      triggers
-    };
-  }));
-  return results.filter((r) => r.status === "fulfilled").map((r) => r.value);
-}
-var CONNECTIONS_PAGE_SIZE = 100;
-var MAX_CONNECTION_PAGES = 20;
-async function fetchAllConnections() {
-  const api = await createApiClient(ConnectionsApi);
-  const connections = [];
-  const seenIds = new Set;
-  let previousPageIds;
-  for (let pageIndex = 0;pageIndex < MAX_CONNECTION_PAGES; pageIndex++) {
-    const page = await api.apiV1ConnectionsGet({
-      allFolders: true,
-      mostRecentFirst: true,
-      pageIndex,
-      pageSize: CONNECTIONS_PAGE_SIZE
-    });
-    for (const connection of page) {
-      const id = connection.id;
-      if (!id || seenIds.has(id)) {
-        continue;
-      }
-      seenIds.add(id);
-      connections.push(connection);
-    }
-    if (page.length < CONNECTIONS_PAGE_SIZE) {
-      return connections;
-    }
-    const pageIds = JSON.stringify(page.map((connection) => connection.id ?? null));
-    if (pageIds === previousPageIds) {
-      throw new Error("Connection discovery returned an identical page twice; refusing to save incomplete results.");
-    }
-    previousPageIds = pageIds;
-  }
-  throw new Error(`Connection discovery exceeded the ${MAX_CONNECTION_PAGES}-page safety limit; refusing to return incomplete results.`);
-}
-async function fetchActivities(auth, connectorKey) {
-  const baseUrl = `${auth.baseUrl}/${auth.organizationId}/${auth.tenantName}`;
-  const url = `${baseUrl}/elements_/v3/element/connectors/${connectorKey}/objects`;
-  const [err, response] = await catchError(fetch(url, {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${auth.accessToken}`,
-      Accept: "application/json"
-    }
-  }));
-  if (err || !response.ok) {
-    logger.debug(`Activities for ${connectorKey}: ${err?.message ?? `status ${response?.status}`}`);
-    return [];
-  }
-  const [parseErr, data] = await catchError(response.json());
-  if (parseErr || !Array.isArray(data)) {
-    return [];
-  }
-  return data.map((a) => ({
-    name: a.name ?? "",
-    displayName: a.displayName ?? a.name ?? "",
-    objectName: a.objectName ?? a.name ?? "",
-    method: a.method ?? "POST",
-    operation: a.operation ?? ""
-  }));
-}
-async function fetchTriggers(auth, connectorKey) {
-  const [err, raw] = await catchError(isGet(auth, `connectors/${connectorKey}/triggers`));
-  if (err) {
-    logger.debug(`Triggers for ${connectorKey}: ${err.message}`);
-    return [];
-  }
-  if (!Array.isArray(raw)) {
-    return [];
-  }
-  return raw.map((t) => ({
-    name: t.name ?? "",
-    displayName: t.displayName ?? t.name ?? "",
-    objectName: t.objectName ?? t.name ?? ""
-  }));
-}
-async function discoverProcesses(auth) {
-  const [err, sdkConfig] = await catchError(createOrchestratorConfig({ tenant: auth.tenantName }));
-  if (err) {
-    logger.warn(`Orchestrator config failed: ${err.message}`);
-    return [];
-  }
-  const releasesApi = new ReleasesApi(sdkConfig);
-  const results = await Promise.allSettled(ORCHESTRATOR_RESOURCE_TYPES.map((type) => fetchReleasesByType(releasesApi, type)));
-  return results.flatMap((r, i) => {
-    if (r.status === "fulfilled") {
-      return r.value;
-    }
-    logger.warn(`Release discovery failed for type ${ORCHESTRATOR_RESOURCE_TYPES[i]}: ${r.reason}`);
-    return [];
-  });
-}
-var RELEASES_PAGE_SIZE = 100;
-async function fetchReleasesByType(releasesApi, type) {
-  const all = [];
-  let skip = 0;
-  while (true) {
-    const response = await releasesApi.releasesListReleases({
-      $filter: `ProcessType eq '${type}'`,
-      $orderby: "Name asc",
-      $top: RELEASES_PAGE_SIZE,
-      $skip: skip
-    });
-    const page = (response.value ?? []).map((r) => ({
-      key: r.key ?? "",
-      name: r.name ?? "",
-      processKey: r.processKey ?? "",
-      processVersion: r.processVersion,
-      type,
-      folder: r.organizationUnitFullyQualifiedName ?? "",
-      folderKey: r.folderKey ?? "",
-      feedId: r.feedId
-    }));
-    all.push(...page);
-    if (page.length < RELEASES_PAGE_SIZE) {
-      break;
-    }
-    skip += RELEASES_PAGE_SIZE;
-  }
-  return all;
-}
-export { BpmnValidateService, FilterParseError, parseFilterString, registerRegistryCommand, CACHE_EXPIRATION_MS, saveRegistry, loadRegistry, loadRegistryMetadata, ORCHESTRATOR_RESOURCE_TYPES, countProcessesByType, pullRegistry, getRegistry, searchRegistry, getExtensionType, getEnrichedActivityMetadata };
-
-//# debugId=B4A478A5C1EED29164756E2164756E21