@uipath/maestro-tool 1.201.0-preview.115 → 1.201.0-preview.122

package/dist/{authoring-de0qdv9t.js → authoring-amyhkfkn.js}

@@ -2,8 +2,9 @@ import {
   registerCheckCommand,
   registerCompileCommand,
   registerDecompileCommand
-} from "./packager-tool-jxb33prs.js";
-import"./packager-tool-066fzdae.js";
+} from "./packager-tool-g50rxa1m.js";
+import"./packager-tool-psy06tjw.js";
+import"./packager-tool-gh6pjm6h.js";
 import"./packager-tool-1cb0d5e0.js";
 import"./packager-tool-wckvcay0.js";
 
@@ -17,4 +18,4 @@ export {
   registerCaseAuthoringCommands
 };
 
-//# debugId=E3E3EE7B4978FB6064756E2164756E21
+//# debugId=78E7E6936790D36F64756E2164756E21

package/dist/{authoring-gqzd8ngc.js → authoring-bmr0pg2g.js}

@@ -2,8 +2,9 @@ import {
   registerCheckCommand,
   registerCompileCommand,
   registerTidyCommand
-} from "./packager-tool-jxb33prs.js";
-import"./packager-tool-066fzdae.js";
+} from "./packager-tool-g50rxa1m.js";
+import"./packager-tool-psy06tjw.js";
+import"./packager-tool-gh6pjm6h.js";
 import"./packager-tool-1cb0d5e0.js";
 import"./packager-tool-wckvcay0.js";
 
@@ -17,4 +18,4 @@ export {
   registerBpmnAuthoringCommands
 };
 
-//# debugId=2D1464E0B968BA6664756E2164756E21
+//# debugId=0CDCE196CF955D8A64756E2164756E21

package/dist/{authoring-0dk6xpfc.js → authoring-z9g5eh42.js}

@@ -3,8 +3,9 @@ import {
   registerCompileCommand,
   registerDecompileCommand,
   registerMergeCommand
-} from "./packager-tool-jxb33prs.js";
-import"./packager-tool-066fzdae.js";
+} from "./packager-tool-g50rxa1m.js";
+import"./packager-tool-psy06tjw.js";
+import"./packager-tool-gh6pjm6h.js";
 import"./packager-tool-1cb0d5e0.js";
 import"./packager-tool-wckvcay0.js";
 
@@ -19,4 +20,4 @@ export {
   registerFlowAuthoringCommands
 };
 
-//# debugId=312B5FA52AB0810D64756E2164756E21
+//# debugId=112658AC6F582E6364756E2164756E21

package/dist/bpmn-refresh-service-m1y0cwfs.js

