@uipath/flow-tool 1.201.0-preview.131 → 1.201.0-preview.133

package/dist/{conversion-W6HMHBWW-6qbqgqks.js → conversion-H2VEEYLB-ng48mbf7.js}

@@ -1,41 +1,45 @@
+import {
+  getExpandedSize,
+  getNodeDimensions,
+  isContainerNodeManifest,
+  require_lib
+} from "./packager-tool-gmrwvnyh.js";
 import {
   MANAGED_HTTP_NODE_TYPE,
+  NodeType,
   buildConnectorHttpRequestDetail,
   createNodeVariable,
   findTerminalNodes,
   getConnectorHttpRequestKey,
-  getExpandedSize,
   getLatestDefinitionByNodeType,
-  isContainerNodeManifest,
+  getManifestKey,
   resolveNodeOutputTypeSchema
-} from "./packager-tool-1169tjst.js";
-import"./packager-tool-3wf3tkrc.js";
-import"./packager-tool-03knb0er.js";
-import"./packager-tool-pvgqbm48.js";
-import"./packager-tool-gbgfwx8f.js";
+} from "./packager-tool-vdd02vns.js";
 import {
+  DYNAMIC_EXTRACT_NODE_TYPE,
   MINIMUM_SUPPORTED_SCHEMA_VERSION,
   generateNextId,
   isLoopNodeType,
-  isSubflowNodeType
-} from "./packager-tool-952kqpax.js";
+  isSubflowNodeType,
+  supportsVariableUpdates
+} from "./packager-tool-78a3szsp.js";
+import"./packager-tool-0567pxpm.js";
 import {
   init_esm_shims
-} from "./packager-tool-jpcm3xas.js";
-import"./packager-tool-c19w8vg9.js";
-import"./packager-tool-1yy9x4vk.js";
+} from "./packager-tool-6ejqwbw9.js";
+import"./packager-tool-mcaf4ewf.js";
+import"./packager-tool-tq9q9m77.js";
 import"./packager-tool-c23zrhj8.js";
 import {
-  __require
+  __require,
+  __toESM
 } from "./packager-tool-wckvcay0.js";
 
