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

package/dist/{conversion-FQTRFHRX-e5wr281j.js → conversion-7O2PDOQB-3wwppx87.js}

@@ -1,63 +1,63 @@
 import {
-  buildExtractionConfig,
-  deriveIdpProcessorBindings,
-  getExpandedSize,
-  getNodeDimensions,
-  isContainerNodeManifest
-} from "./packager-tool-qszay16r.js";
-import {
-  require_lib
-} from "./packager-tool-zfrp8ecz.js";
-import {
+  init_esm_shims,
+  MANIFEST_NAMESPACE,
+  instance,
+  NodeType2,
   MANAGED_HTTP_NODE_TYPE,
-  MULTI_RECORD_RESULTS_KEY,
-  NodeType,
   buildConnectorHttpRequestDetail,
-  createNodeVariable,
-  findTerminalNodes,
+  normalizeConnectorHttpRequestDetail,
+  getLatestDefinitionByNodeType2,
+  getManifestKey2,
+  buildExtractDocumentBuilderNode2,
+  isPublishedIdpProcessorNodeType,
   getConnectorHttpRequestKey,
-  getLatestDefinitionByNodeType,
-  getManifestKey,
+  getAgentToolConnectorHttpRequestKey,
+  MULTI_RECORD_RESULTS_KEY,
   isMultiRecordRead,
-  resolveNodeOutputTypeSchema,
-  withFileShape
-} from "./packager-tool-7bam8cjq.js";
-import"./packager-tool-gbgfwx8f.js";
+  withFileShape,
+  findTerminalNodes
+} from "./packager-tool-mdf7bws6.js";
+import {
+  isUnsafeKey2,
+  isPlainObject2,
+  isContainerNodeType2,
+  supportsVariableUpdates2,
+  isSubflowNodeType2,
+  isConversationalOrVoiceAgentNodeType2,
+  isAgentNodeType2,
+  DYNAMIC_EXTRACT_NODE_TYPE2,
+  isHitlNodeType2,
+  readExtractionOutputSchema2,
+  isNodeUniqueId2
+} from "./packager-tool-fzgfb0jt.js";
 import {
-  DYNAMIC_EXTRACT_NODE_TYPE,
-  MINIMUM_SUPPORTED_SCHEMA_VERSION,
-  generateNextId,
-  isAgentNodeType,
-  isConversationalOrVoiceAgentNodeType,
-  isHitlNodeType,
-  isLoopNodeType,
-  isSubflowNodeType,
-  isUnsafeKey,
-  supportsVariableUpdates
-} from "./packager-tool-s7wb0s9n.js";
-import"./packager-tool-p79yh9ww.js";
-import"./packager-tool-jrnjzs5t.js";
-import"./packager-tool-z83pga0z.js";
+  isContainerNodeManifest,
+  getNodeDimensions,
+  toApiExtractionStrategy,
+  buildExtractionConfig,
+  IDP_PROCESSOR_KEY_INPUT,
+  IDP_PROCESSOR_READONLY_INPUT,
+  IDP_PROCESSOR_NAME_INPUT,
+  IDP_PROCESSOR_FOLDER_PATH_INPUT,
+  deriveIdpProcessorBindings,
+  SERVICES_NAMESPACE
+} from "./packager-tool-6vhefpmq.js";
 import {
-  init_esm_shims
-} from "./packager-tool-6ejqwbw9.js";
-import"./packager-tool-mcaf4ewf.js";
-import"./packager-tool-4mna26cc.js";
-import"./packager-tool-c23zrhj8.js";
+  require_lib
+} from "./packager-tool-951nhh3e.js";
 import {
-  __require,
   __toESM
-} from "./packager-tool-1yh8g550.js";
+} from "./packager-tool-6an893wm.js";
 