@@ -0,0 +1,235 @@
+import {
+  BpmnValidateService
+} from "./packager-tool-z3v4jej7.js";
+import"./packager-tool-3yemmykf.js";
+import"./packager-tool-psy06tjw.js";
+import"./packager-tool-76xq3x08.js";
+import {
+  extractErrorMessageSync,
+  isGuid
+} from "./packager-tool-gh6pjm6h.js";
+import"./packager-tool-9qecd4wb.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  getFileSystem
+} from "./packager-tool-1cb0d5e0.js";
+import"./packager-tool-5arsyj36.js";
+import"./packager-tool-13zbtmhf.js";
+import"./packager-tool-cqrsre00.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-e0ktn9s5.js";
+import {
+  BPMN_PACKAGE_FILES,
+  buildBpmnPackageMetadata,
+  buildConnectionResources,
+  deriveBpmnEntryPoints,
+  formatBpmnPackageFile,
+  isJsonObject,
+  parseBpmnProcesses,
+  parseJson,
+  parseOptionalJson
+} from "./packager-tool-j96qf6qe.js";
+import"./packager-tool-1yy9x4vk.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-wckvcay0.js";
+
+// src/services/bpmn-refresh-service.ts
+class BpmnRefreshService {
+  fs;
+  createUuid;
+  constructor(fs = getFileSystem(), createUuid = () => crypto.randomUUID()) {
+    this.fs = fs;
+    this.createUuid = createUuid;
+  }
+  async execute(projectPath) {
+    const resolvedProjectPath = this.fs.path.resolve(projectPath);
+    const stats = await this.fs.stat(resolvedProjectPath);
+    if (!stats?.isDirectory()) {
+      throw new Error(`Maestro project directory does not exist: ${resolvedProjectPath}`);
+    }
+    const release = await this.fs.acquireLock(this.fs.path.join(resolvedProjectPath, ".bpmn-refresh"));
+    try {
+      const bpmnFile = await this.findBpmnFile(resolvedProjectPath);
+      await this.readProjectFile(resolvedProjectPath);
+      const bpmnPath = this.fs.path.join(resolvedProjectPath, bpmnFile);
+      const xml = await this.fs.readFile(bpmnPath, "utf-8");
+      if (!xml) {
+        throw new Error(`BPMN file is empty: ${bpmnPath}`);
+      }
+      const existing = await this.readGeneratedFiles(resolvedProjectPath);
+      const contents = await this.deriveFiles(bpmnFile, xml, existing);
+      await this.validateProject(resolvedProjectPath, bpmnFile, contents);
+      const planned = BPMN_PACKAGE_FILES.map((name) => ({
+        name,
+        path: this.fs.path.join(resolvedProjectPath, name),
+        content: contents[name],
+        previous: existing[name]
+      }));
+      const changed = planned.filter((file) => file.previous !== file.content);
+      await this.writeFilesWithRollback(changed);
+      return {
+        projectPath: resolvedProjectPath,
+        bpmnFile,
+        writtenFiles: changed.map((file) => file.name),
+        unchangedFiles: planned.filter((file) => file.previous === file.content).map((file) => file.name)
+      };
+    } finally {
+      await release();
+    }
+  }
+  async findBpmnFile(projectPath) {
+    const entries = await this.fs.readdir(projectPath);
+    const files = [];
+    for (const entry of entries.filter((name) => name.endsWith(".bpmn"))) {
+      if ((await this.fs.stat(this.fs.path.join(projectPath, entry)))?.isFile()) {
+        files.push(entry);
+      }
+    }
+    files.sort((left, right) => left.localeCompare(right));
+    if (files.length !== 1) {
+      throw new Error(`Expected one BPMN file in ${projectPath}, found ${files.length}.`);
+    }
+    return files[0];
+  }
+  async readProjectFile(projectPath) {
+    const path = this.fs.path.join(projectPath, "project.uiproj");
+    const raw = await this.fs.readFile(path, "utf-8");
+    if (raw === null)
+      throw new Error(`Required file is missing: ${path}`);
+    const project = parseJson(raw, "project.uiproj");
+    if (project.ProjectType !== "ProcessOrchestration") {
+      throw new Error('project.uiproj must set "ProjectType" to "ProcessOrchestration".');
+    }
+  }
+  async readGeneratedFiles(projectPath) {
+    const result = {};
+    for (const name of BPMN_PACKAGE_FILES) {
+      result[name] = await this.fs.readFile(this.fs.path.join(projectPath, name), "utf-8");
+    }
+    return result;
+  }
+  async deriveFiles(bpmnFile, xml, existing) {
+    const processes = await parseBpmnProcesses(xml);
+    const entryPoints = deriveBpmnEntryPoints(processes);
+    const existingMetadata = {
+      "entry-points.json": null,
+      "bindings_v2.json": null,
+      "operate.json": null,
+      "package-descriptor.json": null
+    };
+    for (const name of [
+      "entry-points.json",
+      "bindings_v2.json",
+      "operate.json"
+    ]) {
+      existingMetadata[name] = parseOptionalJson(existing[name], name);
+    }
+    const existingOperate = existingMetadata["operate.json"];
+    const oldProjectId = existingOperate?.projectId;
+    const projectId = typeof oldProjectId === "string" && isGuid(oldProjectId) ? oldProjectId : this.createUuid();
+    if (!isGuid(projectId)) {
+      throw new Error(`Generated project id "${projectId}" must be a GUID.`);
+    }
+    const oldBindings = existingMetadata["bindings_v2.json"];
+    const existingResources = Array.isArray(oldBindings?.resources) ? oldBindings.resources.filter(isJsonObject) : [];
+    const resources = buildConnectionResources(processes, existingResources);
+    const metadata = buildBpmnPackageMetadata({
+      bpmnFile,
+      entryPoints,
+      projectId,
+      resources,
+      existing: existingMetadata
+    });
+    const contents = Object.fromEntries(BPMN_PACKAGE_FILES.map((name) => [
+      name,
+      formatBpmnPackageFile(metadata[name])
+    ]));
+    return contents;
+  }
+  async validateProject(projectPath, bpmnFile, contents) {
+    const proposedFiles = new Map(BPMN_PACKAGE_FILES.map((name) => [
+      this.fs.path.join(projectPath, name),
+      contents[name]
+    ]));
+    const fileSystem = proposedFileSystem(this.fs, proposedFiles);
+    const result = await new BpmnValidateService(fileSystem).validateFile(this.fs.path.join(projectPath, bpmnFile));
+    if (!result.success) {
+      const errors = result.issues.filter((issue) => issue.severity === "error").map((issue) => issue.ruleCode ? `${issue.ruleCode}: ${issue.message}` : issue.message);
+      throw new Error(`BPMN validation failed: ${errors.join("; ")}`);
+    }
+  }
+  async writeFilesWithRollback(files) {
+    if (files.length === 0)
+      return;
+    const transactionId = this.createUuid();
+    const staged = files.map((file) => ({
+      ...file,
+      stagingPath: `${file.path}.${transactionId}.tmp`,
+      rollbackPath: `${file.path}.${transactionId}.rollback`
+    }));
+    const written = [];
+    try {
+      for (const file of staged) {
+        await this.fs.writeFile(file.stagingPath, file.content);
+      }
+      for (const file of staged) {
+        await this.fs.rename(file.stagingPath, file.path);
+        written.push(file);
+      }
+    } catch (error) {
+      const rollbackErrors = [];
+      for (const file of [...written].reverse()) {
+        try {
+          await this.restoreFile(file);
+        } catch (rollbackError) {
+          rollbackErrors.push(`${file.name}: ${extractErrorMessageSync(rollbackError)}`);
+        }
+      }
+      const rollbackMessage = rollbackErrors.length === 0 ? "" : ` Rollback also failed for ${rollbackErrors.join("; ")}.`;
+      throw new Error(`Could not update all BPMN package files: ${extractErrorMessageSync(error)}.${rollbackMessage}`);
+    } finally {
+      for (const file of staged) {
+        await this.fs.rm(file.stagingPath).catch(() => {
+          return;
+        });
+        await this.fs.rm(file.rollbackPath).catch(() => {
+          return;
+        });
+      }
+    }
+  }
+  async restoreFile(file) {
+    if (file.previous === null) {
+      await this.fs.rm(file.path);
+      return;
+    }
+    await this.fs.writeFile(file.rollbackPath, file.previous);
+    await this.fs.rename(file.rollbackPath, file.path);
+  }
+}
+function proposedFileSystem(fs, proposedFiles) {
+  return new Proxy(fs, {
+    get: (target, property, receiver) => {
+      if (property === "readFile") {
+        return async (path, options) => {
+          const proposed = proposedFiles.get(path);
+          if (proposed !== undefined) {
+            return options ? proposed : new TextEncoder().encode(proposed);
+          }
+          return options ? target.readFile(path, options) : target.readFile(path);
+        };
+      }
+      if (property === "exists") {
+        return (path) => proposedFiles.has(path) ? Promise.resolve(true) : target.exists(path);
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+export {
+  BpmnRefreshService
+};
+
+//# debugId=8D2B7572BFE6BB9064756E2164756E21

package/dist/case-pack-service-728c95dn.js

@@ -0,0 +1,124 @@
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-8qnqz22v.js";
+import {
+  VALID_PACKAGE_NAME_REGEX
+} from "./packager-tool-3yemmykf.js";
+import"./packager-tool-psy06tjw.js";
+import"./packager-tool-76xq3x08.js";
+import {
+  catchError,
+  logger,
+  mapPackageMetadataOptions
+} from "./packager-tool-gh6pjm6h.js";
+import"./packager-tool-9qecd4wb.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  getFileSystem
+} from "./packager-tool-1cb0d5e0.js";
+import"./packager-tool-5arsyj36.js";
+import"./packager-tool-13zbtmhf.js";
+import {
+  NugetPackager,
+  ensureProjectId
+} from "./packager-tool-6n706yfk.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-cqrsre00.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-e0ktn9s5.js";
+import"./packager-tool-1yy9x4vk.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-wckvcay0.js";
+
+// ../case-tool/src/services/case-pack-service.ts
+class CasePackService {
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  async execute(projectPath, options) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const absoluteOutputPath = this.fs.path.resolve(options.output);
+    const packageName = options.name || this.fs.path.basename(projectPath);
+    if (!VALID_PACKAGE_NAME_REGEX.test(packageName)) {
+      throw new Error(`Invalid package name "${packageName}". Package name can only contain letters, numbers, dots (.), underscores (_), and hyphens (-).`);
+    }
+    logger.info(`
+Packing Case project...
+`);
+    logger.info("Details:");
+    logger.info(`  Project:  ${absoluteProjectPath}`);
+    logger.info(`  Package:  ${packageName}@${options.version}`);
+    logger.info(`  Output:   ${absoluteOutputPath}`);
+    logger.info("");
+    await this.validate(absoluteProjectPath);
+    await this.convertCaseToBpmnIfNeeded(absoluteProjectPath);
+    await ensureProjectId(absoluteProjectPath, this.fs);
+    await this.fs.mkdir(absoluteOutputPath);
+    let tempDir;
+    try {
+      tempDir = await this.fs.getTempDir();
+      const stagingDir = this.fs.path.join(tempDir, "case-pack-staging");
+      await this.fs.mkdir(stagingDir);
+      await this.fs.copyDirectory(absoluteProjectPath, this.fs.path.join(stagingDir, "content"));
+      const packageId = `${packageName}.case.Case`;
+      const version = options.version || "1.0.0";
+      const nupkgPath = this.fs.path.join(absoluteOutputPath, `${packageId}.${version}.nupkg`);
+      const packager = new NugetPackager(this.fs);
+      const result = await packager.packAsync(stagingDir, {
+        id: packageId,
+        version,
+        tags: "Case",
+        ...mapPackageMetadataOptions(options)
+      }, nupkgPath);
+      return {
+        packageName: `${packageName}@${options.version}`,
+        outputPath: result.outputPath
+      };
+    } finally {
+      if (tempDir) {
+        await catchError((async () => {
+          if (await this.fs.exists(tempDir)) {
+            await this.fs.rm(tempDir);
+          }
+        })());
+      }
+    }
+  }
+  async convertCaseToBpmnIfNeeded(projectPath) {
+    const caseFilePath = this.fs.path.join(projectPath, "caseplan.json");
+    if (!await this.fs.exists(caseFilePath)) {
+      return;
+    }
+    logger.info("Converting case JSON to BPMN...");
+    const caseContent = String(await this.fs.readFile(caseFilePath, "utf-8"));
+    const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
+    const { bpmnXml: bpmn } = await serializeCaseDiskJsonToBpmnAndRulesJson(caseContent);
+    const bpmnFilePath = this.fs.path.join(projectPath, "caseplan.json.bpmn");
+    await this.fs.writeFile(bpmnFilePath, bpmn);
+    logger.info(`BPMN file written to ${bpmnFilePath}`);
+  }
+  async validate(projectPath) {
+    if (!await this.fs.exists(projectPath)) {
+      throw new Error(`Project path does not exist: ${projectPath}`);
+    }
+    const stats = await this.fs.stat(projectPath);
+    if (!stats?.isDirectory()) {
+      throw new Error(`Project path must be a directory: ${projectPath}`);
+    }
+    const descriptorPath = this.fs.path.join(projectPath, "package-descriptor.json");
+    if (!await this.fs.exists(descriptorPath)) {
+      throw new Error(`Missing package-descriptor.json in: ${projectPath}`);
+    }
+    const operatePath = this.fs.path.join(projectPath, "operate.json");
+    if (!await this.fs.exists(operatePath)) {
+      throw new Error(`Missing operate.json in: ${projectPath}`);
+    }
+  }
+}
+export {
+  CasePackService
+};
+
+//# debugId=B44DF66BCDC6486764756E2164756E21

package/dist/{conversion-MQ7TJMHW-avnhwgjk.js → conversion-W6HMHBWW-44avwx80.js}

@@ -3,35 +3,34 @@ import {
   buildConnectorHttpRequestDetail,
   createNodeVariable,
   findTerminalNodes,
-  getCollapsedSize,
   getConnectorHttpRequestKey,
-  getExpandedShape,
   getExpandedSize,
   getLatestDefinitionByNodeType,
   isContainerNodeManifest,
   resolveNodeOutputTypeSchema
-} from "./packager-tool-anfb35wg.js";
+} from "./packager-tool-h1fkw0s1.js";
 import"./packager-tool-x8d8fpse.js";
-import"./packager-tool-jqtspg41.js";
-import"./packager-tool-htc0z863.js";
-import"./packager-tool-fr5b9qs6.js";
+import"./packager-tool-3wf3tkrc.js";
+import"./packager-tool-03knb0er.js";
+import"./packager-tool-pvgqbm48.js";
 import {
   init_esm_shims
-} from "./packager-tool-ahm4ymrp.js";
+} from "./packager-tool-jpcm3xas.js";
 import"./packager-tool-c19w8vg9.js";
 import"./packager-tool-gbgfwx8f.js";
 import {
   MINIMUM_SUPPORTED_SCHEMA_VERSION,
   generateNextId,
+  isLoopNodeType,
   isSubflowNodeType
-} from "./packager-tool-5fpetbc1.js";
-import"./packager-tool-973f0r2g.js";
+} from "./packager-tool-e0ktn9s5.js";
+import"./packager-tool-1yy9x4vk.js";
 import"./packager-tool-c23zrhj8.js";
 import {
   __require
 } from "./packager-tool-wckvcay0.js";
 
