@uipath/flow-tool 1.204.0 → 1.205.0-preview.258

package/dist/{packager-tool-zzc2yp2h.js → packager-tool-99gban46.js}

@@ -1,3 +1,6 @@
+import {
+  checkForwardMigration
+} from "./packager-tool-0j8v36qh.js";
 import {
   connectorNodeValidator,
   crossNodeBindingValidator,
@@ -5,10 +8,7 @@ import {
   isConnectorWaitForEventType,
   isEventDrivenConnectorType,
   readEssentialConfiguration
-} from "./packager-tool-jaa5gcbv.js";
-import {
-  checkForwardMigration
-} from "./packager-tool-s4etvs59.js";
+} from "./packager-tool-71gqkgg6.js";
 import {
   ERROR_SOURCE_PORT,
   deriveHandleCustomizationSourceOverride,
@@ -25,49 +25,55 @@ import {
 import {
   UI_ONLY_NODE_TYPES
 } from "./packager-tool-e5hj89zm.js";
-import {
-  collectNodeBindingResourceKeys,
-  isProcessNode,
-  resolveProcessTarget
-} from "./packager-tool-epkg5s7f.js";
 import {
   INLINE_ACTIVITY_SOURCE,
   INLINE_ACTIVITY_TYPE_PREFIX,
+  collectNodeBindingResourceKeys,
   collectScriptRefs,
   getInlineActivityConfiguration,
+  isProcessNode,
   loadRegistry,
-  parse
-} from "./packager-tool-y8egb0fa.js";
+  parse,
+  resolveProcessTarget
+} from "./packager-tool-wds3myef.js";
 import {
-  isRecord
-} from "./packager-tool-t3ysatjd.js";
+  loadCurrentTenantNodes
+} from "./packager-tool-nk16zaz3.js";
+import {
+  findProjectsWithoutProcessResource,
+  loadResourceKeyMap,
+  resourcesRefreshCommand
+} from "./packager-tool-phw8ydjx.js";
+import {
+  readSolutionInlineEntities
+} from "./packager-tool-4x7tzvv0.js";
 import {
   findNodeDefinition
-} from "./packager-tool-w5a1hhyj.js";
+} from "./packager-tool-hxyjn885.js";
 import {
-  getLoginStatusAsync
-} from "./packager-tool-6h69pd2a.js";
+  isRecord
+} from "./packager-tool-xk78j7dz.js";
 import {
-  findNearestParentUipxFile,
-  readSolutionManifest
-} from "./packager-tool-m8xtf5ej.js";
+  resolveProjectFlowFile
+} from "./packager-tool-nts5rrch.js";
 import {
-  ManifestClient,
   buildErrorHandle
-} from "./packager-tool-5nqhxb9e.js";
+} from "./packager-tool-dwd6cc01.js";
 import {
-  resolveProjectFlowFile
-} from "./packager-tool-vzbttaje.js";
+  findNearestParentUipxFile,
+  readSolutionManifest
+} from "./packager-tool-8g5931fz.js";
 import {
   canonicalAgentInputPath,
   collectAgentInputLeaves,
   createFlowRefResolver,
   hydrateAgentNodeInputs,
+  inlineEntityBindingIssues,
   inlineFlowRefs,
   parseFlowSource,
   resolveWorkflowRefs,
   runDesignerRules
-} from "./packager-tool-pw6j69m5.js";
+} from "./packager-tool-445qgxdk.js";
 import {
   AGENT_NODE_TYPES,
   DECISION_NODE_TYPE,
@@ -84,13 +90,16 @@ import {
 import {
   OutputFormatter,
   RESULTS,
-  catchError,
   extractErrorMessageSync,
-  logger
-} from "./packager-tool-02f63a08.js";
+  logger,
+  quoteForShell
+} from "./packager-tool-apawc11t.js";
+import {
+  catchError
+} from "./packager-tool-t7ahhaer.js";
 import {
   getFileSystem
-} from "./packager-tool-3h2ktz6q.js";
+} from "./packager-tool-myhbp761.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
@@ -297,7 +306,7 @@ function buildDiagnosticMessage(label, classification, strict) {
   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}`;
+  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 nodes 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}`;
 }
 var MCP_CONNECTOR_KEY = "uipath-uipath-mcp";
 function readDetail(node) {
@@ -397,7 +406,7 @@ async function ensureCatalogRegistered() {
   if (catalogRegistered || !instance.isInitialized)
     return;
   try {
-    const { registerFlowExpressionModelI18n } = await import("./localization-xecwjpe2.js");
+    const { registerFlowExpressionModelI18n } = await import("./localization-d6gjmrsw.js");
     registerFlowExpressionModelI18n(instance);
   } catch (error) {
     logger.warn(`Expression type checking localization unavailable, falling back to English: ${extractErrorMessageSync(error)}`);
@@ -406,7 +415,7 @@ async function ensureCatalogRegistered() {
 }
 var headlessModule;
 function loadHeadless() {
-  headlessModule ??= import("./headless-45dypanh.js").then((mod) => {
+  headlessModule ??= import("./headless-fw8pwyzm.js").then((mod) => {
     logger.info(`Expression type checking: @uipath/flow-expression-model (TypeScript ${mod.HEADLESS_TYPESCRIPT_VERSION})`);
     return mod;
   }).catch((error) => {
@@ -467,7 +476,7 @@ var activityTypeIdValidator = {
       {
         path: `nodes[${node.id}].inputs.detail.uiPathActivityTypeId`,
         severity: "error",
-        message: `${nodeKind} (\`${node.type}\`): \`inputs.detail.uiPathActivityTypeId\` is missing — Studio Web crashes when opening this flow. ` + `Fix: refresh the embedded definition without re-IDing the node — \`uip maestro flow registry get ${quotedType} --output json\`, replace the matching entry in \`definitions[]\` with the returned node object (preserve \`typeVersion\` exactly as returned), ` + `then \`uip maestro flow node configure <file> ${quotedId} --detail <json>\` to re-populate \`inputs.detail.uiPathActivityTypeId\` from the fresh manifest.`
+        message: `${nodeKind} (\`${node.type}\`): \`inputs.detail.uiPathActivityTypeId\` is missing — Studio Web crashes when opening this flow. ` + `Fix: refresh the embedded definition without re-IDing the node — \`uip maestro flow registry get ${quotedType} --output json\`, replace the matching entry in \`definitions[]\` with the returned node object (preserve \`typeVersion\` exactly as returned), ` + `then \`uip maestro flow nodes configure <file> ${quotedId} --detail <json>\` to re-populate \`inputs.detail.uiPathActivityTypeId\` from the fresh manifest.`
       }
     ];
   }
@@ -846,7 +855,7 @@ var inlineActivityValidator = {
     const config = getInlineActivityConfiguration(node);
     if (!config) {
       return [
-        issue("inputs.inlineActivityConfiguration", `Non-catalog activity node (\`${node.type}\`) has no \`inputs.inlineActivityConfiguration\` — the runtime has no activity to run. ` + "Fix: remove the node and re-add it with `uip maestro flow node add <file> <type> --metadata <Name>.json --scripts <dir>`.")
+        issue("inputs.inlineActivityConfiguration", `Non-catalog activity node (\`${node.type}\`) has no \`inputs.inlineActivityConfiguration\` — the runtime has no activity to run. ` + "Fix: remove the node and re-add it with `uip maestro flow nodes create <file> <type> --metadata <Name>.json --scripts <dir>`.")
       ];
     }
     if (!isInlineType) {
@@ -872,10 +881,10 @@ var inlineActivityValidator = {
     if (context && typeof context === "object") {
       const ac = context;
       if (ac.source !== INLINE_ACTIVITY_SOURCE) {
-        issues.push(issue("inputs.detail.activityContext.source", `\`activityContext.source\` must be "${INLINE_ACTIVITY_SOURCE}" for a non-catalog activity (got ${JSON.stringify(ac.source)}). Re-run \`uip maestro flow node configure\`.`));
+        issues.push(issue("inputs.detail.activityContext.source", `\`activityContext.source\` must be "${INLINE_ACTIVITY_SOURCE}" for a non-catalog activity (got ${JSON.stringify(ac.source)}). Re-run \`uip maestro flow nodes configure\`.`));
       }
       if (scriptRef && ac.scriptRef !== scriptRef) {
-        issues.push(issue("inputs.detail.activityContext.scriptRef", `\`activityContext.scriptRef\` (${JSON.stringify(ac.scriptRef)}) does not match the embedded activity's \`scriptRef\` ("${scriptRef}"). Re-run \`uip maestro flow node configure\`.`));
+        issues.push(issue("inputs.detail.activityContext.scriptRef", `\`activityContext.scriptRef\` (${JSON.stringify(ac.scriptRef)}) does not match the embedded activity's \`scriptRef\` ("${scriptRef}"). Re-run \`uip maestro flow nodes configure\`.`));
       }
     }
     return issues;
@@ -902,7 +911,12 @@ var FORBIDDEN_INPUT_FIELDS = [
   "fileName",
   "mimeType"
 ];
-var FILE_REF_PATTERN = /^=js:\$vars\.[A-Za-z_$]/;
+var FILE_REF_BODY_PATTERN = /^\$vars\.[A-Za-z_$]/;
+function isFileRefExpression(fileRef) {
+  const body = getJsExpressionBody(fileRef);
+  return body !== undefined && FILE_REF_BODY_PATTERN.test(body);
+}
+var EXTRACT_V2_NODE_TYPE = "uipath.ixp.extract-document-builder";
 var ixpNodeValidator = {
   id: "ixp-node",
   appliesTo: (node) => typeof node.type === "string" && node.type.startsWith("uipath.ixp."),
@@ -911,21 +925,23 @@ var ixpNodeValidator = {
     const inputs = node.inputs ?? {};
     const outputs = node.outputs ?? {};
     const base = `nodes[${node.id}]`;
-    const model = inputs.model;
     const isNonEmptyString2 = (v) => typeof v === "string" && v.length > 0;
-    if (typeof model !== "object" || model === null || Array.isArray(model) || !isNonEmptyString2(model.modelName) || !isNonEmptyString2(model.folderKey)) {
-      issues.push({
-        path: `${base}.inputs.model`,
-        severity: "error",
-        message: "inputs.model must be an object with non-empty string " + "`modelName` and `folderKey`. Studio Web's property " + "panel destructures these and crashes when either is " + "missing or not a string."
-      });
+    if (node.type !== EXTRACT_V2_NODE_TYPE) {
+      const model = inputs.model;
+      if (typeof model !== "object" || model === null || Array.isArray(model) || !isNonEmptyString2(model.modelName) || !isNonEmptyString2(model.folderKey)) {
+        issues.push({
+          path: `${base}.inputs.model`,
+          severity: "error",
+          message: "inputs.model must be an object with non-empty string " + "`modelName` and `folderKey`. Studio Web's property " + "panel destructures these and crashes when either is " + "missing or not a string."
+        });
+      }
     }
     const fileRef = inputs.fileRef;
-    if (typeof fileRef !== "string" || !FILE_REF_PATTERN.test(fileRef)) {
+    if (!isFileRefExpression(fileRef)) {
       issues.push({
         path: `${base}.inputs.fileRef`,
         severity: "error",
-        message: "inputs.fileRef must be a `=js:$vars.…` expression. " + "The canonical form for an upstream node output is " + "`=js:$vars.<upstream>.output.<field>`. Without the " + "`=js:` prefix the BPMN serializer treats the value " + "as a literal string at runtime."
+        message: "inputs.fileRef must be a `$vars` reference, for " + "example to an upstream node output. Write it either " + "as the string `=js:$vars.<upstream>.output.<field>` " + 'or as `{ "type": "jsExpression", "expression": ' + '"$vars.<upstream>.output.<field>" }` (no `=js:` ' + "prefix inside a jsExpression). Any other value, " + "including a `literal` value, reaches the runtime as " + "a literal and the upstream output never resolves."
       });
     }
     for (const port of ["output", "error"]) {
@@ -2071,6 +2087,7 @@ class FlowValidateService {
   availableModelNames;
   validateCurrentManifests;
   currentManifestOverrides;
+  manifestCache;
   strictBindings;
   strictExpressions;
   connectorCatalogOverride;
@@ -2087,6 +2104,7 @@ class FlowValidateService {
     this.availableModelNames = options.availableModelNames;
     this.validateCurrentManifests = options.validateCurrentManifests === true || options.currentManifests !== undefined;
     this.currentManifestOverrides = options.currentManifests;
+    this.manifestCache = options.manifestCache !== false;
     this.strictBindings = options.strictBindings === true;
     this.strictExpressions = options.strictExpressions === true;
     this.connectorCatalogOverride = options.connectorCatalog;
@@ -2140,27 +2158,13 @@ ${warnings.map((i) => `  - [${i.path}] ${i.message}`).join(`
     if (manifests) {
       return new Map(manifests.map((m) => [m.nodeType.toLowerCase(), m]));
     }
-    const [loginError, loginStatus] = await catchError(getLoginStatusAsync());
-    if (loginError) {
-      logger.warn(`Could not read login status for current manifest validation; using OOTB manifests: ${loginError.message}`);
-    }
-    const client = new ManifestClient({
-      baseUrl: loginStatus?.baseUrl || "localhost"
-    });
-    const auth = loginStatus?.loginStatus === "Logged in" && loginStatus.accessToken && loginStatus.tenantId && loginStatus.organizationId ? {
-      accessToken: loginStatus.accessToken,
-      tenantId: loginStatus.tenantId,
-      organizationId: loginStatus.organizationId
-    } : undefined;
-    const [error, manifest] = await catchError(client.getManifest({
-      ...auth && { auth },
-      inlineAgentNodes: true
-    }));
-    if (error || !manifest?.nodes) {
+    const [error, result] = await catchError(loadCurrentTenantNodes({ force: !this.manifestCache }));
+    if (error || result.nodes.length === 0) {
       logger.warn(`Could not load current OOTB node manifests; skipping stale-handle validation: ${error?.message ?? "manifest response did not include nodes"}`);
       return new Map;
     }
-    return new Map(manifest.nodes.map((m) => [
+    logger.debug(`Current node manifests: ${result.nodes.length} nodes (${result.fromCache ? "from cache" : `fetched, source=${result.source}`})`);
+    return new Map(result.nodes.map((m) => [
       m.nodeType.toLowerCase(),
       m
     ]));
@@ -2201,6 +2205,7 @@ Validating: ${absolutePath}
     issues.push(...await this.validateForwardMigration(content, absolutePath));
     issues.push(...this.validateGraph(workflow, "", rawDefErrorHandling, currentManifests));
     issues.push(...this.validateGlobalVariableUniqueness(workflow, ""));
+    issues.push(...this.validateFileWideIdUniqueness(workflow));
     issues.push(...this.validateGlobalTriggerBindings(workflow, ""));
     issues.push(...this.validateTriggerScopedBareVarReads(workflow, ""));
     issues.push(...this.validateUnboundInputGlobals(workflow, ""));
@@ -2212,7 +2217,8 @@ Validating: ${absolutePath}
     issues.push(...this.validateAgentPromptInputRefs(workflow, hydrationDiagnoses, ""));
     issues.push(...this.validateAgentInputScopeRefs(workflow, hydrationDiagnoses, ""));
     issues.push(...this.validateVoiceAgentSettings(workflow, hydrationDiagnoses, ""));
-    issues.push(...await this.validateSolutionRegistrationAndLayout(absolutePath));
+    issues.push(...await this.validateInlineEntityBindings(workflow, absolutePath));
+    issues.push(...await this.validateSolutionRegistrationAndLayout(absolutePath, workflow));
     issues.push(...await validateExpressions(workflow, "", this.strictExpressions));
     const subflows = workflow.subflows ?? {};
     for (const [subflowId, entry] of Object.entries(subflows)) {
@@ -2750,7 +2756,7 @@ Validating: ${absolutePath}
         const sameTypeVersions = definedVersionsByType.get(node.type);
         const hint = sameTypeVersions?.length ? `
     Hint: \`definitions[]\` has \`${node.type}\` at version(s) ${sameTypeVersions.map((v) => `"${v}"`).join(", ")} but the node uses \`typeVersion: "${node.typeVersion}"\`. Align one side — \`typeVersion\` must match the definition's \`version\` exactly (e.g., \`"1.0"\` ≠ \`"1.0.0"\`).` : `
-    Hint: run \`uip maestro flow registry get ${node.type} --output json\` and append the returned node object to \`definitions[]\` (depending on plugin version, the object is at \`Data.Node\` or the top level). Set \`typeVersion\` to the returned \`version\` exactly — registry may emit \`"1.0"\` while older flows used \`"1.0.0"\`. To scaffold a new node with its definition auto-injected, run \`uip maestro flow node add <file> ${node.type}\` instead.`;
+    Hint: run \`uip maestro flow registry get ${node.type} --output json\` and append the returned node object to \`definitions[]\` (depending on plugin version, the object is at \`Data.Node\` or the top level). Set \`typeVersion\` to the returned \`version\` exactly — registry may emit \`"1.0"\` while older flows used \`"1.0.0"\`. To scaffold a new node with its definition auto-injected, run \`uip maestro flow nodes create <file> ${node.type}\` instead.`;
         issues.push({
           path: `nodes[${node.id}].type`,
           message: `Node type "${key}" has no matching definition.${hint}`,
@@ -2790,6 +2796,49 @@ Validating: ${absolutePath}
     }
     return issues;
   }
+  validateFileWideIdUniqueness(workflow) {
+    const scopes = [
+      {
+        label: "root",
+        nodes: workflow.nodes ?? [],
+        edges: workflow.edges ?? []
+      }
+    ];
+    const subflows = workflow.subflows ?? {};
+    for (const [subflowId, entry] of Object.entries(subflows)) {
+      scopes.push({
+        label: `subflows[${subflowId}]`,
+        nodes: entry?.nodes ?? [],
+        edges: entry?.edges ?? []
+      });
+    }
+    const placesById = new Map;
+    for (const scope of scopes) {
+      for (const kind of ["nodes", "edges"]) {
+        const place = `${kind === "nodes" ? "node" : "edge"} in ${scope.label}`;
+        for (const element of scope[kind]) {
+          const id = element?.id;
+          if (typeof id !== "string")
+            continue;
+          const places = placesById.get(id) ?? [];
+          if (!places.includes(place))
+            places.push(place);
+          placesById.set(id, places);
+        }
+      }
+    }
+    const issues = [];
+    for (const [id, places] of placesById) {
+      if (places.length < 2)
+        continue;
+      issues.push({
+        path: places.some((p) => p.startsWith("node")) ? "nodes" : "edges",
+        message: `Duplicate ID across the file: "${id}" is used by ${places.join(", ")}. Node and edge IDs share one namespace across the root and all subflows; pack merges them into one BPMN document and drops or fails on a repeated ID.`,
+        severity: "error"
+      });
+    }
+    return issues;
+  }
   validateGlobalVariableUniqueness(flow, pathPrefix) {
     const issues = [];
     const globals = flow.variables?.globals ?? [];
@@ -2954,6 +3003,10 @@ Validating: ${absolutePath}
     }
     return issues;
   }
+  async validateInlineEntityBindings(workflow, absolutePath) {
+    const inlineEntities = await readSolutionInlineEntities(this.fs, absolutePath);
+    return inlineEntityBindingIssues(workflow, inlineEntities, absolutePath);
+  }
   validateResourceBindings(workflow) {
     const issues = [];
     const bindings = workflow.bindings ?? [];
@@ -3088,7 +3141,7 @@ Validating: ${absolutePath}
     this.connectorCatalogCache ??= loadConnectorCatalog();
     return this.connectorCatalogCache;
   }
-  async validateSolutionRegistrationAndLayout(absolutePath) {
+  async validateSolutionRegistrationAndLayout(absolutePath, workflow) {
     const issues = [];
     const flowDir = this.fs.path.dirname(absolutePath);
     const discovery = await findNearestParentUipxFile(this.fs, absolutePath);
@@ -3101,20 +3154,20 @@ Validating: ${absolutePath}
     }
     const solutionDir = this.fs.path.dirname(discovery.solutionFile);
     const flowDirReal = await this.canonicalizePath(flowDir);
-    let isRegistered = false;
+    let currentProject;
     for (const p of manifest.projects) {
       const projectDir = this.fs.path.resolve(solutionDir, this.fs.path.dirname(p.ProjectRelativePath));
       const projectDirReal = await this.canonicalizePath(projectDir);
       if (projectDirReal === flowDirReal) {
-        isRegistered = true;
+        currentProject = p;
         break;
       }
     }
-    if (!isRegistered) {
+    if (!currentProject) {
       issues.push({
         path: "(workflow)",
         severity: "warning",
-        message: `.flow file at ${absolutePath} is not registered as a project of solution ${discovery.solutionFile}. Run \`uip solution projects add "${flowDir}"\` so Studio Web and \`flow debug\` can discover it.`
+        message: `.flow file at ${absolutePath} is not registered as a project of solution ${discovery.solutionFile}. So Studio Web and \`flow debug\` can discover it, run: uip solution projects add ${quoteForShell(flowDir)}`
       });
     }
     const flowBase = this.fs.path.basename(absolutePath, ".flow");
@@ -3126,8 +3179,56 @@ Validating: ${absolutePath}
         message: `.flow file at ${absolutePath} does not match canonical layout. Expected the .flow basename ("${flowBase}") to match its parent directory name ("${dirBase}"). The canonical layout is <solution>/<projectName>/<projectName>.flow.`
       });
     }
+    issues.push(...await this.validateInSolutionProcessKeys(workflow, solutionDir, manifest.projects, currentProject?.Id));
     return issues;
   }
+  async validateInSolutionProcessKeys(workflow, solutionDir, projects, currentProjectId) {
+    const definitions = workflow.definitions;
+    const nodes = [
+      ...workflow.nodes.map((n) => ({ ...n, scope: "" })),
+      ...Object.entries(workflow.subflows ?? {}).flatMap(([subflowId, sub]) => (sub.nodes ?? []).map((n) => ({
+        ...n,
+        scope: `subflows[${subflowId}].`
+      })))
+    ];
+    const refs = nodes.flatMap((node) => {
+      const def = findNodeDefinition(definitions, node);
+      const bindings = def?.model?.bindings;
+      const key = bindings?.resourceKey;
+      if (!Array.isArray(def?.tags) || !def.tags.includes("in-solution") || String(bindings?.resource).toLowerCase() !== "process" || typeof key !== "string" || key.length === 0) {
+        return [];
+      }
+      const projectId = typeof def.projectId === "string" ? def.projectId : undefined;
+      return [{ node, key, projectId }];
+    });
+    if (refs.length === 0)
+      return [];
+    const keyByProject = await loadResourceKeyMap(solutionDir);
+    const known = new Set([...keyByProject.values()].map((k) => k.toLowerCase()));
+    const withoutProcessResource = new Map((await findProjectsWithoutProcessResource({
+      solutionDir,
+      projects,
+      currentProjectId
+    })).map((p) => [p.id.toLowerCase(), p]));
+    const severity = this.strictBindings ? "error" : "warning";
+    return refs.filter(({ key }) => !known.has(key.toLowerCase())).map(({ node, key, projectId }) => {
+      const pending = withoutProcessResource.get(key.toLowerCase());
+      if (pending) {
+        return {
+          path: `${node.scope}nodes[${node.id}].bindings`,
+          severity,
+          message: `Node "${node.id}" (type ${node.type}) calls in-solution process key "${key}", which is the project id of '${pending.name}', a project with no process resource yet. The next \`uip solution resources refresh\` gives it a new key, and this call stops matching. Run: ${resourcesRefreshCommand(solutionDir)}. Then re-run \`uip maestro flow registry get <node-type> --local\` and replace the node's definition and bindings.`
+        };
+      }
+      const currentKey = projectId ? keyByProject.get(projectId.toLowerCase()) : undefined;
+      const hint = currentKey ? `Its project now has process key "${currentKey}"; re-run \`uip maestro flow registry get <node-type> --local\` and replace the node's definition and bindings.` : "No project in the solution has that key. Re-add the project, or remove the node.";
+      return {
+        path: `${node.scope}nodes[${node.id}].bindings`,
+        severity,
+        message: `Node "${node.id}" (type ${node.type}) calls in-solution process key "${key}", which matches no process resource in solution ${solutionDir}. ${hint}`
+      };
+    });
+  }
   async canonicalizePath(p) {
     const [err, real] = await catchError(this.fs.realpath(p));
     return err || !real ? p : real;
@@ -3506,4 +3607,4 @@ function describeUnsatisfiableJoin(node, finding, graph) {
 
 export { FlowValidateService };
 
-//# debugId=109FFC78163852D164756E2164756E21
+//# debugId=00181C4930912C2764756E2164756E21

package/dist/packager-tool-9era57c0.js

@@ -0,0 +1,28 @@
+import {
+  getAuthContext
+} from "./packager-tool-kn86394c.js";
+
+// ../solution-sdk/src/solution-auth.ts
+async function getSolutionAuthContext(options) {
+  const ctx = await getAuthContext({
+    tenant: options.tenant,
+    ensureTokenValidityMinutes: options.loginValidity ?? 10,
+    envFilePath: options.envFilePath,
+    requireOrganizationId: true,
+    requireTenantName: true
+  });
+  const organizationId = ctx.organizationId;
+  const tenantName = ctx.tenantName;
+  const basePath = `${ctx.baseUrl}/${organizationId}/${tenantName}/automationsolutions_`;
+  return {
+    accessToken: ctx.accessToken,
+    basePath,
+    organizationId,
+    tenantName,
+    identity: ctx.identity
+  };
+}
+
+export { getSolutionAuthContext };
+
+//# debugId=F76D3832B86881B164756E2164756E21

package/dist/packager-tool-9jxzgsxc.js

@@ -0,0 +1,14 @@
+import {
+  EvalRunApi
+} from "./packager-tool-xk78j7dz.js";
+
+// src/services/flow-eval-run-api.ts
+class FlowEvalRunApi extends EvalRunApi {
+  constructor() {
+    super("Flow");
+  }
+}
+
+export { FlowEvalRunApi };
+
+//# debugId=028E1F1C632C0C6664756E2164756E21

package/dist/{packager-tool-zxp4hya4.js → packager-tool-a5afh1dc.js}

@@ -1,24 +1,29 @@
+import {
+  UnknownEntryPointError
+} from "./packager-tool-4kr6g0zw.js";
 import {
   JobsApi,
   ReleasesApi,
   createOrchestratorConfig,
   resolveFolder
-} from "./packager-tool-n89vrpex.js";
+} from "./packager-tool-skcjythd.js";
 import {
   parseJsonInputOrFile
-} from "./packager-tool-py93409h.js";
+} from "./packager-tool-ymma2s85.js";
 import {
   getPersonalFolderKey
-} from "./packager-tool-peawy22c.js";
+} from "./packager-tool-tqjfdpda.js";
 import {
   ErrorDecision,
   MIN_INTERVAL_MS,
   PollOutcome,
-  catchError,
   logger,
   pollUntil,
   processContext
-} from "./packager-tool-02f63a08.js";
+} from "./packager-tool-apawc11t.js";
+import {
+  catchError
+} from "./packager-tool-t7ahhaer.js";
 
 // src/services/http-client.ts
 function buildCommonHeaders(config, options) {
@@ -78,7 +83,7 @@ async function resolveFlowFolderId(config) {
   });
   return personalFolder.id.toString();
 }
-async function listFlowProcesses(config, filter) {
+async function listFlowProcesses(config, filter, window = {}) {
   const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
   const sdkConfig = await createOrchestratorConfig({
     folderId: folder.id.toString()
@@ -90,7 +95,9 @@ async function listFlowProcesses(config, filter) {
   }
   const filterQuery = filters.length > 0 ? filters.join(" and ") : undefined;
   const response = await releasesApi.releasesGet({
-    $filter: filterQuery
+    $filter: filterQuery,
+    $top: window.limit,
+    $skip: window.offset || undefined
   });
   return response.value || [];
 }
@@ -130,6 +137,18 @@ async function getFlowEntryPoints(config) {
   const response = await orchestratorGet(apiConfig, path);
   return response.value;
 }
+async function defaultFlowEntryPoint(config, mainEntryPointId) {
+  const entryPoints = await getFlowEntryPoints(config);
+  return entryPoints.find((ep) => ep.Id === mainEntryPointId) ?? entryPoints[0];
+}
+async function resolveEntryPoint(config, entryPoint) {
+  const triggers = (await getFlowEntryPoints(config)).filter((ep) => ep.Path.includes("#")).map((ep) => ({ ep, id: ep.Path.slice(ep.Path.lastIndexOf("#") + 1) }));
+  const match = triggers.find((trigger) => trigger.id === entryPoint);
+  if (!match) {
+    throw new UnknownEntryPointError(entryPoint, triggers.map((trigger) => trigger.id));
+  }
+  return match.ep;
+}
 async function startFlowJob(config) {
   const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
   const sdkConfig = await createOrchestratorConfig({
@@ -145,6 +164,9 @@ async function startFlowJob(config) {
   if (config.robotIds && config.robotIds.length > 0) {
     startInfo.robotIds = config.robotIds;
   }
+  if (config.entryPointPath !== undefined) {
+    startInfo.entryPointPath = config.entryPointPath;
+  }
   const response = await jobsApi.jobsStartJobs({
     body: { startInfo }
   });
@@ -382,16 +404,15 @@ function isJobAttachmentReference(value) {
   const ref = value;
   return typeof ref.ID === "string" && typeof ref.FullName === "string";
 }
-async function validateFlowInputs(config, inputs) {
+async function validateFlowInputs(config, inputs, chosenEntryPoint, mainEntryPointId) {
   try {
-    const entryPoints = await getFlowEntryPoints(config);
-    if (entryPoints.length === 0) {
+    const entryPoint = chosenEntryPoint ?? await defaultFlowEntryPoint(config, mainEntryPointId);
+    if (entryPoint === undefined) {
       return {
         valid: false,
         errors: ["No entry points found for this process"]
       };
     }
-    const entryPoint = entryPoints[0];
     const inputSchema = JSON.parse(entryPoint.InputArguments);
     if (inputSchema.type !== "object") {
       return { valid: true };
@@ -438,6 +459,6 @@ async function parseFlowInputs(inputSource) {
   return await parseJsonInputOrFile(inputSource);
 }
 
-export { listFlowProcesses, listFlowJobs, getFlowEntryPoints, spanToTraceEvent, startFlowProjectJob, streamJobTraces, getJobStatusDetailed, validateFlowInputs, parseFlowInputs };
+export { escapeODataStringLiteral, listFlowProcesses, listFlowJobs, getFlowEntryPoints, resolveEntryPoint, spanToTraceEvent, startFlowProjectJob, streamJobTraces, getJobStatusDetailed, validateFlowInputs, parseFlowInputs };
 
-//# debugId=71663E4B97C8B40164756E2164756E21
+//# debugId=A28215A36FCF992064756E2164756E21