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

package/dist/{flow-debug-service-0xn8fk4a.js → flow-debug-service-hy21ddd9.js}

@@ -1,132 +1,105 @@
 import {
-  writeResolvedFlow
-} from "./packager-tool-ykbahxma.js";
+  getFileSystem
+} from "./packager-tool-vgrswa8p.js";
 import {
-  resolveEntryPointNodeId
-} from "./packager-tool-j95w4fj3.js";
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
 import {
-  package_default
-} from "./packager-tool-gpwnzqd9.js";
-import"./packager-tool-4kr6g0zw.js";
+  logger
+} from "./packager-tool-8ed52y5r.js";
 import {
-  assertNoPreviewIds
-} from "./packager-tool-zgsvggdr.js";
-import"./packager-tool-e5hj89zm.js";
+  convertFlowToBpmn,
+  allNodesOf,
+  replaceExporterVersion,
+  hydrateInlineAgentInputVariables,
+  voiceConvertOptions,
+  assertVoiceAgentDefinitionsEmbedded
+} from "./packager-tool-mdf7bws6.js";
+import {
+  isVoiceAgentNodeType2
+} from "./packager-tool-fzgfb0jt.js";
+import"./packager-tool-508ka40b.js";
+import {
+  extractStartEventId2,
+  getPersonalFolderInfo2,
+  getFolderInfoById2,
+  DebugVariablesFetchFailedError2,
+  fetchDebugInstanceVariables2,
+  isSuccessfulDebugStatus2,
+  buildStudioWebDesignerUrl2,
+  uploadAndDebugSolution2,
+  patchConnectionOverwrites2
+} from "./packager-tool-jmrhzfyj.js";
+import"./packager-tool-ze3fnf3s.js";
+import"./packager-tool-2b0tn4p4.js";
+import {
+  createZipFromDir2,
+  buildSolutionPackageFromDir2,
+  uploadOrOverwriteSolution2
+} from "./packager-tool-5ve5ms3b.js";
+import {
+  workflowToFileFormat,
+  readFlowWorkflow2,
+  writeFlowWorkflow2,
+  resolveProjectFlowFile2,
+  findProjectFlowFile2
+} from "./packager-tool-6jpvvxyb.js";
+import"./packager-tool-ac6rvny7.js";
+import"./packager-tool-1rhch6b5.js";
+import {
+  UnboundInlineEntityError2,
+  assertInlineEntitiesBound2
+} from "./packager-tool-8n4bdvke.js";
+import"./packager-tool-gdpw0daf.js";
+import"./packager-tool-kz3t4raw.js";
+import"./packager-tool-65yf8zqb.js";
+import"./packager-tool-1qg04b7q.js";
+import"./packager-tool-p123mtfx.js";
+import"./packager-tool-xb16e3tz.js";
+import"./packager-tool-d07g2kpn.js";
+import"./packager-tool-a1h0q79w.js";
+import"./packager-tool-21t17xzz.js";
+import"./packager-tool-b2pkwwj1.js";
 import {
-  buildInlineAgentDescriptors,
-  ensureProcessBindings,
   fileNodesToPackagingNodes,
   flowToPackagingNodes,
   packageInlineAgents,
   stageInlineAgentPackageFiles,
-  writePackagingArtifacts
-} from "./packager-tool-kkwrd05c.js";
-import"./packager-tool-cqtsj6yh.js";
-import {
-  UnboundInlineEntityError,
-  assertInlineEntitiesBound
-} from "./packager-tool-143kcy6z.js";
-import"./packager-tool-mgwzjh8c.js";
-import"./packager-tool-dxgrhfq5.js";
-import"./packager-tool-7hw344bt.js";
-import"./packager-tool-z21c6mbp.js";
-import"./packager-tool-409n51pv.js";
-import"./packager-tool-skcjythd.js";
-import"./packager-tool-4x7tzvv0.js";
-import"./packager-tool-3jkppykr.js";
-import"./packager-tool-ymma2s85.js";
+  buildInlineAgentDescriptors,
+  writePackagingArtifacts,
+  ensureProcessBindings2
+} from "./packager-tool-5dgpfh5e.js";
+import"./packager-tool-9217bxm2.js";
 import {
-  DebugProvisioningFailedError,
-  DebugVariablesFetchFailedError,
-  buildStudioWebDesignerUrl,
-  extractStartEventId,
-  fetchDebugInstanceVariables,
-  getFolderInfoById,
-  getPersonalFolderInfo,
-  isSuccessfulDebugStatus,
-  patchConnectionOverwrites,
-  uploadAndDebugSolution
-} from "./packager-tool-tqjfdpda.js";
-import"./packager-tool-frjt46rb.js";
-import"./packager-tool-hxyjn885.js";
-import"./packager-tool-xk78j7dz.js";
-import"./packager-tool-8qp60s20.js";
-import"./packager-tool-kn86394c.js";
-import"./packager-tool-0gctz400.js";
-import"./packager-tool-qa9gftnj.js";
-import"./packager-tool-yc4kw997.js";
+  writeResolvedFlow
+} from "./packager-tool-t17t9svg.js";
 import {
-  buildSolutionPackageFromDir,
-  createZipFromDir,
-  uploadOrOverwriteSolution
-} from "./packager-tool-79jnagb9.js";
+  resolveEntryPointNodeId
+} from "./packager-tool-q0f1dvtd.js";
 import {
-  findProjectFlowFile,
-  readFlowWorkflow,
-  resolveProjectFlowFile,
-  writeFlowWorkflow
-} from "./packager-tool-hgfygxyj.js";
-import"./packager-tool-9rmaeaww.js";
-import"./packager-tool-paq9c70w.js";
+  package_default
+} from "./packager-tool-7qtnffkc.js";
 import {
-  findNearestParentUipxFile,
-  findSolutionFile,
-  isProjectRegisteredInSolution,
-  readUipxFile,
-  updateSolutionFile
-} from "./packager-tool-8g5931fz.js";
+  assertNoPreviewIds
+} from "./packager-tool-f7rk9xhv.js";
+import"./packager-tool-2sazb7th.js";
+import"./packager-tool-64r7e4ek.js";
+import"./packager-tool-8ba22j6n.js";
 import {
-  assertVoiceAgentDefinitionsEmbedded,
-  convertFlowToBpmn,
-  hydrateInlineAgentInputVariables,
-  replaceExporterVersion,
-  voiceConvertOptions
-} from "./packager-tool-dw1bm5y7.js";
-import"./packager-tool-pvhx9e12.js";
+  readUipxFile2,
+  findSolutionFile2,
+  updateSolutionFile2,
+  findNearestParentUipxFile2,
+  isProjectRegisteredInSolution2
+} from "./packager-tool-em4ppegs.js";
 import {
-  applyRuntimeProfile,
+  applyRuntimeProfile2,
   resolveRuntimeProfile,
   resolveRuntimeProfileForFlowFile
-} from "./packager-tool-jgfzfqjm.js";
-import"./packager-tool-dbsdy4xx.js";
-import"./packager-tool-qkn0c042.js";
-import"./packager-tool-pacrqxv2.js";
-import"./packager-tool-nkrmjr3a.js";
-import"./packager-tool-rs6jm14d.js";
-import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-mgcz986r.js";
-import"./packager-tool-xj0agqpk.js";
-import"./packager-tool-pcvhcn2k.js";
-import"./packager-tool-sc961w0q.js";
-import"./packager-tool-t07ev0jj.js";
-import"./packager-tool-7bam8cjq.js";
-import"./packager-tool-gbgfwx8f.js";
-import"./packager-tool-6z1hsm2h.js";
-import"./packager-tool-jysvpt8p.js";
-import {
-  inMemoryWorkflowToFileFormat,
-  isVoiceAgentNodeType
-} from "./packager-tool-s7wb0s9n.js";
-import"./packager-tool-p79yh9ww.js";
-import"./packager-tool-jrnjzs5t.js";
-import"./packager-tool-z83pga0z.js";
-import"./packager-tool-6ejqwbw9.js";
-import"./packager-tool-mcaf4ewf.js";
-import"./packager-tool-eypvc2kv.js";
-import {
-  logger
-} from "./packager-tool-apawc11t.js";
-import {
-  catchError
-} from "./packager-tool-t7ahhaer.js";
-import {
-  getFileSystem
-} from "./packager-tool-myhbp761.js";
-import"./packager-tool-4mna26cc.js";
-import"./packager-tool-c23zrhj8.js";
-import {
-  __require
-} from "./packager-tool-1yh8g550.js";
+} from "./packager-tool-14rdgz3c.js";
+import"./packager-tool-jd3v0bh1.js";
+import"./packager-tool-4g87fbz6.js";
+import"./packager-tool-4zt1s51a.js";
 
 // src/services/flow-debug-service.ts
 var FLOW_DEBUG_MISSING_SOLUTION_MESSAGE = "Flow debug requires this Flow to be inside a solution.";