-// ../../node_modules/@uipath/flow-converter/dist/conversion-W6HMHBWW.js
+// ../../node_modules/@uipath/flow-converter/dist/conversion-H2VEEYLB.js
+var import_json5 = __toESM(require_lib(), 1);
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
-function getManifestKey(nodeType, version) {
-  return `${nodeType}:${version}`;
-}
 function findManifestByNodeType(map, nodeType) {
   const latestDef = getLatestDefinitionByNodeType(nodeType);
   if (latestDef) {
@@ -55,7 +59,7 @@ function isArtifactHandle(nodeHandleId, nodeConfig) {
 function shouldUseArtifactEdge(source, target, manifestMap) {
   const sourceNodeConfig = manifestMap.get(getManifestKey(source.type, source.version));
   const targetNodeConfig = manifestMap.get(getManifestKey(target.type, target.version));
-  return Boolean(isArtifactHandle(source.sourceHandle, sourceNodeConfig) && isArtifactHandle(target.targetHandle, targetNodeConfig));
+  return Boolean(isArtifactHandle(source.sourceHandle, sourceNodeConfig) || isArtifactHandle(target.targetHandle, targetNodeConfig));
 }
 function resolveEdgeType(edge, nodes, manifestMap) {
   const lookup = nodes instanceof Map ? (id) => nodes.get(id) : (id) => nodes.find((n) => n.id === id);
@@ -70,29 +74,152 @@ function resolveEdgeType(edge, nodes, manifestMap) {
   return edge;
 }
 init_esm_shims();
-function edgeToInstance(edge) {
+init_esm_shims();
+function getNodeParentId(node) {
+  const dataParentId = node?.data?.parentId;
+  return node?.parentId ?? (typeof dataParentId === "string" ? dataParentId : undefined);
+}
+function computeAbsoluteNodePositions(nodes) {
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const cache = /* @__PURE__ */ new Map;
+  const resolve = (node, visiting = /* @__PURE__ */ new Set) => {
+    const cached = cache.get(node.id);
+    if (cached)
+      return cached;
+    const own = { x: node.position?.x ?? 0, y: node.position?.y ?? 0 };
+    const parentId = getNodeParentId(node);
+    if (!parentId || visiting.has(node.id)) {
+      cache.set(node.id, own);
+      return own;
+    }
+    const parent = nodeById.get(parentId);
+    if (!parent) {
+      cache.set(node.id, own);
+      return own;
+    }
+    visiting.add(node.id);
+    const parentAbs = resolve(parent, visiting);
+    visiting.delete(node.id);
+    const absolute = { x: parentAbs.x + own.x, y: parentAbs.y + own.y };
+    cache.set(node.id, absolute);
+    return absolute;
+  };
+  for (const node of nodes) {
+    resolve(node);
+  }
+  return cache;
+}
+init_esm_shims();
+function translateWaypoints(waypoints, offset) {
+  if (offset.x === 0 && offset.y === 0)
+    return [...waypoints];
+  return waypoints.map((w) => ({ ...w, x: w.x + offset.x, y: w.y + offset.y }));
+}
+function untranslateWaypoints(waypoints, offset) {
+  return translateWaypoints(waypoints, { x: -offset.x, y: -offset.y });
+}
+function getManualWaypoints(data) {
+  const waypoints = data?.waypoints;
+  return waypoints?.length ? waypoints : undefined;
+}
+function getRoutedWaypoints(data) {
+  const routed = data?.routedWaypoints;
+  return routed?.length ? routed : undefined;
+}
+function stripEdgeRouting(edge, keepManual = false) {
+  const data = edge.data;
+  if (!data)
+    return edge;
+  const hasRoute = "routedWaypoints" in data;
+  const hasManual = !keepManual && "waypoints" in data;
+  if (!hasRoute && !hasManual)
+    return edge;
+  const next = { ...data };
+  delete next.routedWaypoints;
+  if (!keepManual)
+    delete next.waypoints;
+  return { ...edge, data: next };
+}
+var STALE_ROUTE_SLACK_PX = 2000;
+function dropStaleEdgeRoutes(edges, nodes) {
+  if (!edges.some((edge) => getManualWaypoints(edge.data) || getRoutedWaypoints(edge.data)))
+    return edges;
+  const positions = computeAbsoluteNodePositions(nodes);
+  const nodeById = new Map(nodes.map((node) => [node.id, node]));
+  const boundsFor = (nodeId) => {
+    const origin = positions.get(nodeId);
+    if (!origin)
+      return;
+    const node = nodeById.get(nodeId);
+    const { width, height } = node ? getNodeDimensions(node) : { width: 0, height: 0 };
+    return { minX: origin.x, maxX: origin.x + (width || 0), minY: origin.y, maxY: origin.y + (height || 0) };
+  };
+  let changed = false;
+  const next = edges.map((edge) => {
+    const waypoints = [...getManualWaypoints(edge.data) ?? [], ...getRoutedWaypoints(edge.data) ?? []];
+    if (waypoints.length === 0)
+      return edge;
+    const source = boundsFor(edge.source);
+    const target = boundsFor(edge.target);
+    if (!source || !target)
+      return edge;
+    const minX = Math.min(source.minX, target.minX) - STALE_ROUTE_SLACK_PX;
+    const maxX = Math.max(source.maxX, target.maxX) + STALE_ROUTE_SLACK_PX;
+    const minY = Math.min(source.minY, target.minY) - STALE_ROUTE_SLACK_PX;
+    const maxY = Math.max(source.maxY, target.maxY) + STALE_ROUTE_SLACK_PX;
+    const stale = waypoints.some((w) => w.x < minX || w.x > maxX || w.y < minY || w.y > maxY);
+    if (!stale)
+      return edge;
+    changed = true;
+    return stripEdgeRouting(edge);
+  });
+  return changed ? next : edges;
+}
+init_esm_shims();
+var NO_OFFSET = { x: 0, y: 0 };
+function edgeToInstance(edge, offset = NO_OFFSET) {
   const edgeData = {};
   if (edge.data?.label) {
     edgeData.label = edge.data.label;
   }
+  const waypoints = getManualWaypoints(edge.data);
+  const routedWaypoints = getRoutedWaypoints(edge.data);
+  const carriedUi = edge.data?.ui;
+  const ui = {
+    ...carriedUi,
+    ...waypoints && { waypoints: untranslateWaypoints(waypoints, offset) },
+    ...routedWaypoints && { routedWaypoints: untranslateWaypoints(routedWaypoints, offset) }
+  };
   return {
     id: edge.id,
     sourceNodeId: edge.source,
     sourcePort: edge.sourceHandle || "default",
     targetNodeId: edge.target,
     targetPort: edge.targetHandle || "default",
-    ...Object.keys(edgeData).length > 0 && { data: edgeData }
+    ...Object.keys(edgeData).length > 0 && { data: edgeData },
+    ...Object.keys(ui).length > 0 && { ui }
   };
 }
-function instanceToEdge(instance, type = "default") {
+function instanceToEdge(instance2, type = "default", offset = NO_OFFSET) {
+  const { waypoints: _manual, routedWaypoints: _routed, ...carriedUi } = instance2.ui ?? {};
+  const route = getManualWaypoints(instance2.ui);
+  const routedRoute = getRoutedWaypoints(instance2.ui);
+  const hasCarriedUi = Object.keys(carriedUi).length > 0;
   return {
-    id: instance.id,
-    source: instance.sourceNodeId,
-    sourceHandle: instance.sourcePort,
-    target: instance.targetNodeId,
-    targetHandle: instance.targetPort,
+    id: instance2.id,
+    source: instance2.sourceNodeId,
+    sourceHandle: instance2.sourcePort,
+    target: instance2.targetNodeId,
+    targetHandle: instance2.targetPort,
     type,
-    ...instance.data && { data: instance.data }
+    ...(instance2.data || route || routedRoute || hasCarriedUi) && {
+      data: {
+        ...instance2.data,
+        ...hasCarriedUi && { ui: carriedUi },
+        ...route && { waypoints: translateWaypoints(route, offset) },
+        ...routedRoute && { routedWaypoints: translateWaypoints(routedRoute, offset) }
+      }
+    }
   };
 }
 function nodeToInstance(node, offset = { x: 0, y: 0 }) {
@@ -125,41 +252,50 @@ function nodeToInstance(node, offset = { x: 0, y: 0 }) {
       ...node.data?.content !== undefined && { content: node.data.content }
     },
     ...instanceOutputs && Object.keys(instanceOutputs).length > 0 && { outputs: instanceOutputs },
-    ...variableUpdates && variableUpdates.length > 0 && { variableUpdates },
+    ...variableUpdates && variableUpdates.length > 0 && supportsVariableUpdates(node.data?.type ?? node.type) && { variableUpdates },
     ...parentId && { parentId }
   };
 }
-function instanceToNode(instance, offset = { x: 0, y: 0 }) {
-  const position = instance.ui?.position ?? { x: 0, y: 0 };
-  const color = instance.inputs?.color;
-  const content = instance.inputs?.content;
-  const variableUpdates = instance.variableUpdates;
+function instanceToNode(instance2, offset = { x: 0, y: 0 }) {
+  const position = instance2.ui?.position ?? { x: 0, y: 0 };
+  const color = instance2.inputs?.color;
+  const content = instance2.inputs?.content;
+  const variableUpdates = instance2.variableUpdates;
   return {
-    id: instance.id,
-    type: instance.type,
+    id: instance2.id,
+    type: instance2.type,
     position: {
       x: position.x + offset.x,
       y: position.y + offset.y
     },
-    ...instance.ui?.size && {
-      width: instance.ui.size.width,
-      height: instance.ui.size.height
+    ...instance2.ui?.size && {
+      width: instance2.ui.size.width,
+      height: instance2.ui.size.height
     },
     data: {
-      type: instance.type,
-      typeVersion: instance.typeVersion,
-      display: instance.display || {},
-      inputs: instance.inputs || {},
-      ui: instance.ui || {},
+      type: instance2.type,
+      typeVersion: instance2.typeVersion,
+      display: instance2.display || {},
+      inputs: instance2.inputs || {},
+      ui: instance2.ui || {},
       ...color !== undefined && { color },
       ...content !== undefined && { content },
       ...variableUpdates && variableUpdates.length > 0 && { variableUpdates },
-      ...instance.parentId && { parentId: instance.parentId }
+      ...instance2.parentId && { parentId: instance2.parentId }
     }
   };
 }
 init_esm_shims();
 init_esm_shims();
+var SCHEME = "uip-sw-local";
+var SCHEME_PREFIX = `${SCHEME}://`;
+var FOLDER_AUTHORITY = "Folder";
+var FOLDER_PREFIX = `${SCHEME_PREFIX}${FOLDER_AUTHORITY}/`;
+function isLocalSolutionUri(uri) {
+  return uri.startsWith(SCHEME_PREFIX);
+}
+init_esm_shims();
+init_esm_shims();
 function createBinding(options) {
   return {
     id: generateNextId("b", 8),
@@ -190,6 +326,11 @@ init_esm_shims();
 init_esm_shims();
 var DEFAULT_TRIGGER_POSITION = { x: 256, y: 144 };
 init_esm_shims();
+init_esm_shims();
+var SCRIPT_NODE_TYPE = NodeType.ActionScript;
+var FILE_ID_KEY = "ID";
+var FILE_PROBE_TYPE = `{ ${FILE_ID_KEY}?: any }`;
+var FILE_ARRAY_PROBE_TYPE = `Array<${FILE_PROBE_TYPE}>`;
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -200,46 +341,35 @@ function mergeManifestOutputOverInstance(instanceValue, manifestValue) {
     return manifestValue;
   return isPlainObject(instanceValue) && isPlainObject(manifestValue) ? { ...instanceValue, ...manifestValue } : manifestValue;
 }
-init_esm_shims();
-init_esm_shims();
-var connectorHttpRequestProcessor = (definition, ctx) => {
-  const connectorKey = getConnectorHttpRequestKey(definition);
-  if (!connectorKey)
-    return;
-  const managed = ctx.getManifest(MANAGED_HTTP_NODE_TYPE);
-  if (!managed)
-    return;
-  return {
-    nodeType: managed.nodeType,
-    manifest: {
-      ...managed,
-      display: {
-        ...managed.display,
-        icon: definition.display?.icon ?? managed.display?.icon
-      },
-      inputDefaults: { ...managed.inputDefaults, detail: buildConnectorHttpRequestDetail(connectorKey) }
-    }
-  };
-};
-var PROCESSORS = [connectorHttpRequestProcessor];
-function processManifest(definition, ctx) {
-  if (!definition)
-    return;
-  for (const processor of PROCESSORS) {
-    const result = processor(definition, ctx);
-    if (result)
-      return result;
+function buildEffectiveNodeOutputs(args) {
+  const manifestOutputs = args.manifestOutputs ?? {};
+  const manifestDefinesOutputs = args.manifestOutputs != null;
+  const nodeVariableOutputs = {};
+  for (const variable of args.nodeVariables) {
+    const outputId = variable.binding?.outputId;
+    if (!outputId)
+      continue;
+    if (manifestDefinesOutputs && !(outputId in manifestOutputs))
+      continue;
+    const declared = manifestOutputs[outputId];
+    const manifestOutput = isPlainObject(declared) ? declared : undefined;
+    nodeVariableOutputs[outputId] = {
+      type: variable.type,
+      ...variable.description && { description: variable.description },
+      ...variable.schema && { schema: variable.schema },
+      ...manifestOutput?.scope && { scope: manifestOutput.scope },
+      ...manifestOutput?.source && { source: manifestOutput.source },
+      ...manifestOutput?.var && { var: manifestOutput.var }
+    };
   }
-  return;
-}
-function resolveEffectiveManifest(rawNodeType, rawDefinition, ctx) {
-  const processed = processManifest(rawDefinition, ctx);
-  return {
-    nodeType: processed?.nodeType ?? rawNodeType,
-    manifest: processed?.manifest ?? rawDefinition
-  };
+  const effective = { ...manifestOutputs, ...nodeVariableOutputs };
+  for (const layer of args.extraLayers ?? [])
+    Object.assign(effective, layer);
+  for (const [key, value] of Object.entries(args.instanceOutputs ?? {})) {
+    effective[key] = key in effective ? mergeManifestOutputOverInstance(value, effective[key]) : value;
+  }
+  return effective;
 }
-init_esm_shims();
 var DEFAULT_ERROR_SCHEMA = {
   $schema: "http://json-schema.org/draft-07/schema#",
   type: "object",
@@ -282,10 +412,30 @@ function buildSubflowOutputDefinition(globals) {
 function buildSubflowInputDefinition(globals) {
   return globals.filter((v) => v.direction === "in");
 }
-function buildSubflowPassThroughOutputDefinition(nodes, edges, manifestMap, nodeOutputsMap, subflows) {
-  if (nodes.length === 0)
+function buildSubflowNodeOutputs(entry, options = {}) {
+  if (!entry)
+    return {};
+  const globals = entry.variables?.globals ?? [];
+  let outputs = getSubflowBaselineOutputs();
+  if (globals.length > 0) {
+    outputs = { ...outputs, ...buildSubflowOutputDefinition(globals) };
+  }
+  if (!globals.some((g) => g.direction === "out") && options.manifests) {
+    const passThrough = buildSubflowPassThroughOutputDefinition(entry, options.manifests, {
+      nodeOutputsMap: options.nodeOutputsMap,
+      subflows: options.subflows
+    });
+    if (Object.keys(passThrough).length > 0) {
+      outputs = { ...outputs, ...passThrough };
+    }
+  }
+  return outputs;
+}
+function buildSubflowPassThroughOutputDefinition(entry, manifestMap, options = {}) {
+  const { nodeOutputsMap, subflows } = options;
+  if (entry.nodes.length === 0)
     return {};
-  const terminalNodes = findTerminalNodes(nodes, edges, (n) => {
+  const terminalNodes = findTerminalNodes(entry.nodes, entry.edges, (n) => {
     const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
     return manifest?.model?.type === "bpmn:StartEvent";
   });
@@ -293,18 +443,22 @@ function buildSubflowPassThroughOutputDefinition(nodes, edges, manifestMap, node
     const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
     const manifestOutputDef = manifest?.outputDefinition;
     let outputDef;
-    if (manifestOutputDef && Object.keys(manifestOutputDef).length > 0) {
-      outputDef = manifestOutputDef;
-    } else {
+    if (isSubflowNodeType(n.type)) {
       outputDef = nodeOutputsMap?.get(n.id);
-      if ((!outputDef || Object.keys(outputDef).length === 0) && isSubflowNodeType(n.type) && subflows) {
+      if ((!outputDef || Object.keys(outputDef).length === 0) && subflows) {
         outputDef = computeSubflowEffectiveOutputDef(n.id, subflows, manifestMap);
       }
+      if (!outputDef || Object.keys(outputDef).length === 0)
+        outputDef = manifestOutputDef;
+    } else if (manifestOutputDef && Object.keys(manifestOutputDef).length > 0) {
+      outputDef = manifestOutputDef;
+    } else {
+      outputDef = nodeOutputsMap?.get(n.id);
     }
     if (!outputDef || Object.keys(outputDef).length === 0)
       return null;
     return { node: n, outputDef };
-  }).filter((t) => t !== null);
+  }).filter((t2) => t2 !== null);
   if (terminalsWithOutputs.length === 0)
     return {};
   const allKeys = /* @__PURE__ */ new Set;
@@ -366,9 +520,9 @@ function computeSubflowEffectiveOutputDef(subflowNodeId, subflows, manifestMap,
   const outputKeys = {};
   for (const n of terminalNodes) {
     const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
-    let outputDef = manifest?.outputDefinition;
-    if ((!outputDef || Object.keys(outputDef).length === 0) && isSubflowNodeType(n.type)) {
-      outputDef = computeSubflowEffectiveOutputDef(n.id, subflows, manifestMap, seen);
+    let outputDef = isSubflowNodeType(n.type) ? computeSubflowEffectiveOutputDef(n.id, subflows, manifestMap, seen) : undefined;
+    if (!outputDef || Object.keys(outputDef).length === 0) {
+      outputDef = manifest?.outputDefinition;
     }
     if (outputDef) {
       for (const [key, val] of Object.entries(outputDef)) {
@@ -380,6 +534,213 @@ function computeSubflowEffectiveOutputDef(subflowNodeId, subflows, manifestMap,
   }
   return Object.keys(outputKeys).length > 0 ? outputKeys : undefined;
 }
+init_esm_shims();
+init_esm_shims();
+var connectorHttpRequestProcessor = (definition, ctx) => {
+  const connectorKey = getConnectorHttpRequestKey(definition);
+  if (!connectorKey)
+    return;
+  const managed = ctx.getManifest(MANAGED_HTTP_NODE_TYPE);
+  if (!managed)
+    return;
+  return {
+    nodeType: managed.nodeType,
+    manifest: {
+      ...managed,
+      display: {
+        ...managed.display,
+        icon: definition.display?.icon ?? managed.display?.icon
+      },
+      inputDefaults: { ...managed.inputDefaults, detail: buildConnectorHttpRequestDetail(connectorKey) }
+    }
+  };
+};
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+var EXTRACTION_METHOD = "external_llm";
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+var buildPrompt = (flags, override) => {
+  const fragments = [];
+  if (override)
+    fragments.push(override);
+  fragments.push(`The user prompt will give table names and columns for one or more tables, possibly adding descriptions/hints.
+The user prompt will be in the following format, shown between triple quotes: """{"tables":<JSON set of tables prompt object>}""".
+This will be followed by one or more images of successive pages in the document.
+The JSON set of tables prompt object has table_names as keys and their values are a JSON table prompt object.
+Each JSON table prompt object is of the format between triple quotes: """{"columns":<array of JSON column prompt objects>}, """and also, optionally, a "table_description/hint" key mapping to a string value.
+A JSON column prompt object has a "column_title" key, and also, optionally, a "column_description/hint" key: both these keys map to string values.
+
+For each table_name, you should consider how best to find the data for it and extract a table of zero or more rows, as appropriate, from the target document, with each column filled.
+Your response should be only a JSON object with each table_name as a key, with the corresponding value being a JSON table response object.
+Each JSON table response object must be of the form shown here between triple quotes: """{"explanation":<a string explaining how you identified the data for this table, finding all the data of this kind to put in rows of the table>,"rows":<an array of JSON row response objects>}"""
+Each JSON row response object has the table's column titles as keys with the appropriate values from the document inserted by you.
+If any column value is missing, fill in with the value "{{missing_marker}}".`);
+  if (flags.includes("append_field_descriptions")) {
+    fragments.push(`"tables":
+{
+    "table_name": "<Field group name>",
+    "table_description/hints": "<Field group description included here>",
+    "columns": [
+        {
+        "column_title": "<Field name>",
+        "column_description/hints": "<Field description included here>"
+        }
+    ]
+}`);
+  }
+  if (flags.includes("append_taxonomy_descriptions")) {
+    fragments.push(`"taxonomy_description/hints": "<Taxonomy description included here>"`);
+  }
+  return fragments.join(`
+
+`);
+};
+init_esm_shims();
+var DEFAULT_EXECUTION_MODE = "standard";
+var DEFAULT_ATTRIBUTION = "word_ids";
+var DEFAULT_PRE_PROCESSING = "none";
+function toModel(modelVersion) {
+  if (!modelVersion)
+    return null;
+  return { family: modelVersion.split("_")[0], version: modelVersion };
+}
+function buildExtractionConfig(modelConfig) {
+  const mc = modelConfig ?? {};
+  return {
+    extraction_method: EXTRACTION_METHOD,
+    model: toModel(mc.model_version),
+    execution_mode: mc.execution_mode ?? DEFAULT_EXECUTION_MODE,
+    "pre-processing": mc.input_config ?? DEFAULT_PRE_PROCESSING,
+    attribution: mc.attribution_method ?? DEFAULT_ATTRIBUTION,
+    model_config: {
+      temperature: mc.temperature ?? null,
+      top_p: mc.top_p ?? null,
+      seed: mc.seed ?? null,
+      frequency_penalty: mc.frequency_penalty ?? null,
+      prompt_override: buildPrompt(mc.flags ?? [], mc.system_prompt_override)
+    }
+  };
+}
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+var TaxonomyFieldKindEnum = {
+  FieldGroup: "field_group",
+  Date: "Date",
+  ExactText: "Exact Text",
+  InferredText: "Inferred Text",
+  MonetaryQuantity: "Monetary Quantity",
+  Number: "Number",
+  Boolean: "Boolean",
+  Choice: "Choice"
+};
+var SELECTABLE_FIELD_KINDS = [];
+var emptyExtractionSchema = {
+  config: {
+    extraction_method: "",
+    model: null,
+    execution_mode: "",
+    "pre-processing": "",
+    attribution: "",
+    model_config: {
+      temperature: null,
+      top_p: null,
+      seed: null,
+      frequency_penalty: null,
+      prompt_override: null
+    }
+  },
+  prompt: "",
+  outputSchema: {
+    type: "object",
+    additionalProperties: false,
+    required: [],
+    properties: {},
+    $defs: {}
+  }
+};
+function migrateLegacySchemaDocument(_legacy) {
+  throw new Error("migrateLegacySchemaDocument is not available in the headless @uipath/ixp-components-wind stub");
+}
+var DEFAULT_FIELD_TYPES = SELECTABLE_FIELD_KINDS.filter((kind) => kind !== TaxonomyFieldKindEnum.Choice).map((kind) => ({
+  id: kind,
+  name: kind,
+  kind
+}));
+function getDefaultExtractionSchema() {
+  try {
+    return migrateLegacySchemaDocument({
+      taxonomy: { overallInstructions: "", lastModified: 0, fieldGroups: [] },
+      fieldTypes: DEFAULT_FIELD_TYPES,
+      businessChecks: []
+    });
+  } catch {
+    return structuredClone(emptyExtractionSchema);
+  }
+}
+function toModelConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  const raw = value;
+  const str = (key) => typeof raw[key] === "string" ? raw[key] : undefined;
+  const num = (key) => typeof raw[key] === "number" ? raw[key] : undefined;
+  return {
+    model_version: str("model_version"),
+    execution_mode: str("execution_mode"),
+    attribution_method: str("attribution_method"),
+    input_config: str("input_config"),
+    system_prompt_override: str("system_prompt_override"),
+    frequency_penalty: num("frequency_penalty"),
+    temperature: num("temperature"),
+    top_p: num("top_p"),
+    seed: num("seed"),
+    flags: Array.isArray(raw.flags) ? raw.flags.filter((flag) => typeof flag === "string") : undefined
+  };
+}
+var ixpDefaultSchemaProcessor = (definition) => {
+  if (definition.nodeType !== DYNAMIC_EXTRACT_NODE_TYPE)
+    return;
+  const inputDefaults = definition.inputDefaults;
+  if (inputDefaults?.schemaDocument !== undefined)
+    return;
+  const seeded = getDefaultExtractionSchema();
+  const modelConfig = toModelConfig(inputDefaults?.modelConfig);
+  const schemaDocument = modelConfig === undefined ? seeded : { ...seeded, config: buildExtractionConfig(modelConfig) };
+  return {
+    nodeType: definition.nodeType,
+    manifest: {
+      ...definition,
+      inputDefaults: { ...inputDefaults, schemaDocument }
+    }
+  };
+};
+var PROCESSORS = [connectorHttpRequestProcessor, ixpDefaultSchemaProcessor];
+function processManifest(definition, ctx) {
+  if (!definition)
+    return;
+  for (const processor of PROCESSORS) {
+    const result = processor(definition, ctx);
+    if (result)
+      return result;
+  }
+  return;
+}
+function resolveEffectiveManifest(rawNodeType, rawDefinition, ctx) {
+  const processed = processManifest(rawDefinition, ctx);
+  return {
+    nodeType: processed?.nodeType ?? rawNodeType,
+    manifest: processed?.manifest ?? rawDefinition
+  };
+}
 function sanitizeNodeLabelLocal(label) {
   const words = label.split(/[^a-zA-Z0-9]+/).filter(Boolean);
   if (words.length === 0)
@@ -409,13 +770,33 @@ function generateNodeIdAndNameLocal(label, existingIds) {
     displayName: label ? index > 1 ? `${label} ${index}` : label : `Node${index > 1 ? ` ${index}` : ""}`
   };
 }
+function isInSolutionDefinition(fileDef) {
+  const model = fileDef.model;
+  return model?.isInSolution === true || !!model?.projectName || !!model?.projectId;
+}
+var isSessionLocator = (value) => typeof value === "string" && isLocalSolutionUri(value);
+function stripSessionScopedFields(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => !isSessionLocator(entry)).map((entry) => stripSessionScopedFields(entry));
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (isSessionLocator(entry)) {
+      continue;
+    }
+    result[key] = stripSessionScopedFields(entry);
+  }
+  return result;
+}
 function resolveDefinition(manifestDef, fileDef) {
   const base = manifestDef ?? fileDef;
   if (!base)
     return;
   if (manifestDef && fileDef) {
-    const isInSolution = !!fileDef.model?.projectId;
-    if (isInSolution) {
+    if (isInSolutionDefinition(fileDef)) {
       return {
         ...manifestDef,
         outputDefinition: fileDef.outputDefinition ?? manifestDef.outputDefinition,
@@ -478,50 +859,17 @@ function reconcileInputs(inputs, model, definition, node) {
   return out;
 }
 function hydrateNodeData(node, definition, nodeVariables = [], subflowEntry, manifestMap, subflows) {
-  const nodeVariableOutputs = {};
-  const nodeOutputs = nodeVariables.filter((v) => v.binding.nodeId === node.id);
-  const manifestOutputs = definition?.outputDefinition ?? {};
-  const manifestDefinesOutputs = definition?.outputDefinition != null;
-  nodeOutputs.forEach((variable) => {
-    if (variable.binding.outputId) {
-      if (manifestDefinesOutputs && !(variable.binding.outputId in manifestOutputs)) {
-        return;
-      }
-      const manifestOutput = manifestOutputs[variable.binding.outputId];
-      nodeVariableOutputs[variable.binding.outputId] = {
-        type: variable.type,
-        ...variable.description && { description: variable.description },
-        ...variable.schema && { schema: variable.schema },
-        ...manifestOutput?.scope && { scope: manifestOutput.scope },
-        ...manifestOutput?.source && { source: manifestOutput.source },
-        ...manifestOutput?.var && { var: manifestOutput.var }
-      };
-    }
+  const subflowGlobals = subflowEntry?.variables?.globals ?? [];
+  const subflowInputs = buildSubflowInputDefinition(subflowGlobals);
+  const subflowOutputVars = subflowGlobals.filter((g) => g.direction === "out");
+  const hasExplicitOutputGlobals = subflowOutputVars.length > 0;
+  const subflowOutputs = buildSubflowNodeOutputs(subflowEntry, { manifests: manifestMap, subflows });
+  const effectiveOutputs = buildEffectiveNodeOutputs({
+    manifestOutputs: definition?.outputDefinition,
+    nodeVariables: nodeVariables.filter((v) => v.binding.nodeId === node.id),
+    extraLayers: [subflowOutputs],
+    instanceOutputs: node.outputs
   });
-  let subflowInputs = [];
-  let subflowOutputVars = [];
-  let subflowOutputs = subflowEntry ? getSubflowBaselineOutputs() : {};
-  const hasExplicitOutputGlobals = subflowEntry?.variables?.globals?.some((g) => g.direction === "out") ?? false;
-  if (subflowEntry?.variables?.globals) {
-    subflowOutputs = { ...subflowOutputs, ...buildSubflowOutputDefinition(subflowEntry.variables.globals) };
-    subflowInputs = buildSubflowInputDefinition(subflowEntry.variables.globals);
-    subflowOutputVars = subflowEntry.variables.globals.filter((g) => g.direction === "out");
-  }
-  if (!hasExplicitOutputGlobals && subflowEntry && manifestMap) {
-    const passThrough = buildSubflowPassThroughOutputDefinition(subflowEntry.nodes, subflowEntry.edges, manifestMap, undefined, subflows);
-    if (Object.keys(passThrough).length > 0) {
-      subflowOutputs = { ...subflowOutputs, ...passThrough };
-    }
-  }
-  const instanceOutputs = node.outputs ?? {};
-  const effectiveOutputs = { ...manifestOutputs, ...nodeVariableOutputs, ...subflowOutputs };
-  for (const [key, value] of Object.entries(instanceOutputs)) {
-    if (key in effectiveOutputs) {
-      effectiveOutputs[key] = mergeManifestOutputOverInstance(value, effectiveOutputs[key]);
-    } else {
-      effectiveOutputs[key] = value;
-    }
-  }
   const model = node.model;
   const nodeInputs = reconcileInputs(node.inputs, model, definition, node);
   const variableUpdates = node.variableUpdates;
@@ -547,9 +895,9 @@ function hydrateNodeData(node, definition, nodeVariables = [], subflowEntry, man
     ...projectId && { projectId }
   };
 }
-function instanceToHydratedNode(instance, definition, options = {}) {
-  const base = instanceToNode(instance, options.offset);
-  base.data = hydrateNodeData(instance, definition, options.nodeVariables ?? [], options.subflowEntry, options.manifestMap, options.subflows);
+function instanceToHydratedNode(instance2, definition, options = {}) {
+  const base = instanceToNode(instance2, options.offset);
+  base.data = hydrateNodeData(instance2, definition, options.nodeVariables ?? [], options.subflowEntry, options.manifestMap, options.subflows);
   return base;
 }
 function xyFlowToPackagingNode(nodes) {
@@ -584,7 +932,11 @@ function workflowToXYFlow(workflow, manifestMap) {
     const { nodeType: effectiveType, manifest: definition } = resolveEffectiveManifest(node.type, resolved, {
       getManifest: (type) => findManifestByNodeType(manifestMap, type)
     });
-    const effectiveNode = effectiveType === node.type ? node : { ...node, type: effectiveType, typeVersion: definition?.version ?? node.typeVersion };
+    let effectiveNode = effectiveType === node.type ? node : { ...node, type: effectiveType, typeVersion: definition?.version ?? node.typeVersion };
+    if (!supportsVariableUpdates(effectiveType) && "variableUpdates" in effectiveNode) {
+      const { variableUpdates: _variableUpdates, ...withoutVariableUpdates } = effectiveNode;
+      effectiveNode = withoutVariableUpdates;
+    }
     const base = instanceToHydratedNode(effectiveNode, definition, {
       nodeVariables,
       subflowEntry: workflow.subflows?.[node.id],
@@ -604,8 +956,14 @@ function workflowToXYFlow(workflow, manifestMap) {
     return base;
   });
   const orderedNodes = sortNodesParentFirst(nodes);
-  const edges = workflow.edges.map((connection) => resolveEdgeType(instanceToEdge(connection), orderedNodes, manifestMap));
-  return { nodes: orderedNodes, edges, definitions, bindings, workflowVariables };
+  const edges = dropStaleEdgeRoutes(workflow.edges.map((connection) => resolveEdgeType(instanceToEdge(connection), orderedNodes, manifestMap)), orderedNodes);
+  return {
+    nodes: orderedNodes,
+    edges,
+    definitions,
+    bindings,
+    workflowVariables: pruneVariableUpdatesForNodes(orderedNodes, workflowVariables)
+  };
 }
 function convertSubflowsToXYFlow(workflow, manifestMap) {
   if (!workflow.subflows)
@@ -663,7 +1021,7 @@ function sortNodesParentFirst(nodes) {
   }
   return sorted;
 }
-function xyFlowToWorkflow(workflowId, workflowVersion, workflowName, nodes, edges, definitions, bindings = [], variables = { nodes: [], globals: [] }, options = {}) {
+function xyFlowToWorkflow(workflowId, workflowVersion, workflowName, nodes, edges, definitions, bindings = [], variables = { nodes: [], globals: [] }) {
   const orderedNodes = sortNodesParentFirst(nodes);
   const workflowNodes = orderedNodes.map((node) => {
     const base = nodeToInstance(node);
@@ -686,8 +1044,7 @@ function xyFlowToWorkflow(workflowId, workflowVersion, workflowName, nodes, edge
       }
     };
   });
-  const workflowEdges = edges.map(edgeToInstance);
-  const { solutionId, projectId } = options;
+  const workflowEdges = edges.map((edge) => edgeToInstance(edge));
   const generatedVariables = generateNodeVariablesFromNodes(orderedNodes, variables, definitions);
   return {
     id: workflowId,
@@ -701,9 +1058,30 @@ function xyFlowToWorkflow(workflowId, workflowVersion, workflowName, nodes, edge
       ...generatedVariables.nodes.length > 0 && { nodes: generatedVariables.nodes },
       ...generatedVariables.variableUpdates && Object.keys(generatedVariables.variableUpdates).length > 0 && { variableUpdates: generatedVariables.variableUpdates }
     },
-    ...bindings && bindings.length > 0 && { bindings },
-    ...solutionId && { solutionId },
-    ...projectId && { projectId }
+    ...bindings && bindings.length > 0 && { bindings }
+  };
+}
+function getVariableUpdateNodeType(node) {
+  return (typeof node.data?.type === "string" ? node.data.type : undefined) ?? node.type;
+}
+function pruneVariableUpdatesForNodes(nodes, variables) {
+  if (!variables.variableUpdates)
+    return variables;
+  const nodeMap = new Map(nodes.map((node) => [node.id, node]));
+  const variableUpdates = Object.fromEntries(Object.entries(variables.variableUpdates).filter(([nodeId, updates]) => nodeMap.has(nodeId) && supportsVariableUpdates(getVariableUpdateNodeType(nodeMap.get(nodeId))) && Boolean(updates?.length)));
+  return { ...variables, variableUpdates };
+}
+function pruneVariableUpdatesForSubflow(entry) {
+  const nodes = entry.nodes.map((node) => {
+    if (supportsVariableUpdates(node.type) || !("variableUpdates" in node))
+      return node;
+    const { variableUpdates: _variableUpdates, ...rest } = node;
+    return rest;
+  });
+  return {
+    ...entry,
+    nodes,
+    variables: entry.variables ? pruneVariableUpdatesForNodes(nodes, entry.variables) : undefined
   };
 }
 function createWorkflowNodeFromManifest(manifest, id, position = { x: 0, y: 0 }, label) {
@@ -790,14 +1168,7 @@ function generateNodeVariablesFromNodes(nodes, variables, definitions = []) {
     return v.binding.outputId in outputs;
   });
   const allNodeVariables = [...validNodeVariables, ...generatedNodeVariables.filter((g) => !validNodeVariables.some((v) => v.id === g.id))];
-  const variableUpdatesMap = {};
-  if (variables.variableUpdates) {
-    for (const [nodeId, updates] of Object.entries(variables.variableUpdates)) {
-      if (nodeMap.has(nodeId) && updates?.length) {
-        variableUpdatesMap[nodeId] = updates;
-      }
-    }
-  }
+  const variableUpdatesMap = pruneVariableUpdatesForNodes(nodes, variables).variableUpdates ?? {};
   return {
     globals: globalVariables,
     nodes: allNodeVariables,
@@ -816,7 +1187,7 @@ function applyGlobalInputOverrides(raw, inputs) {
     }
   }
 }
-var warmSerializationChunks = () => Promise.all([import("./index-zvxfkpkr.js"), import("./serialization-GTFWODSH-p7wmsmj7.js")]);
+var warmSerializationChunks = () => Promise.all([import("./index-er6vy3jk.js"), import("./serialization-GAW7UFOK-9hkdmmd2.js")]);
 async function flowJsonToBpmnXml(flowJson, options) {
   const [{ fileFormatToInMemoryWorkflow }, { toXml }] = await warmSerializationChunks();
   const raw = JSON.parse(flowJson);
@@ -829,7 +1200,8 @@ async function flowJsonToBpmnXml(flowJson, options) {
   const { nodes, edges, definitions, workflowVariables, bindings } = workflowToXYFlow(workflow, manifestMap);
   return toXml(nodes, edges, definitions, bindings, workflowVariables, workflow.subflows, {
     detached: options?.detached,
-    voiceAgentDefinitions: options?.voiceAgentDefinitions
+    voiceAgentDefinitions: options?.voiceAgentDefinitions,
+    encoding: options?.encoding
   });
 }
 export {
@@ -837,8 +1209,11 @@ export {
   xyFlowToPackagingNode,
   workflowToXYFlow,
   warmSerializationChunks,
+  stripSessionScopedFields,
   resolveDefinition,
   reconcileInputs,
+  pruneVariableUpdatesForSubflow,
+  pruneVariableUpdatesForNodes,
   mapDefinitionToNodeData,
   instanceToHydratedNode,
   generateNodeVariablesFromNodes,
@@ -850,4 +1225,4 @@ export {
   applyGlobalInputOverrides
 };
 
-//# debugId=0E4531B286550A0F64756E2164756E21
+//# debugId=B7B72B82DACA90CD64756E2164756E21