@uipath/flow-tool 1.202.1-preview.159 → 1.203.0-preview.160

package/dist/{packager-tool-114a3x6s.js → packager-tool-9kx94sj5.js}

@@ -6,12 +6,12 @@ import {
   orchestratorGet,
   orchestratorPost,
   studioWebPost
-} from "./packager-tool-sc5tddfj.js";
+} from "./packager-tool-s0mzv3sx.js";
 import {
   RESULTS,
   catchError,
   logger
-} from "./packager-tool-rew0hp2h.js";
+} from "./packager-tool-6k8s7pt9.js";
 
 // ../maestro-sdk/src/debug-service.ts
 import { randomUUID } from "node:crypto";
@@ -56,7 +56,12 @@ function injectSolutionProjectProcessEntries(fpsProperties, solutionProjects) {
   const entries = solutionProjects.map((project) => ({
     name: project.name,
     projectType: project.projectType,
-    executorInfo: JSON.stringify({
+    executorInfo: JSON.stringify(project.projectType === "Function" ? {
+      projectId: project.projectId,
+      command: "debug",
+      args: ["--attach=none"],
+      entryPoint: project.entryPoint
+    } : {
       projectId: project.projectId,
       debugArgs: {
         debugMode: project.debugMode ?? DEBUG_MODE_MAP.Default,
@@ -274,6 +279,7 @@ var PIMS_TERMINAL_STATUSES = [
   "Cancelled",
   "Failed"
 ];
+var ORCHESTRATOR_JOB_KEY = /^[0-9a-fA-F-]+$/;
 var ORCHESTRATOR_TERMINAL_STATUSES = [
   "Successful",
   "Faulted",
@@ -320,6 +326,10 @@ function buildPollTimeoutFailureOutput(err, inspectCommand) {
 async function pollDebugInstanceStatus(config, instanceId, callbacks, pollInterval = 2000, maxPolls = 300, jobKey) {
   let pollCount = 0;
   let lastStatus = "";
+  const canCheckOrchestratorJob = jobKey !== undefined && ORCHESTRATOR_JOB_KEY.test(jobKey);
+  if (jobKey !== undefined && !canCheckOrchestratorJob) {
+    logger.warn(`Skipping the Orchestrator job status fallback: "${jobKey}" is not a job key.`);
+  }
   while (pollCount < maxPolls) {
     const status = await debugPimsGet(config, `/api/v1/debug-instances/${instanceId}/element-executions`, "poll-instance-status");
     if (status.status !== lastStatus) {
@@ -340,8 +350,8 @@ async function pollDebugInstanceStatus(config, instanceId, callbacks, pollInterv
       logger.info(`Debug session reached terminal status: ${status.status}`);
       return status;
     }
-    if (jobKey && pollCount > 0 && pollCount % 5 === 0) {
-      const [, jobResponse] = await catchError(orchestratorGet(config, `/odata/Jobs?$filter=Key eq '${jobKey}'&$top=1`, "check-orchestrator-job-status"));
+    if (canCheckOrchestratorJob && pollCount > 0 && pollCount % 5 === 0) {
+      const [, jobResponse] = await catchError(orchestratorGet(config, `/odata/Jobs?$filter=Key eq ${jobKey}&$top=1`, "check-orchestrator-job-status"));
       const jobState = jobResponse?.value?.[0]?.State;
       if (jobState && ORCHESTRATOR_TERMINAL_STATUSES.includes(jobState)) {
         const jobInfo = jobResponse?.value?.[0]?.Info ?? "";
@@ -599,4 +609,4 @@ async function patchConnectionOverwrites(config, organizationName, solutionId, s
 
 export { FpsPropertiesInjectionError, injectInlineAgentProcessEntries, injectSolutionProjectProcessEntries, extractStartEventId, getPersonalFolderKey, getPersonalFolderInfo, prepareForCustomDebug, getFolderInfoById, beginDebugSession, DEBUG_MODE_MAP, SIMULATION_MODE_MAP, createDebugInstance, DebugPollTimeoutError, buildPollTimeoutFailureOutput, pollDebugInstanceStatus, fetchDebugInstanceIncidents, DebugVariablesFetchFailedError, fetchDebugInstanceVariables, isFaultedDebugStatus, isSuccessfulDebugStatus, resolveFaultIncidents, buildStudioWebDesignerUrl, uploadAndDebugSolution, patchConnectionOverwrites };
 
-//# debugId=50B9C8A084F4991B64756E2164756E21
+//# debugId=F817DF346555CDD564756E2164756E21

package/dist/{packager-tool-30ras1nc.js → packager-tool-9mm51nrg.js}

@@ -3,7 +3,7 @@ import {
 } from "./packager-tool-w0kr4mbc.js";
 import {
   FlowToolFactory
-} from "./packager-tool-tr5gfx9a.js";
+} from "./packager-tool-r7j4amsv.js";
 
 // src/packager-tool.ts
 function registerPackagerFactories() {

package/dist/{packager-tool-0d7tcvg1.js → packager-tool-b1xs6aty.js}

@@ -158,6 +158,9 @@ class ZipService {
     });
     return zipData;
   }
+  compressEntries(entries) {
+    return zipSync(entries, { level: 6 });
+  }
 }
 function isPluralForm(value) {
   return typeof value === "object" && value !== null && "other" in value;
@@ -1443,4 +1446,4 @@ var toolsFactoryRepository = _global[REGISTRY_KEY];
 
 export { Path, TemporaryStorageService, ZipService, I18nManager, translate, LogLevel, LogMessage, NugetConstants, ProjectTypes, TargetFramework, ToolErrorCodes, ToolResult, ensureProjectId, writeContentOperateFile, NugetPackager, ProjectTool, toolsFactoryRepository };
 
-//# debugId=9B8BA321036CF45D64756E2164756E21
+//# debugId=F3B2EBDF290E821564756E2164756E21

package/dist/{packager-tool-0e9sf7xz.js → packager-tool-b3m0jr5g.js}

@@ -1,8 +1,9 @@
 // package.json
 var package_default = {
   name: "@uipath/flow-tool",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.1-preview.159",
+  version: "1.203.0-preview.160",
   description: "Create, debug, and run UiPath Flow projects and jobs.",
   private: false,
   repository: {
@@ -53,7 +54,7 @@ var package_default = {
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
     "@uipath/flow-converter": "0.69.3",
-    "@uipath/flow-core": "0.112.0",
+    "@uipath/flow-core": "0.115.4-develop",
     "@uipath/flow-expression-model": "0.11.4",
     "@uipath/flow-migrations": "0.56.2",
     "@uipath/flow-schema": "0.68.0",
@@ -74,4 +75,4 @@ var package_default = {
 
 export { package_default };
 
-//# debugId=BB50081F8023F01064756E2164756E21
+//# debugId=0374E14B9144CC6F64756E2164756E21

package/dist/{packager-tool-vefnjbz8.js → packager-tool-bhgzjh7h.js}

@@ -1,21 +1,21 @@
 import {
   enableErrorHandlingForErrorEdges,
   expandHandleIds
-} from "./packager-tool-nq4rcqqg.js";
+} from "./packager-tool-1frs4sr4.js";
 import {
   readFlowWorkflow,
   writeFlowWorkflow
-} from "./packager-tool-j5mr6edn.js";
+} from "./packager-tool-rpr68as1.js";
 import {
   DEFAULT_LAYOUT_OPTIONS,
   GRID_SPACING,
   resolveHeight,
   resolveWidth,
   snapToGrid
-} from "./packager-tool-29eg86w6.js";
+} from "./packager-tool-6rsegsby.js";
 import {
   generateNodeVariables
-} from "./packager-tool-jjpc0yka.js";
+} from "./packager-tool-vcjq9xkc.js";
 import {
   __require,
   __toESM
@@ -437,11 +437,187 @@ var ElkLayoutEngine = class {
     return { totalWidth: maxX - minX, totalHeight: maxY - minY, executionTime };
   }
 };
+var SPINE_STRAIGHTNESS_PRIORITY = "1";
+function findSpineEdgeIds(childIds, edges) {
+  if (childIds.length === 0 || edges.length === 0)
+    return /* @__PURE__ */ new Set;
+  const idSet = new Set(childIds);
+  const outDegree = new Map(childIds.map((id) => [id, 0]));
+  const inDegree = new Map(childIds.map((id) => [id, 0]));
+  for (const e of edges) {
+    const src = e.sources[0];
+    const tgt = e.targets[0];
+    if (!idSet.has(src) || !idSet.has(tgt) || src === tgt)
+      continue;
+    outDegree.set(src, (outDegree.get(src) ?? 0) + 1);
+    inDegree.set(tgt, (inDegree.get(tgt) ?? 0) + 1);
+  }
+  const spine = /* @__PURE__ */ new Set;
+  for (const e of edges) {
+    const src = e.sources[0];
+    const tgt = e.targets[0];
+    if (!idSet.has(src) || !idSet.has(tgt) || src === tgt)
+      continue;
+    if ((outDegree.get(src) ?? 0) === 1 && (inDegree.get(tgt) ?? 0) === 1) {
+      spine.add(e.id);
+    }
+  }
+  return spine;
+}
+function buildTidyElkContainer(containerId, params) {
+  const directChildren = params.childrenByParent.get(containerId) ?? [];
+  const localEdges = params.edgesByParent.get(containerId) ?? [];
+  const elkChildren = directChildren.map((child) => {
+    if (child.isContainer)
+      return buildTidyElkContainer(child.id, params);
+    const oh = params.overhangById?.get(child.id);
+    return {
+      id: child.id,
+      width: child.width + (oh?.left ?? 0) + (oh?.right ?? 0),
+      height: child.height + (oh?.top ?? 0) + (oh?.bottom ?? 0)
+    };
+  });
+  const spineEdgeIds = findSpineEdgeIds(directChildren.map((c) => c.id), localEdges);
+  const annotatedEdges = localEdges.map((e) => spineEdgeIds.has(e.id) ? { ...e, layoutOptions: { ...e.layoutOptions, "org.eclipse.elk.layered.priority.straightness": SPINE_STRAIGHTNESS_PRIORITY } } : e);
+  return {
+    id: containerId,
+    width: params.fit.minWidth,
+    height: params.fit.minHeight,
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": params.direction,
+      "elk.padding": params.fit.elkPadding,
+      "elk.spacing.nodeNode": String(params.nodeSpacing),
+      "elk.layered.spacing.nodeNodeBetweenLayers": String(params.layerSpacing),
+      "elk.layered.nodePlacement.strategy": "BRANDES_KOEPF",
+      "elk.layered.nodePlacement.bk.fixedAlignment": "BALANCED",
+      "elk.layered.considerModelOrder.strategy": "NODES_AND_EDGES",
+      "elk.layered.crossingMinimization.forceNodeModelOrder": "true",
+      ...params.orthogonalRouting ? { "elk.edgeRouting": "ORTHOGONAL" } : {},
+      "elk.hierarchyHandling": "SEPARATE_CHILDREN",
+      "elk.nodeSize.constraints": "MINIMUM_SIZE",
+      "elk.nodeSize.minimum": `(${params.fit.minWidth},${params.fit.minHeight})`
+    },
+    children: elkChildren,
+    edges: annotatedEdges
+  };
+}
+function clamp(value, lo, hi) {
+  if (hi < lo)
+    return lo;
+  return Math.min(hi, Math.max(lo, value));
+}
+function applyTidyContainerLayout(node, updates, containerOffsets, params) {
+  const { fit } = params;
+  const horizontal = params.direction === "RIGHT" || params.direction === "LEFT";
+  const children = node.children ?? [];
+  const isContainerElkNode = node.layoutOptions !== undefined;
+  if (children.length === 0) {
+    if (isContainerElkNode) {
+      const w = params.snapUp(Math.max(fit.minWidth, node.width ?? 0));
+      const h = params.snapUp(Math.max(fit.minHeight, node.height ?? 0));
+      updates.set(node.id, { width: w, height: h });
+      return { width: w, height: h };
+    }
+    return { width: node.width ?? params.defaultNodeSize, height: node.height ?? params.defaultNodeSize };
+  }
+  const childSizes = /* @__PURE__ */ new Map;
+  for (const child of children) {
+    childSizes.set(child.id, applyTidyContainerLayout(child, updates, containerOffsets, params));
+  }
+  const childAnchorAdjustments = horizontal && params.hooks?.resolveChildAnchorAdjustments ? params.hooks.resolveChildAnchorAdjustments(node.id, children, childSizes) : /* @__PURE__ */ new Map;
+  let minX = Number.POSITIVE_INFINITY;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxX = 0;
+  let maxY = 0;
+  for (const child of children) {
+    const x = child.x ?? 0;
+    const y = (child.y ?? 0) + (childAnchorAdjustments.get(child.id) ?? 0);
+    const { width: w, height: h } = childSizes.get(child.id);
+    if (x < minX)
+      minX = x;
+    if (y < minY)
+      minY = y;
+    if (x + w > maxX)
+      maxX = x + w;
+    if (y + h > maxY)
+      maxY = y + h;
+  }
+  const bboxWidth = maxX - minX;
+  const bboxHeight = maxY - minY;
+  const finalWidth = params.snapUp(Math.max(fit.minWidth, bboxWidth + fit.paddingLeft + fit.paddingRight));
+  const baseHeight = params.snapUp(Math.max(fit.minHeight, bboxHeight + fit.paddingTop + fit.paddingBottom));
+  const dxTarget = (finalWidth - bboxWidth) / 2 - minX;
+  const dx = clamp(dxTarget, fit.paddingLeft - minX, finalWidth - fit.paddingRight - maxX);
+  const entryRailY = horizontal && params.hooks?.resolveEntryRail ? params.hooks.resolveEntryRail(node.id, children, childSizes, childAnchorAdjustments) : undefined;
+  let finalHeight = baseHeight;
+  let dy = clamp((finalHeight - bboxHeight) / 2 - minY, fit.paddingTop - minY, finalHeight - fit.paddingBottom - maxY);
+  if (typeof entryRailY === "number") {
+    finalHeight = params.snapUp(Math.max(baseHeight, 2 * (fit.paddingTop - minY + entryRailY), 2 * (maxY - entryRailY + fit.paddingBottom)));
+    dy = finalHeight / 2 - entryRailY;
+  }
+  containerOffsets.set(node.id, { dx, dy });
+  updates.set(node.id, { width: finalWidth, height: finalHeight });
+  for (const child of children) {
+    const size = childSizes.get(child.id);
+    const oh = params.overhangById?.get(child.id);
+    const offsetX = oh?.left ?? 0;
+    const offsetY = oh?.top ?? 0;
+    const realWidth = size.width - offsetX - (oh?.right ?? 0);
+    const realHeight = size.height - offsetY - (oh?.bottom ?? 0);
+    updates.set(child.id, {
+      position: {
+        x: snapToGrid((child.x ?? 0) + dx + offsetX),
+        y: snapToGrid((child.y ?? 0) + (childAnchorAdjustments.get(child.id) ?? 0) + dy + offsetY)
+      },
+      width: realWidth,
+      height: realHeight
+    });
+  }
+  return { width: finalWidth, height: finalHeight };
+}
+async function tidyContainerHierarchy(params) {
+  const root = buildTidyElkContainer(params.containerId, params);
+  const layouted = await params.layout(root);
+  const updates = /* @__PURE__ */ new Map;
+  const containerOffsets = /* @__PURE__ */ new Map;
+  applyTidyContainerLayout(layouted, updates, containerOffsets, params);
+  return { layouted, updates, containerOffsets };
+}
+function snapUpToGrid(value, gridSize = GRID_SPACING) {
+  return Math.ceil(value / gridSize) * gridSize;
+}
+var DEFAULT_INTERIOR_NODE_SPACING = 32;
+var DEFAULT_INTERIOR_LAYER_SPACING = 64;
+var DEFAULT_MIN_WIDTH = 560;
+var DEFAULT_MIN_HEIGHT = 320;
+var DEFAULT_PADDING_TOP = 96;
+var DEFAULT_PADDING_BOTTOM = 48;
+var DEFAULT_PADDING_LEFT = 144;
+var DEFAULT_PADDING_RIGHT = 144;
+function defaultContainerFit() {
+  return {
+    minWidth: DEFAULT_MIN_WIDTH,
+    minHeight: DEFAULT_MIN_HEIGHT,
+    paddingTop: DEFAULT_PADDING_TOP,
+    paddingBottom: DEFAULT_PADDING_BOTTOM,
+    paddingLeft: DEFAULT_PADDING_LEFT,
+    paddingRight: DEFAULT_PADDING_RIGHT,
+    elkPadding: `[top=${DEFAULT_PADDING_TOP},left=${DEFAULT_PADDING_LEFT},bottom=${DEFAULT_PADDING_BOTTOM},right=${DEFAULT_PADDING_RIGHT}]`
+  };
+}
 
 // src/services/tidy-service.ts
 var COLLAPSED_NODE_SIZE = 96;
 var EXPANDED_RECTANGLE_WIDTH = 288;
-var CONTAINER_SIZE = { width: 560, height: 320 };
+var CONTAINER_SIZE = {
+  width: defaultContainerFit().minWidth,
+  height: defaultContainerFit().minHeight
+};
+function parentIdOf(node) {
+  const pid = node?.parentId;
+  return typeof pid === "string" && pid.length > 0 ? pid : undefined;
+}
 function expandedSizeForShape(shape) {
   if (shape === "container") {
     return { ...CONTAINER_SIZE };
@@ -625,6 +801,9 @@ function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
   let repositioned = 0;
   let resized = 0;
   for (const node of nodes) {
+    if (UI_ONLY_NODE_TYPES.has(node.type)) {
+      continue;
+    }
     const newPos = positionMap.get(node.id);
     if (!newPos)
       continue;
@@ -634,9 +813,6 @@ function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
       node.ui.position = { x: newPos.x, y: newPos.y };
       repositioned++;
     }
-    if (UI_ONLY_NODE_TYPES.has(node.type)) {
-      continue;
-    }
     const targetSize = expandedSizeForShape(shapeOf(node));
     const currentSize = node.ui.size;
     const sizeNeedsUpdate = currentSize?.width !== targetSize.width || currentSize?.height !== targetSize.height;
@@ -647,23 +823,140 @@ function applyLayoutToNodes(nodes, layoutedNodes, shapeOf) {
   }
   return { repositioned, resized };
 }
+function applyContainerLayout(nodes, childRelPositions, nodeSizes) {
+  let repositioned = 0;
+  let resized = 0;
+  for (const node of nodes) {
+    const rel = childRelPositions.get(node.id);
+    if (rel && (node.ui.position.x !== rel.x || node.ui.position.y !== rel.y)) {
+      node.ui.position = { x: rel.x, y: rel.y };
+      repositioned++;
+    }
+    const size = nodeSizes.get(node.id);
+    if (size && (node.ui.size?.width !== size.width || node.ui.size?.height !== size.height)) {
+      node.ui.size = size;
+      resized++;
+    }
+  }
+  return { repositioned, resized };
+}
 async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
   if (nodes.length === 0) {
     return { repositioned: 0, resized: 0 };
   }
   const allNodes = nodesToLayoutNodes(nodes, shapeOf);
   const allEdges = edgesToLayoutEdges(edges);
+  const nodeIds = new Set(allNodes.map((n) => n.id));
+  const layoutNodeById = new Map(allNodes.map((n) => [n.id, n]));
+  const nodeInstanceOf = (id) => id === undefined ? undefined : layoutNodeById.get(id)?.data;
+  const isContainerId = (id) => {
+    const inst = nodeInstanceOf(id);
+    return inst !== undefined && shapeOf(inst) === "container";
+  };
+  const chainTerminates = (id) => {
+    const seen = new Set;
+    let cur = id;
+    while (cur !== undefined) {
+      if (seen.has(cur))
+        return false;
+      seen.add(cur);
+      const p = parentIdOf(nodeInstanceOf(cur));
+      if (p === undefined || !nodeIds.has(p))
+        return true;
+      cur = p;
+    }
+    return true;
+  };
+  const childrenByParent = new Map;
+  for (const n of allNodes) {
+    if (UI_ONLY_NODE_TYPES.has(n.type))
+      continue;
+    const pid = parentIdOf(n.data);
+    if (pid && pid !== n.id && nodeIds.has(pid) && isContainerId(pid) && chainTerminates(n.id)) {
+      const group = childrenByParent.get(pid);
+      if (group)
+        group.push(n);
+      else
+        childrenByParent.set(pid, [n]);
+    }
+  }
+  const containerChildIds = new Set([...childrenByParent.values()].flat().map((n) => n.id));
+  const interiorEdgesByParent = new Map;
+  for (const e of allEdges) {
+    const sp = parentIdOf(nodeInstanceOf(e.source));
+    const tp = parentIdOf(nodeInstanceOf(e.target));
+    if (sp && sp === tp) {
+      const list = interiorEdgesByParent.get(sp);
+      if (list)
+        list.push(e);
+      else
+        interiorEdgesByParent.set(sp, [e]);
+    }
+  }
+  const tidyChildrenByParent = new Map;
+  for (const [pid, kids] of childrenByParent) {
+    tidyChildrenByParent.set(pid, kids.map((k) => ({
+      id: k.id,
+      width: k.width ?? COLLAPSED_NODE_SIZE,
+      height: k.height ?? COLLAPSED_NODE_SIZE,
+      isContainer: childrenByParent.has(k.id)
+    })));
+  }
+  const elkEdgesByParent = new Map;
+  for (const [pid, es] of interiorEdgesByParent) {
+    elkEdgesByParent.set(pid, es.map((e) => ({
+      id: e.id,
+      sources: [e.source],
+      targets: [e.target]
+    })));
+  }
+  const childRelPositions = new Map;
+  const nodeSizes = new Map;
+  const topLevelContainerIds = [...childrenByParent.keys()].filter((id) => !containerChildIds.has(id));
+  for (const containerId of topLevelContainerIds) {
+    const { updates } = await tidyContainerHierarchy({
+      containerId,
+      childrenByParent: tidyChildrenByParent,
+      edgesByParent: elkEdgesByParent,
+      fit: defaultContainerFit(),
+      direction: "RIGHT",
+      nodeSpacing: DEFAULT_INTERIOR_NODE_SPACING,
+      layerSpacing: DEFAULT_INTERIOR_LAYER_SPACING,
+      orthogonalRouting: true,
+      snapUp: snapUpToGrid,
+      defaultNodeSize: COLLAPSED_NODE_SIZE,
+      layout: (root) => engine.layoutHierarchical(root)
+    });
+    for (const [id, upd] of updates) {
+      if (upd.position) {
+        childRelPositions.set(id, upd.position);
+      }
+      if (upd.width !== undefined && upd.height !== undefined) {
+        nodeSizes.set(id, { width: upd.width, height: upd.height });
+      }
+    }
+  }
   const artifactChildIds = identifyArtifactChildIds(allEdges, portResolver, allNodes);
   const collapsedIds = new Set(allNodes.filter((n) => n.data?.ui?.isCollapsed).map((n) => n.id));
   const hiddenIds = collectArtifactDescendants(collapsedIds, allEdges, artifactChildIds);
-  const layoutNodes = allNodes.filter((n) => !hiddenIds.has(n.id));
-  const layoutEdges = allEdges.filter((e) => !hiddenIds.has(e.source) && !hiddenIds.has(e.target));
+  const excludedIds = new Set([...hiddenIds, ...containerChildIds]);
+  const layoutNodes = allNodes.filter((n) => !excludedIds.has(n.id));
+  const layoutEdges = allEdges.filter((e) => !excludedIds.has(e.source) && !excludedIds.has(e.target));
   const hiddenNodes = allNodes.filter((n) => hiddenIds.has(n.id));
+  for (const n of layoutNodes) {
+    const grown = nodeSizes.get(n.id);
+    if (grown) {
+      n.width = grown.width;
+      n.height = grown.height;
+    }
+  }
   if (layoutNodes.length === 0) {
     return { repositioned: 0, resized: 0 };
   }
   const preLayoutPositions = new Map(layoutNodes.map((n) => [n.id, { ...n.position }]));
-  const leftmostNode = layoutNodes.reduce((left, node) => node.position.x < left.position.x ? node : left);
+  const anchorCandidates = layoutNodes.filter((node) => !UI_ONLY_NODE_TYPES.has(node.type ?? ""));
+  const anchorPool = anchorCandidates.length > 0 ? anchorCandidates : layoutNodes;
+  const leftmostNode = anchorPool.reduce((left, node) => node.position.x < left.position.x ? node : left, anchorPool[0]);
   const originalLeftX = leftmostNode.position.x;
   const originalLeftY = leftmostNode.position.y;
   const { nodes: layoutedNodes } = await engine.layout(layoutNodes, layoutEdges, { ...DEFAULT_LAYOUT_OPTIONS, animate: false }, portResolver);
@@ -678,7 +971,11 @@ async function tidyNodesAndEdges(engine, nodes, edges, portResolver, shapeOf) {
   }
   const hiddenUpdates = propagateHiddenArtifactPositions(layoutedNodes, preLayoutPositions, hiddenNodes, allEdges, artifactChildIds);
   const allUpdated = [...layoutedNodes, ...hiddenUpdates];
-  return applyLayoutToNodes(nodes, allUpdated, shapeOf);
+  const result = applyLayoutToNodes(nodes, allUpdated, shapeOf);
+  const nested = applyContainerLayout(nodes, childRelPositions, nodeSizes);
+  result.repositioned += nested.repositioned;
+  result.resized += nested.resized;
+  return result;
 }
 async function tidyFlow(filePath) {
   const { workflow, refMap } = await readFlowWorkflow(filePath);
@@ -754,4 +1051,4 @@ function regenerateNodeVariables(workflow) {
 
 export { UI_ONLY_NODE_TYPES, tidyFlow };
 
-//# debugId=61782660AAF1BE9364756E2164756E21
+//# debugId=DEA00C408BBCA7A764756E2164756E21

package/dist/{packager-tool-r3fjpcv2.js → packager-tool-cgr7y554.js}

@@ -1,13 +1,16 @@
 import {
   isRecord
-} from "./packager-tool-8j92afwp.js";
+} from "./packager-tool-gzpvdcnw.js";
 import {
   collectAgentInputLeaves,
   isInlineAgentNodeType
-} from "./packager-tool-tr5gfx9a.js";
+} from "./packager-tool-r7j4amsv.js";
+import {
+  isStartEventNode
+} from "./packager-tool-fvm2dddf.js";
 import {
   catchError
-} from "./packager-tool-rew0hp2h.js";
+} from "./packager-tool-6k8s7pt9.js";
 
 // src/services/flow-eval-node-target.ts
 function findFlowNode(flowContent, nodeId) {
@@ -21,6 +24,21 @@ function findFlowNode(flowContent, nodeId) {
   const node = [...topLevel, ...nested].find((candidate) => isRecord(candidate) && candidate.id === nodeId);
   return { flowParsed: true, node };
 }
+function listTriggerNodeIds(flowContent) {
+  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+  if (parseError || !isRecord(parsed) || !Array.isArray(parsed.nodes)) {
+    return [];
+  }
+  return parsed.nodes.filter((node) => isRecord(node) && typeof node.id === "string" && typeof node.type === "string" && isStartEventNode({
+    id: node.id,
+    type: node.type,
+    typeVersion: typeof node.typeVersion === "string" ? node.typeVersion : "1.0"
+  })).map((node) => node.id);
+}
+function formatTriggerIdsHint(flowContent) {
+  const triggerIds = flowContent === undefined ? [] : listTriggerNodeIds(flowContent);
+  return triggerIds.length > 0 ? ` Valid trigger node ids: ${triggerIds.join(", ")}.` : "";
+}
 function readAgentSourceId(node) {
   const inputs = isRecord(node.inputs) ? node.inputs : undefined;
   const source = inputs?.source;
@@ -116,6 +134,6 @@ function readEvalSetScope(set) {
   return "flow";
 }
 
-export { findFlowNode, readAgentSourceId, isNodeEvalTarget, isDocumentEvalNode, readNodeTargetId, FlowAgentNodeSchemaReader, readEvalSetScope };
+export { findFlowNode, listTriggerNodeIds, formatTriggerIdsHint, readAgentSourceId, isNodeEvalTarget, isDocumentEvalNode, readNodeTargetId, FlowAgentNodeSchemaReader, readEvalSetScope };
 
-//# debugId=D51E7B5AE34841EC64756E2164756E21
+//# debugId=53DBC3C325A7BC8264756E2164756E21