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

package/dist/node-service-frvz67y3.js

@@ -0,0 +1,83 @@
+import {
+  NodeTypeNotEnabledError,
+  NodeTypeNotFoundError,
+  PROCESS_NODE_PREFIXES,
+  SourceRequiredError,
+  addNodeToFlow,
+  collectNodeBindingResourceKeys,
+  deleteNodeFromFlow,
+  ensureProcessBindings,
+  isProcessNode,
+  listNodesInFlow,
+  resolveProcessTarget,
+  resolveProcessTargetKey
+} from "./packager-tool-q2gwvnf5.js";
+import"./packager-tool-mfrdmqmt.js";
+import"./packager-tool-7msx23gd.js";
+import"./packager-tool-2xrng5ff.js";
+import"./packager-tool-dqxz5v18.js";
+import"./packager-tool-d2813z49.js";
+import"./packager-tool-9pccpz3r.js";
+import"./packager-tool-zzxt99e4.js";
+import"./packager-tool-cr0z8cbj.js";
+import"./packager-tool-ygrrb1zh.js";
+import"./packager-tool-eypvc2kv.js";
+import"./packager-tool-ydg78w9z.js";
+import"./packager-tool-8qp60s20.js";
+import"./packager-tool-fq7wtkd3.js";
+import"./packager-tool-dh5nppv4.js";
+import"./packager-tool-vck7ct1e.js";
+import"./packager-tool-paq9c70w.js";
+import"./packager-tool-4r35ye9r.js";
+import"./packager-tool-yrsrzz1a.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-095jzn8v.js";
+import"./packager-tool-mj89jhvb.js";
+import"./packager-tool-kb554twx.js";
+import"./packager-tool-h8x54cvx.js";
+import"./packager-tool-te6rrpsz.js";
+import"./packager-tool-6rsegsby.js";
+import"./packager-tool-wd01egnx.js";
+import"./packager-tool-2513jrxr.js";
+import"./packager-tool-khm7zsm8.js";
+import"./packager-tool-vcjq9xkc.js";
+import"./packager-tool-b803sdfp.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-rs6jm14d.js";
+import"./packager-tool-hk1gxnth.js";
+import"./packager-tool-7q6z6npd.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-gpwec9sp.js";
+import"./packager-tool-vqcnvaae.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-d88rqwk8.js";
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-fvm2dddf.js";
+import"./packager-tool-p79yh9ww.js";
+import"./packager-tool-vdc8r21p.js";
+import"./packager-tool-z83pga0z.js";
+import"./packager-tool-6ejqwbw9.js";
+import"./packager-tool-mcaf4ewf.js";
+import"./packager-tool-z6nkdv48.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-4mna26cc.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-1yh8g550.js";
+export {
+  NodeTypeNotEnabledError,
+  NodeTypeNotFoundError,
+  PROCESS_NODE_PREFIXES,
+  SourceRequiredError,
+  addNodeToFlow,
+  collectNodeBindingResourceKeys,
+  deleteNodeFromFlow,
+  ensureProcessBindings,
+  isProcessNode,
+  listNodesInFlow,
+  resolveProcessTarget,
+  resolveProcessTargetKey
+};
+
+//# debugId=D826C1461EE16A0964756E2164756E21

package/dist/{node-sync-service-zwvm30qg.js → node-sync-service-wa2t7c65.js}

@@ -7,25 +7,25 @@ import {
   searchNodeSummariesWithAvailability,
   searchNodes,
   searchNodesWithFilters
-} from "./packager-tool-317z6dc1.js";
-import"./packager-tool-1zpm7wts.js";
-import"./packager-tool-pm3qh1hy.js";
-import"./packager-tool-w20r6n9v.js";
-import"./packager-tool-pap09zfh.js";
-import"./packager-tool-f0kd5kq4.js";
+} from "./packager-tool-ydg78w9z.js";
+import"./packager-tool-8qp60s20.js";
+import"./packager-tool-fq7wtkd3.js";
+import"./packager-tool-dh5nppv4.js";
+import"./packager-tool-vck7ct1e.js";
+import"./packager-tool-paq9c70w.js";
+import"./packager-tool-yrsrzz1a.js";
 import"./packager-tool-0gctz400.js";
 import"./packager-tool-qa9gftnj.js";
 import"./packager-tool-yc4kw997.js";