-// ../../node_modules/@uipath/flow-converter/dist/conversion-FQTRFHRX.js
+// ../../node_modules/@uipath/flow-converter/dist/conversion-7O2PDOQB.js
 var import_json5 = __toESM(require_lib(), 1);
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
 function findManifestByNodeType(map, nodeType) {
-  const latestDef = getLatestDefinitionByNodeType(nodeType);
+  const latestDef = getLatestDefinitionByNodeType2(nodeType);
   if (latestDef) {
-    const found = map.get(getManifestKey(nodeType, latestDef.version));
+    const found = map.get(getManifestKey2(nodeType, latestDef.version));
     if (found)
       return found;
   }
@@ -71,8 +71,8 @@ function isArtifactHandle(nodeHandleId, nodeConfig) {
   return Boolean(nodeHandleId && nodeConfig && nodeConfig.handleConfiguration.some((handleGroup) => handleGroup.handles.some((h) => h.id === nodeHandleId && h.handleType === "artifact")));
 }
 function shouldUseArtifactEdge(source, target, manifestMap) {
-  const sourceNodeConfig = manifestMap.get(getManifestKey(source.type, source.version));
-  const targetNodeConfig = manifestMap.get(getManifestKey(target.type, target.version));
+  const sourceNodeConfig = manifestMap.get(getManifestKey2(source.type, source.version));
+  const targetNodeConfig = manifestMap.get(getManifestKey2(target.type, target.version));
   return Boolean(isArtifactHandle(source.sourceHandle, sourceNodeConfig) || isArtifactHandle(target.targetHandle, targetNodeConfig));
 }
 function resolveEdgeType(edge, nodes, manifestMap) {
@@ -89,6 +89,9 @@ function resolveEdgeType(edge, nodes, manifestMap) {
 }
 init_esm_shims();
 init_esm_shims();
+init_esm_shims();
+var GRID_SPACING = 16;
+init_esm_shims();
 function getNodeParentId(node) {
   const dataParentId = node?.data?.parentId;
   return node?.parentId ?? (typeof dataParentId === "string" ? dataParentId : undefined);
@@ -129,9 +132,6 @@ function translateWaypoints(waypoints, offset) {
     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;
@@ -154,6 +154,8 @@ function stripEdgeRouting(edge, keepManual = false) {
     delete next.waypoints;
   return { ...edge, data: next };
 }
+var LOOP_BACK_STEM_PX = 2 * GRID_SPACING;
+var TIMEOUT_ROUTE_CLEARANCE_PX = GRID_SPACING / 2;
 var STALE_ROUTE_SLACK_PX = 2000;
 function dropStaleEdgeRoutes(edges, nodes) {
   if (!edges.some((edge) => getManualWaypoints(edge.data) || getRoutedWaypoints(edge.data)))
@@ -221,7 +223,7 @@ function reconcileStaleHitlOutcomeEdges(edges, nodes) {
   const realHandleIdsByNode = /* @__PURE__ */ new Map;
   for (const node of nodes) {
     const nodeType = node.data?.type ?? node.type ?? "";
-    if (!isHitlNodeType(nodeType))
+    if (!isHitlNodeType2(nodeType))
       continue;
     const outcomes = parseOutcomes(node.data?.inputs?.schema).filter((o) => typeof o.id === "string" && o.id.length > 0);
     if (outcomes.length === 0)
@@ -256,44 +258,21 @@ function reconcileStaleHitlOutcomeEdges(edges, nodes) {
 }
 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(ui).length > 0 && { ui }
-  };
-}
-function instanceToEdge(instance, type = "default", offset = NO_OFFSET) {
-  const { waypoints: _manual, routedWaypoints: _routed, ...carriedUi } = instance.ui ?? {};
-  const route = getManualWaypoints(instance.ui);
-  const routedRoute = getRoutedWaypoints(instance.ui);
+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 || route || routedRoute || hasCarriedUi) && {
+    ...(instance2.data || route || routedRoute || hasCarriedUi) && {
       data: {
-        ...instance.data,
+        ...instance2.data,
         ...hasCarriedUi && { ui: carriedUi },
         ...route && { waypoints: translateWaypoints(route, offset) },
         ...routedRoute && { routedWaypoints: translateWaypoints(routedRoute, offset) }
@@ -301,78 +280,43 @@ function instanceToEdge(instance, type = "default", offset = NO_OFFSET) {
     }
   };
 }
-function nodeToInstance(node, offset = { x: 0, y: 0 }) {
-  const typeVersion = node.data?.typeVersion || "1.0.0";
-  const display = node.data?.display || {};
-  const inputs = node.data?.inputs || {};
-  const ui = node.data?.ui || {};
-  const width = node.width ?? node.measured?.width;
-  const height = node.height ?? node.measured?.height;
-  const variableUpdates = node.data?.variableUpdates;
-  const parentId = node.data?.parentId;
-  const allOutputs = node.data?.outputs;
-  const instanceOutputs = allOutputs ? Object.fromEntries(Object.entries(allOutputs).filter(([, def]) => def?.source != null)) : undefined;
+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: node.id,
-    type: node.type,
-    typeVersion,
-    ui: {
-      ...ui,
-      position: {
-        x: (node.position?.x ?? 0) - offset.x,
-        y: (node.position?.y ?? 0) - offset.y
-      },
-      ...width && height ? { size: { width, height } } : {}
-    },
-    display,
-    inputs: {
-      ...inputs,
-      ...node.data?.color !== undefined && { color: node.data.color },
-      ...node.data?.content !== undefined && { content: node.data.content }
-    },
-    ...instanceOutputs && Object.keys(instanceOutputs).length > 0 && { outputs: instanceOutputs },
-    ...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;
-  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 },
+      ...isNodeUniqueId2(instance2.uniqueId) && { uniqueId: instance2.uniqueId }
     }
   };
 }
 init_esm_shims();
 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();
 init_esm_shims();
@@ -381,37 +325,112 @@ init_esm_shims();
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
-function createBinding(options) {
-  return {
-    id: generateNextId("b", 8),
-    name: options.name,
-    type: "string",
-    resource: options.resource,
-    resourceKey: options.resourceKey ?? options.resource,
-    ...options.value && { default: options.value },
-    ...options.propertyAttribute && { propertyAttribute: options.propertyAttribute },
-    ...options.resourceSubType && { resourceSubType: options.resourceSubType }
-  };
-}
-function createBindingsFromManifest(manifest) {
-  const model = manifest.model;
-  const bindingsTemplate = model?.bindings;
-  if (!bindingsTemplate?.values)
-    return [];
-  return bindingsTemplate.values.map((v) => createBinding({
-    name: v.name,
-    value: v.default ?? "",
-    resource: bindingsTemplate.resource,
-    resourceKey: bindingsTemplate.resourceKey,
-    propertyAttribute: v.propertyAttribute,
-    resourceSubType: bindingsTemplate.resourceSubType
-  }));
-}
 init_esm_shims();
+var t = instance.getFixedT(null, SERVICES_NAMESPACE);
 init_esm_shims();
-var DEFAULT_TRIGGER_POSITION = { x: 256, y: 144 };
 init_esm_shims();
 init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+function inferSchemaFromValue2(value) {
+  if (value === null || value === undefined) {
+    return { type: "null" };
+  }
+  switch (typeof value) {
+    case "string":
+      return { type: "string" };
+    case "boolean":
+      return { type: "boolean" };
+    case "number":
+      return Number.isInteger(value) ? { type: "integer" } : { type: "number" };
+  }
+  if (Array.isArray(value)) {
+    return inferArraySchema(value);
+  }
+  if (typeof value === "object") {
+    return inferObjectSchema(value);
+  }
+  return {};
+}
+function inferArraySchema(value) {
+  if (value.length === 0) {
+    return { type: "array" };
+  }
+  const itemSchemas = value.map(inferSchemaFromValue2);
+  const items = mergeSchemas(itemSchemas);
+  return { type: "array", items };
+}
+function inferObjectSchema(value) {
+  const properties = {};
+  const required = [];
+  for (const [key, val] of Object.entries(value)) {
+    if (isUnsafeKey2(key))
+      continue;
+    properties[key] = inferSchemaFromValue2(val);
+    if (val !== null && val !== undefined) {
+      required.push(key);
+    }
+  }
+  const schema = { type: "object", properties, additionalProperties: true };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+function mergeSchemas(schemas) {
+  if (schemas.length === 0)
+    return {};
+  if (schemas.length === 1)
+    return schemas[0];
+  const types = new Set(schemas.map((s) => s.type).filter(Boolean));
+  if (types.size === 1) {
+    const type = [...types][0];
+    if (type !== "object" && type !== "array") {
+      return { type };
+    }
+    if (type === "object") {
+      const allProperties = {};
+      for (const schema of schemas) {
+        if (schema.properties) {
+          for (const [key, propSchema] of Object.entries(schema.properties)) {
+            if (!allProperties[key])
+              allProperties[key] = [];
+            allProperties[key].push(propSchema);
+          }
+        }
+      }
+      const mergedProperties = {};
+      for (const [key, propSchemas] of Object.entries(allProperties)) {
+        mergedProperties[key] = mergeSchemas(propSchemas);
+      }
+      const required = Object.keys(allProperties).filter((key) => allProperties[key].length === schemas.length);
+      const result = { type: "object", properties: mergedProperties, additionalProperties: true };
+      if (required.length > 0) {
+        result.required = required;
+      }
+      return result;
+    }
+  }
+  const unique = deduplicateSchemas(schemas);
+  if (unique.length === 1)
+    return unique[0];
+  return { anyOf: unique };
+}
+function deduplicateSchemas(schemas) {
+  const seen = /* @__PURE__ */ new Set;
+  const result = [];
+  for (const schema of schemas) {
+    const key = JSON.stringify(schema);
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(schema);
+    }
+  }
+  return result;
+}
 function buildAgentOutputEntry(v) {
   const type = v.type || "string";
   const entry = { type, description: v.description };
@@ -431,7 +450,7 @@ function buildAgentOutputEntry(v) {
   return entry;
 }
 function mergeAgentOutputDefinition(nodeType, inputs, baseOutputDef) {
-  if (!nodeType || !isAgentNodeType(nodeType))
+  if (!nodeType || !isAgentNodeType2(nodeType))
     return baseOutputDef;
   const agentOutputVars = inputs?.agentOutputVariables;
   if (!agentOutputVars || agentOutputVars.length === 0)
@@ -440,7 +459,7 @@ function mergeAgentOutputDefinition(nodeType, inputs, baseOutputDef) {
   for (const v of agentOutputVars) {
     outputProperties[v.id] = buildAgentOutputEntry(v);
   }
-  const baseOutput = isConversationalOrVoiceAgentNodeType(nodeType) ? baseOutputDef?.output : undefined;
+  const baseOutput = isConversationalOrVoiceAgentNodeType2(nodeType) ? baseOutputDef?.output : undefined;
   const dynamicOutput = {
     output: {
       ...baseOutput,
@@ -453,9 +472,9 @@ function mergeAgentOutputDefinition(nodeType, inputs, baseOutputDef) {
   };
   return { ...baseOutputDef, ...dynamicOutput };
 }
-var READ_ENTITY_NODE_TYPE = NodeType.DataFabricRead;
-var UPDATE_ENTITY_NODE_TYPE = NodeType.DataFabricUpdate;
-var CREATE_ENTITY_NODE_TYPE = NodeType.DataFabricCreate;
+var READ_ENTITY_NODE_TYPE = NodeType2.DataFabricRead;
+var UPDATE_ENTITY_NODE_TYPE = NodeType2.DataFabricUpdate;
+var CREATE_ENTITY_NODE_TYPE = NodeType2.DataFabricCreate;
 var DATA_FABRIC_SCHEMA_NODE_TYPES = /* @__PURE__ */ new Set([READ_ENTITY_NODE_TYPE, UPDATE_ENTITY_NODE_TYPE, CREATE_ENTITY_NODE_TYPE]);
 function mergeReadEntityOutputDefinition(nodeType, inputs, baseOutputDef) {
   if (!nodeType || !DATA_FABRIC_SCHEMA_NODE_TYPES.has(nodeType))
@@ -486,14 +505,38 @@ function readEntityRecordSchema(schema) {
     return schema.items;
   return schema;
 }
+function mergeExtractTaxonomyOutputDefinition(nodeType, inputs, baseOutputDef) {
+  if (nodeType !== DYNAMIC_EXTRACT_NODE_TYPE2)
+    return baseOutputDef;
+  const taxonomy = readExtractionOutputSchema2(inputs?.schemaDocument);
+  if (!taxonomy)
+    return baseOutputDef;
+  const output = baseOutputDef?.output;
+  if (!output)
+    return baseOutputDef;
+  const nested = isPlainObject2(output.schema) ? output.schema : undefined;
+  const shape = nested ?? output;
+  const declared = shape.properties?.taxonomy;
+  if (!declared)
+    return baseOutputDef;
+  const derived = {
+    ...inferSchemaFromValue2(taxonomy),
+    ...declared.description !== undefined && { description: declared.description }
+  };
+  const reshaped = { ...shape, properties: { ...shape.properties, taxonomy: derived } };
+  return {
+    ...baseOutputDef,
+    output: nested ? { ...output, schema: reshaped } : reshaped
+  };
+}
 function resolveInstanceOutputDefinition(nodeType, inputs, baseOutputDef) {
-  return mergeReadEntityOutputDefinition(nodeType, inputs, mergeAgentOutputDefinition(nodeType, inputs, baseOutputDef));
+  return mergeExtractTaxonomyOutputDefinition(nodeType, inputs, mergeReadEntityOutputDefinition(nodeType, inputs, mergeAgentOutputDefinition(nodeType, inputs, baseOutputDef)));
 }
-var SCRIPT_NODE_TYPE = NodeType.ActionScript;
+var SCRIPT_NODE_TYPE = NodeType2.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) {
+function isPlainObject22(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function mergeManifestOutputOverInstance(instanceValue, manifestValue) {
@@ -501,7 +544,7 @@ function mergeManifestOutputOverInstance(instanceValue, manifestValue) {
     return instanceValue;
   if (instanceValue === undefined)
     return manifestValue;
-  return isPlainObject(instanceValue) && isPlainObject(manifestValue) ? { ...instanceValue, ...manifestValue } : manifestValue;
+  return isPlainObject22(instanceValue) && isPlainObject22(manifestValue) ? { ...instanceValue, ...manifestValue } : manifestValue;
 }
 function buildEffectiveNodeOutputs(args) {
   const manifestOutputs = args.manifestOutputs ?? {};
@@ -514,11 +557,17 @@ function buildEffectiveNodeOutputs(args) {
     if (manifestDefinesOutputs && !(outputId in manifestOutputs))
       continue;
     const declared = manifestOutputs[outputId];
-    const manifestOutput = isPlainObject(declared) ? declared : undefined;
+    const manifestOutput = isPlainObject22(declared) ? declared : undefined;
+    const manifestShape = variable.schema ? { schema: variable.schema } : {
+      ...manifestOutput?.schema && { schema: manifestOutput.schema },
+      ...manifestOutput?.properties && { properties: manifestOutput.properties },
+      ...manifestOutput?.items && { items: manifestOutput.items },
+      ...manifestOutput?.required && { required: manifestOutput.required }
+    };
     nodeVariableOutputs[outputId] = {
       type: variable.type,
       ...variable.description && { description: variable.description },
-      ...variable.schema && { schema: variable.schema },
+      ...manifestShape,
       ...manifestOutput?.scope && { scope: manifestOutput.scope },
       ...manifestOutput?.source && { source: manifestOutput.source },
       ...manifestOutput?.var && { var: manifestOutput.var }
@@ -598,14 +647,14 @@ function buildSubflowPassThroughOutputDefinition(entry, manifestMap, options = {
   if (entry.nodes.length === 0)
     return {};
   const terminalNodes = findTerminalNodes(entry.nodes, entry.edges, (n) => {
-    const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
+    const manifest = manifestMap.get(getManifestKey2(n.type, n.typeVersion));
     return manifest?.model?.type === "bpmn:StartEvent";
   });
   const terminalsWithOutputs = terminalNodes.map((n) => {
-    const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
+    const manifest = manifestMap.get(getManifestKey2(n.type, n.typeVersion));
     const manifestOutputDef = manifest?.outputDefinition;
     let outputDef;
-    if (isSubflowNodeType(n.type)) {
+    if (isSubflowNodeType2(n.type)) {
       outputDef = nodeOutputsMap?.get(n.id);
       if ((!outputDef || Object.keys(outputDef).length === 0) && subflows) {
         outputDef = computeSubflowEffectiveOutputDef(n.id, subflows, manifestMap);
@@ -620,7 +669,7 @@ function buildSubflowPassThroughOutputDefinition(entry, manifestMap, options = {
     if (!outputDef || Object.keys(outputDef).length === 0)
       return null;
     return { node: n, outputDef };
-  }).filter((t2) => t2 !== null);
+  }).filter((t22) => t22 !== null);
   if (terminalsWithOutputs.length === 0)
     return {};
   const allKeys = /* @__PURE__ */ new Set;
@@ -633,17 +682,17 @@ function buildSubflowPassThroughOutputDefinition(entry, manifestMap, options = {
   if (terminalsWithOutputs.length === 1) {
     const { outputDef } = terminalsWithOutputs[0];
     for (const key of allKeys) {
-      if (isUnsafeKey(key))
+      if (isUnsafeKey2(key))
         continue;
       result[key] = toSchemaType(outputDef[key]);
     }
   } else {
     for (const key of allKeys) {
-      if (isUnsafeKey(key))
+      if (isUnsafeKey2(key))
         continue;
       const properties = {};
       for (const { node, outputDef } of terminalsWithOutputs) {
-        if (isUnsafeKey(node.id))
+        if (isUnsafeKey2(node.id))
           continue;
         if (key in outputDef) {
           properties[node.id] = toSchemaType(outputDef[key]);
@@ -672,19 +721,19 @@ function computeSubflowEffectiveOutputDef(subflowNodeId, subflows, manifestMap,
     return buildSubflowOutputDefinition(allGlobals);
   }
   const terminalNodes = findTerminalNodes(entry.nodes, entry.edges, (n) => {
-    const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
+    const manifest = manifestMap.get(getManifestKey2(n.type, n.typeVersion));
     return manifest?.model?.type === "bpmn:StartEvent";
   });
   const outputKeys = {};
   for (const n of terminalNodes) {
-    const manifest = manifestMap.get(getManifestKey(n.type, n.typeVersion));
-    let outputDef = isSubflowNodeType(n.type) ? computeSubflowEffectiveOutputDef(n.id, subflows, manifestMap, seen) : undefined;
+    const manifest = manifestMap.get(getManifestKey2(n.type, n.typeVersion));
+    let outputDef = isSubflowNodeType2(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)) {
-        if (isUnsafeKey(key))
+        if (isUnsafeKey2(key))
           continue;
         outputKeys[key] = val;
       }
@@ -694,6 +743,27 @@ function computeSubflowEffectiveOutputDef(subflowNodeId, subflows, manifestMap,
 }
 init_esm_shims();
 init_esm_shims();
+var agentToolConnectorHttpRequestProcessor = (definition, ctx) => {
+  const connectorKey = getAgentToolConnectorHttpRequestKey(definition);
+  if (!connectorKey)
+    return;
+  const builtin = ctx.getManifest(NodeType2.AgentToolBuiltinHttpRequest);
+  if (!builtin)
+    return;
+  return {
+    nodeType: builtin.nodeType,
+    manifest: {
+      ...builtin,
+      display: {
+        ...builtin.display,
+        icon: definition.display?.icon ?? builtin.display?.icon
+      },
+      inputDefaults: { ...builtin.inputDefaults, detail: buildConnectorHttpRequestDetail(connectorKey) }
+    },
+    normalizeInputs: (inputs) => ({ ...inputs, detail: normalizeConnectorHttpRequestDetail(inputs.detail, connectorKey) })
+  };
+};
+init_esm_shims();
 var connectorHttpRequestProcessor = (definition, ctx) => {
   const connectorKey = getConnectorHttpRequestKey(definition);
   if (!connectorKey)
@@ -716,6 +786,126 @@ var connectorHttpRequestProcessor = (definition, ctx) => {
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
+var SUPPORTED_VENDORS = /* @__PURE__ */ new Set(["OpenAi", "VertexAi", "AwsBedrock", "NativeOpenAi"]);
+var SUPPORTED_API_FLAVORS = /* @__PURE__ */ new Set(["OpenAiChatCompletions", "GeminiGenerateContent", "AwsBedrockInvoke", "AnthropicMessages"]);
+function isSubmittable(row) {
+  if (row.isBlockedByPolicy === true)
+    return false;
+  if (row.vendor != null && !SUPPORTED_VENDORS.has(row.vendor))
+    return false;
+  if (row.apiFlavor != null && !SUPPORTED_API_FLAVORS.has(row.apiFlavor))
+    return false;
+  return true;
+}
+function isAttributionModelReachable(attributionCatalogue) {
+  if (attributionCatalogue === null)
+    return null;
+  return attributionCatalogue.some(isSubmittable);
+}
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+init_esm_shims();
+var DEFAULT_MODEL_CONFIG = {
+  kind: "gpt_ixp",
+  configuration_mode: "inline",
+  model_version: "gemini_2_5_flash",
+  execution_mode: "standard",
+  attribution_method: "word_ids",
+  attribution_model_version: "gemini-2.5-flash",
+  input_config: "none",
+  language_support: "latin",
+  layout_parsing: "none",
+  layout_model_version: null,
+  system_prompt_override: null,
+  frequency_penalty: null,
+  temperature: null,
+  top_p: null,
+  seed: null,
+  experimentalSettings: null,
+  flags: ["append_taxonomy_descriptions", "append_type_descriptions", "append_group_descriptions", "append_field_descriptions"]
+};
+var HELIX_3_0 = {
+  key: "helix_3_0",
+  label: "Helix 3.0",
+  modelFamily: "Helix",
+  shortVersion: "3.0",
+  isPreview: true,
+  isDefaultForFamily: true,
+  isDataResidencyCompliant: true
+};
+var EXTRACTION_MODELS = [
+  {
+    key: "gpt_4o_2024_05_13",
+    label: "gpt-4o",
+    modelFamily: "GPT",
+    shortVersion: "gpt-4o",
+    isPreview: false,
+    isDefaultForFamily: true,
+    isDataResidencyCompliant: true
+  },
+  {
+    key: "gpt_5_1_2025_11_13",
+    label: "gpt-5.1-2025-11-13",
+    modelFamily: "GPT",
+    shortVersion: "gpt-5.1-2025-11-13",
+    isPreview: true,
+    isDefaultForFamily: false,
+    isDataResidencyCompliant: false
+  },
+  {
+    key: "gpt_5_4_2026_03_05",
+    label: "gpt-5.4-2026-03-05",
+    modelFamily: "GPT",
+    shortVersion: "gpt-5.4-2026-03-05",
+    isPreview: true,
+    isDefaultForFamily: false,
+    isDataResidencyCompliant: false
+  },
+  {
+    key: "gemini_2_5_flash",
+    label: "Gemini 2.5 Flash",
+    modelFamily: "Gemini",
+    shortVersion: "2.5 Flash",
+    isPreview: false,
+    isDefaultForFamily: true,
+    isDataResidencyCompliant: true
+  },
+  {
+    key: "gemini_2_5_pro",
+    label: "Gemini 2.5 Pro",
+    modelFamily: "Gemini",
+    shortVersion: "2.5 Pro",
+    isPreview: true,
+    isDefaultForFamily: false,
+    isDataResidencyCompliant: false
+  },
+  {
+    key: "gemini_3_1_pro_preview",
+    label: "Gemini 3.1 Pro Preview",
+    modelFamily: "Gemini",
+    shortVersion: "3.1 Pro Preview",
+    isPreview: true,
+    isDefaultForFamily: false,
+    isDataResidencyCompliant: false
+  },
+  {
+    key: "gemini_3_1_flash_lite_preview",
+    label: "Gemini 3.1 Flash Lite",
+    modelFamily: "Gemini",
+    shortVersion: "3.1 Flash Lite",
+    isPreview: true,
+    isDefaultForFamily: false,
+    isDataResidencyCompliant: false
+  },
+  HELIX_3_0
+];
+var MODEL_FAMILIES = [...new Set(EXTRACTION_MODELS.map((o) => o.modelFamily))];
+var DEFAULT_MODEL_FAMILY = EXTRACTION_MODELS.find((o) => o.key === DEFAULT_MODEL_CONFIG.model_version)?.modelFamily ?? MODEL_FAMILIES[0];
+var defaultLanguageSupport = (ocrEngines) => ocrEngines?.some((engine) => engine.type === "auto") ? "auto" : "latin";
+init_esm_shims();
+init_esm_shims();
 var TaxonomyFieldKindEnum = {
   FieldGroup: "field_group",
   Date: "Date",
@@ -764,15 +954,26 @@ var DEFAULT_FIELD_TYPES = SELECTABLE_FIELD_KINDS.filter((kind) => kind !== Taxon
 }));
 function getDefaultExtractionSchema() {
   try {
-    return migrateLegacySchemaDocument({
+    return withCalendarDate(migrateLegacySchemaDocument({
       taxonomy: { overallInstructions: "", lastModified: 0, fieldGroups: [] },
       fieldTypes: DEFAULT_FIELD_TYPES,
       businessChecks: []
-    });
+    }));
   } catch {
     return structuredClone(emptyExtractionSchema);
   }
 }
+var DATE_FIELD_TYPE_ID = defaultFieldTypeId(TaxonomyFieldKindEnum.Date);
+function withCalendarDate(schema) {
+  const definitions = schema.outputSchema.$defs;
+  const date = definitions?.[DATE_FIELD_TYPE_ID];
+  if (date?.format !== "timestamp")
+    return schema;
+  return {
+    ...schema,
+    outputSchema: { ...schema.outputSchema, $defs: { ...definitions, [DATE_FIELD_TYPE_ID]: { ...date, format: "date" } } }
+  };
+}
 function toModelConfig(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return;
@@ -784,6 +985,11 @@ function toModelConfig(value) {
     execution_mode: str("execution_mode"),
     attribution_method: str("attribution_method"),
     input_config: str("input_config"),
+    language_support: str("language_support"),
+    layout_parsing: str("layout_parsing"),
+    layout_engine: str("layout_engine"),
+    layout_model_version: str("layout_model_version"),
+    attribution_model_version: str("attribution_model_version"),
     system_prompt_override: str("system_prompt_override"),
     frequency_penalty: num("frequency_penalty"),
     temperature: num("temperature"),
@@ -792,24 +998,72 @@ function toModelConfig(value) {
     flags: Array.isArray(raw.flags) ? raw.flags.filter((flag) => typeof flag === "string") : undefined
   };
 }
-var ixpDefaultSchemaProcessor = (definition) => {
-  if (definition.nodeType !== DYNAMIC_EXTRACT_NODE_TYPE)
+function withDiscoveredLanguageSupport(modelConfig, ctx) {
+  if (typeof modelConfig !== "object" || modelConfig === null || Array.isArray(modelConfig))
+    return modelConfig;
+  if (modelConfig.language_support !== "latin")
+    return modelConfig;
+  const languageSupport = defaultLanguageSupport(ctx.ocrEngines ?? null);
+  return languageSupport === "latin" ? modelConfig : { ...modelConfig, language_support: languageSupport };
+}
+function withDiscoveredAttribution(modelConfig, ctx) {
+  if (typeof modelConfig !== "object" || modelConfig === null || Array.isArray(modelConfig))
+    return modelConfig;
+  const config = modelConfig;
+  if (config.attribution_method !== "word_ids")
+    return modelConfig;
+  if (toApiExtractionStrategy(config.execution_mode) !== "SingleExtract")
+    return modelConfig;
+  if (isAttributionModelReachable(ctx.attributionCatalogue ?? null) !== false)
+    return modelConfig;
+  return { ...config, attribution_method: "table_heuristic", attribution_model_version: null };
+}
+var ixpDefaultSchemaProcessor = (definition, ctx) => {
+  if (definition.nodeType !== DYNAMIC_EXTRACT_NODE_TYPE2)
     return;
   const inputDefaults = definition.inputDefaults;
   if (inputDefaults?.schemaDocument !== undefined)
     return;
+  if (inputDefaults?.[IDP_PROCESSOR_READONLY_INPUT] === true)
+    return;
   const seeded = getDefaultExtractionSchema();
-  const modelConfig = toModelConfig(inputDefaults?.modelConfig);
+  const rawModelConfig = withDiscoveredAttribution(withDiscoveredLanguageSupport(inputDefaults?.modelConfig, ctx), ctx);
+  const modelConfig = toModelConfig(rawModelConfig);
   const schemaDocument = modelConfig === undefined ? seeded : { ...seeded, config: buildExtractionConfig(modelConfig) };
   return {
     nodeType: definition.nodeType,
     manifest: {
       ...definition,
-      inputDefaults: { ...inputDefaults, schemaDocument }
+      inputDefaults: {
+        ...inputDefaults,
+        ...rawModelConfig === inputDefaults?.modelConfig ? {} : { modelConfig: rawModelConfig },
+        schemaDocument
+      }
     }
   };
 };
-var PROCESSORS = [connectorHttpRequestProcessor, ixpDefaultSchemaProcessor];
+init_esm_shims();
+var SEEDED_INPUTS = [IDP_PROCESSOR_KEY_INPUT, IDP_PROCESSOR_READONLY_INPUT, IDP_PROCESSOR_NAME_INPUT, IDP_PROCESSOR_FOLDER_PATH_INPUT];
+var publishedIdpProcessorProcessor = (definition, ctx) => {
+  if (!isPublishedIdpProcessorNodeType(definition.nodeType))
+    return;
+  const rowInputs = definition.inputDefaults ?? {};
+  const seeded = Object.fromEntries(SEEDED_INPUTS.map((name) => [name, rowInputs[name]]));
+  const target = ctx.getManifest(DYNAMIC_EXTRACT_NODE_TYPE2) ?? buildExtractDocumentBuilderNode2();
+  return {
+    nodeType: DYNAMIC_EXTRACT_NODE_TYPE2,
+    manifest: {
+      ...target,
+      inputDefaults: { ...target.inputDefaults, schemaDocument: undefined, ...seeded }
+    }
+  };
+};
+var PROCESSORS = [
+  connectorHttpRequestProcessor,
+  agentToolConnectorHttpRequestProcessor,
+  publishedIdpProcessorProcessor,
+  ixpDefaultSchemaProcessor
+];
 function processManifest(definition, ctx) {
   if (!definition)
     return;
@@ -824,59 +1078,15 @@ 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)
-    return "node";
-  return words.map((word, index) => {
-    const lower = word.toLowerCase();
-    if (index === 0)
-      return lower;
-    return lower.charAt(0).toUpperCase() + lower.slice(1);
-  }).join("");
-}
-function lowerCaseFirstLetterLocal(str) {
-  if (!str)
-    return str;
-  return str.charAt(0).toLowerCase() + str.slice(1);
-}
-function generateNodeIdAndNameLocal(label, existingIds) {
-  const baseId = lowerCaseFirstLetterLocal(sanitizeNodeLabelLocal(label).replace("createNew", ""));
-  let index = 1;
-  let candidateId = `${baseId}${index}`;
-  while (existingIds.has(candidateId)) {
-    index++;
-    candidateId = `${baseId}${index}`;
-  }
-  return {
-    id: candidateId,
-    displayName: label ? index > 1 ? `${label} ${index}` : label : `Node${index > 1 ? ` ${index}` : ""}`
+    manifest: processed?.manifest ?? rawDefinition,
+    normalizeInputs: processed?.normalizeInputs
   };
 }
+var manifestT = instance.getFixedT(null, MANIFEST_NAMESPACE);
 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)
@@ -893,32 +1103,6 @@ function resolveDefinition(manifestDef, fileDef) {
   }
   return base;
 }
-function getInputDefaults(manifest) {
-  if (manifest.inputDefaults)
-    return structuredClone(manifest.inputDefaults);
-  if (manifest.inputDefinition)
-    return structuredClone(manifest.inputDefinition);
-  return {};
-}
-function mapDefinitionToNodeData(initialData, definition) {
-  const inputDefaults = getInputDefaults(definition);
-  const { canvasLabel: _strippedFromManifest, ...definitionDisplay } = definition.display;
-  const display = {
-    ...definitionDisplay,
-    ...initialData.display,
-    label: definition.display.label
-  };
-  const syntheticInstance = {
-    id: typeof initialData.nodeId === "string" ? initialData.nodeId : "",
-    type: definition.nodeType,
-    typeVersion: definition.version,
-    ui: { position: { x: 0, y: 0 } },
-    display,
-    inputs: inputDefaults,
-    loading: typeof initialData.loading === "boolean" ? initialData.loading : undefined
-  };
-  return hydrateNodeData(syntheticInstance, definition, []);
-}
 function reconcileInputs(inputs, model, definition, node) {
   const out = { ...inputs };
   if (out.color === undefined && node?.color !== undefined)
@@ -962,11 +1146,12 @@ function hydrateNodeData(node, definition, nodeVariables = [], subflowEntry, man
   });
   const variableUpdates = node.variableUpdates;
   const projectId = node.projectId ?? definition?.model?.projectId;
-  const liveIcon = manifestMap ? manifestMap.get(getManifestKey(node.type, node.typeVersion))?.display?.icon : definition?.display?.icon;
+  const liveIcon = manifestMap ? manifestMap.get(getManifestKey2(node.type, node.typeVersion))?.display?.icon : definition?.display?.icon;
   const { icon: _staleIcon, ...displayRest } = node.display ?? {};
   const display = liveIcon ? { ...displayRest, icon: liveIcon } : displayRest;
   return {
     nodeId: node.id,
+    ...isNodeUniqueId2(node.uniqueId) && { uniqueId: node.uniqueId },
     type: node.type,
     typeVersion: node.typeVersion,
     display,
@@ -983,23 +1168,11 @@ 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) {
-  return nodes.map((n) => ({
-    id: n.id,
-    type: n.data.type,
-    typeVersion: n.data.typeVersion,
-    label: n.data.label,
-    name: n.data.name,
-    display: n.data.display,
-    inputs: n.data.inputs,
-    outputs: n.data.outputs
-  }));
-}
 function workflowToXYFlow(workflow, manifestMap) {
   const definitions = workflow.definitions;
   const bindings = workflow.bindings || [];
@@ -1014,14 +1187,23 @@ function workflowToXYFlow(workflow, manifestMap) {
     if (node.type === "stickyNote") {
       return instanceToNode(node);
     }
-    const manifestDef = manifestMap.get(getManifestKey(node.type, node.typeVersion));
+    const manifestDef = manifestMap.get(getManifestKey2(node.type, node.typeVersion));
     const fileDef = definitions.find((def) => def.nodeType === node.type && def.version === node.typeVersion);
     const resolved = resolveDefinition(manifestDef, fileDef);
-    const { nodeType: effectiveType, manifest: definition } = resolveEffectiveManifest(node.type, resolved, {
+    const {
+      nodeType: effectiveType,
+      manifest: definition,
+      normalizeInputs
+    } = resolveEffectiveManifest(node.type, resolved, {
       getManifest: (type) => findManifestByNodeType(manifestMap, type)
     });
-    let effectiveNode = effectiveType === node.type ? node : { ...node, type: effectiveType, typeVersion: definition?.version ?? node.typeVersion };
-    if (!supportsVariableUpdates(effectiveType) && "variableUpdates" in effectiveNode) {
+    let effectiveNode = effectiveType === node.type ? node : {
+      ...node,
+      type: effectiveType,
+      typeVersion: definition?.version ?? node.typeVersion,
+      ...normalizeInputs ? { inputs: normalizeInputs(node.inputs ?? {}) } : {}
+    };
+    if (!supportsVariableUpdates2(effectiveType) && "variableUpdates" in effectiveNode) {
       const { variableUpdates: _variableUpdates, ...withoutVariableUpdates } = effectiveNode;
       effectiveNode = withoutVariableUpdates;
     }
@@ -1033,10 +1215,10 @@ function workflowToXYFlow(workflow, manifestMap) {
     });
     if (node.parentId) {
       const parentNode = workflow.nodes.find((candidate) => candidate.id === node.parentId);
-      const parentManifestDef = parentNode ? manifestMap.get(getManifestKey(parentNode.type, parentNode.typeVersion)) : undefined;
+      const parentManifestDef = parentNode ? manifestMap.get(getManifestKey2(parentNode.type, parentNode.typeVersion)) : undefined;
       const parentFileDef = parentNode ? definitions.find((def) => def.nodeType === parentNode.type && def.version === parentNode.typeVersion) : undefined;
       const parentDefinition = resolveDefinition(parentManifestDef, parentFileDef);
-      if (isLoopNodeType(parentNode?.type) && isContainerNodeManifest(parentDefinition)) {
+      if (isContainerNodeType2(parentNode?.type) && isContainerNodeManifest(parentDefinition)) {
         base.parentId = node.parentId;
         base.extent = "parent";
       }
@@ -1054,23 +1236,6 @@ function workflowToXYFlow(workflow, manifestMap) {
     workflowVariables: pruneVariableUpdatesForNodes(orderedNodes, workflowVariables)
   };
 }
-function convertSubflowsToXYFlow(workflow, manifestMap) {
-  if (!workflow.subflows)
-    return;
-  const result = {};
-  for (const [nodeId, entry] of Object.entries(workflow.subflows)) {
-    if (entry.nodes.length === 0) {
-      continue;
-    }
-    const converted = workflowToXYFlow({ ...workflow, nodes: entry.nodes, edges: entry.edges, variables: entry.variables }, manifestMap);
-    result[nodeId] = {
-      nodes: converted.nodes,
-      edges: converted.edges,
-      variables: converted.workflowVariables
-    };
-  }
-  return Object.keys(result).length > 0 ? result : undefined;
-}
 function getNodeOrderParentId(node) {
   return node.parentId ?? node.data?.parentId;
 }
@@ -1110,46 +1275,6 @@ function sortNodesParentFirst(nodes) {
   }
   return sorted;
 }
-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);
-    const isCollapsed = Boolean(node.data.isCollapsed);
-    const instanceDisplay = node.data?.display || {};
-    const shape = instanceDisplay.shape;
-    const width = base.ui.size?.width;
-    const height = base.ui.size?.height;
-    const sizeValue = !width || !height ? getExpandedSize(shape) : { width, height };
-    return {
-      ...base,
-      ui: {
-        ...base.ui,
-        collapsed: isCollapsed,
-        size: sizeValue
-      },
-      display: {
-        ...base.display,
-        ...shape !== undefined && { shape }
-      }
-    };
-  });
-  const workflowEdges = edges.map((edge) => edgeToInstance(edge));
-  const generatedVariables = generateNodeVariablesFromNodes(orderedNodes, variables, definitions);
-  return {
-    id: workflowId,
-    version: workflowVersion,
-    name: workflowName,
-    nodes: workflowNodes,
-    edges: workflowEdges,
-    definitions,
-    variables: {
-      ...generatedVariables.globals.length > 0 && { globals: generatedVariables.globals },
-      ...generatedVariables.nodes.length > 0 && { nodes: generatedVariables.nodes },
-      ...generatedVariables.variableUpdates && Object.keys(generatedVariables.variableUpdates).length > 0 && { variableUpdates: generatedVariables.variableUpdates }
-    },
-    ...bindings && bindings.length > 0 && { bindings }
-  };
-}
 function getVariableUpdateNodeType(node) {
   return (typeof node.data?.type === "string" ? node.data.type : undefined) ?? node.type;
 }
@@ -1157,113 +1282,9 @@ 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)));
+  const variableUpdates = Object.fromEntries(Object.entries(variables.variableUpdates).filter(([nodeId, updates]) => nodeMap.has(nodeId) && supportsVariableUpdates2(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) {
-  const node = {
-    id,
-    type: manifest.nodeType,
-    typeVersion: manifest.version,
-    ui: { position },
-    display: { label: label ?? manifest.display?.label ?? id },
-    inputs: getInputDefaults(manifest)
-  };
-  if (manifest.model?.entryPointId) {
-    node.inputs = { ...node.inputs, entryPointId: crypto.randomUUID() };
-  }
-  if (manifest.model?.source) {
-    node.inputs = { ...node.inputs, source: crypto.randomUUID() };
-  }
-  return node;
-}
-function createEmptyWorkflow(id = crypto.randomUUID(), name = "Untitled Workflow", triggerManifest) {
-  const nodes = [];
-  let bindings = [];
-  if (triggerManifest) {
-    const label = triggerManifest.display?.label || triggerManifest.nodeType;
-    const { id: newTriggerID, displayName } = generateNodeIdAndNameLocal(label, /* @__PURE__ */ new Set);
-    const triggerNode = createWorkflowNodeFromManifest(triggerManifest, newTriggerID, { ...DEFAULT_TRIGGER_POSITION }, displayName);
-    if (triggerNode.inputs?.entryPointId) {
-      triggerNode.inputs.isDefaultEntryPoint = true;
-    }
-    nodes.push(triggerNode);
-    bindings = createBindingsFromManifest(triggerManifest);
-  }
-  return {
-    id,
-    version: MINIMUM_SUPPORTED_SCHEMA_VERSION,
-    name,
-    nodes,
-    edges: [],
-    definitions: [],
-    bindings
-  };
-}
-function generateNodeVariablesFromNodes(nodes, variables, definitions = []) {
-  const generatedNodeVariables = [];
-  const contractResolvedIds = /* @__PURE__ */ new Set;
-  const definitionOutputs = /* @__PURE__ */ new Map;
-  for (const def of definitions) {
-    if (def.outputDefinition && Object.keys(def.outputDefinition).length > 0) {
-      definitionOutputs.set(def.nodeType, def.outputDefinition);
-    }
-  }
-  for (const node of nodes) {
-    const nodeOutputs = node.data?.outputs || {};
-    const outputs = Object.keys(nodeOutputs).length > 0 ? nodeOutputs : definitionOutputs.get(node.type) ?? {};
-    const nodeId = node.id;
-    for (const [outputKey, outputDef] of Object.entries(outputs)) {
-      if (outputDef && typeof outputDef === "object") {
-        const def = outputDef;
-        const resolved = node.type ? resolveNodeOutputTypeSchema(node.type, node.data?.inputs?.detail, outputKey) : undefined;
-        if (resolved)
-          contractResolvedIds.add(`${nodeId}.${outputKey}`);
-        generatedNodeVariables.push(createNodeVariable({
-          nodeId,
-          outputId: outputKey,
-          type: (resolved?.jsonSchemaType ?? def.type) || "string",
-          subType: def.subType,
-          description: def.description,
-          schema: def.schema
-        }));
-      }
-    }
-  }
-  const globalVariables = variables.globals || [];
-  const nodeVariables = variables.nodes || [];
-  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
-  const validNodeVariables = nodeVariables.filter((v) => {
-    const node = nodeMap.get(v.binding.nodeId);
-    if (!node)
-      return false;
-    if (contractResolvedIds.has(v.id))
-      return false;
-    const nodeOutputs = node.data?.outputs || {};
-    const outputs = Object.keys(nodeOutputs).length > 0 ? nodeOutputs : definitionOutputs.get(node.type) ?? {};
-    return v.binding.outputId in outputs;
-  });
-  const allNodeVariables = [...validNodeVariables, ...generatedNodeVariables.filter((g) => !validNodeVariables.some((v) => v.id === g.id))];
-  const variableUpdatesMap = pruneVariableUpdatesForNodes(nodes, variables).variableUpdates ?? {};
-  return {
-    globals: globalVariables,
-    nodes: allNodeVariables,
-    variableUpdates: variableUpdatesMap
-  };
-}
 function applyGlobalInputOverrides(raw, inputs) {
   if (!inputs || Object.keys(inputs).length === 0)
     return;
@@ -1276,7 +1297,7 @@ function applyGlobalInputOverrides(raw, inputs) {
     }
   }
 }
-var warmSerializationChunks = () => Promise.all([import("./index-cg9qhfb1.js"), import("./serialization-BXU6AKAN-vdqyr29x.js")]);
+var warmSerializationChunks = () => Promise.all([import("./index-ng011fzs.js"), import("./serialization-Z3UYT6BW-y9gb55mp.js")]);
 async function flowJsonToBpmnXml(flowJson, options) {
   const [{ fileFormatToInMemoryWorkflow }, { toXml }] = await warmSerializationChunks();
   const raw = JSON.parse(flowJson);
@@ -1284,35 +1305,19 @@ async function flowJsonToBpmnXml(flowJson, options) {
   const workflow = fileFormatToInMemoryWorkflow(raw);
   const manifestMap = /* @__PURE__ */ new Map;
   for (const def of workflow.definitions ?? []) {
-    manifestMap.set(getManifestKey(def.nodeType, def.version ?? "1.0.0"), def);
+    manifestMap.set(getManifestKey2(def.nodeType, def.version ?? "1.0.0"), def);
   }
   const { nodes, edges, definitions, workflowVariables, bindings } = workflowToXYFlow(workflow, manifestMap);
   const allBindings = [...bindings, ...deriveIdpProcessorBindings(workflow)];
   return toXml(nodes, edges, definitions, allBindings, workflowVariables, workflow.subflows, {
     detached: options?.detached,
     voiceAgentDefinitions: options?.voiceAgentDefinitions,
-    encoding: options?.encoding
+    encoding: options?.encoding,
+    flowJson: options?.embedFlowJson ? flowJson : undefined
   });
 }
 export {
-  applyGlobalInputOverrides,
-  convertSubflowsToXYFlow,
-  createEmptyWorkflow,
-  createWorkflowNodeFromManifest,
-  flowJsonToBpmnXml,
-  generateNodeIdAndNameLocal,
-  generateNodeVariablesFromNodes,
-  instanceToHydratedNode,
-  mapDefinitionToNodeData,
-  pruneVariableUpdatesForNodes,
-  pruneVariableUpdatesForSubflow,
-  reconcileInputs,
-  resolveDefinition,
-  stripSessionScopedFields,
-  warmSerializationChunks,
-  workflowToXYFlow,
-  xyFlowToPackagingNode,
-  xyFlowToWorkflow
+  flowJsonToBpmnXml
 };
 
-//# debugId=7303B7BDBDC933A464756E2164756E21
+//# debugId=EBA8A8907ECD56B864756E2164756E21