-// ../../node_modules/@uipath/flow-converter/dist/conversion-MQ7TJMHW.js
+// ../../node_modules/@uipath/flow-converter/dist/conversion-W6HMHBWW.js
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
@@ -192,12 +191,16 @@ init_esm_shims();
 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();
-var ARTIFACT_GROUP_SPACING = 96;
-var ARTIFACT_HORIZONTAL_SPACING = ARTIFACT_GROUP_SPACING / 2;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeManifestOutputOverInstance(instanceValue, manifestValue) {
+  if (manifestValue === undefined)
+    return instanceValue;
+  if (instanceValue === undefined)
+    return manifestValue;
+  return isPlainObject(instanceValue) && isPlainObject(manifestValue) ? { ...instanceValue, ...manifestValue } : manifestValue;
+}
 init_esm_shims();
 init_esm_shims();
 var connectorHttpRequestProcessor = (definition, ctx) => {
@@ -315,12 +318,18 @@ function buildSubflowPassThroughOutputDefinition(nodes, edges, manifestMap, node
   if (terminalsWithOutputs.length === 1) {
     const { outputDef } = terminalsWithOutputs[0];
     for (const key of allKeys) {
+      if (isUnsafeKey(key))
+        continue;
       result[key] = toSchemaType(outputDef[key]);
     }
   } else {
     for (const key of allKeys) {
+      if (isUnsafeKey(key))
+        continue;
       const properties = {};
       for (const { node, outputDef } of terminalsWithOutputs) {
+        if (isUnsafeKey(node.id))
+          continue;
         if (key in outputDef) {
           properties[node.id] = toSchemaType(outputDef[key]);
         }
@@ -330,6 +339,10 @@ function buildSubflowPassThroughOutputDefinition(nodes, edges, manifestMap, node
   }
   return result;
 }
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isUnsafeKey(key) {
+  return UNSAFE_KEYS.has(key);
+}
 function toSchemaType(def) {
   const { source: _, var: _v, ...schema } = def ?? {};
   return { type: "object", ...schema };
@@ -360,14 +373,14 @@ function computeSubflowEffectiveOutputDef(subflowNodeId, subflows, manifestMap,
     }
     if (outputDef) {
       for (const [key, val] of Object.entries(outputDef)) {
+        if (isUnsafeKey(key))
+          continue;
         outputKeys[key] = val;
       }
     }
   }
   return Object.keys(outputKeys).length > 0 ? outputKeys : undefined;
 }
-init_esm_shims();
-var LOOP_NODE_TYPE = "core.logic.loop";
 function sanitizeNodeLabelLocal(label) {
   const words = label.split(/[^a-zA-Z0-9]+/).filter(Boolean);
   if (words.length === 0)
@@ -504,9 +517,9 @@ function hydrateNodeData(node, definition, nodeVariables = [], subflowEntry, man
   const instanceOutputs = node.outputs ?? {};
   const effectiveOutputs = { ...manifestOutputs, ...nodeVariableOutputs, ...subflowOutputs };
   for (const [key, value] of Object.entries(instanceOutputs)) {
-    if (value && typeof value === "object" && effectiveOutputs[key] && typeof effectiveOutputs[key] === "object") {
-      effectiveOutputs[key] = { ...value, ...effectiveOutputs[key] };
-    } else if (!(key in effectiveOutputs)) {
+    if (key in effectiveOutputs) {
+      effectiveOutputs[key] = mergeManifestOutputOverInstance(value, effectiveOutputs[key]);
+    } else {
       effectiveOutputs[key] = value;
     }
   }
@@ -584,17 +597,11 @@ function workflowToXYFlow(workflow, manifestMap) {
       const parentManifestDef = parentNode ? manifestMap.get(getManifestKey(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 (parentNode?.type === LOOP_NODE_TYPE && isContainerNodeManifest(parentDefinition)) {
+      if (isLoopNodeType(parentNode?.type) && isContainerNodeManifest(parentDefinition)) {
         base.parentId = node.parentId;
         base.extent = "parent";
       }
     }
-    const isCollapsed = Boolean(node.ui?.collapsed);
-    if (isCollapsed && base.width !== undefined && base.height !== undefined) {
-      const collapsedSize = getCollapsedSize();
-      base.width = collapsedSize.width;
-      base.height = collapsedSize.height;
-    }
     return base;
   });
   const orderedNodes = sortNodesParentFirst(nodes);
@@ -663,10 +670,10 @@ function xyFlowToWorkflow(workflowId, workflowVersion, workflowName, nodes, edge
     const base = nodeToInstance(node);
     const isCollapsed = Boolean(node.data.isCollapsed);
     const instanceDisplay = node.data?.display || {};
-    const expandedShape = getExpandedShape(instanceDisplay.shape);
+    const shape = instanceDisplay.shape;
     const width = base.ui.size?.width;
     const height = base.ui.size?.height;
-    const sizeValue = isCollapsed || !width || !height ? getExpandedSize(expandedShape) : { width, height };
+    const sizeValue = !width || !height ? getExpandedSize(shape) : { width, height };
     return {
       ...base,
       ui: {
@@ -676,7 +683,7 @@ function xyFlowToWorkflow(workflowId, workflowVersion, workflowName, nodes, edge
       },
       display: {
         ...base.display,
-        ...expandedShape !== undefined && { shape: expandedShape }
+        ...shape !== undefined && { shape }
       }
     };
   });
@@ -810,7 +817,7 @@ function applyGlobalInputOverrides(raw, inputs) {
     }
   }
 }
-var warmSerializationChunks = () => Promise.all([import("./index-y93b9sgy.js"), import("./serialization-JNQMGOXW-3g31rma2.js")]);
+var warmSerializationChunks = () => Promise.all([import("./index-z4fsz3f9.js"), import("./serialization-GTFWODSH-e6yv9561.js")]);
 async function flowJsonToBpmnXml(flowJson, options) {
   const [{ fileFormatToInMemoryWorkflow }, { toXml }] = await warmSerializationChunks();
   const raw = JSON.parse(flowJson);
@@ -822,7 +829,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
+    detached: options?.detached,
+    voiceAgentDefinitions: options?.voiceAgentDefinitions
   });
 }
 export {
@@ -843,4 +851,4 @@ export {
   applyGlobalInputOverrides
 };
 
-//# debugId=94A5251CF6EBB5CC64756E2164756E21
+//# debugId=60CCA250311E9DEE64756E2164756E21