-import"./packager-tool-jjpc0yka.js";
-import"./packager-tool-gbgfwx8f.js";
-import"./packager-tool-r87gxwqa.js";
+import"./packager-tool-h8x54cvx.js";
+import"./packager-tool-vcjq9xkc.js";
+import"./packager-tool-7q6z6npd.js";
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-e8td7b01.js";
-import"./packager-tool-p79yh9ww.js";
-import"./packager-tool-79gws1zn.js";
+import"./packager-tool-d88rqwk8.js";
+import"./packager-tool-jysvpt8p.js";
+import"./packager-tool-vdc8r21p.js";
+import"./packager-tool-z6nkdv48.js";
 import"./packager-tool-0v3s8r01.js";
-import"./packager-tool-4mna26cc.js";
-import"./packager-tool-c23zrhj8.js";
 import"./packager-tool-1yh8g550.js";
 export {
   getNode,

package/dist/{packager-tool-me5q0naa.js → packager-tool-095jzn8v.js}

@@ -6,12 +6,12 @@ import {
   orchestratorGet,
   orchestratorPost,
   studioWebPost
-} from "./packager-tool-qgh5yaeh.js";
+} from "./packager-tool-mj89jhvb.js";
 import {
   RESULTS,
   catchError,
   logger
-} from "./packager-tool-79gws1zn.js";
+} from "./packager-tool-z6nkdv48.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-y5f2qhfe.js → packager-tool-19030vpg.js}

@@ -49,6 +49,36 @@ function deriveOutcomeHandleIds(node) {
     return [];
   return outcomes.filter((o) => o != null && typeof o === "object" && typeof o.id === "string").map((o) => `outcome-${o.id}`);
 }
+function deriveHandleCustomizationSourceOverride(node) {
+  const customization = node.handleCustomization;
+  if (!customization || typeof customization !== "object")
+    return null;
+  const groups = customization.groups;
+  if (!Array.isArray(groups))
+    return null;
+  const positions = [];
+  const ids = [];
+  for (const group of groups) {
+    if (!group || typeof group !== "object")
+      continue;
+    const g = group;
+    if (typeof g.position === "string") {
+      positions.push(g.position);
+    }
+    const handles = g.handles;
+    if (!Array.isArray(handles))
+      continue;
+    for (const handle of handles) {
+      if (!handle || typeof handle !== "object")
+        continue;
+      const h = handle;
+      if (h.type === "source" && typeof h.id === "string") {
+        ids.push(h.id);
+      }
+    }
+  }
+  return ids.length > 0 ? { positions, sourceHandleIds: ids } : null;
+}
 function expandHandleIds(handle, node) {
   if (!handle.repeat) {
     return [handle.id];
@@ -82,6 +112,6 @@ function portMatchesTemplate(requestedPort, templateId) {
   return pattern.test(requestedPort);
 }
 
-export { ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, parseVisibleInputKey, isHandleVisible, deriveOutcomeHandleIds, expandHandleIds, isTemplatedHandleId, portMatchesTemplate };
+export { ERROR_SOURCE_PORT, enableErrorHandlingForErrorEdges, parseVisibleInputKey, isHandleVisible, deriveOutcomeHandleIds, deriveHandleCustomizationSourceOverride, expandHandleIds, isTemplatedHandleId, portMatchesTemplate };
 
-//# debugId=2E339C2C31CB6B9B64756E2164756E21
+//# debugId=2F25674933DFAE8564756E2164756E21

package/dist/{packager-tool-gtqkcj4x.js → packager-tool-2c1rbj85.js}

@@ -1,21 +1,21 @@
 import {
   enableErrorHandlingForErrorEdges,
   expandHandleIds
-} from "./packager-tool-y5f2qhfe.js";
+} from "./packager-tool-19030vpg.js";
 import {
   readFlowWorkflow,
   writeFlowWorkflow
-} from "./packager-tool-802qm7jy.js";
+} from "./packager-tool-zzxt99e4.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}]`
+  };
+}
 
 // ../flow-tool/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=81821D34E2C8874964756E2164756E21
+//# debugId=7C51F0DC5FF85EC464756E2164756E21