@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/{packager-tool-3vdpx9ng.js → packager-tool-zke08y39.js}

@@ -1,187 +1,377 @@
 import {
-  ManifestClient,
-  buildErrorHandle,
-  getConnectorInfo,
-  getNode,
-  isConnectorNode,
-  isKnownSdkNodeType,
-  loadRegistry,
-  readFlowWorkflow,
-  validateIntSvcNode,
-  writeFlowWorkflow
-} from "./packager-tool-3y0k15sv.js";
+  UI_ONLY_NODE_TYPES
+} from "./packager-tool-4fhgws0x.js";
+import {
+  checkForwardMigration
+} from "./packager-tool-mwvbq6ef.js";
+import {
+  crossNodeBindingValidator,
+  isConnectorTriggerType,
+  isConnectorWaitForEventType,
+  isEventDrivenConnectorType
+} from "./packager-tool-2wefykg9.js";
+import {
+  ERROR_SOURCE_PORT,
+  deriveOutcomeHandleIds,
+  expandHandleIds,
+  isHandleVisible,
+  isTemplatedHandleId,
+  parseVisibleInputKey,
+  portMatchesTemplate
+} from "./packager-tool-nq4rcqqg.js";
+import {
+  isRecord
+} from "./packager-tool-8j92afwp.js";
+import {
+  collectNodeBindingResourceKeys,
+  isProcessNode,
+  resolveProcessTarget
+} from "./packager-tool-v2rkcehq.js";
+import {
+  loadRegistry
+} from "./packager-tool-cdwpc9fh.js";
+import {
+  validateIntSvcNode
+} from "./packager-tool-v9psxdy5.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-f0kd5kq4.js";
 import {
   findNearestParentUipxFile,
-  getLoginStatusAsync,
   readSolutionManifest
-} from "./packager-tool-0sz8se22.js";
+} from "./packager-tool-eebq62fq.js";
+import {
+  resolveProjectFlowFile
+} from "./packager-tool-94w17vf8.js";
+import {
+  canonicalAgentInputPath,
+  collectAgentInputLeaves,
+  createFlowRefResolver,
+  resolveWorkflowRefs
+} from "./packager-tool-6m078z5s.js";
 import {
   OutputFormatter,
   RESULTS,
   catchError,
+  extractErrorMessageSync,
   logger
-} from "./packager-tool-cvwr40ax.js";
+} from "./packager-tool-5qaxht3k.js";
 import {
   getFileSystem
-} from "./packager-tool-1cb0d5e0.js";
+} from "./packager-tool-0v3s8r01.js";
 import {
-  addBinding,
-  addNode,
-  buildInlineAgentContract,
-  createBinding,
-  createFlowRefResolver,
-  generateNodeIdAndName,
-  getMigrationChain,
-  isInlineAgentNodeType,
-  migrateWorkflowToFloor,
-  minimumSupportedVersion,
-  operateRuntimeOptions,
-  readInlineAgentSource,
-  registerFlowMigrationsI18n,
-  resolveWorkflowRefs,
-  runtimeMigrations,
-  runtimeVersion
-} from "./packager-tool-17cn3xb7.js";
+  ManifestClient,
+  buildErrorHandle
+} from "./packager-tool-p9stswjj.js";
 import {
   AGENT_NODE_TYPES,
-  EntryPointType,
-  ProjectType,
   cliRules,
   conditionExpressionRule,
   decodeLiteral,
-  generateBindingsJson,
-  generateEntryPointsJson,
-  generateOperateJson,
-  getBindingResources,
-  getEntryPoints,
   getJsExpressionBody,
   instance,
   isBlockingSeverity,
-  isConversationalOrVoiceAgentNodeType,
   isExpressionValue,
   isStartEventNode,
   isVoiceAgentNodeType,
-  mergeBindingResources,
   parseWorkflowJson,
-  registerFlowSchemaI18n,
-  runRules
-} from "./packager-tool-78a3szsp.js";
+  runRules,
+  toSerializedNodes
+} from "./packager-tool-m5qfverj.js";
+import {
+  registerFlowSchemaI18n
+} from "./packager-tool-e0p2zsyc.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
 