@@ -190,24 +163,16 @@ function buildFlowDebugMissingResourcesInstructions(missingResources) {
   return steps.join(" ");
 }
 
-class DebugProvisioningMissingResourcesError extends DebugProvisioningFailedError {
+class FlowDebugMissingResourcesError extends Error {
   instructions;
   missingResources;
-  constructor(cause, missingResources) {
-    super(cause.status, cause.errors);
-    this.name = "DebugProvisioningMissingResourcesError";
-    this.message = `${cause.message} These resources were not found before upload and may be the cause: ` + missingResources.join("; ");
+  constructor(missingResources) {
+    super("Debug did not start and nothing was uploaded: the solution binds resources that do not exist, " + `so Studio Web cannot provision them: ${missingResources.join("; ")}`);
+    this.name = "FlowDebugMissingResourcesError";
     this.missingResources = missingResources;
     this.instructions = buildFlowDebugMissingResourcesInstructions(missingResources);
-    this.cause = cause;
   }
 }
-function withMissingResourceContext(error, missingResourceWarnings) {
-  if (error instanceof DebugProvisioningFailedError && error.isValidationFailure && missingResourceWarnings.length > 0) {
-    return new DebugProvisioningMissingResourcesError(error, missingResourceWarnings);
-  }
-  return error;
-}
 var VOICE_TRIGGER_TYPE = "core.trigger.voice";
 var FLOW_DEBUG_INBOUND_VOICE_MESSAGE = "Inbound voice flows cannot be debugged from the CLI.";
 var buildFlowDebugInboundVoiceInstructions = (triggerLabel) => [
@@ -240,7 +205,7 @@ class FlowDebugService {
   }
   async assertEnclosingSolution(projectPath) {
     const absoluteProjectPath = this.fs.path.resolve(projectPath);
-    const discovery = await findNearestParentUipxFile(this.fs, absoluteProjectPath);
+    const discovery = await findNearestParentUipxFile2(this.fs, absoluteProjectPath);
     if (discovery.status === "found") {
       return discovery.solutionFile;
     }
@@ -248,7 +213,7 @@ class FlowDebugService {
   }
   async assertProjectRegisteredInSolution(projectPath, solutionFile) {
     const absoluteProjectPath = this.fs.path.resolve(projectPath);
-    const isRegistered = await isProjectRegisteredInSolution(this.fs, absoluteProjectPath, solutionFile);
+    const isRegistered = await isProjectRegisteredInSolution2(this.fs, absoluteProjectPath, solutionFile);
     if (!isRegistered) {
       throw new UnregisteredProjectError(absoluteProjectPath, solutionFile);
     }
@@ -261,7 +226,7 @@ class FlowDebugService {
     if (!absolutePath.endsWith(".flow")) {
       throw new Error(`Expected a .flow file but got: ${this.fs.path.basename(absolutePath)}`);
     }
-    const { workflow } = await readFlowWorkflow(absolutePath);
+    const { workflow } = await readFlowWorkflow2(absolutePath);
     return workflow;
   }
   async readBpmnFile(bpmnFilePath) {
@@ -281,12 +246,12 @@ class FlowDebugService {
       await this.hydrateInlineAgentInputs(workflow, projectDir);
     }
     const flowNodes = workflow.nodes ?? [];
-    const voiceNodes = flowNodes.filter((node) => isVoiceAgentNodeType(node.type));
+    const voiceNodes = flowNodes.filter((node) => isVoiceAgentNodeType2(node.type));
     if (voiceNodes.length > 0 && !projectDir) {
       throw new Error("This flow contains voice agent nodes; the flow project directory is required to resolve their agent definitions.");
     }
     const voiceAgentPackages = projectDir ? await packageInlineAgents(this.fs, projectDir, voiceNodes) : [];
-    const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+    const fileFormat = workflowToFileFormat(workflow);
     const flowJson = JSON.stringify(fileFormat, null, 2);
     const { bpmn: rawBpmn } = await convertFlowToBpmn(flowJson, voiceConvertOptions({
       flowJson,
@@ -302,13 +267,13 @@ class FlowDebugService {
     return bpmn;
   }
   async hydrateInlineAgentInputs(workflow, projectDir) {
-    const nodes = workflow.nodes ?? [];
+    const nodes = allNodesOf(workflow);
     await hydrateInlineAgentInputVariables(nodes, async (source) => {
       const agentJsonPath = this.fs.path.join(projectDir, source, "agent.json");
-      const [readErr, raw] = await catchError(this.fs.readFile(agentJsonPath, "utf-8"));
+      const [readErr, raw] = await catchError2(this.fs.readFile(agentJsonPath, "utf-8"));
       if (readErr || typeof raw !== "string")
         return;
-      const [parseErr, agent] = catchError(() => JSON.parse(raw));
+      const [parseErr, agent] = catchError2(() => JSON.parse(raw));
       if (parseErr || !agent)
         return;
       return agent.inputSchema;
@@ -318,13 +283,13 @@ class FlowDebugService {
     const safeName = flowData.name.replace(/[^a-zA-Z0-9_-]/g, "_");
     const projectDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-debug-${safeName}-${Date.now()}`);
     const safeMkdir = async (dir) => {
-      const [err] = await catchError(this.fs.mkdir(dir));
+      const [err] = await catchError2(this.fs.mkdir(dir));
       if (err && err.code !== "EEXIST") {
         throw err;
       }
     };
     await safeMkdir(projectDir);
-    const resolvedStartEventId = startEventId ?? extractStartEventId(bpmnXml);
+    const resolvedStartEventId = startEventId ?? extractStartEventId2(bpmnXml);
     const bpmnFileName = `${safeName}.bpmn`;
     const packagingNodes = flowToPackagingNodes(flowData);
     const entryPointNodes = fileNodesToPackagingNodes(flowData.nodes);
@@ -337,7 +302,7 @@ class FlowDebugService {
     };
     await this.fs.writeFile(this.fs.path.join(projectDir, "project.uiproj"), `${JSON.stringify(projectUiproj, null, 2)}
 `);
-    await applyRuntimeProfile(this.fs, projectDir, profile);
+    await applyRuntimeProfile2(this.fs, projectDir, profile);
     await writePackagingArtifacts(this.fs, projectDir, flowData.id, packagingNodes, bindings, variables, bpmnFileName, resolvedStartEventId, `${safeName}.flow`, definitions, { entryPointNodes, profile });
     await this.fs.writeFile(this.fs.path.join(projectDir, `${safeName}.bpmn`), bpmnXml);
     if (flowFileContent) {
@@ -376,7 +341,7 @@ class FlowDebugService {
     await this.fs.mkdir(destProjectDir);
     await this.fs.copyDirectory(projectDir, destProjectDir);
     const uisPath = this.fs.path.join(this.fs.env.tmpdir(), `${projectName}Solution-${Date.now()}.uis`);
-    const zipData = await createZipFromDir(this.fs, stagingDir);
+    const zipData = await createZipFromDir2(this.fs, stagingDir);
     await this.fs.writeFile(uisPath, zipData);
     await this.fs.rm(stagingDir).catch(() => {});
     return uisPath;
@@ -432,30 +397,30 @@ class FlowDebugService {
     return descriptors;
   }
   async generateSiblingFlowPackage(projectStagingDir, hostProjectName, sourceProjectDir = projectStagingDir) {
-    const [resolveError, flowFilePath] = await catchError(findProjectFlowFile(projectStagingDir));
+    const [resolveError, flowFilePath] = await catchError2(findProjectFlowFile2(projectStagingDir));
     if (resolveError || !flowFilePath) {
       logger.warn(`No .flow found for sibling project ${projectStagingDir}; skipping BPMN generation.`);
       return [];
     }
     const flowFileName = this.fs.path.basename(flowFilePath);
-    const { workflow: flowData } = await readFlowWorkflow(flowFilePath);
-    await assertInlineEntitiesBound(this.fs, this.fs.path.join(sourceProjectDir, this.fs.path.relative(projectStagingDir, flowFilePath)), flowData);
-    ensureProcessBindings(flowData);
+    const { workflow: flowData } = await readFlowWorkflow2(flowFilePath);
+    await assertInlineEntitiesBound2(this.fs, this.fs.path.join(sourceProjectDir, this.fs.path.relative(projectStagingDir, flowFilePath)), flowData);
+    ensureProcessBindings2(flowData);
     const bpmnXml = await this.convertToBpmn(flowData, this.fs.path.dirname(flowFilePath));
-    const inlineAgentPackages = await packageInlineAgents(this.fs, projectStagingDir, flowData.nodes);
+    const inlineAgentPackages = await packageInlineAgents(this.fs, projectStagingDir, allNodesOf(flowData));
     await this.writeFlowProjectPackage(projectStagingDir, flowData, bpmnXml, flowFileName, inlineAgentPackages, await resolveRuntimeProfile(this.fs, sourceProjectDir));
     await stageInlineAgentPackageFiles(this.fs, projectStagingDir, projectStagingDir, inlineAgentPackages, (source) => `Staged inline agent "${source}" for sibling Flow debug`);
     logger.info(`Generated BPMN package for sibling flow "${flowFileName.replace(/\.flow$/i, "")}"`);
-    return buildInlineAgentDescriptors(flowData.nodes).map((agent) => ({
+    return buildInlineAgentDescriptors(allNodesOf(flowData)).map((agent) => ({
       ...agent,
       hostProjectName
     }));
   }
   async writeFlowProjectPackage(projectDir, flowData, bpmnXml, flowFileName, inlineAgentPackages = [], profile = "Standard" /* Standard */) {
     const bpmnFileName = `${flowFileName.replace(/\.flow$/i, "")}.bpmn`;
-    await writeFlowWorkflow(this.fs.path.join(projectDir, flowFileName), flowData);
+    await writeFlowWorkflow2(this.fs.path.join(projectDir, flowFileName), flowData);
     await this.fs.writeFile(this.fs.path.join(projectDir, bpmnFileName), bpmnXml);
-    const startEventId = extractStartEventId(bpmnXml);
+    const startEventId = extractStartEventId2(bpmnXml);
     await writePackagingArtifacts(this.fs, projectDir, flowData.id, flowToPackagingNodes(flowData), flowData.bindings ?? [], flowData.variables ?? {}, bpmnFileName, startEventId, flowFileName, flowData.definitions ?? [], {
       entryPointNodes: fileNodesToPackagingNodes(flowData.nodes),
       additionalEntryPoints: inlineAgentPackages.map((agent) => agent.entryPoint),
@@ -496,7 +461,7 @@ class FlowDebugService {
     if (!content) {
       return "";
     }
-    const [err, parsed] = catchError(() => JSON.parse(content));
+    const [err, parsed] = catchError2(() => JSON.parse(content));
     const filePath = err ? undefined : parsed.entryPoints?.[0]?.filePath;
     return typeof filePath === "string" ? filePath : "";
   }
@@ -510,7 +475,7 @@ class FlowDebugService {
     if (!content) {
       return "";
     }
-    return `/${bpmnFile}#${extractStartEventId(content)}`;
+    return `/${bpmnFile}#${extractStartEventId2(content)}`;
   }
   async readProjectTypeRaw(projectDir) {
     const path = this.fs.path.join(projectDir, "project.uiproj");
@@ -521,7 +486,7 @@ class FlowDebugService {
     if (!content) {
       return;
     }
-    const [err, parsed] = catchError(() => JSON.parse(content));
+    const [err, parsed] = catchError2(() => JSON.parse(content));
     const projectType = err ? undefined : parsed.ProjectType;
     return typeof projectType === "string" ? projectType : undefined;
   }
@@ -552,8 +517,8 @@ class FlowDebugService {
     const projectUiproj = JSON.parse(projectUiprojContent);
     const projectName = projectUiproj.Name;
     const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const flowFilePath = await resolveProjectFlowFile(absoluteProjectPath);
-    const { workflow: flowData } = await readFlowWorkflow(flowFilePath);
+    const flowFilePath = await resolveProjectFlowFile2(absoluteProjectPath);
+    const { workflow: flowData } = await readFlowWorkflow2(flowFilePath);
     assertNotInboundVoiceFlow(flowData);
     const startNodeId = resolveEntryPointNodeId(flowData.nodes ?? [], options?.entryPoint);
     if (options?.inputs && flowData.variables?.globals) {
@@ -563,8 +528,8 @@ class FlowDebugService {
         }
       }
     }
-    await assertInlineEntitiesBound(this.fs, flowFilePath, flowData);
-    ensureProcessBindings(flowData);
+    await assertInlineEntitiesBound2(this.fs, flowFilePath, flowData);
+    ensureProcessBindings2(flowData);
     logger.info("Found .flow file, converting to BPMN...");
     const bpmnXml = await this.convertToBpmn(flowData, this.fs.path.dirname(flowFilePath));
     const solutionDir = this.fs.path.resolve(absoluteProjectPath, "..");
@@ -573,7 +538,7 @@ class FlowDebugService {
     let uisPath;
     let entryPoint;
     try {
-      const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, solutionDir));
+      const [uipxError, uipxResult] = await catchError2(readUipxFile2(this.fs, solutionDir));
       if (uipxError) {
         logger.warn(`Could not read .uipx: ${uipxError.message}. Falling back to flow-only upload.`);
       }
@@ -603,9 +568,9 @@ class FlowDebugService {
             const siblingStagingDir = this.fs.path.join(stagingDir, projectDir);
             await this.fs.copyDirectory(srcProjectPath, siblingStagingDir);
             if (project.Type === "Flow") {
-              const [packageError, agents] = await catchError(this.generateSiblingFlowPackage(siblingStagingDir, projectDir, srcProjectPath));
+              const [packageError, agents] = await catchError2(this.generateSiblingFlowPackage(siblingStagingDir, projectDir, srcProjectPath));
               if (packageError) {
-                if (packageError instanceof UnboundInlineEntityError) {
+                if (packageError instanceof UnboundInlineEntityError2) {
                   throw packageError;
                 }
                 logger.warn(`Could not package sibling Flow "${projectDir}": ${packageError.message}. Continuing.`);
@@ -622,20 +587,20 @@ class FlowDebugService {
       const stagingProjectDir = this.fs.path.join(stagingDir, flowProjectRelDir);
       await this.fs.mkdir(stagingProjectDir);
       await this.fs.writeFile(this.fs.path.join(stagingProjectDir, "project.uiproj"), projectUiprojContent);
-      const inlineAgentPackages = await packageInlineAgents(this.fs, absoluteProjectPath, flowData.nodes);
+      const inlineAgentPackages = await packageInlineAgents(this.fs, absoluteProjectPath, allNodesOf(flowData));
       const profile = await resolveRuntimeProfile(this.fs, absoluteProjectPath);
-      await applyRuntimeProfile(this.fs, stagingProjectDir, profile);
+      await applyRuntimeProfile2(this.fs, stagingProjectDir, profile);
       const { bpmnFileName, startEventId } = await this.writeFlowProjectPackage(stagingProjectDir, flowData, bpmnXml, `${safeName}.flow`, inlineAgentPackages, profile);
       if (inlineAgentPackages.length > 0) {
         await stageInlineAgentPackageFiles(this.fs, absoluteProjectPath, stagingProjectDir, inlineAgentPackages, (source) => `Staged inline agent "${source}" for debug`);
       }
       const inlineAgents = [
         ...siblingInlineAgents,
-        ...buildInlineAgentDescriptors(flowData.nodes)
+        ...buildInlineAgentDescriptors(allNodesOf(flowData))
       ];
       const startNode = startNodeId ?? startEventId;
       entryPoint = `/${bpmnFileName}#${startNode}`;
-      const [refreshError, refreshResult] = await catchError(import("./index-1b2je9n2.js").then((mod) => mod.resourceRefreshAsync(stagingDir)));
+      const [refreshError, refreshResult] = await catchError2(import("./index-px95xmkg.js").then((mod) => mod.resourceRefreshAsync(stagingDir)));
       let missingResourceWarnings = [];
       if (refreshError) {
         logger.warn(`Resource refresh threw before debug: ${refreshError.message}. Continuing without generated overwrites.`);
@@ -648,10 +613,14 @@ class FlowDebugService {
       } else {
         logger.warn(`Resource refresh skipped before debug: ${refreshResult.message}. Continuing.`);
       }
+      if (!options?.uploadOnly && missingResourceWarnings.length > 0) {
+        throw new FlowDebugMissingResourcesError(missingResourceWarnings);
+      }
       logger.info("Building solution package (all projects)...");
-      uisPath = await buildSolutionPackageFromDir(this.fs, stagingDir);
+      const builtUisPath = await buildSolutionPackageFromDir2(this.fs, stagingDir);
+      uisPath = builtUisPath;
       logger.info("Looking for .uipx solution file...");
-      const solutionInfo = await findSolutionFile(this.fs, absoluteProjectPath);
+      const solutionInfo = await findSolutionFile2(this.fs, absoluteProjectPath);
       const existingSolutionId = solutionInfo?.solutionId;
       const apiConfig = {
         baseUrl: config.baseUrl,
@@ -661,10 +630,10 @@ class FlowDebugService {
         authToken: config.authToken,
         organizationUnitId: config.organizationUnitId
       };
-      const folderInfo = config.userProvidedFolderId !== undefined ? await getFolderInfoById(apiConfig, config.userProvidedFolderId) : await getPersonalFolderInfo(apiConfig);
+      const folderInfo = config.userProvidedFolderId !== undefined ? await getFolderInfoById2(apiConfig, config.userProvidedFolderId) : await getPersonalFolderInfo2(apiConfig);
       const uploadAndPatch = async () => {
-        const importResult = await uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, existingSolutionId, this.fs);
-        const patchedCount = await patchConnectionOverwrites(apiConfig, config.organizationName, importResult.id, solutionDir, folderInfo, this.fs);
+        const importResult = await uploadOrOverwriteSolution2(apiConfig, config.organizationName, builtUisPath, existingSolutionId, this.fs);
+        const patchedCount = await patchConnectionOverwrites2(apiConfig, config.organizationName, importResult.id, solutionDir, folderInfo, this.fs);
         if (patchedCount > 0) {
           logger.info(`Patched ${patchedCount} connection overwrite(s) on Studio Web`);
         }
@@ -672,9 +641,9 @@ class FlowDebugService {
       };
       if (options?.uploadOnly) {
         const importResult = await uploadAndPatch();
-        await updateSolutionFile(this.fs, absoluteProjectPath, importResult.id);
+        await updateSolutionFile2(this.fs, absoluteProjectPath, importResult.id);
         const project = importResult.projects.find((candidate) => candidate.name === projectName) ?? importResult.projects[0];
-        const studioWebUrl = buildStudioWebDesignerUrl({
+        const studioWebUrl = buildStudioWebDesignerUrl2({
           baseUrl: apiConfig.baseUrl,
           organizationName: config.organizationName,
           projectId: project.id,
@@ -688,9 +657,9 @@ class FlowDebugService {
           studioWebUrl
         };
       }
-      const [debugError, result] = await catchError(uploadAndDebugSolution({
+      const result = await uploadAndDebugSolution2({
         upload: uploadAndPatch,
-        onSolutionId: (id) => updateSolutionFile(this.fs, absoluteProjectPath, id),
+        onSolutionId: (id) => updateSolutionFile2(this.fs, absoluteProjectPath, id),
         projectName,
         entryPoint,
         projectType: "Flow",
@@ -704,10 +673,7 @@ class FlowDebugService {
         requireDebugPreparation: true,
         inlineAgents,
         buildSolutionProjects: (uploadedProjects, solutionId) => this.buildSolutionProjectDescriptors(uploadedProjects, solutionId, stagingDir, projectName, entryPoint, FlowDebugService.buildProjectTypeMap(uipxResult?.uipx.Projects))
-      }));
-      if (debugError) {
-        throw withMissingResourceContext(debugError, missingResourceWarnings);
-      }
+      });
       const outputIds = declaredOutputIds(flowData);
       const outputs = await fetchOutputVariables(apiConfig, result, outputIds);
       return {
@@ -718,10 +684,10 @@ class FlowDebugService {
         declaredOutputIds: outputIds
       };
     } finally {
-      const [cleanupErr] = await catchError((async () => {
+      const [cleanupErr] = await catchError2((async () => {
         if (uisPath)
           await this.fs.rm(uisPath);
-        await this.fs.rm(stagingDir, { recursive: true });
+        await this.fs.rm(stagingDir);
       })());
       if (cleanupErr) {
         logger.warn(`Cleanup failed: ${cleanupErr.message}`);
@@ -747,7 +713,7 @@ class FlowDebugService {
       if (!await this.fs.exists(absolutePath)) {
         throw new Error(`File not found: ${absolutePath}`);
       }
-      const { workflow: flowData } = await readFlowWorkflow(absolutePath);
+      const { workflow: flowData } = await readFlowWorkflow2(absolutePath);
       expectGlobals = declaredOutputIds(flowData);
       if (inputs && flowData.variables?.globals) {
         for (const variable of flowData.variables.globals) {
@@ -756,22 +722,22 @@ class FlowDebugService {
           }
         }
       }
-      const flowFileContent = JSON.stringify(inMemoryWorkflowToFileFormat(flowData), null, 2);
+      const flowFileContent = JSON.stringify(workflowToFileFormat(flowData), null, 2);
       logger.info("Converting .flow to BPMN...");
       bpmnXml = await this.convertToBpmn(flowData, this.fs.path.dirname(absolutePath));
-      startEventId = extractStartEventId(bpmnXml);
+      startEventId = extractStartEventId2(bpmnXml);
       logger.info("Generating project files...");
       projectDir = await this.generateProjectFiles(flowData, bpmnXml, flowFileContent, startEventId, await resolveRuntimeProfileForFlowFile(this.fs, absolutePath));
       projectName = flowData.name.replace(/[^a-zA-Z0-9_-]/g, "_");
       entryPointBpmnFile = `${projectName}.bpmn`;
     } else {
       bpmnXml = await this.readBpmnFile(filePath);
-      startEventId = extractStartEventId(bpmnXml);
+      startEventId = extractStartEventId2(bpmnXml);
       projectName = this.fs.path.basename(filePath, ".bpmn");
       const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
       projectDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-debug-${safeName}-${Date.now()}`);
       const safeMkdir = async (dir) => {
-        const [err] = await catchError(this.fs.mkdir(dir));
+        const [err] = await catchError2(this.fs.mkdir(dir));
         if (err && err.code !== "EEXIST") {
           throw err;
         }
@@ -810,8 +776,8 @@ class FlowDebugService {
       organizationUnitId: config.organizationUnitId
     };
     const entryPoint = `/${entryPointBpmnFile}#${startEventId}`;
-    const result = await uploadAndDebugSolution({
-      upload: () => uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, undefined, this.fs),
+    const result = await uploadAndDebugSolution2({
+      upload: () => uploadOrOverwriteSolution2(apiConfig, config.organizationName, uisPath, undefined, this.fs),
       projectName,
       entryPoint,
       projectType: "Flow",
@@ -836,11 +802,11 @@ async function fetchOutputVariables(apiConfig, run, expectGlobals) {
   const onFetched = (done) => {
     fetch = done;
   };
-  const [error, variables] = await catchError(fetchDebugInstanceVariables(apiConfig, instanceId, isSuccessfulDebugStatus(run.finalStatus) ? { expectGlobals, terminalStatusAt, onFetched } : { delays: [], terminalStatusAt, onFetched }));
+  const [error, variables] = await catchError2(fetchDebugInstanceVariables2(apiConfig, instanceId, isSuccessfulDebugStatus2(run.finalStatus) ? { expectGlobals, terminalStatusAt, onFetched } : { delays: [], terminalStatusAt, onFetched }));
   if (!error) {
     return fetch && fetch.attempts > 1 ? { variables, variablesFetch: fetch } : { variables };
   }
-  if (error instanceof DebugVariablesFetchFailedError) {
+  if (error instanceof DebugVariablesFetchFailedError2) {
     logger.warn(`Could not fetch output variables after ${error.details.attempts} attempt(s): ${error.details.message}. ` + "The run completed; its outputs are unknown, not empty.");
     return { variablesError: error.details };
   }
@@ -855,21 +821,11 @@ async function fetchOutputVariables(apiConfig, run, expectGlobals) {
   };
 }
 export {
-  DebugProvisioningMissingResourcesError,
-  FLOW_DEBUG_INBOUND_VOICE_MESSAGE,
-  FLOW_DEBUG_MISSING_SOLUTION_INSTRUCTIONS,
-  FLOW_DEBUG_MISSING_SOLUTION_MESSAGE,
-  FLOW_DEBUG_UNREGISTERED_PROJECT_MESSAGE,
+  FlowDebugMissingResourcesError,
   FlowDebugService,
   InboundVoiceDebugError,
   MissingSolutionWrapperError,
-  UnregisteredProjectError,
-  assertNotInboundVoiceFlow,
-  buildFlowDebugInboundVoiceInstructions,
-  buildFlowDebugMissingResourcesInstructions,
-  buildFlowDebugUnregisteredProjectInstructions,
-  selectMissingResourceWarnings,
-  withMissingResourceContext
+  UnregisteredProjectError
 };
 
-//# debugId=451F3D3D0B6C786064756E2164756E21
+//# debugId=65057D23F601511964756E2164756E21

package/dist/flow-eval-node-target-tdrwqca7.js

@@ -0,0 +1,29 @@
+import {
+  findFlowNode2,
+  isNodeEvalTarget2,
+  isDocumentEvalNode2,
+  readNodeTargetId2,
+  FlowAgentNodeSchemaReader2,
+  readEvalSetScope2
+} from "./packager-tool-5104bnpv.js";
+import"./packager-tool-ac6rvny7.js";
+import"./packager-tool-mdf7bws6.js";
+import"./packager-tool-2b0tn4p4.js";
+import"./packager-tool-14rdgz3c.js";
+import"./packager-tool-jd3v0bh1.js";
+import"./packager-tool-4g87fbz6.js";
+import"./packager-tool-ze3fnf3s.js";
+import"./packager-tool-fzgfb0jt.js";
+import"./packager-tool-8ed52y5r.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-vgrswa8p.js";
+export {
+  FlowAgentNodeSchemaReader2 as FlowAgentNodeSchemaReader,
+  findFlowNode2 as findFlowNode,
+  isDocumentEvalNode2 as isDocumentEvalNode,
+  isNodeEvalTarget2 as isNodeEvalTarget,
+  readEvalSetScope2 as readEvalSetScope,
+  readNodeTargetId2 as readNodeTargetId
+};
+
+//# debugId=01C57003DE4F035264756E2164756E21