-// src/services/connector-node-types.ts
-function isConnectorTriggerType(nodeType) {
-  return nodeType.startsWith("uipath.connector.trigger");
+// src/services/connector-binding-validator.ts
+var STATIC_CONNECTOR_KEYWORDS = [
+  "slack",
+  "gmail",
+  "outlook",
+  "office365",
+  "exchange",
+  "jira",
+  "confluence",
+  "salesforce",
+  "sfdc",
+  "hubspot",
+  "servicenow",
+  "zendesk",
+  "intercom",
+  "notion",
+  "asana",
+  "trello",
+  "monday",
+  "github",
+  "gitlab",
+  "bitbucket",
+  "discord",
+  "teams",
+  "sharepoint",
+  "onedrive",
+  "dropbox",
+  "box",
+  "googledrive",
+  "docusign",
+  "adobesign",
+  "mailchimp",
+  "sendgrid",
+  "twilio",
+  "stripe",
+  "shopify",
+  "quickbooks",
+  "xero",
+  "workday",
+  "successfactors",
+  "bamboohr",
+  "sap",
+  "netsuite",
+  "oracle",
+  "marketo",
+  "pardot",
+  "segment",
+  "snowflake",
+  "bigquery",
+  "redshift",
+  "databricks",
+  "tableau",
+  "powerbi"
+];
+var ACTION_VERBS = [
+  "send",
+  "post",
+  "create",
+  "update",
+  "delete",
+  "get",
+  "fetch",
+  "list",
+  "read",
+  "write",
+  "upload",
+  "download",
+  "find",
+  "add",
+  "remove",
+  "query",
+  "search",
+  "notify",
+  "publish",
+  "subscribe",
+  "trigger",
+  "watch",
+  "share",
+  "invite",
+  "schedule",
+  "assign",
+  "close",
+  "open",
+  "reply",
+  "forward",
+  "archive"
+];
+var MANAGED_HTTP_NODE_TYPE = "core.action.http.v2";
+async function loadConnectorCatalog() {
+  const keywords = new Set(STATIC_CONNECTOR_KEYWORDS);
+  const activityTokenBags = [];
+  const [err, registry] = await catchError(loadRegistry());
+  if (err) {
+    logger.debug(`Connector-binding validator: could not load IS catalog cache (${err.message}); falling back to static keyword list.`);
+    return { keywords, activityTokenBags };
+  }
+  if (!registry) {
+    return { keywords, activityTokenBags };
+  }
+  for (const connector of registry.discovered.connectors) {
+    addConnectorKeywords(connector, keywords);
+    for (const activity of connector.activities) {
+      const tokens = tokenize(activity.displayName);
+      if (tokens.size > 0) {
+        activityTokenBags.push({
+          connectorKey: connector.key,
+          connectorName: connector.name,
+          tokens
+        });
+      }
+    }
+  }
+  return { keywords, activityTokenBags };
 }
-function isConnectorWaitForEventType(nodeType) {
-  return nodeType.startsWith("uipath.connector.event");
+function addConnectorKeywords(connector, out) {
+  const keyParts = connector.key.toLowerCase().split("-").filter((p) => p && p !== "uipath");
+  for (const part of keyParts)
+    out.add(part);
+  for (const t of tokenize(connector.name))
+    out.add(t);
 }
-function isEventDrivenConnectorType(nodeType) {
-  return isConnectorTriggerType(nodeType) || isConnectorWaitForEventType(nodeType);
+function tokenize(label) {
+  if (!label)
+    return new Set;
+  const tokens = label.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1);
+  return new Set(tokens);
 }
-
-// src/services/node-validators/connector-validator.ts
-var connectorNodeValidator = {
-  id: "uipath-connector",
-  appliesTo: (node) => node.type?.startsWith("uipath.connector") ?? false,
-  validate: (node) => {
-    const rawDetail = node.inputs?.detail;
-    if (!rawDetail || typeof rawDetail !== "object" || Array.isArray(rawDetail)) {
-      return [];
-    }
-    const detail = rawDetail;
-    if (Object.keys(detail).length === 0)
-      return [];
-    const isEventDriven = isEventDrivenConnectorType(node.type);
-    const context = {
-      nodeId: node.id,
-      nodeKind: isEventDriven ? "trigger" : "activity",
-      connectionId: detail.connectionId,
-      folderKey: detail.connectionFolderKey,
-      objectName: detail.objectName ?? detail.connector,
-      httpMethod: detail.method,
-      endpoint: detail.endpoint,
-      eventMode: detail.eventMode,
-      eventType: detail.eventType,
-      bodyParameters: detail.bodyParameters,
-      queryParameters: detail.queryParameters,
-      pathParameters: detail.pathParameters,
-      eventParameters: detail.eventParameters,
-      configuration: detail.configuration
-    };
-    const issues = validateIntSvcNode(context).map((issue) => ({
-      path: `nodes[${node.id}].inputs.detail`,
-      message: issue.title,
-      severity: issue.type === "Error" ? "error" : "warning"
-    }));
-    issues.push(...validateCeqlFilterShape(node.id, detail));
-    return issues;
+function readNodeLabel(node) {
+  const fromDisplay = node.display?.label;
+  if (typeof fromDisplay === "string" && fromDisplay.length > 0) {
+    return fromDisplay;
   }
-};
-function validateCeqlFilterShape(nodeId, detail) {
-  const issues = [];
-  const queryParameters = readObjectField(detail, "queryParameters");
-  if (queryParameters && Object.hasOwn(queryParameters, "$where")) {
-    issues.push({
-      path: `nodes[${nodeId}].inputs.detail.queryParameters["$where"]`,
-      severity: "error",
-      message: 'Connector node uses OData-style `"$where"` (with leading `$`) ' + "in queryParameters. CEQL uses bare `where` — rename the key " + 'from `"$where"` to `"where"`. The leading `$` is the OData ' + "system-query-option prefix and is not recognized by " + "uipath.connector.* nodes. See uipath-maestro-flow skill — " + 'plugins/connector/impl.md, "Hand-authored CEQL strings" ' + "(MST-9265)."
-    });
+  const fromName = node.name;
+  if (typeof fromName === "string" && fromName.length > 0) {
+    return fromName;
   }
-  const queryWhere = queryParameters?.where;
-  const queryWhereAuthored = isNonEmptyString(queryWhere);
-  const queryWhereIsWholeValueExpression = typeof queryWhere === "string" && queryWhere.startsWith("=js:");
-  const savedTrees = readObjectField(detail, "savedFilterTrees") ?? readEssentialSavedFilterTrees(detail);
-  const savedWhereAuthored = savedTrees !== undefined && isNonEmptyObject(savedTrees.where);
-  if (queryWhereAuthored && !queryWhereIsWholeValueExpression && !savedWhereAuthored) {
-    issues.push({
-      path: `nodes[${nodeId}].inputs.detail.savedFilterTrees.where`,
-      severity: "error",
-      message: "Connector node has `queryParameters.where` set but no " + "matching `savedFilterTrees.where` AST — neither at " + "`inputs.detail.savedFilterTrees.where` nor as " + "`essentialConfiguration.savedFilterTrees.where` inside " + "`inputs.detail.configuration`. CEQL filters must be authored " + "as both the raw filter expression (`queryParameters.where`) " + "AND a parallel canonical AST (`filters[].id` / `.operator` / " + "`.value.value`). The Studio Web canvas needs the AST to " + "render the filter UI; the runtime needs the expression. " + "Re-run `uip maestro flow node configure --detail.filter` to " + "author both. See uipath-maestro-flow skill — " + 'plugins/connector/impl.md, "Hand-authored CEQL strings" ' + "(MST-9265)."
-    });
+  return;
+}
+function hasConnectorBinding(node) {
+  const detail = node.inputs?.detail;
+  if (!detail || typeof detail !== "object" || Array.isArray(detail)) {
+    return false;
   }
-  if (savedWhereAuthored && !queryWhereAuthored) {
-    issues.push({
-      path: `nodes[${nodeId}].inputs.detail.queryParameters.where`,
-      severity: "error",
-      message: "Connector node has `savedFilterTrees.where` AST but no " + "matching `queryParameters.where` expression. CEQL filters " + "must be authored on both keys in parallel — the runtime " + "evaluates `queryParameters.where`, not the AST. See " + 'uipath-maestro-flow skill — plugins/connector/impl.md, "Hand-authored ' + 'CEQL strings" (MST-9265).'
-    });
+  const d = detail;
+  const authentication = d.authentication;
+  if (authentication === "connector") {
+    const connectionId = d.connectionId;
+    const targetConnector = d.targetConnector;
+    return typeof connectionId === "string" && connectionId.length > 0 && connectionId !== "ImplicitConnection" && typeof targetConnector === "string" && targetConnector.length > 0;
   }
-  return issues;
-}
-function readEssentialSavedFilterTrees(detail) {
-  const configuration = detail.configuration;
-  if (typeof configuration !== "string")
-    return;
-  const [, parsed] = catchError(() => JSON.parse(configuration.replace(/^=jsonString:/, "")));
-  if (!parsed)
-    return;
-  const essentialConfiguration = readObjectField(parsed, "essentialConfiguration");
-  if (!essentialConfiguration)
-    return;
-  return readObjectField(essentialConfiguration, "savedFilterTrees");
-}
-function readObjectField(parent, key) {
-  const value = parent[key];
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return;
+  if (authentication === "manual") {
+    const url = d.url;
+    return typeof url === "string" && url.length > 0;
   }
-  return value;
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function isNonEmptyObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+  return false;
 }
-
-// src/services/node-validators/activity-type-id-validator.ts
-var activityTypeIdValidator = {
-  id: "activity-type-id",
-  appliesTo: (node) => {
-    const t = node.type;
-    if (!t)
-      return false;
-    return t === "core.action.http.v2" || t.startsWith("uipath.connector.");
-  },
+function classifyLabel(label, catalog) {
+  const tokens = tokenize(label);
+  if (tokens.size === 0)
+    return null;
+  for (const bag of catalog.activityTokenBags) {
+    let overlap = 0;
+    for (const t of bag.tokens) {
+      if (tokens.has(t))
+        overlap += 1;
+    }
+    if (overlap >= 2) {
+      const keyword = pickConnectorKeyword(tokens, catalog.keywords);
+      return {
+        connectorKeyword: keyword ?? bag.connectorKey,
+        matchedActivity: {
+          connectorKey: bag.connectorKey,
+          connectorName: bag.connectorName
+        }
+      };
+    }
+  }
+  const matchedKeyword = pickConnectorKeyword(tokens, catalog.keywords);
+  if (!matchedKeyword)
+    return null;
+  const hasVerb = [...tokens].some((t) => ACTION_VERBS.includes(t));
+  if (!hasVerb)
+    return null;
+  return { connectorKeyword: matchedKeyword };
+}
+function pickConnectorKeyword(tokens, keywords) {
+  for (const t of tokens) {
+    if (keywords.has(t))
+      return t;
+  }
+  return;
+}
+function buildDiagnosticMessage(label, classification, strict) {
+  const connectorHint = classification.matchedActivity ? `looks like a "${classification.matchedActivity.connectorName}" connector activity` : `mentions the "${classification.connectorKeyword}" connector keyword`;
+  const strictNote = strict ? " (--strict-bindings promoted this to an error.)" : " Pass `--strict-bindings` to fail validation on this.";
+  const connectorDetail = `{"authentication":"connector",` + `"targetConnector":"${classification.connectorKeyword}",` + `"connectionId":"<uuid>","folderKey":"<uuid>","method":"GET","url":"<path>"}`;
+  const manualDetail = `{"authentication":"manual","method":"GET","url":"https://…"}`;
+  return `Node "${label}" ${connectorHint} but uses the generic Managed HTTP type \`${MANAGED_HTTP_NODE_TYPE}\` ` + "with no connection binding. The runtime will issue a raw HTTP call to an undefined endpoint. " + `Either bind a real Integration Service connection with \`uip maestro flow node configure <file> <node-id> --detail '${connectorDetail}'\`, ` + `or configure manual-mode HTTP with \`--detail '${manualDetail}'\`. ` + "If this node is intentionally a raw HTTP call, rename it so the label doesn't " + `imply a connector binding.${strictNote}`;
+}
+function validateConnectorBindings(workflow, catalog, options = {}) {
+  const issues = [];
+  const severity = options.strict ? "error" : "warning";
+  const checkNode = (node, scope) => {
+    if (node.type !== MANAGED_HTTP_NODE_TYPE)
+      return;
+    if (hasConnectorBinding(node))
+      return;
+    const label = readNodeLabel(node);
+    if (!label)
+      return;
+    const classification = classifyLabel(label, catalog);
+    if (!classification)
+      return;
+    issues.push({
+      path: `${scope}nodes[${node.id}].inputs.detail`,
+      severity,
+      message: buildDiagnosticMessage(label, classification, options.strict === true)
+    });
+  };
+  for (const node of workflow.nodes) {
+    checkNode(node, "");
+  }
+  for (const [subflowId, sub] of Object.entries(workflow.subflows ?? {})) {
+    for (const node of sub.nodes ?? []) {
+      checkNode(node, `subflows[${subflowId}].`);
+    }
+  }
+  return issues;
+}
+
+// src/services/expression-validator.ts
+var catalogRegistered = false;
+async function ensureCatalogRegistered() {
+  if (catalogRegistered || !instance.isInitialized)
+    return;
+  try {
+    const { registerFlowExpressionModelI18n } = await import("./localization-h8a53z6p.js");
+    registerFlowExpressionModelI18n(instance);
+  } catch (error) {
+    logger.warn(`Expression type checking localization unavailable, falling back to English: ${extractErrorMessageSync(error)}`);
+  }
+  catalogRegistered = true;
+}
+var headlessModule;
+function loadHeadless() {
+  headlessModule ??= import("./headless-h1myzz32.js").then((mod) => {
+    logger.info(`Expression type checking: @uipath/flow-expression-model (TypeScript ${mod.HEADLESS_TYPESCRIPT_VERSION})`);
+    return mod;
+  }).catch((error) => {
+    logger.warn(`Expression type checking unavailable, skipping: ${extractErrorMessageSync(error)}`);
+    return null;
+  });
+  return headlessModule;
+}
+function findingPath(finding) {
+  if (!finding.nodeId)
+    return finding.fieldPath ?? "(workflow)";
+  if (!finding.fieldPath)
+    return `nodes[${finding.nodeId}]`;
+  return `nodes[${finding.nodeId}].${finding.fieldPath}`;
+}
+async function validateExpressions(graph, pathPrefix, strict = false) {
+  await ensureCatalogRegistered();
+  const headless = await loadHeadless();
+  if (!headless)
+    return [];
+  const [error, findings] = await catchError(headless.checkWorkflowExpressionsHeadless(graph));
+  if (error || !findings) {
+    logger.warn(`Expression type checking failed, skipping: ${extractErrorMessageSync(error)}`);
+    return [];
+  }
+  return findings.map((finding) => ({
+    path: `${pathPrefix}${findingPath(finding)}`,
+    message: `[${finding.code}] ${finding.message}`,
+    severity: strict ? "error" : "warning"
+  }));
+}
+
+// src/services/node-validators/activity-type-id-validator.ts
+var activityTypeIdValidator = {
+  id: "activity-type-id",
+  appliesTo: (node) => {
+    const t = node.type;
+    if (!t)
+      return false;
+    return t === "core.action.http.v2" || t.startsWith("uipath.connector.");
+  },
   validate: (node) => {
     const rawDetail = node.inputs?.detail;
     if (!rawDetail || typeof rawDetail !== "object" || Array.isArray(rawDetail)) {
@@ -5827,97 +6017,153 @@ var ceqlQueryValidator = {
   }
 };
 
-// src/services/node-validators/cross-node-binding-validator.ts
-var IDENTIFIER_ROOT_RE = /(?<![.\w$])([A-Za-z_$][\w$]*)\.(?!\.)/g;
-function findCrossNodeBindingReferences(value, nodeIds) {
-  if (nodeIds.size === 0)
-    return [];
-  const trimmed = value.trimStart();
-  if (!trimmed.startsWith("=js:"))
-    return [];
-  const body = trimmed.slice(4);
-  const referenced = new Set;
-  const fixedBody = body.replace(IDENTIFIER_ROOT_RE, (match, identifier) => {
-    if (!nodeIds.has(identifier))
-      return match;
-    referenced.add(identifier);
-    return `$vars.${match}`;
-  });
-  if (referenced.size === 0)
-    return [];
-  const fixedValue = `=js:${fixedBody}`;
-  return [...referenced].map((nodeId) => ({ nodeId, fixedValue }));
+// src/services/node-validators/connector-validator.ts
+var connectorNodeValidator = {
+  id: "uipath-connector",
+  appliesTo: (node) => node.type?.startsWith("uipath.connector") ?? false,
+  validate: (node) => {
+    const rawDetail = node.inputs?.detail;
+    const emptyDetailWarning = {
+      path: `nodes[${node.id}].inputs.detail`,
+      severity: "warning",
+      message: "Connector is not configured, no detail found. " + "Run `uip maestro flow node configure <file> <node-id> " + `--detail '{"connectionId":"<id>","folderKey":"<key>",...}'\` ` + "to bind an Integration Service connection."
+    };
+    if (!rawDetail || typeof rawDetail !== "object" || Array.isArray(rawDetail)) {
+      return [emptyDetailWarning];
+    }
+    const detail = rawDetail;
+    if (Object.keys(detail).length === 0)
+      return [emptyDetailWarning];
+    const isEventDriven = isEventDrivenConnectorType(node.type);
+    const context = {
+      nodeId: node.id,
+      nodeKind: isEventDriven ? "trigger" : "activity",
+      connectionId: detail.connectionId,
+      folderKey: detail.connectionFolderKey,
+      objectName: detail.objectName ?? detail.connector,
+      httpMethod: detail.method,
+      endpoint: detail.endpoint,
+      eventMode: detail.eventMode,
+      eventType: detail.eventType,
+      bodyParameters: detail.bodyParameters,
+      queryParameters: detail.queryParameters,
+      pathParameters: detail.pathParameters,
+      eventParameters: detail.eventParameters,
+      configuration: detail.configuration
+    };
+    const issues = validateIntSvcNode(context).map((issue) => ({
+      path: `nodes[${node.id}].inputs.detail`,
+      message: issue.title,
+      severity: issue.type === "Error" ? "error" : "warning"
+    }));
+    issues.push(...validateCeqlFilterShape(node.id, detail));
+    if (!isEventDriven) {
+      issues.push(...validateEndpointMatchesActivityPath(node.id, detail));
+    }
+    return issues;
+  }
+};
+function staticSegments(path, substitutedValues) {
+  const cut = path.search(/[?#]/);
+  return (cut === -1 ? path : path.slice(0, cut)).split("/").filter((seg) => seg.length > 0).filter((seg) => !(seg.startsWith("{") && seg.endsWith("}"))).filter((seg) => !substitutedValues.has(seg));
 }
-function crossNodeBindingMessage(originalValue, ref2) {
-  return `Expression "${originalValue}" references node "${ref2.nodeId}" without the "$vars." prefix — ` + `cross-node outputs resolve to undefined at runtime (the bare identifier reads as an ` + `undeclared local, not the runtime variable). Use "${ref2.fixedValue}" instead. ` + "See uipath-maestro-flow skill — node-output-wiring.md (FPD-538).";
+function endpointNamesActivity(endpointSegments, activitySegments) {
+  const extra = endpointSegments.length - activitySegments.length;
+  if (extra < 0 || extra > 1)
+    return false;
+  return activitySegments.every((seg, i2) => seg === endpointSegments[i2]);
 }
-function scanContainerForCrossNodeBindings(obj, path, nodeIds, severity, issues) {
-  if (typeof obj === "string") {
-    for (const ref2 of findCrossNodeBindingReferences(obj, nodeIds)) {
-      issues.push({
-        path,
-        severity,
-        message: crossNodeBindingMessage(obj, ref2)
-      });
-    }
+function readEssentialConfiguration(detail) {
+  const configuration = detail.configuration;
+  if (typeof configuration !== "string")
     return;
-  }
-  if (Array.isArray(obj)) {
-    for (let i2 = 0;i2 < obj.length; i2++) {
-      scanContainerForCrossNodeBindings(obj[i2], `${path}[${i2}]`, nodeIds, severity, issues);
-    }
+  const [, parsed] = catchError(() => JSON.parse(configuration.replace(/^=jsonString:/, "")));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     return;
   }
-  if (obj && typeof obj === "object") {
-    for (const [key, value] of Object.entries(obj)) {
-      scanContainerForCrossNodeBindings(value, `${path}.${key}`, nodeIds, severity, issues);
+  return readObjectField(parsed, "essentialConfiguration");
+}
+function readEssentialPath(detail) {
+  const path = readEssentialConfiguration(detail)?.path;
+  return typeof path === "string" && path.length > 0 ? path : undefined;
+}
+function validateEndpointMatchesActivityPath(nodeId, detail) {
+  const endpoint = detail.endpoint;
+  if (typeof endpoint !== "string" || endpoint.length === 0)
+    return [];
+  const activityPath = readEssentialPath(detail);
+  if (!activityPath)
+    return [];
+  const substituted = new Set;
+  const pathParameters = detail.pathParameters;
+  if (pathParameters && typeof pathParameters === "object") {
+    for (const v of Object.values(pathParameters)) {
+      if (typeof v === "string" || typeof v === "number") {
+        substituted.add(String(v));
+      }
     }
   }
-}
-var PARAMETER_CONTAINER_KEYS = [
-  "bodyParameters",
-  "queryParameters",
-  "pathParameters"
-];
-function scanDetailForCrossNodeBindings(detail, nodeIds, severity = "warning") {
-  if (!detail || nodeIds.size === 0)
+  if (endpointNamesActivity(staticSegments(endpoint, substituted), staticSegments(activityPath, substituted))) {
     return [];
-  const issues = [];
-  for (const containerKey of PARAMETER_CONTAINER_KEYS) {
-    const container = detail[containerKey];
-    if (!container || typeof container !== "object" || Array.isArray(container)) {
-      continue;
+  }
+  return [
+    {
+      path: `nodes[${nodeId}].inputs.detail.endpoint`,
+      severity: "warning",
+      message: `endpoint "${endpoint}" does not name the activity this node is configured for — its path is "${activityPath}" ` + "(essentialConfiguration.path). The runtime calls the endpoint verbatim, so the request reaches a different operation and fails at debug " + "with the provider's words for a missing or unknown field (e.g. Slack [102003] no_text when the v1 endpoint receives the v2 body). " + `Re-run node configure with --detail.endpoint "${activityPath}" (keep {param} segments; values go in pathParameters).`
     }
-    scanContainerForCrossNodeBindings(container, `detail.${containerKey}`, nodeIds, severity, issues);
+  ];
+}
+function validateCeqlFilterShape(nodeId, detail) {
+  const issues = [];
+  const queryParameters = readObjectField(detail, "queryParameters");
+  if (queryParameters && Object.hasOwn(queryParameters, "$where")) {
+    issues.push({
+      path: `nodes[${nodeId}].inputs.detail.queryParameters["$where"]`,
+      severity: "error",
+      message: 'Connector node uses OData-style `"$where"` (with leading `$`) ' + "in queryParameters. CEQL uses bare `where` — rename the key " + 'from `"$where"` to `"where"`. The leading `$` is the OData ' + "system-query-option prefix and is not recognized by " + "uipath.connector.* nodes. See uipath-maestro-flow skill — " + 'plugins/connector/impl.md, "Hand-authored CEQL strings" ' + "(MST-9265)."
+    });
+  }
+  const queryWhere = queryParameters?.where;
+  const queryWhereAuthored = isNonEmptyString(queryWhere);
+  const queryWhereIsWholeValueExpression = typeof queryWhere === "string" && queryWhere.startsWith("=js:");
+  const savedTrees = readObjectField(detail, "savedFilterTrees") ?? readEssentialSavedFilterTrees(detail);
+  const savedWhereAuthored = savedTrees !== undefined && isNonEmptyObject(savedTrees.where);
+  if (queryWhereAuthored && !queryWhereIsWholeValueExpression && !savedWhereAuthored) {
+    issues.push({
+      path: `nodes[${nodeId}].inputs.detail.savedFilterTrees.where`,
+      severity: "error",
+      message: "Connector node has `queryParameters.where` set but no " + "matching `savedFilterTrees.where` AST — neither at " + "`inputs.detail.savedFilterTrees.where` nor as " + "`essentialConfiguration.savedFilterTrees.where` inside " + "`inputs.detail.configuration`. CEQL filters must be authored " + "as both the raw filter expression (`queryParameters.where`) " + "AND a parallel canonical AST (`filters[].id` / `.operator` / " + "`.value.value`). The Studio Web canvas needs the AST to " + "render the filter UI; the runtime needs the expression. " + "Re-run `uip maestro flow node configure --detail.filter` to " + "author both. See uipath-maestro-flow skill — " + 'plugins/connector/impl.md, "Hand-authored CEQL strings" ' + "(MST-9265)."
+    });
+  }
+  if (savedWhereAuthored && !queryWhereAuthored) {
+    issues.push({
+      path: `nodes[${nodeId}].inputs.detail.queryParameters.where`,
+      severity: "error",
+      message: "Connector node has `savedFilterTrees.where` AST but no " + "matching `queryParameters.where` expression. CEQL filters " + "must be authored on both keys in parallel — the runtime " + "evaluates `queryParameters.where`, not the AST. See " + 'uipath-maestro-flow skill — plugins/connector/impl.md, "Hand-authored ' + 'CEQL strings" (MST-9265).'
+    });
   }
   return issues;
 }
-var crossNodeBindingValidator = {
-  id: "cross-node-binding",
-  appliesTo: (node) => {
-    const t = node.type;
-    if (!t)
-      return false;
-    if (isEventDrivenConnectorType(t))
-      return false;
-    return t.startsWith("uipath.connector.") || t === "core.action.http" || t === "core.action.http.v2";
-  },
-  validate: (node, context) => {
-    const nodeIds = context.nodeIds ?? new Set;
-    if (nodeIds.size === 0)
-      return [];
-    const rawDetail = node.inputs?.detail;
-    if (!rawDetail || typeof rawDetail !== "object" || Array.isArray(rawDetail)) {
-      return [];
-    }
-    const severity = context.strictBindings ? "error" : "warning";
-    const issues = scanDetailForCrossNodeBindings(rawDetail, nodeIds, severity);
-    return issues.map((issue) => ({
-      ...issue,
-      path: `nodes[${node.id}].inputs.${issue.path}`
-    }));
+function readEssentialSavedFilterTrees(detail) {
+  const essentialConfiguration = readEssentialConfiguration(detail);
+  if (!essentialConfiguration)
+    return;
+  return readObjectField(essentialConfiguration, "savedFilterTrees");
+}
+function readObjectField(parent, key) {
+  const value = parent[key];
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
   }
-};
+  return value;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isNonEmptyObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
 
 // src/services/node-validators/expression-prefix-validator.ts
 var expressionPrefixValidator = {
@@ -6098,7 +6344,8 @@ var jsExpressionSyntaxValidator = {
     for (const containerKey of [
       "bodyParameters",
       "queryParameters",
-      "pathParameters"
+      "pathParameters",
+      "filterVariables"
     ]) {
       const container = detail[containerKey];
       if (!container || typeof container !== "object" || Array.isArray(container)) {
@@ -6147,1632 +6394,561 @@ function scanForInvalidJsExpressions(obj, path, severity, issues) {
     }
     return;
   }
-  if (obj && typeof obj === "object") {
-    for (const [key, value] of Object.entries(obj)) {
-      scanForInvalidJsExpressions(value, `${path}.${key}`, severity, issues);
-    }
-  }
-}
-function reportInvalidExpression(expression, path, severity, issues) {
-  if (expression.trim() === "")
-    return;
-  const error = syntaxErrorFrom(() => parse3(`(${expression}
-)`, {
-    ecmaVersion: 2020,
-    sourceType: "script"
-  }));
-  if (!error)
-    return;
-  issues.push({
-    path,
-    severity,
-    message: `Expression at this field is not valid JavaScript: ${error.message}. Fix the syntax — validate cannot otherwise catch JavaScript expression errors; they surface only at flow debug.`
-  });
-}
-function syntaxErrorFrom(parseSource) {
-  try {
-    parseSource();
-    return;
-  } catch (err) {
-    return err instanceof Error ? err : new Error(String(err));
-  }
-}
-
-// src/services/node-validators/model-source-validator.ts
-var modelSourceValidator = {
-  id: "model-source",
-  appliesTo: () => true,
-  validate: (node, context) => {
-    const definition = context.definitions.find((d) => d.nodeType === node.type);
-    if (!definition)
-      return [];
-    const requiresModelSource = readModelSourceFlag(definition);
-    if (!requiresModelSource)
-      return [];
-    const legacySource = readLegacyModelSource(node);
-    if (legacySource !== undefined) {
-      return [
-        {
-          path: `nodes[${node.id}].model.source`,
-          severity: "error",
-          message: `Node type "${node.type}" carries the deprecated ` + `"model.source" UUID on the node instance. ` + `flow-core 0.2.50+ requires the canvas-generated ` + `UUID at "inputs.source"; remove "model.source" ` + `from the node and place the value under ` + `"inputs": { "source": "<uuid>" } instead. ` + `See uipath-maestro-flow skill — ` + `inline-agent/impl.md (MST-9265).`
-        }
-      ];
-    }
-    const inputsSource = node.inputs?.source;
-    if (typeof inputsSource === "string" && inputsSource.length > 0) {
-      return [];
-    }
-    return [
-      {
-        path: `nodes[${node.id}].inputs.source`,
-        severity: "error",
-        message: `Node type "${node.type}" requires a stable UUID at ` + `"inputs.source" — the agent's ProjectId for inline ` + `agent nodes, or the resource id from the parent inline ` + `agent's "resources[]" for agent-tool resource nodes. ` + `Set "inputs": { "source": "<uuid>" } on the node ` + `(use the ProjectId returned by ` + `"uip agent init --inline-in-flow" for inline agents). ` + `See uipath-maestro-flow skill — inline-agent/impl.md ` + `(MST-9265).`
-      }
-    ];
-  }
-};
-function readModelSourceFlag(definition) {
-  const model = definition.model;
-  if (!model || typeof model !== "object" || Array.isArray(model)) {
-    return false;
-  }
-  const source = model.source;
-  return source === true;
-}
-function readLegacyModelSource(node) {
-  const model = node.model;
-  if (!model || typeof model !== "object" || Array.isArray(model)) {
-    return;
-  }
-  const source = model.source;
-  if (typeof source === "string" && source.length > 0) {
-    return source;
-  }
-  return;
-}
-
-// src/services/node-validators/index.ts
-var defaultNodeValidators = [
-  activityTypeIdValidator,
-  ceqlQueryValidator,
-  connectorNodeValidator,
-  crossNodeBindingValidator,
-  expressionPrefixValidator,
-  jsExpressionSyntaxValidator,
-  ixpNodeValidator,
-  modelSourceValidator
-];
-
-// src/utils/error-edge-handling.ts
-var ERROR_SOURCE_PORT = "error";
-function collectErrorEdgeSourceNodeIds(edges) {
-  return new Set(edges.filter((edge) => edge.sourcePort === ERROR_SOURCE_PORT).map((edge) => edge.sourceNodeId));
-}
-function enableErrorHandlingForErrorEdges(nodes, edges) {
-  const sourceNodeIds = collectErrorEdgeSourceNodeIds(edges);
-  let updated = 0;
-  for (const node of nodes) {
-    if (!sourceNodeIds.has(node.id))
-      continue;
-    if (node.inputs?.errorHandlingEnabled === true)
-      continue;
-    node.inputs = {
-      ...node.inputs ?? {},
-      errorHandlingEnabled: true
-    };
-    updated += 1;
-  }
-  return updated;
-}
-
-// src/utils/handle-expansion.ts
-var VISIBLE_INPUT_EXPRESSION = /^\{inputs\.([A-Za-z0-9_]+)\}$/;
-function parseVisibleInputKey(visible) {
-  if (typeof visible !== "string")
-    return null;
-  const match = VISIBLE_INPUT_EXPRESSION.exec(visible);
-  return match ? match[1] : null;
-}
-function isHandleVisible(handle, node) {
-  const { visible } = handle;
-  if (visible === undefined || visible === true)
-    return true;
-  if (visible === false)
-    return false;
-  const inputKey = parseVisibleInputKey(visible);
-  if (inputKey === null) {
-    return true;
-  }
-  return node.inputs?.[inputKey] === true;
-}
-function expandHandleIds(handle, node) {
-  if (!handle.repeat) {
-    return [handle.id];
-  }
-  const repeatPath = handle.repeat.split(".");
-  let collection = node;
-  for (const segment of repeatPath) {
-    if (collection && typeof collection === "object") {
-      collection = collection[segment];
-    } else {
-      collection = undefined;
-      break;
-    }
-  }
-  if (!Array.isArray(collection)) {
-    return [handle.id];
-  }
-  return collection.filter((item) => item != null && typeof item === "object").map((item) => handle.id.replace(/\{item\.(\w+)\}/g, (_match, key) => String(item[key] ?? "")));
-}
-function isTemplatedHandleId(id) {
-  return id.includes("{");
-}
-var escapeRegexMetachars = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-function portMatchesTemplate(requestedPort, templateId) {
-  if (!isTemplatedHandleId(templateId)) {
-    return requestedPort === templateId;
-  }
-  const parts = templateId.split(/\{[^}]*\}/);
-  const escapedParts = parts.map(escapeRegexMetachars);
-  const pattern = new RegExp(`^${escapedParts.join(".+")}$`);
-  return pattern.test(requestedPort);
-}
-
-// src/services/connector-binding-validator.ts
-var STATIC_CONNECTOR_KEYWORDS = [
-  "slack",
-  "gmail",
-  "outlook",
-  "office365",
-  "exchange",
-  "jira",
-  "confluence",
-  "salesforce",
-  "sfdc",
-  "hubspot",
-  "servicenow",
-  "zendesk",
-  "intercom",
-  "notion",
-  "asana",
-  "trello",
-  "monday",
-  "github",
-  "gitlab",
-  "bitbucket",
-  "discord",
-  "teams",
-  "sharepoint",
-  "onedrive",
-  "dropbox",
-  "box",
-  "googledrive",
-  "docusign",
-  "adobesign",
-  "mailchimp",
-  "sendgrid",
-  "twilio",
-  "stripe",
-  "shopify",
-  "quickbooks",
-  "xero",
-  "workday",
-  "successfactors",
-  "bamboohr",
-  "sap",
-  "netsuite",
-  "oracle",
-  "marketo",
-  "pardot",
-  "segment",
-  "snowflake",
-  "bigquery",
-  "redshift",
-  "databricks",
-  "tableau",
-  "powerbi"
-];
-var ACTION_VERBS = [
-  "send",
-  "post",
-  "create",
-  "update",
-  "delete",
-  "get",
-  "fetch",
-  "list",
-  "read",
-  "write",
-  "upload",
-  "download",
-  "find",
-  "add",
-  "remove",
-  "query",
-  "search",
-  "notify",
-  "publish",
-  "subscribe",
-  "trigger",
-  "watch",
-  "share",
-  "invite",
-  "schedule",
-  "assign",
-  "close",
-  "open",
-  "reply",
-  "forward",
-  "archive"
-];
-var MANAGED_HTTP_NODE_TYPE = "core.action.http.v2";
-async function loadConnectorCatalog() {
-  const keywords2 = new Set(STATIC_CONNECTOR_KEYWORDS);
-  const activityTokenBags = [];
-  const [err, registry] = await catchError(loadRegistry());
-  if (err) {
-    logger.debug(`Connector-binding validator: could not load IS catalog cache (${err.message}); falling back to static keyword list.`);
-    return { keywords: keywords2, activityTokenBags };
-  }
-  if (!registry) {
-    return { keywords: keywords2, activityTokenBags };
-  }
-  for (const connector of registry.discovered.connectors) {
-    addConnectorKeywords(connector, keywords2);
-    for (const activity of connector.activities) {
-      const tokens = tokenize(activity.displayName);
-      if (tokens.size > 0) {
-        activityTokenBags.push({
-          connectorKey: connector.key,
-          connectorName: connector.name,
-          tokens
-        });
-      }
-    }
-  }
-  return { keywords: keywords2, activityTokenBags };
-}
-function addConnectorKeywords(connector, out) {
-  const keyParts = connector.key.toLowerCase().split("-").filter((p) => p && p !== "uipath");
-  for (const part of keyParts)
-    out.add(part);
-  for (const t of tokenize(connector.name))
-    out.add(t);
-}
-function tokenize(label) {
-  if (!label)
-    return new Set;
-  const tokens = label.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 1);
-  return new Set(tokens);
-}
-function readNodeLabel(node) {
-  const fromDisplay = node.display?.label;
-  if (typeof fromDisplay === "string" && fromDisplay.length > 0) {
-    return fromDisplay;
-  }
-  const fromName = node.name;
-  if (typeof fromName === "string" && fromName.length > 0) {
-    return fromName;
-  }
-  return;
-}
-function hasConnectorBinding(node) {
-  const detail = node.inputs?.detail;
-  if (!detail || typeof detail !== "object" || Array.isArray(detail)) {
-    return false;
-  }
-  const d = detail;
-  const authentication = d.authentication;
-  if (authentication === "connector") {
-    const connectionId = d.connectionId;
-    const targetConnector = d.targetConnector;
-    return typeof connectionId === "string" && connectionId.length > 0 && connectionId !== "ImplicitConnection" && typeof targetConnector === "string" && targetConnector.length > 0;
-  }
-  if (authentication === "manual") {
-    const url = d.url;
-    return typeof url === "string" && url.length > 0;
-  }
-  return false;
-}
-function classifyLabel(label, catalog) {
-  const tokens = tokenize(label);
-  if (tokens.size === 0)
-    return null;
-  for (const bag of catalog.activityTokenBags) {
-    let overlap = 0;
-    for (const t of bag.tokens) {
-      if (tokens.has(t))
-        overlap += 1;
-    }
-    if (overlap >= 2) {
-      const keyword = pickConnectorKeyword(tokens, catalog.keywords);
-      return {
-        connectorKeyword: keyword ?? bag.connectorKey,
-        matchedActivity: {
-          connectorKey: bag.connectorKey,
-          connectorName: bag.connectorName
-        }
-      };
-    }
-  }
-  const matchedKeyword = pickConnectorKeyword(tokens, catalog.keywords);
-  if (!matchedKeyword)
-    return null;
-  const hasVerb = [...tokens].some((t) => ACTION_VERBS.includes(t));
-  if (!hasVerb)
-    return null;
-  return { connectorKeyword: matchedKeyword };
-}
-function pickConnectorKeyword(tokens, keywords2) {
-  for (const t of tokens) {
-    if (keywords2.has(t))
-      return t;
-  }
-  return;
-}
-function buildDiagnosticMessage(label, classification, strict) {
-  const connectorHint = classification.matchedActivity ? `looks like a "${classification.matchedActivity.connectorName}" connector activity` : `mentions the "${classification.connectorKeyword}" connector keyword`;
-  const strictNote = strict ? " (--strict-bindings promoted this to an error.)" : " Pass `--strict-bindings` to fail validation on this.";
-  const connectorDetail = `{"authentication":"connector",` + `"targetConnector":"${classification.connectorKeyword}",` + `"connectionId":"<uuid>","folderKey":"<uuid>","method":"GET","url":"<path>"}`;
-  const manualDetail = `{"authentication":"manual","method":"GET","url":"https://…"}`;
-  return `Node "${label}" ${connectorHint} but uses the generic Managed HTTP type \`${MANAGED_HTTP_NODE_TYPE}\` ` + "with no connection binding. The runtime will issue a raw HTTP call to an undefined endpoint. " + `Either bind a real Integration Service connection with \`uip maestro flow node configure <file> <node-id> --detail '${connectorDetail}'\`, ` + `or configure manual-mode HTTP with \`--detail '${manualDetail}'\`. ` + "If this node is intentionally a raw HTTP call, rename it so the label doesn't " + `imply a connector binding.${strictNote}`;
-}
-function validateConnectorBindings(workflow, catalog, options = {}) {
-  const issues = [];
-  const severity = options.strict ? "error" : "warning";
-  const checkNode = (node, scope) => {
-    if (node.type !== MANAGED_HTTP_NODE_TYPE)
-      return;
-    if (hasConnectorBinding(node))
-      return;
-    const label = readNodeLabel(node);
-    if (!label)
-      return;
-    const classification = classifyLabel(label, catalog);
-    if (!classification)
-      return;
-    issues.push({
-      path: `${scope}nodes[${node.id}].inputs.detail`,
-      severity,
-      message: buildDiagnosticMessage(label, classification, options.strict === true)
-    });
-  };
-  for (const node of workflow.nodes) {
-    checkNode(node, "");
-  }
-  for (const [subflowId, sub] of Object.entries(workflow.subflows ?? {})) {
-    for (const node of sub.nodes ?? []) {
-      checkNode(node, `subflows[${subflowId}].`);
-    }
-  }
-  return issues;
-}
-
-// src/services/flow-eval-schema/prompts.ts
-var DEFAULT_EVALUATOR_PROMPT = `As an expert evaluator, analyze the semantic similarity of these JSON contents to determine a score from 0-100. Focus on comparing the meaning and contextual equivalence of corresponding fields, accounting for alternative valid expressions, synonyms, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
-----
-ExpectedOutput:
-{{ExpectedOutput}}
-----
-ActualOutput:
-{{ActualOutput}}
-`;
-var DEFAULT_TRAJECTORY_EVALUATOR_PROMPT = `As an expert evaluator, determine how well the agent did on a scale of 0-100. Focus on if the simulation was successful and if the agent behaved according to the expected output accounting for alternative valid expressions, and reasonable variations in language while maintaining high standards for accuracy and completeness. Provide your score with a justification, explaining briefly and concisely why you gave that score.
-----
-UserOrSyntheticInputGivenToAgent:
-{{UserOrSyntheticInput}}
-----
-SimulationInstructions:
-{{SimulationInstructions}}
-----
-ExpectedAgentBehavior:
-{{ExpectedAgentBehavior}}
-----
-AgentRunHistory:
-{{AgentRunHistory}}
-`;
-
-// src/services/flow-eval-schema/evaluator-fields.ts
-var targetOutputKeyConfigField = {
-  key: "targetOutputKey",
-  label: "Target Output Key",
-  type: "targetOutputKey",
-  required: false,
-  description: "The key in the output to evaluate"
-};
-var caseSensitiveConfigField = {
-  key: "caseSensitive",
-  label: "Case Sensitive",
-  type: "boolean",
-  required: false,
-  default: false,
-  description: "If true, the comparison is case-sensitive"
-};
-var negatedConfigField = {
-  key: "negated",
-  label: "Negated",
-  type: "boolean",
-  required: false,
-  default: false,
-  description: "If true, the evaluation passes when the match is not found"
-};
-var expectedOutputCriteriaField = {
-  key: "expectedOutput",
-  label: "Expected Output",
-  type: "object",
-  required: false,
-  description: "The expected output value for this evaluator"
-};
-var llmBaseConfigFields = [
-  {
-    key: "model",
-    label: "Model",
-    type: "llmModel",
-    required: true,
-    description: "The LLM model to use for judging"
-  },
-  {
-    key: "prompt",
-    label: "Evaluation Prompt",
-    type: "string",
-    required: true,
-    default: DEFAULT_EVALUATOR_PROMPT,
-    description: "Custom prompt template for the LLM judge"
-  },
-  {
-    key: "temperature",
-    label: "Temperature",
-    type: "number",
-    required: true,
-    default: 0,
-    min: 0,
-    max: 2,
-    step: 0.1,
-    description: "Temperature for LLM generation"
-  },
-  {
-    key: "maxTokens",
-    label: "Max Tokens",
-    type: "number",
-    required: true,
-    default: 8192,
-    min: 0,
-    max: 16384,
-    step: 256,
-    description: "Maximum tokens for LLM response"
-  }
-];
-var llmTrajectoryBaseConfigFields = llmBaseConfigFields.map((field) => field.key === "prompt" ? { ...field, default: DEFAULT_TRAJECTORY_EVALUATOR_PROMPT } : field);
-
-// src/services/flow-eval-schema/deterministic-evaluators.ts
-var DETERMINISTIC_EVALUATOR_TYPES = {
-  "uipath-contains": {
-    name: "Contains Text",
-    description: "Check if output contains specific text",
-    category: "deterministic",
-    shortDescription: "Passes when output contains given text",
-    configFields: [
-      targetOutputKeyConfigField,
-      caseSensitiveConfigField,
-      {
-        ...negatedConfigField,
-        label: "Negated (should NOT contain)"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "searchText",
-        label: "Search Text",
-        type: "string",
-        required: false,
-        minLength: 1,
-        description: "The text to search for in the output"
-      }
-    ],
-    examples: {
-      criteria: { searchText: "loan approved" }
-    }
-  },
-  "uipath-exact-match": {
-    name: "Exact Match",
-    description: "Check if output exactly matches expected value",
-    category: "deterministic",
-    shortDescription: "Passes when output is an exact match",
-    configFields: [
-      targetOutputKeyConfigField,
-      caseSensitiveConfigField,
-      negatedConfigField
-    ],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      criteria: { expectedOutput: { value: "Application approved" } }
-    }
-  },
-  "uipath-json-similarity": {
-    name: "JSON Similarity",
-    description: "Compare JSON output similarity",
-    category: "deterministic",
-    shortDescription: "Passes when JSON structures are similar",
-    configFields: [targetOutputKeyConfigField],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      criteria: { expectedOutput: { status: "ok" } }
-    }
-  }
-};
-
-// src/services/flow-eval-schema/llm-judge-evaluators.ts
-var LLM_JUDGE_EVALUATOR_TYPES = {
-  "uipath-llm-judge-output-semantic-similarity": {
-    name: "LLM Judge Output",
-    description: "Use LLM to judge semantic similarity of outputs",
-    category: "llm-judge",
-    shortDescription: "AI judges if output semantically matches expected",
-    configFields: [...llmBaseConfigFields, targetOutputKeyConfigField],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      config: { model: "gpt-4o", temperature: 0 },
-      criteria: {
-        expectedOutput: {
-          text: "The loan has been approved for the requested amount."
-        }
-      }
-    }
-  },
-  "uipath-llm-judge-output-strict-json-similarity": {
-    name: "LLM Judge Strict JSON",
-    description: "Use LLM to judge strict JSON similarity",
-    category: "llm-judge",
-    shortDescription: "AI judges strict JSON structural match",
-    configFields: [...llmBaseConfigFields, targetOutputKeyConfigField],
-    criteriaFields: [expectedOutputCriteriaField],
-    examples: {
-      config: { model: "gpt-4o", temperature: 0 },
-      criteria: { expectedOutput: { result: "success" } }
-    }
-  },
-  "uipath-llm-judge-trajectory-similarity": {
-    name: "LLM Judge Trajectory",
-    description: "Use LLM to judge agent trajectory and behavior",
-    category: "llm-judge",
-    shortDescription: "AI judges if agent followed expected behavior",
-    configFields: llmTrajectoryBaseConfigFields,
-    criteriaFields: [
-      {
-        key: "expectedAgentBehavior",
-        label: "Expected Agent Behavior",
-        type: "string",
-        required: false,
-        description: "Description of expected agent behavior and actions"
-      }
-    ],
-    examples: {
-      config: { model: "gpt-4o" },
-      criteria: {
-        expectedAgentBehavior: "Agent checks eligibility, then calls approval API"
-      }
-    }
-  },
-  "uipath-llm-judge-trajectory-simulation": {
-    name: "LLM Judge Simulation",
-    description: "Use LLM to judge simulation trajectory",
-    category: "llm-judge",
-    shortDescription: "AI judges simulated agent execution path",
-    configFields: llmTrajectoryBaseConfigFields,
-    criteriaFields: [
-      {
-        key: "expectedAgentBehavior",
-        label: "Expected Agent Behavior",
-        type: "string",
-        required: false,
-        description: "Description of expected agent behavior during simulation"
-      }
-    ],
-    examples: {
-      config: { model: "gpt-4o" },
-      criteria: {
-        expectedAgentBehavior: "Agent simulates the user journey through checkout flow"
-      }
-    }
-  }
-};
-
-// src/services/flow-eval-schema/tool-call-evaluators.ts
-var TOOL_CALL_EVALUATOR_TYPES = {
-  "uipath-tool-call-args": {
-    name: "Tool Call Arguments",
-    description: "Verify tool call arguments match expected values",
-    category: "tool-call",
-    shortDescription: "Checks that tools were called with correct arguments",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact match of all tool call arguments"
-      },
-      {
-        key: "subset",
-        label: "Subset Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, allows actual tool calls to be a subset of expected"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolCalls",
-        label: "Tool Calls",
-        type: "toolCallArgs",
-        required: false,
-        description: "Expected tool calls with names and arguments"
-      }
-    ]
-  },
-  "uipath-tool-call-count": {
-    name: "Tool Call Count",
-    description: "Verify tool call counts match expected values",
-    category: "tool-call",
-    shortDescription: "Checks number of times each tool was called",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact count match"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolCallsCount",
-        label: "Tool Calls Count",
-        type: "toolCallCount",
-        required: false,
-        description: "Expected tool call counts with comparison operators"
-      }
-    ]
-  },
-  "uipath-tool-call-order": {
-    name: "Tool Call Order",
-    description: "Verify tool calls occur in expected order",
-    category: "tool-call",
-    shortDescription: "Checks that tools were called in the right sequence",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact order match"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolCallsOrder",
-        label: "Tool Calls Order",
-        type: "toolCallOrder",
-        required: false,
-        description: "Tool names in expected execution order"
-      }
-    ]
-  },
-  "uipath-tool-call-output": {
-    name: "Tool Call Output",
-    description: "Verify tool call outputs match expected values",
-    category: "tool-call",
-    shortDescription: "Checks that tool outputs match expected values",
-    configFields: [
-      {
-        key: "strict",
-        label: "Strict Mode",
-        type: "boolean",
-        required: false,
-        default: false,
-        description: "If true, requires exact output match"
-      }
-    ],
-    criteriaFields: [
-      {
-        key: "toolOutputs",
-        label: "Tool Outputs",
-        type: "toolCallOutput",
-        required: false,
-        description: "Expected tool outputs with names and output values"
-      }
-    ]
-  }
-};
-
-// src/services/flow-eval-schema/registry.ts
-var EVALUATOR_TYPE_REGISTRY = {
-  ...DETERMINISTIC_EVALUATOR_TYPES,
-  ...LLM_JUDGE_EVALUATOR_TYPES,
-  ...TOOL_CALL_EVALUATOR_TYPES
-};
-var EVALUATOR_TYPE_ALIASES = {
-  "exact-match": "uipath-exact-match",
-  "json-similarity": "uipath-json-similarity",
-  contains: "uipath-contains",
-  "llm-judge-output": "uipath-llm-judge-output-semantic-similarity",
-  "llm-judge-strict-json": "uipath-llm-judge-output-strict-json-similarity",
-  "llm-judge-trajectory": "uipath-llm-judge-trajectory-similarity",
-  "llm-judge-trajectory-simulation": "uipath-llm-judge-trajectory-simulation"
-};
-
-// src/services/flow-eval-schema/helpers.ts
-function evaluatorTypeAliases() {
-  return Object.keys(EVALUATOR_TYPE_ALIASES);
-}
-function isEvaluatorTypeId(value) {
-  return value in EVALUATOR_TYPE_REGISTRY;
-}
-function getEvaluatorTypeDefinition(typeId) {
-  if (!isEvaluatorTypeId(typeId)) {
-    return null;
-  }
-  return EVALUATOR_TYPE_REGISTRY[typeId];
-}
-function resolveEvaluatorType(type) {
-  const resolved = EVALUATOR_TYPE_ALIASES[type] ?? type;
-  if (!isEvaluatorTypeId(resolved)) {
-    throw new Error(`Unknown evaluator type "${type}". Valid types: ${evaluatorTypeAliases().join(", ")}`);
-  }
-  return resolved;
-}
-function getDefaultConfigForEvaluatorType(typeId) {
-  return collectFieldDefaults(EVALUATOR_TYPE_REGISTRY[typeId].configFields);
-}
-function collectFieldDefaults(fields) {
-  const defaults = {};
-  for (const field of fields) {
-    if (field.default !== undefined) {
-      defaults[field.key] = field.default;
-    }
-  }
-  return defaults;
-}
-function evaluatorTypeHasConfigField(typeId, fieldKey) {
-  return getEvaluatorTypeDefinition(typeId)?.configFields.some((field) => field.key === fieldKey) ?? false;
-}
-function evaluatorCanUseSharedExpectedOutput(typeId) {
-  return getEvaluatorTypeDefinition(typeId)?.criteriaFields.some((field) => field.key === "expectedOutput" && field.type === "object") ?? false;
-}
-// src/services/flow-eval-utils.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-function isUUID(value) {
-  return UUID_RE.test(value);
-}
-function stripJsonExt(name) {
-  return name.endsWith(".json") ? name.slice(0, -".json".length) : name;
-}
-function slugify(text) {
-  const slug = text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  return slug || "untitled";
-}
-function getEvaluatorRef(evaluator) {
-  return stripJsonExt(evaluator.fileName ?? `${evaluator.id}.json`);
-}
-function buildEvaluatorConfig(typeId, options) {
-  const evaluatorConfig = {
-    name: options.name,
-    ...getDefaultConfigForEvaluatorType(typeId)
-  };
-  if (evaluatorTypeHasConfigField(typeId, "targetOutputKey")) {
-    evaluatorConfig.targetOutputKey = options.targetOutputKey ?? "*";
-  }
-  if (options.model !== undefined) {
-    evaluatorConfig.model = options.model;
-  }
-  if (options.prompt !== undefined) {
-    evaluatorConfig.prompt = options.prompt;
-  }
-  return evaluatorConfig;
-}
-function buildDefaultCriteria(evaluators, expectedOutput, searchText) {
-  const criterias = {};
-  for (const evaluator of evaluators) {
-    const key = evaluator.id;
-    if (expectedOutput !== undefined && evaluatorCanUseSharedExpectedOutput(evaluator.evaluatorTypeId)) {
-      criterias[key] = { expectedOutput };
-    } else if (searchText !== undefined && evaluator.evaluatorTypeId === "uipath-contains") {
-      criterias[key] = { searchText };
-    } else {
-      const defaultCriteria = evaluator.evaluatorConfig.defaultEvaluationCriteria;
-      criterias[key] = isRecord(defaultCriteria) ? defaultCriteria : null;
-    }
-  }
-  return criterias;
-}
-
-// src/services/flow-migration-check.ts
-if (!instance.isInitialized) {
-  instance.init({
-    lng: "en",
-    fallbackLng: "en",
-    defaultNS: "validation",
-    resources: {},
-    interpolation: { escapeValue: false }
-  });
-}
-registerFlowMigrationsI18n(instance);
-function captureMigrationIssues() {
-  const paths = [];
-  const tracker = {
-    trackError: (_error, _severity, details) => {
-      if (!("issues" in details))
-        return;
-      const issues = details.issues;
-      if (!Array.isArray(issues))
-        return;
-      for (const issue of issues) {
-        if (!issue || typeof issue !== "object")
-          continue;
-        if (!("path" in issue))
-          continue;
-        const path = issue.path;
-        if (Array.isArray(path) && path.length > 0) {
-          paths.push(path.map(String).join("."));
-        }
-      }
-    }
-  };
-  return { tracker, fieldPaths: () => [...new Set(paths)] };
-}
-function formatMigrationFailureMessage(step, rawMessage, fieldPaths) {
-  const parts = [`Workflow migration failed at ${step}: ${rawMessage}.`];
-  if (fieldPaths.length > 0) {
-    const shown = fieldPaths.slice(0, 10);
-    const extra = fieldPaths.length > shown.length ? `, +${fieldPaths.length - shown.length} more` : "";
-    parts.push(`Offending field(s): ${shown.join(", ")}${extra}.`);
-  }
-  parts.push("Fix the flagged field(s) or re-scaffold the affected node, then re-run.");
-  return parts.join(" ");
-}
-function checkForwardMigration(rawWorkflow) {
-  try {
-    getMigrationChain(runtimeMigrations, String(rawWorkflow.version ?? ""), runtimeVersion);
-  } catch {
-    return { ok: true };
-  }
-  const { tracker, fieldPaths } = captureMigrationIssues();
-  const result = migrateWorkflowToFloor(runtimeMigrations, rawWorkflow, runtimeVersion, minimumSupportedVersion, tracker);
-  if (!result.error)
-    return { ok: true };
-  const paths = fieldPaths();
-  return {
-    ok: false,
-    step: result.error.step,
-    rawMessage: result.error.message,
-    message: formatMigrationFailureMessage(result.error.step, result.error.message, paths),
-    fieldPaths: paths
-  };
-}
-
-// src/services/flow-eval-file-store.ts
-async function ensureDirectory(fs, path) {
-  if (await fs.exists(path)) {
-    return;
-  }
-  const parent = fs.path.dirname(path);
-  if (parent && parent !== path && !await fs.exists(parent)) {
-    await ensureDirectory(fs, parent);
-  }
-  const [error] = await catchError(fs.mkdir(path));
-  if (error && !await fs.exists(path)) {
-    throw error;
-  }
-}
-
-class FlowEvalFileStore {
-  fs;
-  constructor(fs) {
-    this.fs = fs;
-  }
-  async readJsonFiles(dir) {
-    const [readDirError, files] = await catchError(this.fs.readdir(dir));
-    if (readDirError) {
-      return [];
-    }
-    const items = [];
-    for (const file of files) {
-      if (!file.endsWith(".json")) {
-        continue;
-      }
-      const filePath = this.fs.path.join(dir, file);
-      const [readError, raw] = await catchError(this.fs.readFile(filePath, "utf-8"));
-      if (readError) {
-        throw new Error(`Failed to read JSON file "${filePath}": ${readError.message}`);
-      }
-      if (raw === null) {
-        continue;
-      }
-      const [parseError, data2] = catchError(() => JSON.parse(String(raw)));
-      if (parseError) {
-        throw new Error(`Invalid JSON in "${filePath}": ${parseError.message}`);
-      }
-      data2.fileName = file;
-      items.push(data2);
-    }
-    return items;
-  }
-  async writeJsonFile(path, value) {
-    await ensureDirectory(this.fs, this.fs.path.dirname(path));
-    await this.fs.writeFile(path, `${JSON.stringify(value, null, 2)}
-`);
-  }
-  async remove(path) {
-    await this.fs.rm(path);
-  }
-}
-
-// src/services/packaging-utils.ts
-function fileNodesToPackagingNodes(nodes) {
-  return nodes.map((node) => ({
-    id: node.id,
-    type: node.type,
-    typeVersion: node.typeVersion ?? "1.0",
-    display: node.display,
-    inputs: node.inputs,
-    outputs: node.outputs,
-    ...node.model ? { model: node.model } : {}
-  }));
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function toResourceList(value) {
-  if (!Array.isArray(value))
-    return;
-  const resources = value.filter(isRecord2);
-  return resources.length === value.length ? resources : undefined;
-}
-function normalizePackagingBindingsJson(value) {
-  if (!isRecord2(value))
-    return;
-  const resources = toResourceList(value.resources);
-  if (!resources)
-    return;
-  return {
-    ...value,
-    version: typeof value.version === "string" ? value.version : "2.0",
-    resources
-  };
-}
-function emptyPackagingBindingsJson() {
-  return { version: "2.0", resources: [] };
-}
-function mergePackagingBindingsJson(bindingsJsons) {
-  const first = bindingsJsons.find((bindingsJson) => bindingsJson !== undefined);
-  return {
-    ...first ?? emptyPackagingBindingsJson(),
-    resources: mergeBindingResources(bindingsJsons.flatMap((bindingsJson) => bindingsJson?.resources ?? []))
-  };
-}
-var inlineAgentPackagerLogger = {
-  debug: (message) => logger.debug(message),
-  info: (message) => logger.info(message),
-  warn: (message) => logger.warn(message),
-  error: (message) => logger.error(message),
-  progress: (message) => logger.info(message),
-  log: (message, level) => {
-    if (level === "Error" /* Error */)
-      logger.error(message);
-    else if (level === "Warning" /* Warn */)
-      logger.warn(message);
-    else if (level === "Debug" /* Debug */)
-      logger.debug(message);
-    else
-      logger.info(message);
-  },
-  logMessage: (message) => inlineAgentPackagerLogger.log(message.message, message.logLevel)
-};
-async function createInlineAgentContract(fs, agentDir) {
-  const outputPath = fs.path.join(fs.env.tmpdir(), `.inline-agent-contract-${crypto.randomUUID()}`);
-  await fs.mkdir(outputPath);
-  try {
-    const built = await buildInlineAgentContract({
-      fileSystem: fs,
-      logger: inlineAgentPackagerLogger,
-      projectPath: agentDir,
-      outputPath
-    });
-    const bindingsJson = normalizePackagingBindingsJson(built.bindingsJson);
-    if (!bindingsJson) {
-      throw new Error("Agent packager returned an invalid binding contract");
-    }
-    return { agentJson: built.agentJson, bindingsJson };
-  } finally {
-    const [cleanupError] = await catchError(fs.rm(outputPath, { recursive: true }));
-    if (cleanupError) {
-      logger.debug(`Could not remove inline-agent contract directory ${outputPath}: ${cleanupError.message}`);
-    }
-  }
-}
-async function inlineAgentExists(fs, projectDir, source) {
-  const agentJsonPath = fs.path.join(projectDir, source, "agent.json");
-  return fs.exists(agentJsonPath);
-}
-async function packageInlineAgents(fs, projectDir, nodes) {
-  const result = [];
-  for (const node of nodes) {
-    if (!isInlineAgentNodeType(node.type))
-      continue;
-    const source = readInlineAgentSource(node);
-    if (!source)
-      continue;
-    if (/[/\\.]/.test(source))
-      continue;
-    if (!await inlineAgentExists(fs, projectDir, source))
-      continue;
-    const contract = await createInlineAgentContract(fs, fs.path.join(projectDir, source));
-    const inputSchema = contract.agentJson.inputSchema ?? {
-      type: "object",
-      properties: {}
-    };
-    const outputSchema = contract.agentJson.outputSchema ?? {
-      type: "object",
-      properties: {}
-    };
-    result.push({
-      source,
-      entryPoint: {
-        filePath: `content/${source}/agent.json`,
-        uniqueId: contract.agentJson.projectId ?? source,
-        type: EntryPointType.Agent,
-        input: inputSchema,
-        output: outputSchema,
-        displayName: contract.agentJson.name ?? "Agent"
-      },
-      agentJson: contract.agentJson,
-      bindingsJson: contract.bindingsJson
-    });
-    logger.info(`Packaged inline agent "${source}" for entry-points`);
-  }
-  return result;
-}
-async function stageInlineAgentPackageFiles(fs, sourceProjectPath, stagingProjectDir, inlineAgents, formatLogMessage) {
-  for (const agent of inlineAgents) {
-    const srcDir = fs.path.join(sourceProjectPath, agent.source);
-    const destDir = fs.path.join(stagingProjectDir, agent.source);
-    if (fs.path.resolve(srcDir) !== fs.path.resolve(destDir) && await fs.exists(srcDir)) {
-      await fs.copyDirectory(srcDir, destDir);
-    }
-    const agentBuilderDir = fs.path.join(destDir, ".agent-builder");
-    await ensureDirectory(fs, agentBuilderDir);
-    await fs.writeFile(fs.path.join(agentBuilderDir, "agent.json"), JSON.stringify({
-      ...agent.agentJson,
-      resources: agent.agentJson.resources ?? [],
-      features: agent.agentJson.features ?? []
-    }, null, 2));
-    await fs.writeFile(fs.path.join(agentBuilderDir, "bindings.json"), `${JSON.stringify(agent.bindingsJson ?? emptyPackagingBindingsJson(), null, 2)}
-`);
-    logger.info(formatLogMessage(agent.source));
-  }
-}
-function buildInlineAgentDescriptors(nodes) {
-  const out = [];
-  for (const node of nodes) {
-    if (!isInlineAgentNodeType(node.type))
-      continue;
-    const source = readInlineAgentSource(node);
-    if (!source)
-      continue;
-    const label = node.display?.label ?? "Agent";
-    out.push({
-      name: label,
-      agentProjectId: source,
-      isConversational: isConversationalOrVoiceAgentNodeType(node.type),
-      entryPointPath: `${source}/agent.json`
-    });
-  }
-  return out;
-}
-async function writePackagingArtifacts(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
-  const { entryPoints } = await writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions, options);
-  return entryPoints;
-}
-async function writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
-  const flowEntryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
-  const entryPoints = [
-    ...flowEntryPoints,
-    ...options.additionalEntryPoints ?? []
-  ];
-  await fs.writeFile(fs.path.join(projectDir, "entry-points.json"), `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}
-`);
-  const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
-  const bindingsJson = normalizePackagingBindingsJson(generateBindingsJson(bindingResources)) ?? emptyPackagingBindingsJson();
-  const stagedBindingsJson = mergePackagingBindingsJson([
-    bindingsJson,
-    ...options.additionalBindingsJsons ?? []
-  ]);
-  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(stagedBindingsJson, null, 2)}
-`);
-  const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
-  const operateJson = generateOperateJson(projectId, mainEntryPoint, operateRuntimeOptions(packagingNodes));
-  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
-`);
-  const packageDescriptorJson = options.packageDescriptorJson ?? {
-    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-    files: {
-      "operate.json": "operate.json",
-      "entry-points.json": "entry-points.json",
-      "bindings.json": "bindings_v2.json",
-      [bpmnFileName]: bpmnFileName,
-      ...flowFileName ? { [flowFileName]: flowFileName } : {}
+  if (obj && typeof obj === "object") {
+    for (const [key, value] of Object.entries(obj)) {
+      scanForInvalidJsExpressions(value, `${path}.${key}`, severity, issues);
     }
-  };
-  await fs.writeFile(fs.path.join(projectDir, "package-descriptor.json"), `${JSON.stringify(packageDescriptorJson, null, 2)}
-`);
-  return { entryPoints, bindingsJson: stagedBindingsJson };
+  }
 }
-function backfillNodeModelsFromDefinitions(nodes, definitions) {
-  if (definitions.length === 0)
-    return nodes;
-  const definitionByType = new Map;
-  for (const def of definitions) {
-    if (def?.nodeType)
-      definitionByType.set(def.nodeType, def);
-  }
-  return nodes.map((n) => {
-    if (n.model)
-      return n;
-    const def = definitionByType.get(n.type);
-    if (!def?.model)
-      return n;
-    return { ...n, model: def.model };
+function reportInvalidExpression(expression, path, severity, issues) {
+  if (expression.trim() === "")
+    return;
+  const error = syntaxErrorFrom(() => parse3(`(${expression}
+)`, {
+    ecmaVersion: 2020,
+    sourceType: "script"
+  }));
+  if (!error)
+    return;
+  issues.push({
+    path,
+    severity,
+    message: `Expression at this field is not valid JavaScript: ${error.message}. Fix the syntax — validate cannot otherwise catch JavaScript expression errors; they surface only at flow debug.`
   });
 }
-async function regenerateBindingsFile(fs, flowFilePath) {
-  const absolutePath = fs.path.resolve(flowFilePath);
-  const projectDir = fs.path.dirname(absolutePath);
-  const content = await fs.readFile(absolutePath, "utf-8");
-  if (!content) {
-    throw new Error(`Could not read .flow file at ${absolutePath}`);
-  }
-  const [parseErr, flowData] = catchError(() => JSON.parse(content));
-  if (parseErr) {
-    throw new Error(`Failed to parse .flow file at ${absolutePath}: ${parseErr.message}`);
-  }
-  const packagingNodes = backfillNodeModelsFromDefinitions(fileNodesToPackagingNodes(flowData.nodes ?? []), flowData.definitions ?? []);
-  const bindingResources = getBindingResources(packagingNodes, flowData.bindings ?? [], flowData.definitions ?? []);
-  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
-`);
-}
-
-// src/services/node-service.ts
-class NodeTypeNotFoundError extends Error {
-  code = "NodeTypeNotFound";
-  instructions;
-  constructor(message, instructions) {
-    super(message);
-    this.name = "NodeTypeNotFoundError";
-    this.instructions = instructions;
-  }
-}
-
-class NodeTypeNotEnabledError extends Error {
-  code = "NodeTypeNotEnabled";
-  instructions;
-  constructor(message, instructions) {
-    super(message);
-    this.name = "NodeTypeNotEnabledError";
-    this.instructions = instructions;
+function syntaxErrorFrom(parseSource) {
+  try {
+    parseSource();
+    return;
+  } catch (err) {
+    return err instanceof Error ? err : new Error(String(err));
   }
 }
 
-class SourceRequiredError extends Error {
-  code = "SourceRequired";
-  instructions;
-  constructor(message, instructions) {
-    super(message);
-    this.name = "SourceRequiredError";
-    this.instructions = instructions;
+// src/services/node-validators/model-source-validator.ts
+var modelSourceValidator = {
+  id: "model-source",
+  appliesTo: () => true,
+  validate: (node, context) => {
+    const definition = context.definitions.find((d) => d.nodeType === node.type);
+    if (!definition)
+      return [];
+    const requiresModelSource = readModelSourceFlag(definition);
+    if (!requiresModelSource)
+      return [];
+    const legacySource = readLegacyModelSource(node);
+    if (legacySource !== undefined) {
+      return [
+        {
+          path: `nodes[${node.id}].model.source`,
+          severity: "error",
+          message: `Node type "${node.type}" carries the deprecated ` + `"model.source" UUID on the node instance. ` + `flow-core 0.2.50+ requires the canvas-generated ` + `UUID at "inputs.source"; remove "model.source" ` + `from the node and place the value under ` + `"inputs": { "source": "<uuid>" } instead. ` + `See uipath-maestro-flow skill — ` + `inline-agent/impl.md (MST-9265).`
+        }
+      ];
+    }
+    const inputsSource = node.inputs?.source;
+    if (typeof inputsSource === "string" && inputsSource.length > 0) {
+      return [];
+    }
+    return [
+      {
+        path: `nodes[${node.id}].inputs.source`,
+        severity: "error",
+        message: `Node type "${node.type}" requires a stable UUID at ` + `"inputs.source" — the agent's ProjectId for inline ` + `agent nodes, or the resource id from the parent inline ` + `agent's "resources[]" for agent-tool resource nodes. ` + `Set "inputs": { "source": "<uuid>" } on the node ` + `(use the ProjectId returned by ` + `"uip agent init --inline-in-flow" for inline agents). ` + `See uipath-maestro-flow skill — inline-agent/impl.md ` + `(MST-9265).`
+      }
+    ];
   }
-}
-var listNodesInFlow = async (filePath) => {
-  const { workflow } = await readFlowWorkflow(filePath);
-  const nodes = workflow.nodes.map((n) => ({
-    id: n.id,
-    type: n.type,
-    label: n.display.label ?? "",
-    position: n.ui.position
-  }));
-  return { nodes, count: nodes.length };
 };
-var PROCESS_NODE_PREFIXES = [
-  "uipath.core.rpa-workflow.",
-  "uipath.agent.resource.tool.process.",
-  "uipath.core.agent.",
-  "uipath.core.api-workflow."
-];
-function isProcessNode(manifest) {
-  return PROCESS_NODE_PREFIXES.some((prefix) => manifest.nodeType?.startsWith(prefix));
-}
-function extractProcessGuid(nodeType) {
-  const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
-  if (!match) {
-    throw new Error(`Invalid process node type: "${nodeType}". ` + "Expected a known prefix followed by a process GUID.");
-  }
-  return match[1];
-}
-function resolveProcessTarget(node, definitions) {
-  if (!isProcessNode({ nodeType: node.type }))
-    return;
-  let subType = "Process";
-  if (definitions) {
-    const sameType = definitions.filter((d) => d.nodeType === node.type);
-    const def = sameType.find((d) => node.typeVersion !== undefined && d.version === node.typeVersion) ?? sameType[0];
-    const model = def?.model;
-    const defBindings = model?.bindings;
-    if (defBindings?.resourceSubType)
-      subType = defBindings.resourceSubType;
-    if (defBindings?.resourceKey) {
-      return { key: defBindings.resourceKey, subType };
-    }
-  }
-  return { key: extractProcessGuid(node.type), subType };
-}
-function resolveProcessTargetKey(node, definitions) {
-  return resolveProcessTarget(node, definitions)?.key;
-}
-function createProcessBindings(manifest) {
-  const processGuid = extractProcessGuid(manifest.nodeType);
-  const model = manifest.model;
-  const rawValues = model?.bindings?.values;
-  let processName;
-  let folderPath;
-  if (Array.isArray(rawValues)) {
-    processName = rawValues.find((v) => v.propertyAttribute === "name")?.default ?? "";
-    folderPath = rawValues.find((v) => v.propertyAttribute === "folderPath")?.default;
-  } else {
-    processName = rawValues?.name ?? "";
-    folderPath = rawValues?.folderPath;
-  }
-  if (folderPath == null) {
-    throw new Error("Manifest is missing model.bindings.values.folderPath. " + "Cannot create process bindings without a folder path.");
-  }
-  const subType = model?.bindings?.resourceSubType ?? "Process";
-  const resourceKey = model?.bindings?.resourceKey ?? processGuid;
-  const nameBinding = createBinding({
-    name: "name",
-    value: processName,
-    resource: "process",
-    resourceKey,
-    propertyAttribute: "name",
-    resourceSubType: subType
-  });
-  const folderBinding = createBinding({
-    name: "folderPath",
-    value: folderPath,
-    resource: "process",
-    resourceKey,
-    propertyAttribute: "folderPath",
-    resourceSubType: subType
-  });
-  if (folderPath === "" && folderBinding.default === undefined) {
-    folderBinding.default = "";
+function readModelSourceFlag(definition) {
+  const model = definition.model;
+  if (!model || typeof model !== "object" || Array.isArray(model)) {
+    return false;
   }
-  return { nameBinding, folderBinding };
+  const source = model.source;
+  return source === true;
 }
-function resolveProcessBindingsInContext(node, nameBinding, folderBinding) {
+function readLegacyModelSource(node) {
   const model = node.model;
-  if (!model?.context)
+  if (!model || typeof model !== "object" || Array.isArray(model)) {
     return;
-  for (const entry of model.context) {
-    if (entry.name === "name" && typeof entry.value === "string") {
-      entry.default = nameBinding.default;
-      entry.value = `=bindings.${nameBinding.id}`;
-    } else if (entry.name === "folderPath" && typeof entry.value === "string") {
-      entry.default = folderBinding.default;
-      entry.value = `=bindings.${folderBinding.id}`;
-    }
   }
+  const source = model.source;
+  if (typeof source === "string" && source.length > 0) {
+    return source;
+  }
+  return;
 }
-var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
-function ensureProcessBindings(workflow) {
-  const nodes = workflow.nodes;
-  const definitions = workflow.definitions ?? [];
-  let bindingsCreated = 0;
-  for (const node of nodes) {
-    if (!isProcessNode({ nodeType: node.type }))
-      continue;
-    const nodeModel = node.model;
-    const defModel = definitions.find((d) => d.nodeType === node.type)?.model;
-    const hasUnresolved = [nodeModel, defModel].some((m) => m?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
-    if (!hasUnresolved)
-      continue;
-    const definition = definitions.find((d) => d.nodeType === node.type);
-    if (!definition)
+
+// src/services/node-validators/index.ts
+var defaultNodeValidators = [
+  activityTypeIdValidator,
+  ceqlQueryValidator,
+  connectorNodeValidator,
+  crossNodeBindingValidator,
+  expressionPrefixValidator,
+  jsExpressionSyntaxValidator,
+  ixpNodeValidator,
+  modelSourceValidator
+];
+
+// src/services/vars-reference-rule.ts
+var VARS_REF_RE = /\$vars((?:\s*\??\.\s*[A-Za-z_$][\w$]*|\s*\[\s*(?:'[^']*'|"[^"]*")\s*\])+)/g;
+var VARS_STEP_RE = /(\??\.)\s*([A-Za-z_$][\w$]*)|\[\s*(?:'([^']*)'|"([^"]*)")\s*\]/g;
+var JS_EXPRESSION_PREFIX = "=js:";
+var ARRAY_MEMBERS = new Set([
+  "length",
+  "at",
+  "concat",
+  "copyWithin",
+  "entries",
+  "every",
+  "fill",
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "flat",
+  "flatMap",
+  "forEach",
+  "includes",
+  "indexOf",
+  "join",
+  "keys",
+  "lastIndexOf",
+  "map",
+  "pop",
+  "push",
+  "reduce",
+  "reduceRight",
+  "reverse",
+  "shift",
+  "slice",
+  "some",
+  "sort",
+  "splice",
+  "toLocaleString",
+  "toReversed",
+  "toSorted",
+  "toSpliced",
+  "toString",
+  "unshift",
+  "values",
+  "with"
+]);
+var LOOP_NODE_TYPE = "core.logic.loop";
+var LOOP_BACK_TARGET_PORT = "loopBack";
+var SCRIPT_NODE_TYPE = "core.action.script";
+var JS_EXPRESSION_TYPE = "jsExpression";
+function undefinedSafe(ref2, k) {
+  return ref2.guarded.has(k + 1);
+}
+function stripJsComments(source) {
+  let out = "";
+  let i2 = 0;
+  const n = source.length;
+  while (i2 < n) {
+    const c = source[i2];
+    const next = source[i2 + 1];
+    if (c === "/" && next === "/") {
+      while (i2 < n && source[i2] !== `
+`)
+        i2++;
       continue;
-    const [err, bindings] = catchError(() => createProcessBindings(definition));
-    if (err) {
-      logger.warn(`Skipping binding resolution for node "${node.id}": ${err.message}`);
+    }
+    if (c === "/" && next === "*") {
+      const end = source.indexOf("*/", i2 + 2);
+      i2 = end === -1 ? n : end + 2;
+      out += " ";
       continue;
     }
-    const { nameBinding, folderBinding } = bindings;
-    const beforeCount = workflow.bindings?.length ?? 0;
-    addBinding(workflow, nameBinding);
-    addBinding(workflow, folderBinding);
-    const storedBindings = workflow.bindings;
-    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
-    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
-    resolveProcessBindingsInContext(node, storedName, storedFolder);
-    if (defModel?.context) {
-      for (const entry of defModel.context) {
-        if (entry.name === "name" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
-          entry.default = storedName.default;
-          entry.value = `=bindings.${storedName.id}`;
-        } else if (entry.name === "folderPath" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
-          entry.default = storedFolder.default;
-          entry.value = `=bindings.${storedFolder.id}`;
-        }
+    if (c === "'" || c === '"' || c === "`") {
+      let j = i2 + 1;
+      while (j < n && source[j] !== c) {
+        if (source[j] === "\\")
+          j++;
+        else if (c !== "`" && source[j] === `
+`)
+          break;
+        j++;
       }
+      out += source.slice(i2, Math.min(j + 1, n));
+      i2 = j + 1;
+      continue;
     }
-    const added = (workflow.bindings?.length ?? 0) - beforeCount;
-    bindingsCreated += added;
-    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
-  }
-  if (bindingsCreated > 0) {
-    logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
+    out += c;
+    i2++;
   }
-  return bindingsCreated;
+  return out;
 }
-var BINDING_REF_PATTERN = /^=bindings\.(.+)$/;
-function collectNodeBindingRefs(node) {
-  const refs = new Set;
-  if (node.inputs) {
-    for (const value of Object.values(node.inputs)) {
-      if (typeof value === "string") {
-        const match = value.match(BINDING_REF_PATTERN);
-        if (match)
-          refs.add(match[1]);
-      }
+function isExpressionObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && typeof v.expression === "string" && typeof v.type === "string";
+}
+function parseRefs(text) {
+  const refs = [];
+  for (const m of text.matchAll(VARS_REF_RE)) {
+    const chain = m[1];
+    const segments = [];
+    const guarded = new Set;
+    for (const step of chain.matchAll(VARS_STEP_RE)) {
+      if (step[1] === "?.")
+        guarded.add(segments.length);
+      const key = step[2] ?? step[3] ?? step[4] ?? "";
+      for (const part of key.split(".")) {
+        if (part)
+          segments.push(part);
+      }
+    }
+    if (segments.length > 0) {
+      refs.push({
+        segments,
+        text: `$vars${chain.replace(/\s+/g, "")}`,
+        guarded
+      });
     }
   }
   return refs;
 }
-function collectNodeBindingResourceKeys(node, bindings, definitions) {
-  const keys = new Set;
-  const processKey = resolveProcessTargetKey(node, definitions);
-  if (processKey) {
-    keys.add(processKey);
-  }
-  const inputs = node.inputs;
-  if (typeof inputs?.detail?.connectionResourceId === "string") {
-    keys.add(inputs.detail.connectionResourceId);
-  }
-  const refs = collectNodeBindingRefs(node);
-  for (const binding of bindings) {
-    if (refs.has(binding.id)) {
-      keys.add(binding.resourceKey);
+function scanNodeFields(node, updates) {
+  const out = [];
+  const walk = (val, path, underAgentBinding) => {
+    const isScriptBody = node.type === SCRIPT_NODE_TYPE && path === "inputs.script";
+    if (typeof val === "string") {
+      if (!val.includes("$vars"))
+        return;
+      out.push({
+        fieldPath: path,
+        isAgentBinding: underAgentBinding,
+        isJs: isScriptBody || val.startsWith(JS_EXPRESSION_PREFIX),
+        text: val
+      });
+      return;
+    }
+    if (isExpressionObject(val)) {
+      if (!val.expression.includes("$vars"))
+        return;
+      out.push({
+        fieldPath: `${path}.expression`,
+        isAgentBinding: underAgentBinding,
+        isJs: isScriptBody || val.type === JS_EXPRESSION_TYPE,
+        text: val.expression
+      });
+      return;
+    }
+    if (Array.isArray(val)) {
+      for (const [i2, v] of val.entries()) {
+        walk(v, `${path}[${i2}]`, underAgentBinding);
+      }
+      return;
+    }
+    if (val && typeof val === "object") {
+      for (const [k, v] of Object.entries(val)) {
+        if (path === "inputs.detail" && k === "configuration")
+          continue;
+        walk(v, `${path}.${k}`, underAgentBinding || path === "inputs" && k === "agentInputVariables");
+      }
+    }
+  };
+  if (node.inputs)
+    walk(node.inputs, "inputs", false);
+  if (node.outputs)
+    walk(node.outputs, "outputs", false);
+  if (Array.isArray(updates)) {
+    for (const [i2, u] of updates.entries()) {
+      const expr = u?.expression;
+      if (typeof expr === "string" || isExpressionObject(expr)) {
+        walk(expr, `variableUpdates[${i2}]`, false);
+      }
     }
   }
-  return keys;
-}
-var addNodeToFlow = async (filePath, nodeType, options = {}) => {
-  const [registryErr, registryManifest] = await catchError(getNode(nodeType));
-  let manifest = registryManifest ?? null;
-  if (registryErr) {
-    logger.debug(`Registry node lookup failed for ${nodeType}: ${registryErr.message}`);
-  }
-  let localErr = null;
-  if (!manifest) {
-    const [err, localManifest] = await catchError(getNode(nodeType, { local: true }));
-    manifest = localManifest ?? null;
-    if (err) {
-      localErr = err;
-      logger.warn(`In-solution node lookup failed for ${nodeType}: ${err.message}`);
-    }
-  }
-  if (!manifest) {
-    if (isKnownSdkNodeType(nodeType)) {
-      throw new NodeTypeNotEnabledError(`Node type '${nodeType}' is not enabled for this tenant.`, "Ask an admin to enable the feature flag for this node type, " + "or run `uip maestro flow registry list` to see every " + "known type with its `AvailableOnTenant` flag.");
-    }
-    const details = [
-      registryErr && `Registry lookup failed: ${registryErr.message}`,
-      localErr && `In-solution lookup failed: ${localErr.message}`
-    ].filter(Boolean).join(". ");
-    const hint = details || "If this is an in-solution node, make sure you are running " + "from inside a solution directory (with a .uipx file in CWD, parent, or grandparent).";
-    throw new NodeTypeNotFoundError(`Node type not found: ${nodeType}. ${hint}`, "Run `uip maestro flow registry search <keyword>` to find the " + "correct node type, or `uip maestro flow registry list` " + "to see every known type (including ones not enabled on this tenant).");
-  }
-  if (manifest.model?.source === true) {
-    const fromFlag = typeof options.source === "string" && options.source.length > 0;
-    const inputsSourceCandidate = options.inputs?.source;
-    const fromInputs = typeof inputsSourceCandidate === "string" && inputsSourceCandidate.length > 0;
-    if (!fromFlag && !fromInputs) {
-      throw new SourceRequiredError(`Node type "${nodeType}" requires a source UUID at inputs.source. Pass --source <uuid>.`, "Use the agent's ProjectId (returned by " + '`uip agent init "<flow-dir>" --inline-in-flow`) for inline ' + "agent nodes, or the resource id declared in the parent " + "inline agent's `resources[]` for agent-tool resource nodes. " + '`--input \'{"source":"<uuid>"}\'` is also accepted.');
-    }
-  }
-  const { workflow, refMap } = await readFlowWorkflow(filePath);
-  const existingIds = new Set(workflow.nodes.map((n) => n.id));
-  const existingDefCount = workflow.definitions.length;
-  const { id, displayName } = generateNodeIdAndName(options.label ?? manifest.display.label, existingIds);
-  const bindingsBefore = workflow.bindings?.length ?? 0;
-  const node = addNode(workflow, manifest, id, options.position ?? { x: 0, y: 0 }, options.label ?? displayName);
-  const schema = manifest.inputDefinition;
-  if (manifest.inputDefaults === undefined && schema?.type === "object") {
-    for (const schemaKey of Object.keys(schema)) {
-      delete node.inputs[schemaKey];
-    }
-  }
-  let bindingsCreated = 0;
-  if (isProcessNode(manifest)) {
-    const { nameBinding, folderBinding } = createProcessBindings(manifest);
-    addBinding(workflow, nameBinding);
-    addBinding(workflow, folderBinding);
-    const storedBindings = workflow.bindings;
-    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
-    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
-    if (folderBinding.default === "" && storedFolder.default === undefined) {
-      storedFolder.default = "";
-    }
-    resolveProcessBindingsInContext(node, storedName, storedFolder);
-    bindingsCreated = (workflow.bindings?.length ?? 0) - bindingsBefore;
-  }
-  if (options.inputs && Object.keys(options.inputs).length > 0) {
-    node.inputs = { ...node.inputs ?? {}, ...options.inputs };
-  }
-  const manifestModel = manifest.model;
-  if (manifestModel?.source === true) {
-    if (typeof options.source === "string" && options.source.length > 0) {
-      const inputs = node.inputs ?? {};
-      inputs.source = options.source;
-      node.inputs = inputs;
-    }
-    if (node.model) {
-      delete node.model;
-    }
-  }
-  if (typeof options.parent === "string" && options.parent.length > 0) {
-    const allNodes = workflow.nodes;
-    if (!allNodes.some((n) => n.id === options.parent)) {
-      throw new Error(`--parent value "${options.parent}" is not an existing node id in this flow. ` + "Run 'uip maestro flow node list <file>' to see valid ids.");
-    }
-    node.parentId = options.parent;
-  }
-  await writeFlowWorkflow(filePath, workflow, refMap);
-  if (isProcessNode(manifest)) {
-    const fs = getFileSystem();
-    const [regenErr] = await catchError(regenerateBindingsFile(fs, filePath));
-    if (regenErr) {
-      logger.warn(`Failed to regenerate bindings_v2.json after adding ${manifest.nodeType}: ${regenErr.message}`);
-    }
-  }
-  const definitionAdded = workflow.definitions.length > existingDefCount;
-  const variableCount = workflow.variables?.nodes?.length ?? 0;
-  if (isConnectorNode(manifest)) {
-    const connInfo = getConnectorInfo(manifest);
-    return {
-      node,
-      definitionAdded,
-      bindingsCreated,
-      variableCount,
-      connectorInfo: connInfo ?? undefined
-    };
-  } else {
-    return { node, definitionAdded, bindingsCreated, variableCount };
-  }
-};
-function removeConnectedEdges(workflow, nodeId) {
-  const edges = workflow.edges ?? [];
-  const before = edges.length;
-  workflow.edges = edges.filter((e) => e.sourceNodeId !== nodeId && e.targetNodeId !== nodeId);
-  return before - workflow.edges.length;
+  return out;
 }
-function removeOrphanedBindings(workflow, deletedNodeKeys, remainingNodes, bindings) {
-  if (deletedNodeKeys.size === 0 || bindings.length === 0)
-    return 0;
-  const defs = workflow.definitions ?? [];
-  const remainingKeys = new Set;
-  for (const node of remainingNodes) {
-    for (const key of collectNodeBindingResourceKeys(node, bindings, defs)) {
-      remainingKeys.add(key);
+function buildAncestors(flow) {
+  const preds = new Map;
+  for (const e of flow.edges) {
+    const set = preds.get(e.targetNodeId) ?? new Set;
+    set.add(e.sourceNodeId);
+    preds.set(e.targetNodeId, set);
+  }
+  const result = new Map;
+  for (const n of flow.nodes) {
+    const seen = new Set;
+    const stack = [...preds.get(n.id) ?? []];
+    while (stack.length > 0) {
+      const x = stack.pop();
+      if (seen.has(x))
+        continue;
+      seen.add(x);
+      for (const p of preds.get(x) ?? [])
+        stack.push(p);
     }
+    result.set(n.id, seen);
   }
-  const before = bindings.length;
-  workflow.bindings = bindings.filter((b) => !deletedNodeKeys.has(b.resourceKey) || remainingKeys.has(b.resourceKey));
-  return before - workflow.bindings.length;
-}
-function connectorConnectionBindingName(node, definitions) {
-  if (!node.type.startsWith("uipath.connector"))
-    return "";
-  const def = definitions.find((d) => d.nodeType === node.type);
-  const context = def?.model?.context;
-  const connectorKey = context?.find((c) => c.name === "connectorKey")?.value;
-  return typeof connectorKey === "string" && connectorKey.length > 0 ? `${connectorKey} connection` : "";
-}
-function removeOrphanedConnectorStub(workflow, deletedNode, remainingNodes, definitions) {
-  const stubName = connectorConnectionBindingName(deletedNode, definitions);
-  if (!stubName)
-    return 0;
-  const stillOwned = remainingNodes.some((n) => connectorConnectionBindingName(n, definitions) === stubName);
-  if (stillOwned)
-    return 0;
-  const bindings = workflow.bindings ?? [];
-  if (bindings.length === 0)
-    return 0;
-  const before = bindings.length;
-  workflow.bindings = bindings.filter((b) => !(b.resource?.toLowerCase() === "connection" && b.propertyAttribute === "ConnectionId" && !b.resourceKey && !b.default && b.name === stubName));
-  return before - workflow.bindings.length;
+  return result;
 }
-function removeOrphanedDefinitions(workflow, remainingNodes) {
-  const definitions = workflow.definitions ?? [];
-  const usedKeys = new Set(remainingNodes.map((n) => `${n.type}:${n.typeVersion}`));
-  const before = definitions.length;
-  workflow.definitions = definitions.filter((d) => usedKeys.has(`${d.nodeType}:${d.version}`));
-  return before - workflow.definitions.length;
+function buildMustRun(flow, modelTypeOf) {
+  const nodesById = new Map(flow.nodes.map((n) => [n.id, n]));
+  const incoming = new Map;
+  for (const e of flow.edges) {
+    if (e.targetPort === LOOP_BACK_TARGET_PORT && nodesById.get(e.targetNodeId)?.type === LOOP_NODE_TYPE) {
+      continue;
+    }
+    const list2 = incoming.get(e.targetNodeId) ?? [];
+    list2.push(e.sourceNodeId);
+    incoming.set(e.targetNodeId, list2);
+  }
+  const memo = new Map;
+  const visiting = new Set;
+  const mustRun = (id) => {
+    const hit = memo.get(id);
+    if (hit)
+      return hit;
+    if (visiting.has(id))
+      return new Set;
+    visiting.add(id);
+    const ins = incoming.get(id) ?? [];
+    let acc = new Set;
+    if (ins.length > 0) {
+      const sets = ins.map((s) => new Set([...mustRun(s), s]));
+      const node = nodesById.get(id);
+      const isJoin = node !== undefined && (node.type === "core.logic.merge" || modelTypeOf(node) === "bpmn:ParallelGateway");
+      if (isJoin) {
+        for (const s of sets)
+          for (const x of s)
+            acc.add(x);
+      } else {
+        acc = new Set(sets[0]);
+        for (const s of sets.slice(1)) {
+          for (const x of [...acc])
+            if (!s.has(x))
+              acc.delete(x);
+        }
+      }
+    }
+    acc.add(id);
+    visiting.delete(id);
+    memo.set(id, acc);
+    return acc;
+  };
+  return mustRun;
+}
+function declaredOutputs(node, definition) {
+  const names = new Set;
+  if (node.outputs && typeof node.outputs === "object") {
+    for (const k of Object.keys(node.outputs))
+      names.add(k);
+  }
+  const outDef = definition?.outputDefinition;
+  if (outDef && typeof outDef === "object") {
+    for (const k of Object.keys(outDef))
+      names.add(k);
+  }
+  if (node.type === "core.subflow")
+    names.add("output");
+  const isListOutput = node.type.startsWith("uipath.connector.") && connectorOperation(node) === "list";
+  const declaredType = (name) => {
+    const entry = outDef?.[name];
+    const t = entry?.type;
+    return typeof t === "string" ? t : undefined;
+  };
+  const typeOf = (name) => name === "output" && isListOutput ? "array" : declaredType(name);
+  const whyArray = (name) => declaredType(name) === "array" ? 'declared type "array"' : 'a list operation — inputMetadata.operation is "list", the response is the bare array of records';
+  return { names, typeOf, whyArray };
 }
-function removeVariableUpdates(workflow, nodeId) {
-  const variables = workflow.variables;
-  if (!variables?.variableUpdates)
-    return 0;
-  const updates = variables.variableUpdates[nodeId];
-  if (!updates)
-    return 0;
-  const count = updates.length;
-  delete variables.variableUpdates[nodeId];
-  return count;
+function connectorOperation(node) {
+  const detail = node.inputs?.detail;
+  const op = detail?.inputMetadata?.operation;
+  return typeof op === "string" ? op.toLowerCase() : undefined;
+}
+function boundedEditDistance(a, b, max) {
+  if (Math.abs(a.length - b.length) > max)
+    return max + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i2 = 1;i2 <= a.length; i2++) {
+    const cur = [i2];
+    let rowMin = i2;
+    for (let j = 1;j <= b.length; j++) {
+      const cost = a[i2 - 1] === b[j - 1] ? 0 : 1;
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+      rowMin = Math.min(rowMin, cur[j]);
+    }
+    if (rowMin > max)
+      return max + 1;
+    prev = cur;
+  }
+  return prev[b.length];
+}
+var HINT_MAX_EDITS = 2;
+var HINT_MIN_PREFIX = 3;
+function nearestNodeId(root, ids) {
+  const lower = root.toLowerCase();
+  let best;
+  let bestScore = Number.POSITIVE_INFINITY;
+  for (const id of ids) {
+    const l = id.toLowerCase();
+    if (l === lower)
+      return id;
+    if (lower.length < HINT_MIN_PREFIX)
+      continue;
+    let score = boundedEditDistance(lower, l, HINT_MAX_EDITS);
+    if (score > HINT_MAX_EDITS) {
+      const [short, long] = lower.length <= l.length ? [lower, l] : [l, lower];
+      const isPrefix = short.length >= HINT_MIN_PREFIX && short.length * 2 >= long.length && long.startsWith(short);
+      if (!isPrefix)
+        continue;
+      score = HINT_MAX_EDITS + (long.length - short.length);
+    }
+    if (score < bestScore) {
+      best = id;
+      bestScore = score;
+    }
+  }
+  return best;
 }
-function removeNodeVariables(workflow, nodeId) {
-  const variables = workflow.variables;
-  if (!variables?.nodes)
-    return 0;
-  const before = variables.nodes.length;
-  variables.nodes = variables.nodes.filter((v) => v.binding.nodeId !== nodeId);
-  return before - variables.nodes.length;
+function labelOf(node) {
+  return node.display?.label ?? node.id;
 }
-var deleteNodeFromFlow = async (filePath, nodeId) => {
-  const { workflow, refMap } = await readFlowWorkflow(filePath);
-  const nodes = workflow.nodes;
-  const nodeIndex = nodes.findIndex((n) => n.id === nodeId);
-  if (nodeIndex === -1) {
-    const available = nodes.map((n) => n.id).join(", ") || "(none)";
-    throw new Error(`Node not found: "${nodeId}". Available node IDs: ${available}`);
-  }
-  const targetNode = nodes[nodeIndex];
-  const deletedWasProcessNode = isProcessNode({ nodeType: targetNode.type });
-  const deletedNode = {
-    id: targetNode.id,
-    type: targetNode.type,
-    label: targetNode.display.label ?? "",
-    position: targetNode.ui.position
-  };
-  const bindings = workflow.bindings ?? [];
-  const definitions = workflow.definitions ?? [];
-  const deletedNodeResourceKeys = collectNodeBindingResourceKeys(targetNode, bindings, definitions);
-  nodes.splice(nodeIndex, 1);
-  const edgesRemoved = removeConnectedEdges(workflow, nodeId);
-  const bindingsRemoved = removeOrphanedBindings(workflow, deletedNodeResourceKeys, nodes, bindings) + removeOrphanedConnectorStub(workflow, targetNode, nodes, definitions);
-  const definitionsRemoved = removeOrphanedDefinitions(workflow, nodes);
-  const variablesRemoved = removeNodeVariables(workflow, nodeId);
-  const variableUpdatesRemoved = removeVariableUpdates(workflow, nodeId);
-  await writeFlowWorkflow(filePath, workflow, refMap);
-  if (deletedWasProcessNode || bindingsRemoved > 0) {
-    const fs = getFileSystem();
-    const [regenErr] = await catchError(regenerateBindingsFile(fs, filePath));
-    if (regenErr) {
-      logger.warn(`Failed to regenerate bindings_v2.json after deleting ${targetNode.type}: ${regenErr.message}`);
-    }
+function arrayMemberIssue(args) {
+  const { names, typeOf, whyArray } = declaredOutputs(args.producer, args.definition);
+  if (!names.has(args.second) || typeOf(args.second) !== "array") {
+    return;
+  }
+  if (/^\d+$/.test(args.third) || ARRAY_MEMBERS.has(args.third)) {
+    return;
   }
+  const { root, second, third } = args;
   return {
-    deletedNode,
-    edgesRemoved,
-    bindingsRemoved,
-    definitionsRemoved,
-    variablesRemoved,
-    variableUpdatesRemoved
+    path: args.path,
+    severity: args.undefinedSafe || args.embedded ? "warning" : args.severity,
+    message: `"${args.reader}" reads "${args.refText}", but "$vars.${root}.${second}" is an array (${whyArray(second)}), so ".${third}" is undefined. ` + `Iterate it (a Loop's collection is "$vars.${root}.${second}" itself), index it ("[0].${third}"), or use an Array method.`
   };
-};
+}
+function validateVarsReferences(flow, options = {}) {
+  const issues = [];
+  const nodesById = new Map(flow.nodes.map((n) => [n.id, n]));
+  if (nodesById.size === 0)
+    return issues;
+  const knownRoots = new Set(options.extraKnownRoots ?? []);
+  const variables = flow.variables;
+  for (const g of variables?.globals ?? []) {
+    if (typeof g?.id === "string")
+      knownRoots.add(g.id);
+  }
+  const updatesByNode = variables?.variableUpdates ?? {};
+  const defByKey = new Map;
+  const defByType = new Map;
+  for (const d of flow.definitions) {
+    defByKey.set(`${d.nodeType}:${d.version}`, d);
+    if (!defByType.has(d.nodeType))
+      defByType.set(d.nodeType, d);
+  }
+  const definitionOf = (n) => (n.typeVersion ? defByKey.get(`${n.type}:${n.typeVersion}`) : undefined) ?? defByType.get(n.type);
+  const modelTypeOf = (n) => typeof n.model?.type === "string" ? n.model.type : definitionOf(n)?.model?.type;
+  const ancestors = buildAncestors(flow);
+  const mustRun = buildMustRun(flow, modelTypeOf);
+  for (const node of flow.nodes) {
+    const reader = labelOf(node);
+    const reported = new Set;
+    for (const field of scanNodeFields(node, updatesByNode[node.id])) {
+      const path = `nodes[${node.id}].${field.fieldPath}`;
+      const severity = field.fieldPath.startsWith("inputs") ? "error" : "warning";
+      const text = field.isJs ? stripJsComments(field.text) : field.text;
+      const bareValue = text.replace(/^=(js:)?/, "").replace(/\s+/g, "");
+      for (const ref2 of parseRefs(text)) {
+        const embedded = bareValue !== ref2.text;
+        const [root, second, third] = ref2.segments;
+        const key = `${field.fieldPath}|${ref2.segments.join(".")}`;
+        if (reported.has(key))
+          continue;
+        reported.add(key);
+        if (root === node.id)
+          continue;
+        if (knownRoots.has(root))
+          continue;
+        const producer = nodesById.get(root);
+        const anc = ancestors.get(node.id) ?? new Set;
+        if (field.isAgentBinding) {
+          if (producer && anc.size > 0 && anc.has(root)) {
+            if (!mustRun(node.id).has(root)) {
+              issues.push({
+                path,
+                severity: undefinedSafe(ref2, 0) ? "warning" : severity,
+                message: `Agent "${reader}" input binds "${ref2.text}", but "${root}" runs only on some of the paths that reach "${node.id}" (it sits behind a Decision or Switch branch the agent does not depend on). ` + "On the other paths the input is undefined and the agent invocation faults ([400300] Error evaluating expression in activity inputs). " + "Bind a node that runs on every path to the agent, or compute the value on each branch before they rejoin."
+              });
+            } else if (second !== undefined && third !== undefined) {
+              const issue = arrayMemberIssue({
+                producer,
+                definition: definitionOf(producer),
+                root,
+                second,
+                third,
+                reader,
+                refText: ref2.text,
+                path,
+                undefinedSafe: undefinedSafe(ref2, 2),
+                embedded,
+                severity
+              });
+              if (issue)
+                issues.push(issue);
+            }
+          }
+          continue;
+        }
+        if (!producer) {
+          const hint = nearestNodeId(root, nodesById.keys());
+          issues.push({
+            path,
+            severity: undefinedSafe(ref2, 0) ? "warning" : severity,
+            message: `"${reader}" reads "${ref2.text}", but no node or workflow variable named "${root}" exists in this flow` + (hint ? ` (did you mean node "${hint}"?)` : "") + ". At runtime the reference resolves to nothing — a Script reading it faults ([300501]), a Decision or Switch faults ([400302]), a Transform or connector input silently gets an empty value. Fix the id or declare the variable under variables.globals."
+          });
+          continue;
+        }
+        if (anc.size > 0 && !anc.has(root)) {
+          const runsAfter = (ancestors.get(root) ?? new Set).has(node.id);
+          const why = runsAfter ? `"${root}" runs AFTER "${node.id}" (it is downstream of it)` : `"${root}" is not on any path that reaches "${node.id}" (another branch, or not connected)`;
+          issues.push({
+            path,
+            severity: undefinedSafe(ref2, 0) ? "warning" : severity,
+            message: `"${reader}" reads "${ref2.text}", but ${why}, so "${root}" has not produced a value when this expression is evaluated ` + "(Decision/Switch: [400302]; Script: [300501]; agent or connector input: [400300]/empty value). " + `Reference a node that runs earlier on this path, or move "${node.id}" after "${root}".`
+          });
+          continue;
+        }
+        if (second !== undefined) {
+          const { names } = declaredOutputs(producer, definitionOf(producer));
+          const declaresOutputs = [...names].some((n) => n !== "error");
+          if (declaresOutputs && !names.has(second)) {
+            const available = [...names].sort((a, b) => a.localeCompare(b)).join(", ");
+            issues.push({
+              path,
+              severity: undefinedSafe(ref2, 1) ? "warning" : severity,
+              message: `"${reader}" reads "${ref2.text}", but node "${root}" has no output named "${second}" — its outputs are: ${available}. ` + `Read "$vars.${root}.<one of those>" (e.g. a Decision exposes "$vars.${root}.matchedCaseId", not ".output.matchedCaseId").`
+            });
+            continue;
+          }
+          if (third !== undefined) {
+            const issue = arrayMemberIssue({
+              producer,
+              definition: definitionOf(producer),
+              root,
+              second,
+              third,
+              reader,
+              refText: ref2.text,
+              path,
+              undefinedSafe: undefinedSafe(ref2, 2),
+              embedded,
+              severity
+            });
+            if (issue)
+              issues.push(issue);
+          }
+        }
+      }
+    }
+  }
+  return issues;
+}
 
 // src/services/flow-validate-service.ts
 if (!instance.isInitialized) {
@@ -7947,19 +7123,7 @@ function validationErrorToIssue(error) {
   };
 }
 function buildValidationContext(flow) {
-  const nodes = flow.nodes.map((n) => ({
-    id: n.id,
-    type: n.type,
-    data: {
-      inputs: n.inputs ?? {},
-      outputs: n.outputs ?? {},
-      ...n.typeVersion !== undefined && { typeVersion: n.typeVersion },
-      ...n.display !== undefined && {
-        display: n.display,
-        label: n.display.label
-      }
-    }
-  }));
+  const nodes = toSerializedNodes(flow.nodes);
   const edges = flow.edges.map((e) => ({
     id: e.id,
     source: e.sourceNodeId,
@@ -8026,6 +7190,7 @@ class FlowValidateService {
   validateCurrentManifests;
   currentManifestOverrides;
   strictBindings;
+  strictExpressions;
   connectorCatalogOverride;
   currentManifestCache;
   connectorCatalogCache;
@@ -8041,6 +7206,7 @@ class FlowValidateService {
     this.validateCurrentManifests = options.validateCurrentManifests === true || options.currentManifests !== undefined;
     this.currentManifestOverrides = options.currentManifests;
     this.strictBindings = options.strictBindings === true;
+    this.strictExpressions = options.strictExpressions === true;
     this.connectorCatalogOverride = options.connectorCatalog;
   }
   async execute(flowFilePath) {
@@ -8118,13 +7284,13 @@ ${warnings.map((i2) => `  - [${i2.path}] ${i2.message}`).join(`
     ]));
   }
   async validateFile(flowFilePath) {
-    const absolutePath = this.fs.path.resolve(flowFilePath);
+    let absolutePath = this.fs.path.resolve(flowFilePath);
     if (!await this.fs.exists(absolutePath)) {
       throw new Error(`File not found: ${absolutePath}`);
     }
     const stats = await this.fs.stat(absolutePath);
     if (stats?.isDirectory()) {
-      throw new Error(`Expected a .flow file but got a directory: ${absolutePath}`);
+      absolutePath = await resolveProjectFlowFile(absolutePath);
     }
     if (!absolutePath.endsWith(".flow")) {
       throw new Error(`Expected a .flow file but got: ${this.fs.path.basename(absolutePath)}`);
@@ -8176,6 +7342,7 @@ Validating: ${absolutePath}
     issues.push(...this.validateAgentInputScopeRefs(workflow, hydrationDiagnoses, ""));
     issues.push(...this.validateVoiceAgentSettings(workflow, hydrationDiagnoses, ""));
     issues.push(...await this.validateSolutionRegistrationAndLayout(absolutePath));
+    issues.push(...await validateExpressions(workflow, "", this.strictExpressions));
     const subflows = workflow.subflows ?? {};
     for (const [subflowId, entry] of Object.entries(subflows)) {
       const subNodes = entry.nodes;
@@ -8189,7 +7356,7 @@ Validating: ${absolutePath}
         variables: entry.variables
       };
       const prefix = `subflows[${subflowId}].`;
-      issues.push(...this.validateGraph(subGraph, prefix, rawDefErrorHandling, currentManifests));
+      issues.push(...this.validateGraph(subGraph, prefix, rawDefErrorHandling, currentManifests, (workflow.variables?.globals ?? []).map((g) => g.id).filter((id) => typeof id === "string")));
       issues.push(...this.validateGlobalVariableUniqueness(subGraph, prefix));
       issues.push(...this.validateGlobalTriggerBindings(subGraph, prefix));
       issues.push(...this.validateUnboundInputGlobals(subGraph, prefix));
@@ -8197,6 +7364,10 @@ Validating: ${absolutePath}
       issues.push(...this.validateAgentPromptInputRefs(subGraph, hydrationDiagnoses, prefix));
       issues.push(...this.validateAgentInputScopeRefs(subGraph, hydrationDiagnoses, prefix));
       issues.push(...this.rejectSubflowVoiceAgents(subGraph, prefix));
+      issues.push(...await validateExpressions({
+        ...subGraph,
+        subflows
+      }, prefix, this.strictExpressions));
     }
     this.enrichInlineAgentPromptIssues(issues, hydrationDiagnoses, flowDir);
     return {
@@ -8352,6 +7523,12 @@ Validating: ${absolutePath}
         const props = inputSchema.properties;
         if (props && typeof props === "object") {
           diag.declaredInputKeys = Object.keys(props);
+          const leaves = collectAgentInputLeaves(inputSchema);
+          diag.declaredInputLeaves = leaves;
+          diag.declaredInputPaths = new Set([
+            ...leaves.map((leaf) => leaf.path),
+            ...diag.declaredInputKeys.map(canonicalAgentInputPath)
+          ]);
         }
       }
     }
@@ -8397,9 +7574,10 @@ Validating: ${absolutePath}
       if (!byField)
         continue;
       const declared = new Set(diag.declaredInputKeys ?? []);
+      const declaredPaths = diag.declaredInputPaths ?? new Set;
       const label = node.display?.label ?? node.id;
       for (const [field, vars] of Object.entries(byField)) {
-        issues.push(...this.buildPromptInputRefIssues(node, field, vars ?? [], declared, label, pathPrefix));
+        issues.push(...this.buildPromptInputRefIssues(node, field, vars ?? [], declared, declaredPaths, label, pathPrefix));
       }
     }
     return issues;
@@ -8461,7 +7639,7 @@ Validating: ${absolutePath}
     }
     return issues;
   }
-  buildPromptInputRefIssues(node, field, vars, declared, label, pathPrefix) {
+  buildPromptInputRefIssues(node, field, vars, declared, declaredPaths, label, pathPrefix) {
     const issues = [];
     const malformed = [];
     const undeclared = [];
@@ -8469,7 +7647,7 @@ Validating: ${absolutePath}
       const key = this.canonicalInputKey(raw);
       if (key === undefined) {
         malformed.push(raw);
-      } else if (!declared.has(key)) {
+      } else if (!declared.has(key) && !declaredPaths.has(canonicalAgentInputPath(key))) {
         undeclared.push(key);
       }
     }
@@ -8539,8 +7717,8 @@ Validating: ${absolutePath}
       if (notUpstream.length > 0) {
         issues.push({
           path,
-          message: `Agent "${label}" reads ${notUpstream.join(", ")}, but no edge path leads from that node to "${node.id}", so it has not run when the agent does and its output is not written yet. Studio Web reports the same variable as not available in this scope. Wire the node upstream of the agent, or bind an input the agent can see.`,
-          severity: "warning"
+          message: `Agent "${label}" reads ${notUpstream.join(", ")}, but no edge path leads from that node to "${node.id}", so it has not run when the agent does and its output is not written yet ([400300] Error evaluating expression in activity inputs). Studio Web reports the same variable as not available in this scope. Wire the node upstream of the agent, or bind an input the agent can see.`,
+          severity: "error"
         });
       }
       const invalidFields = [];
@@ -8585,10 +7763,10 @@ Validating: ${absolutePath}
         }
       }
     };
-    for (const key of diag?.declaredInputKeys ?? []) {
-      const ref2 = decodeSchemaKeyNodeRef(key);
+    for (const leaf of diag?.declaredInputLeaves ?? []) {
+      const ref2 = decodeSchemaKeyNodeRef(leaf.flatKey);
       if (ref2) {
-        add(ref2.nodeId, ref2.field, `\`$vars.${key.split("__").join(".")}\` (agent.json input "${key}")`);
+        add(ref2.nodeId, ref2.field, `\`$vars.${leaf.path}\` (agent.json input "${leaf.flatKey}")`);
       }
     }
     const bound = node.inputs?.agentInputVariables;
@@ -8648,11 +7826,13 @@ Validating: ${absolutePath}
     Hint: ${hint}`;
     }
   }
-  validateGraph(graph, pathPrefix, rawDefErrorHandling = new Map, currentManifests = new Map) {
+  validateGraph(graph, pathPrefix, rawDefErrorHandling = new Map, currentManifests = new Map, parentVariableIds = []) {
     const issues = [];
     issues.push(...this.validateEdgeReferences(graph));
     issues.push(...this.validateNodeTypeDefinitions(graph));
-    issues.push(...this.validateUniqueIds(graph));
+    issues.push(...this.validateUniqueIds(graph), ...this.validateExclusiveBranchJoins(graph), ...validateVarsReferences(graph, {
+      extraKnownRoots: parentVariableIds
+    }));
     issues.push(...this.validateEdgeHandles(graph, rawDefErrorHandling));
     issues.push(...this.validateEdgeHandlesAgainstCurrentManifests(graph, currentManifests));
     const ctx = buildValidationContext(graph);
@@ -8662,7 +7842,10 @@ Validating: ${absolutePath}
     if (this.availableModelNames) {
       ctx.availableModelNames = this.availableModelNames;
     }
-    const rules = pathPrefix ? cliRules.filter((r) => r.id !== "trigger-required") : cliRules;
+    const dropped = new Set(["expression-ref"]);
+    if (pathPrefix)
+      dropped.add("trigger-required");
+    const rules = cliRules.filter((r) => !dropped.has(r.id));
     const ruleErrors = runRules([
       ...rules,
       conditionExpressionRule,
@@ -8672,6 +7855,17 @@ Validating: ${absolutePath}
     issues.push(...this.runNodeValidators(graph));
     return pathPrefix ? issues.map((i2) => ({ ...i2, path: `${pathPrefix}${i2.path}` })) : issues;
   }
+  validateExclusiveBranchJoins(flow) {
+    const graph = indexJoinGraph(flow);
+    const issues = [];
+    for (const node of flow.nodes) {
+      const finding = findUnsatisfiableJoin(node, graph);
+      if (finding) {
+        issues.push(describeUnsatisfiableJoin(node, finding, graph));
+      }
+    }
+    return issues;
+  }
   validateEdgeReferences(flow) {
     const issues = [];
     const nodeIds = new Set(flow.nodes.map((n) => n.id));
@@ -8703,6 +7897,9 @@ Validating: ${absolutePath}
       definedVersionsByType.set(d.nodeType, versions);
     }
     for (const node of flow.nodes) {
+      if (UI_ONLY_NODE_TYPES.has(node.type)) {
+        continue;
+      }
       const key = `${node.type}:${node.typeVersion}`;
       if (!definedTypes.has(key)) {
         const sameTypeVersions = definedVersionsByType.get(node.type);
@@ -9177,6 +8374,13 @@ Validating: ${absolutePath}
           visible: buildErrorHandle().visible
         });
       }
+      if (entry.source.size > 0 || entry.sourceTemplates.length > 0) {
+        for (const outcomeHandleId of deriveOutcomeHandleIds(node)) {
+          if (!entry.source.has(outcomeHandleId)) {
+            entry.source.set(outcomeHandleId, {});
+          }
+        }
+      }
       handlesByNode.set(node.id, entry);
     }
     const sourceCounts = new Map;
@@ -9296,7 +8500,78 @@ Validating: ${absolutePath}
     return issues;
   }
 }
+function indexJoinGraph(flow) {
+  const modelTypeByNodeType = new Map;
+  for (const def of flow.definitions) {
+    if (typeof def.model?.type === "string") {
+      modelTypeByNodeType.set(def.nodeType, def.model.type);
+    }
+  }
+  const incomingByTarget = new Map;
+  for (const edge of flow.edges) {
+    const list2 = incomingByTarget.get(edge.targetNodeId) ?? [];
+    list2.push(edge);
+    incomingByTarget.set(edge.targetNodeId, list2);
+  }
+  return {
+    nodesById: new Map(flow.nodes.map((n) => [n.id, n])),
+    incomingByTarget,
+    modelTypeOf: (node) => typeof node.model?.type === "string" ? node.model.type : modelTypeByNodeType.get(node.type)
+  };
+}
+function isParallelJoin(node, graph) {
+  return node.type === "core.logic.merge" || graph.modelTypeOf(node) === "bpmn:ParallelGateway";
+}
+function isExclusiveSplit(node, graph) {
+  return node.type === "core.logic.decision" || node.type === "core.logic.switch" || graph.modelTypeOf(node) === "bpmn:ExclusiveGateway";
+}
+function walkToExclusiveSplit(edge, graph) {
+  let current2 = edge;
+  const seen = new Set;
+  while (current2 !== undefined && !seen.has(current2.sourceNodeId)) {
+    const source = graph.nodesById.get(current2.sourceNodeId);
+    if (!source)
+      return;
+    seen.add(source.id);
+    if (isExclusiveSplit(source, graph)) {
+      return { splitId: source.id, port: current2.sourcePort };
+    }
+    const upstream = graph.incomingByTarget.get(source.id) ?? [];
+    current2 = upstream.length === 1 ? upstream[0] : undefined;
+  }
+  return;
+}
+function findUnsatisfiableJoin(node, graph) {
+  if (!isParallelJoin(node, graph))
+    return;
+  const incoming = graph.incomingByTarget.get(node.id) ?? [];
+  if (incoming.length < 2)
+    return;
+  const origins = incoming.map((edge) => walkToExclusiveSplit(edge, graph));
+  if (origins.includes(undefined))
+    return;
+  const resolved = origins;
+  const splitIds = new Set(resolved.map((o) => o.splitId));
+  if (splitIds.size !== 1)
+    return;
+  const ports = [...new Set(resolved.map((o) => o.port))].sort((a, b) => a.localeCompare(b));
+  if (ports.length < 2)
+    return;
+  return { splitId: resolved[0].splitId, ports };
+}
+function describeUnsatisfiableJoin(node, finding, graph) {
+  const split = graph.nodesById.get(finding.splitId);
+  const splitLabel = split?.display?.label ?? finding.splitId;
+  const joinLabel = node.display?.label ?? node.id;
+  const splitKind = split?.type === "core.logic.switch" ? "Switch" : "Decision";
+  const portList = finding.ports.map((p) => `"${p}"`).join(", ");
+  return {
+    path: `nodes[${node.id}]`,
+    message: `Merge "${joinLabel}" can never complete: every one of its incoming paths comes from a ` + `different branch of the same ${splitKind} "${splitLabel}" (ports ${portList}). ` + `A Merge is a parallel join that waits for ALL incoming paths, but a ${splitKind} takes exactly one branch, ` + `so the run would stop at "${joinLabel}" and never reach an End node. ` + `Connect each branch directly to the node that should run next (a node accepts several incoming edges), ` + `and use Merge only to rejoin branches that run in parallel.`,
+    severity: "error"
+  };
+}
 
-export { ensureDirectory, FlowEvalFileStore, fileNodesToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile, NodeTypeNotFoundError, NodeTypeNotEnabledError, SourceRequiredError, listNodesInFlow, ensureProcessBindings, collectNodeBindingResourceKeys, addNodeToFlow, deleteNodeFromFlow, ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, expandHandleIds, portMatchesTemplate, evaluatorTypeAliases, resolveEvaluatorType, isRecord, isUUID, stripJsonExt, slugify, getEvaluatorRef, buildEvaluatorConfig, buildDefaultCriteria, captureMigrationIssues, formatMigrationFailureMessage, isConnectorTriggerType, isConnectorWaitForEventType, isEventDrivenConnectorType, scanDetailForCrossNodeBindings, connectorNodeValidator, FlowValidateService };
+export { connectorNodeValidator, FlowValidateService };
 
-//# debugId=9B1959973F3B05AD64756E2164756E21
+//# debugId=17529DB3913E727964756E2164756E21