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

package/dist/packager-tool-vcjq9xkc.js

@@ -0,0 +1,1895 @@
+import {
+  en_default as en_default2
+} from "./packager-tool-7q6z6npd.js";
+import {
+  __glob as __glob2
+} from "./packager-tool-sc961w0q.js";
+import {
+  en_default
+} from "./packager-tool-d88rqwk8.js";
+import {
+  __glob
+} from "./packager-tool-jysvpt8p.js";
+import {
+  currentStorageSchema,
+  currentStorageSchemaMigration,
+  exports_external,
+  instance,
+  jsep,
+  require_dist,
+  require_index_cjs
+} from "./packager-tool-vdc8r21p.js";
+import {
+  __require,
+  __toESM
+} from "./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/chunk-GWRTD4DY.js
+var JS_EXPRESSION_PREFIX = "=js:";
+var expressionFieldTypeSchema = exports_external.enum(["string", "number", "boolean", "object", "array", "null"]);
+var expressionModeSchema = exports_external.enum(["literal", "jsExpression"]);
+var expressionValueSchema = exports_external.object({
+  type: expressionModeSchema,
+  expression: exports_external.string(),
+  fieldType: expressionFieldTypeSchema
+}).strict();
+var expressionLikeSchema = exports_external.union([exports_external.string(), expressionValueSchema]);
+function isExpressionValue(v) {
+  return expressionValueSchema.safeParse(v).success;
+}
+function inferFieldType(value) {
+  if (Array.isArray(value))
+    return "array";
+  if (value === null)
+    return "null";
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === "object")
+    return t;
+  return "string";
+}
+function encodeLiteral(raw, fieldType) {
+  switch (fieldType) {
+    case "string":
+      if (typeof raw === "string")
+        return raw;
+      if (raw == null)
+        return "";
+      if (typeof raw === "object") {
+        try {
+          return JSON.stringify(raw);
+        } catch {
+          return String(raw);
+        }
+      }
+      return String(raw);
+    case "number":
+    case "boolean":
+      return raw == null ? "" : String(raw);
+    case "null":
+      return "null";
+    case "object":
+    case "array":
+      return JSON.stringify(raw ?? null);
+  }
+}
+function coerceToExpressionValue(value, fieldType) {
+  if (isExpressionValue(value))
+    return value;
+  const resolvedFieldType = fieldType ?? inferFieldType(value);
+  if (typeof value === "string") {
+    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
+      return {
+        type: "jsExpression",
+        expression: value.slice(JS_EXPRESSION_PREFIX.length),
+        fieldType: resolvedFieldType
+      };
+    }
+    return { type: "literal", expression: value, fieldType: resolvedFieldType };
+  }
+  return { type: "literal", expression: encodeLiteral(value, resolvedFieldType), fieldType: resolvedFieldType };
+}
+function jsonSchemaTypeToFieldType(raw) {
+  if (Array.isArray(raw)) {
+    for (const t of raw) {
+      const mapped = jsonSchemaTypeToFieldType(t);
+      if (mapped)
+        return mapped;
+    }
+    return;
+  }
+  if (typeof raw !== "string")
+    return;
+  switch (raw) {
+    case "string":
+    case "number":
+    case "boolean":
+    case "object":
+    case "array":
+    case "null":
+      return raw;
+    case "integer":
+      return "number";
+    default:
+      return;
+  }
+}
+function coerceInputsViaSchema(value, schema) {
+  if (isExpressionValue(value))
+    return value;
+  if (Array.isArray(value)) {
+    if (schema?.items) {
+      for (let i = 0;i < value.length; i++) {
+        value[i] = coerceInputsViaSchema(value[i], schema.items);
+      }
+    }
+    return value;
+  }
+  if (value !== null && typeof value === "object") {
+    if (schema?.properties) {
+      const props = schema.properties;
+      for (const [k, v] of Object.entries(value)) {
+        value[k] = coerceInputsViaSchema(v, props[k]);
+      }
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.startsWith(JS_EXPRESSION_PREFIX)) {
+      return coerceToExpressionValue(value, jsonSchemaTypeToFieldType(schema?.type));
+    }
+    if (hasMustacheInterpolation(value)) {
+      return {
+        type: "literal",
+        expression: value,
+        fieldType: jsonSchemaTypeToFieldType(schema?.type) ?? "string"
+      };
+    }
+  }
+  return value;
+}
+function hasMustacheInterpolation(s) {
+  const stripped = s.replace(/\\\{/g, "").replace(/\\\}/g, "");
+  return /\{\{[^{}]+\}\}/.test(stripped);
+}
+var RESERVED_WORDS = [
+  "break",
+  "case",
+  "catch",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "in",
+  "instanceof",
+  "new",
+  "return",
+  "switch",
+  "this",
+  "throw",
+  "try",
+  "typeof",
+  "var",
+  "void",
+  "while",
+  "with",
+  "class",
+  "const",
+  "enum",
+  "export",
+  "extends",
+  "import",
+  "super",
+  "implements",
+  "interface",
+  "let",
+  "package",
+  "private",
+  "protected",
+  "public",
+  "static",
+  "yield"
+];
+var VALID_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function generateRandomId(length) {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0;i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+function generateNextId(prefix, count = 6) {
+  return `${prefix}${generateRandomId(count)}`;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return a === b;
+  if (a === undefined || b === undefined)
+    return a === b;
+  if (typeof a !== typeof b)
+    return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length)
+      return false;
+    return a.every((val, i) => deepEqual(val, b[i]));
+  }
+  if (typeof a === "object") {
+    if (Array.isArray(b))
+      return false;
+    const objA = a;
+    const objB = b;
+    const keysA = Object.keys(objA);
+    const keysB = Object.keys(objB);
+    if (keysA.length !== keysB.length)
+      return false;
+    return keysA.every((key) => (key in objB) && deepEqual(objA[key], objB[key]));
+  }
+  return false;
+}
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/chunk-TBJMAYP4.js
+var SUPPORTED_LOCALES = ["en", "es", "pt", "de", "fr", "ja", "ko", "ru", "tr", "ro", "zh-CN", "zh-TW", "pt-BR", "es-MX"];
+function normalizeCasing(locale) {
+  const [language, country] = locale.split("-");
+  return country ? `${language}-${country.toUpperCase()}` : language;
+}
+function resolveSupportedLocale(locale) {
+  const cased = normalizeCasing(locale);
+  const supported = SUPPORTED_LOCALES;
+  if (supported.includes(cased))
+    return cased;
+  const base = cased.split("-")[0];
+  if (supported.includes(base))
+    return base;
+  return null;
+}
+var REGISTERED = /* @__PURE__ */ new WeakMap;
+function createI18nRegistrar(options) {
+  const { namespace, englishBundle, loadCatalog } = options;
+  return (instance2) => {
+    let registered = REGISTERED.get(instance2);
+    if (registered?.has(namespace))
+      return;
+    if (!registered) {
+      registered = /* @__PURE__ */ new Set;
+      REGISTERED.set(instance2, registered);
+    }
+    registered.add(namespace);
+    instance2.addResourceBundle("en", namespace, englishBundle, true, true);
+    const loaded = { en: true };
+    const loadForLocale = async (lng) => {
+      const target = resolveSupportedLocale(lng);
+      if (!target || loaded[target])
+        return;
+      try {
+        const mod = await loadCatalog(target);
+        instance2.addResourceBundle(target, namespace, mod.default, true, true);
+        loaded[target] = true;
+      } catch (err) {
+        console.warn(`[i18n] Failed to load '${target}' catalog for namespace '${namespace}':`, err);
+      }
+    };
+    instance2.on("languageChanged", (lng) => {
+      loadForLocale(lng);
+    });
+    if (instance2.language) {
+      loadForLocale(instance2.language);
+    }
+  };
+}
+var globImport_locales_json = __glob({
+  "../../locales/de.json": () => import("./de-MUJPA4EB-dpg7t2rw.js"),
+  "../../locales/en.json": () => import("./en-FBPVNKFN-dqt573xn.js"),
+  "../../locales/es-MX.json": () => import("./es-MX-2MYFZU7X-3rek4r73.js"),
+  "../../locales/es.json": () => import("./es-7SE7HX2X-8yh1aj2y.js"),
+  "../../locales/fr.json": () => import("./fr-MDFKNZ4C-h4a122k9.js"),
+  "../../locales/ja.json": () => import("./ja-UTQEAP34-8e0q6swp.js"),
+  "../../locales/ko.json": () => import("./ko-AXCHW2OK-askct7f6.js"),
+  "../../locales/pt-BR.json": () => import("./pt-BR-Y6K6XHXK-mp3hwhw1.js"),
+  "../../locales/pt.json": () => import("./pt-3DIO5QWG-59b3f4bc.js"),
+  "../../locales/ro.json": () => import("./ro-BWR3ONRR-vzx3hy8a.js"),
+  "../../locales/ru.json": () => import("./ru-WBLQ5B2U-s4em88p0.js"),
+  "../../locales/tr.json": () => import("./tr-5IIHSFW5-hw4cewew.js"),
+  "../../locales/zh-CN.json": () => import("./zh-CN-R2KU4U5L-tc1hat59.js"),
+  "../../locales/zh-TW.json": () => import("./zh-TW-GNKMELBF-j674515r.js")
+});
+var VALIDATION_NAMESPACE = "validation";
+var registerFlowSchemaI18n = createI18nRegistrar({
+  namespace: VALIDATION_NAMESPACE,
+  englishBundle: en_default,
+  loadCatalog: (lng) => globImport_locales_json(`../../locales/${lng}.json`)
+});
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/chunk-B7WWLYD7.js
+var import_ajv_errors = __toESM(require_dist(), 1);
+var agentEnforcementsSchema = exports_external.object({
+  maxTokens: exports_external.number().nullable(),
+  maxTemperature: exports_external.number().nullable(),
+  policyName: exports_external.string(),
+  shouldEnforceHumanInTheLoop: exports_external.boolean().optional(),
+  maxIterations: exports_external.number().nullable().optional()
+});
+var t = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t2 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+function isTriggerNodeType(nodeType2) {
+  if (typeof nodeType2 !== "string")
+    return false;
+  return nodeType2.startsWith("core.trigger") || nodeType2.toLowerCase().includes("trigger");
+}
+function isEndNodeType(nodeType2) {
+  return nodeType2 === "core.control.end" || nodeType2 === "core.logic.terminate" || nodeType2 === "core.control.response";
+}
+var DOWHILE_NODE_TYPE = "core.logic.dowhile";
+var CONVERSATIONAL_AGENT_ICON = "conversational-agent";
+var CONVERSATIONAL_VOICE_END_CALL_NODE_TYPE = "uipath.conversational.voice.end-call";
+var t3 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t4 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t5 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var ESCALATION_QUICK_FORM_NODE_TYPE = "uipath.agent.resource.escalation.quick-form";
+var ESCALATION_TASK_TYPE = {
+  AppTask: "app-task",
+  QuickForm: "quick-form",
+  DocumentValidationTask: "document-validation-task"
+};
+var ESCALATION_TASK_TYPES = new Set(Object.values(ESCALATION_TASK_TYPE));
+var DEFAULT_STORAGE_VERSION = currentStorageSchema.version;
+var _defaultAgentContent;
+function getDefaultAgentContent() {
+  if (!_defaultAgentContent) {
+    const entry = currentStorageSchemaMigration.defaultStorageContents.files.find((f) => f.name === "agent.json");
+    if (!entry) {
+      throw new Error("@uipath/agents-storage-schemas: missing agent.json in defaultStorageContents");
+    }
+    _defaultAgentContent = entry.content;
+  }
+  return _defaultAgentContent;
+}
+var t6 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t7 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t8 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t9 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var VARS_PATH_CAPTURE = String.raw`[a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*|\[\d+\])*`;
+var VARS_REF_REGEX = new RegExp(String.raw`\{\{\s*\$vars\.(${VARS_PATH_CAPTURE})\s*\}\}`, "g");
+var RAW_VARS_REF_REGEX = new RegExp(String.raw`(?<!\w)\$vars\.(${VARS_PATH_CAPTURE})`, "g");
+var HITL_NODE_TYPE = "uipath.human-in-the-loop";
+var HITL_QUICK_FORM_NODE_TYPE = "uipath.human-in-the-loop.quick-form";
+var HITL_CODED_ACTION_NODE_TYPE = "uipath.human-in-the-loop.coded-action-app";
+var HITL_DOC_VALIDATION_NODE_TYPE = "uipath.human-in-the-loop.document-validation";
+var DYNAMIC_EXTRACT_NODE_TYPE = "uipath.ixp.extract-document-builder";
+var HITL_NODE_TYPES = /* @__PURE__ */ new Set([
+  HITL_QUICK_FORM_NODE_TYPE,
+  HITL_CODED_ACTION_NODE_TYPE,
+  HITL_DOC_VALIDATION_NODE_TYPE,
+  HITL_NODE_TYPE
+]);
+function isHitlNodeType(t13) {
+  return HITL_NODE_TYPES.has(t13);
+}
+var JobAttachmentSchema = {
+  type: "object",
+  "x-uipath-resource-kind": "JobAttachment",
+  properties: {
+    ID: {
+      type: "string",
+      description: "Orchestrator attachment key"
+    },
+    FullName: {
+      type: "string",
+      description: "File name"
+    },
+    MimeType: {
+      type: "string",
+      description: 'The MIME type of the content, such as "application/json" or "image/png"'
+    },
+    Metadata: {
+      type: "object",
+      description: "Dictionary of metadata",
+      additionalProperties: {
+        type: "string"
+      }
+    }
+  },
+  required: ["ID"]
+};
+var ANALYZE_FILES_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachments: {
+        type: "array",
+        items: JobAttachmentSchema,
+        description: "Array of files, documents, images, or other attachments to process"
+      },
+      analysisTask: {
+        type: "string",
+        description: "The task, question, or instruction for processing the files (e.g., 'summarize this document', 'extract key points', 'what is in this image')"
+      }
+    },
+    required: ["attachments", "analysisTask"]
+  },
+  outputSchema: {
+    type: "object",
+    properties: {
+      analysis: {
+        type: "string",
+        description: "Analysis result of the attachments (analysis, summary, extracted information, etc.)"
+      }
+    },
+    required: ["analysis"]
+  }
+};
+var SUMMARIZE_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachment: {
+        type: "object",
+        title: "Source",
+        description: "File or document to summarize",
+        properties: JobAttachmentSchema.properties,
+        required: JobAttachmentSchema.required
+      }
+    },
+    required: ["attachment"]
+  },
+  outputSchema: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The content of the analyzed attachment"
+        }
+      }
+    }
+  }
+};
+var BATCH_TRANSFORM_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      attachment: {
+        type: "object",
+        title: "Source",
+        description: "CSV file to transform",
+        properties: JobAttachmentSchema.properties,
+        required: JobAttachmentSchema.required
+      }
+    },
+    required: ["attachment"]
+  },
+  outputSchema: {
+    type: "array",
+    items: {
+      type: "object",
+      properties: {
+        content: {
+          type: "string",
+          description: "The content of the transformed row"
+        }
+      }
+    }
+  }
+};
+var nameValuePairSchema = (nameDescription, valueDescription) => ({
+  type: "object",
+  properties: {
+    name: {
+      type: "string",
+      description: nameDescription
+    },
+    value: {
+      type: "string",
+      description: valueDescription
+    }
+  },
+  required: ["name", "value"]
+});
+var HTTP_REQUEST_SCHEMA = {
+  inputSchema: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "The absolute URL to send the request to."
+      },
+      method: {
+        type: "string",
+        description: "HTTP method to use, one of: GET, POST, PUT, PATCH, DELETE."
+      },
+      headers: {
+        type: "array",
+        description: "Request headers as a list of name/value pairs.",
+        items: nameValuePairSchema("Header name.", "Header value.")
+      },
+      params: {
+        type: "array",
+        description: "Query-string parameters as a list of name/value pairs.",
+        items: nameValuePairSchema("Parameter name.", "Parameter value.")
+      },
+      body: {
+        type: "string",
+        description: "Request body sent as-is. Provide JSON as a string and set a Content-Type header if the endpoint expects JSON."
+      },
+      timeout: {
+        type: "number",
+        description: "Request timeout in seconds."
+      }
+    },
+    required: ["url"]
+  },
+  outputSchema: {
+    type: "object",
+    properties: {}
+  }
+};
+var BUILT_IN_TOOL_SCHEMAS = {
+  "uipath.agent.resource.tool.builtin.analyzefiles": ANALYZE_FILES_SCHEMA,
+  "uipath.agent.resource.tool.builtin.summarize": SUMMARIZE_SCHEMA,
+  "uipath.agent.resource.tool.builtin.batchtransform": BATCH_TRANSFORM_SCHEMA,
+  "uipath.agent.resource.tool.builtin.httprequest": HTTP_REQUEST_SCHEMA
+};
+var FILE_SCHEMA_FIELDS = Object.keys(JobAttachmentSchema.properties ?? {});
+function isFileShapedInputNode(node) {
+  if (!node || typeof node !== "object")
+    return false;
+  const n = node;
+  if (n["x-uipath-resource-kind"] === "JobAttachment")
+    return true;
+  if (typeof n.$ref === "string" && n.$ref.toLowerCase().includes("job-attachment"))
+    return true;
+  if (n.type === "file" || n.type === "octet-stream")
+    return true;
+  if (n.properties && FILE_SCHEMA_FIELDS.every((field) => (field in n.properties)))
+    return true;
+  return isFileShapedInputNode(n.items);
+}
+function schemaAcceptsFileInput(inputSchema) {
+  const properties = inputSchema?.properties;
+  if (!properties)
+    return false;
+  return Object.values(properties).some(isFileShapedInputNode);
+}
+var FILE_CAPABLE_BUILTIN_TOOL_TYPES = new Set(Object.entries(BUILT_IN_TOOL_SCHEMAS).filter(([, schemas]) => schemaAcceptsFileInput(schemas.inputSchema)).map(([nodeType2]) => nodeType2));
+var t10 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t11 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+var t12 = instance.getFixedT(null, VALIDATION_NAMESPACE);
+
+// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/index.js
+var import_object = __toESM(require_index_cjs(), 1);
+var workflowRuntimeSchema = exports_external.enum(["maestro", "api-function"]);
+var DEFAULT_WORKFLOW_RUNTIME = "maestro";
+var argumentBindingSchema = exports_external.object({
+  nodeId: exports_external.string(),
+  outputId: exports_external.string()
+});
+var workflowVariableSchema = exports_external.object({
+  id: exports_external.string().min(1),
+  direction: exports_external.enum(["in", "out", "inout"]),
+  type: exports_external.string().default("string"),
+  subType: exports_external.string().optional(),
+  schema: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  defaultValue: exports_external.unknown().optional(),
+  description: exports_external.string().optional(),
+  triggerNodeId: exports_external.string().optional()
+});
+var variableUpdateSchema = exports_external.object({
+  variableId: exports_external.string(),
+  expression: expressionLikeSchema
+});
+var nodeVariableSchema = exports_external.object({
+  id: exports_external.string().min(1),
+  type: exports_external.string().default("string"),
+  subType: exports_external.string().optional(),
+  schema: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  description: exports_external.string().optional(),
+  binding: argumentBindingSchema
+});
+var workflowVariablesSchema = exports_external.object({
+  globals: exports_external.array(workflowVariableSchema).optional(),
+  nodes: exports_external.array(nodeVariableSchema).optional(),
+  variableUpdates: exports_external.record(exports_external.string(), exports_external.array(variableUpdateSchema)).optional()
+});
+var EMPTY_VARIABLES = Object.freeze({ globals: [], nodes: [], variableUpdates: {} });
+var workflowConnectionSchema = exports_external.object({
+  type: exports_external.enum(["cloud", "local"]),
+  environment: exports_external.enum(["cloud", "staging", "alpha"]).optional(),
+  baseUrl: exports_external.string().optional(),
+  organizationId: exports_external.string().optional(),
+  tenantId: exports_external.string().optional(),
+  tenantName: exports_external.string().optional(),
+  localUrl: exports_external.string().url().optional()
+});
+var nodeLayoutSchema = exports_external.looseObject({
+  position: exports_external.object({ x: exports_external.number(), y: exports_external.number() }),
+  size: exports_external.object({ width: exports_external.number(), height: exports_external.number() }).optional(),
+  collapsed: exports_external.boolean().optional()
+});
+var waypointSchema = exports_external.object({
+  id: exports_external.string(),
+  x: exports_external.number(),
+  y: exports_external.number()
+});
+var edgeLayoutSchema = exports_external.looseObject({
+  waypoints: exports_external.array(waypointSchema).optional(),
+  routedWaypoints: exports_external.array(waypointSchema).optional()
+});
+var layoutSchema = exports_external.object({
+  nodes: exports_external.record(exports_external.string(), nodeLayoutSchema),
+  edges: exports_external.record(exports_external.string(), edgeLayoutSchema).optional()
+});
+var bindingSchema = exports_external.object({
+  id: exports_external.string(),
+  name: exports_external.string(),
+  type: exports_external.string(),
+  resource: exports_external.string(),
+  resourceKey: exports_external.string(),
+  default: exports_external.string().optional(),
+  propertyAttribute: exports_external.string().optional(),
+  resourceSubType: exports_external.string().optional()
+});
+var categoryManifestSchema = exports_external.object({
+  id: exports_external.string().min(1),
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  parentId: exports_external.string().optional(),
+  sortOrder: exports_external.number().int().nonnegative(),
+  color: exports_external.string().min(1).optional(),
+  colorDark: exports_external.string().min(1).optional(),
+  icon: exports_external.string().min(1).optional(),
+  tags: exports_external.array(exports_external.string())
+});
+var handleTargetSchema = exports_external.object({
+  nodeType: exports_external.string(),
+  handleId: exports_external.string().optional()
+});
+var connectionConstraintSchema = exports_external.object({
+  maxConnections: exports_external.number().int().positive().optional(),
+  minConnections: exports_external.number().int().nonnegative().optional(),
+  allowedTargets: exports_external.array(handleTargetSchema).optional(),
+  forbiddenTargets: exports_external.array(handleTargetSchema).optional(),
+  allowedSources: exports_external.array(handleTargetSchema).optional(),
+  forbiddenSources: exports_external.array(handleTargetSchema).optional(),
+  allowedTargetCategories: exports_external.array(exports_external.string()).optional(),
+  forbiddenTargetCategories: exports_external.array(exports_external.string()).optional(),
+  allowedSourceCategories: exports_external.array(exports_external.string()).optional(),
+  forbiddenSourceCategories: exports_external.array(exports_external.string()).optional(),
+  customValidation: exports_external.string().optional(),
+  validationMessage: exports_external.string().optional(),
+  severity: exports_external["enum"]([
+    "warning",
+    "error",
+    "critical",
+    "info"
+  ]).optional()
+});
+var handlePositionSchema = exports_external["enum"]([
+  "left",
+  "top",
+  "right",
+  "bottom"
+]);
+var handleBoundarySchema = exports_external["enum"]([
+  "outer",
+  "inner"
+]);
+var handleTypeSchema = exports_external["enum"]([
+  "source",
+  "target"
+]);
+var handleTypeDisplaySchema = exports_external["enum"]([
+  "artifact",
+  "input",
+  "output"
+]);
+var handleLabelVisibilitySchema = exports_external["enum"]([
+  "always",
+  "hover"
+]);
+var handleConfigurationSpecificPositionSchema = exports_external.object({
+  height: exports_external.number().optional(),
+  width: exports_external.number().optional(),
+  top: exports_external.number().optional(),
+  bottom: exports_external.number().optional(),
+  left: exports_external.number().optional(),
+  right: exports_external.number().optional()
+});
+var handleManifestSchema = exports_external.object({
+  id: exports_external.string().min(1),
+  type: handleTypeSchema,
+  handleType: handleTypeDisplaySchema,
+  label: exports_external.string().optional(),
+  visible: exports_external.union([
+    exports_external.boolean(),
+    exports_external.string()
+  ]).optional(),
+  repeat: exports_external.string().optional(),
+  itemVar: exports_external.string().optional(),
+  indexVar: exports_external.string().optional(),
+  showButton: exports_external.boolean().optional(),
+  labelVisibility: handleLabelVisibilitySchema.optional(),
+  constraints: connectionConstraintSchema.optional(),
+  isDefaultForType: exports_external.boolean().optional()
+});
+var handleGroupManifestSchema = exports_external.object({
+  position: handlePositionSchema,
+  boundary: handleBoundarySchema.optional(),
+  customPositionAndOffsets: handleConfigurationSpecificPositionSchema.optional(),
+  handles: exports_external.array(handleManifestSchema),
+  visible: exports_external.boolean().optional()
+});
+var handleGroupOverrideSchema = exports_external.object({
+  position: handlePositionSchema,
+  handles: exports_external.array(handleManifestSchema),
+  visible: exports_external.boolean().optional()
+});
+var nodeShapeSchema = exports_external["enum"]([
+  "circle",
+  "square",
+  "rectangle",
+  "container"
+]);
+var toolbarActionSchema = exports_external.object({
+  id: exports_external.string(),
+  icon: exports_external.string(),
+  label: exports_external.string(),
+  shortcut: exports_external.string().optional(),
+  condition: exports_external.object({
+    requiresPermissions: exports_external.array(exports_external.string()).optional(),
+    hideOnExecution: exports_external.boolean().optional(),
+    nodeTypes: exports_external.array(exports_external.string()).optional(),
+    shapes: exports_external.array(nodeShapeSchema).optional(),
+    handles: exports_external.array(exports_external.object({
+      handleType: exports_external["enum"]([
+        "output",
+        "input",
+        "artifact"
+      ]),
+      type: exports_external["enum"]([
+        "source",
+        "target"
+      ]).optional()
+    })).optional()
+  }).optional()
+});
+var modeToolbarConfigSchema = exports_external.object({
+  actions: exports_external.array(toolbarActionSchema),
+  overflowActions: exports_external.array(toolbarActionSchema).optional()
+});
+var toolbarConfigurationSchema = exports_external.record(exports_external.string(), modeToolbarConfigSchema);
+var nodeDebugManifestSchema = exports_external.object({
+  runtime: exports_external.string().min(1)
+});
+var nodeDisplayManifestSchema = exports_external.object({
+  label: exports_external.string().min(1),
+  canvasLabel: exports_external.string().min(1).optional(),
+  description: exports_external.string().optional(),
+  icon: exports_external.string().min(1).optional(),
+  shape: nodeShapeSchema.optional(),
+  color: exports_external.string().optional(),
+  background: exports_external.string().optional(),
+  iconBackground: exports_external.string().optional(),
+  iconBackgroundDark: exports_external.string().optional(),
+  iconColor: exports_external.string().optional(),
+  shadow: exports_external.boolean().optional()
+});
+var nodeRuntimeConstraintsManifestSchema = exports_external.union([
+  exports_external.object({
+    include: exports_external.array(exports_external.string())
+  }),
+  exports_external.object({
+    exclude: exports_external.array(exports_external.string())
+  })
+]);
+var nodeManifestSchema = exports_external.object({
+  nodeType: exports_external.string().min(1),
+  version: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  category: exports_external.string().min(1).optional(),
+  tags: exports_external.array(exports_external.string()),
+  sortOrder: exports_external.number().int().nonnegative(),
+  display: nodeDisplayManifestSchema,
+  handleConfiguration: exports_external.array(handleGroupManifestSchema),
+  toolbarExtensions: toolbarConfigurationSchema.optional(),
+  suppressDefaultToolbarActions: exports_external.record(exports_external.string(), exports_external.array(exports_external.string())).optional(),
+  inputDefaults: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  inputDefinition: exports_external.record(exports_external.string(), exports_external.any()).optional(),
+  outputDefinition: exports_external.record(exports_external.string(), exports_external.any()).optional(),
+  drillable: exports_external.boolean().optional(),
+  debug: nodeDebugManifestSchema.optional(),
+  model: exports_external.any().optional(),
+  defaultProperties: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  form: exports_external.custom().optional(),
+  deprecated: exports_external.boolean().optional(),
+  runtimeConstraints: nodeRuntimeConstraintsManifestSchema.optional()
+});
+var idSchema = exports_external.string().min(1);
+var versionSchema = exports_external.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be in semver format (e.g., "1.0.0")');
+var typeVersionKeySchema = exports_external.string().regex(/^.+:\d+\.\d+\.\d+$/, 'TypeVersionKey must be in format "type:version" (e.g., "myType:1.0.0")');
+var displayConfigSchema = exports_external.object({
+  label: exports_external.string().optional(),
+  canvasLabel: exports_external.string().optional(),
+  subLabel: exports_external.any().optional(),
+  shape: nodeShapeSchema.optional(),
+  background: exports_external.string().optional(),
+  iconBackground: exports_external.string().optional(),
+  iconBackgroundDark: exports_external.string().optional(),
+  iconColor: exports_external.string().optional(),
+  icon: exports_external.string().optional(),
+  iconElement: exports_external.any().optional(),
+  color: exports_external.string().optional(),
+  labelTooltip: exports_external.string().optional(),
+  labelBackgroundColor: exports_external.string().optional(),
+  centerAdornmentComponent: exports_external.any().optional(),
+  footerComponent: exports_external.any().optional(),
+  footerVariant: exports_external.string().optional(),
+  shadow: exports_external.boolean().optional()
+}).catchall(exports_external.unknown());
+var waypointSchema2 = exports_external.object({
+  id: exports_external.string().min(1),
+  x: exports_external.number(),
+  y: exports_external.number()
+});
+var edgeUiSchema = exports_external.object({
+  waypoints: exports_external.array(waypointSchema2).optional(),
+  routedWaypoints: exports_external.array(waypointSchema2).optional(),
+  autoRouted: exports_external.boolean().optional()
+}).catchall(exports_external.unknown());
+var edgeSchema = exports_external.object({
+  id: idSchema,
+  sourceNodeId: idSchema,
+  sourcePort: exports_external.string().min(1),
+  targetNodeId: idSchema,
+  targetPort: exports_external.string().min(1),
+  ui: edgeUiSchema.nullish().transform((value) => value ?? undefined).optional(),
+  data: exports_external.object({
+    label: exports_external.string().optional()
+  }).passthrough().optional()
+});
+var uiSchema = exports_external.object({
+  position: exports_external.object({
+    x: exports_external.number(),
+    y: exports_external.number()
+  }),
+  size: exports_external.object({
+    width: exports_external.number(),
+    height: exports_external.number()
+  }).optional(),
+  collapsed: exports_external.boolean().optional()
+}).catchall(exports_external.unknown());
+var nodeSchema = exports_external.object({
+  id: idSchema,
+  type: exports_external.string().min(1),
+  typeVersion: versionSchema,
+  ui: uiSchema,
+  display: displayConfigSchema,
+  inputs: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  outputs: exports_external.record(exports_external.string(), exports_external.unknown()).optional(),
+  handleCustomization: exports_external.object({
+    groups: exports_external.array(handleGroupOverrideSchema)
+  }).optional(),
+  model: exports_external.unknown().optional(),
+  parentId: idSchema.optional()
+});
+var edgeSchema2 = edgeSchema.extend({
+  ui: edgeLayoutSchema.optional()
+});
+var nodeSchema2 = nodeSchema.extend({
+  typeVersion: exports_external.string().regex(/^\d+\.\d+(\.\d+)?$/, 'Version must be in format "x.y" or "x.y.z"')
+});
+var nodeManifestSchema2 = exports_external.lazy(() => nodeManifestSchema.extend({
+  display: nodeDisplayManifestSchema.extend({ isPreview: exports_external.boolean().optional() }),
+  projectId: exports_external.string().optional(),
+  entryPointPath: exports_external.string().optional(),
+  unsupportedRuntime: exports_external.boolean().optional(),
+  takeoverTabs: exports_external.array(exports_external.string()).optional()
+}));
+var categoryManifestSchema2 = exports_external.lazy(() => categoryManifestSchema.extend({
+  displayIfEmpty: exports_external.boolean().optional()
+}));
+var versionSchema2 = exports_external.string().regex(/^\d+\.\d+(\.\d+)?$/, 'Version must be in format "x.y" or "x.y.z"');
+var subflowEntrySchema = exports_external.object({
+  nodes: exports_external.array(nodeSchema2),
+  edges: exports_external.array(edgeSchema2),
+  variables: workflowVariablesSchema.optional()
+});
+var workflowSchema = exports_external.object({
+  id: idSchema,
+  version: versionSchema2,
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  runtime: workflowRuntimeSchema.optional(),
+  nodes: exports_external.array(nodeSchema2),
+  edges: exports_external.array(edgeSchema2),
+  definitions: exports_external.array(nodeManifestSchema2),
+  bindings: exports_external.array(bindingSchema).optional(),
+  variables: workflowVariablesSchema.optional(),
+  connection: workflowConnectionSchema.optional(),
+  subflows: exports_external.record(exports_external.string(), subflowEntrySchema).optional()
+});
+var fileFormatNodeSchema = exports_external.lazy(() => nodeSchema2.extend({
+  ui: nodeSchema2.shape.ui.optional()
+}));
+var subflowFileSchema = exports_external.object({
+  nodes: exports_external.array(fileFormatNodeSchema),
+  edges: exports_external.array(edgeSchema2),
+  variables: workflowVariablesSchema.optional(),
+  layout: layoutSchema.optional()
+});
+var workflowSchemaV1_0_0 = exports_external.object({
+  id: idSchema,
+  version: exports_external.literal("1.0.0"),
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  runtime: workflowRuntimeSchema.optional(),
+  nodes: exports_external.array(fileFormatNodeSchema),
+  edges: exports_external.array(edgeSchema2),
+  definitions: exports_external.array(nodeManifestSchema2),
+  bindings: exports_external.array(bindingSchema).optional(),
+  variables: workflowVariablesSchema.optional(),
+  connection: workflowConnectionSchema.optional(),
+  subflows: exports_external.record(exports_external.string(), subflowFileSchema).optional(),
+  layout: layoutSchema.optional()
+});
+var fileFormatNodeSchema2 = exports_external.lazy(() => nodeSchema2.extend({
+  ui: nodeSchema2.shape.ui.optional()
+}));
+var subflowFileSchema2 = exports_external.object({
+  nodes: exports_external.array(fileFormatNodeSchema2),
+  edges: exports_external.array(edgeSchema2),
+  variables: workflowVariablesSchema.optional(),
+  layout: layoutSchema.optional()
+});
+var workflowSchemaV1_0 = exports_external.object({
+  id: idSchema,
+  version: exports_external.literal("1.0"),
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  runtime: workflowRuntimeSchema.optional(),
+  nodes: exports_external.array(fileFormatNodeSchema2),
+  edges: exports_external.array(edgeSchema2),
+  definitions: exports_external.array(nodeManifestSchema2),
+  bindings: exports_external.array(bindingSchema).optional(),
+  variables: workflowVariablesSchema.optional(),
+  connection: workflowConnectionSchema.optional(),
+  subflows: exports_external.record(exports_external.string(), subflowFileSchema2).optional(),
+  layout: layoutSchema.optional()
+});
+var workflowSchemaV1_1 = workflowSchemaV1_0.extend({
+  version: exports_external.literal("1.1")
+});
+var workflowSchemaV1_2 = workflowSchemaV1_1.extend({
+  version: exports_external.literal("1.2")
+});
+var fileFormatNodeSchema3 = exports_external.lazy(() => nodeSchema2.extend({
+  ui: nodeSchema2.shape.ui.optional()
+}));
+var v1_3VariableUpdateSchema = exports_external.object({
+  variableId: exports_external.string(),
+  expression: expressionValueSchema
+});
+var v1_3WorkflowVariablesSchema = exports_external.object({
+  globals: exports_external.array(workflowVariableSchema).optional(),
+  nodes: exports_external.array(nodeVariableSchema).optional(),
+  variableUpdates: exports_external.record(exports_external.string(), exports_external.array(v1_3VariableUpdateSchema)).optional()
+});
+var subflowFileSchema3 = exports_external.object({
+  nodes: exports_external.array(fileFormatNodeSchema3),
+  edges: exports_external.array(edgeSchema2),
+  variables: v1_3WorkflowVariablesSchema.optional(),
+  layout: layoutSchema.optional()
+});
+var workflowSchemaV1_3 = exports_external.object({
+  id: idSchema,
+  version: exports_external.literal("1.3"),
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  runtime: workflowRuntimeSchema.optional(),
+  nodes: exports_external.array(fileFormatNodeSchema3),
+  edges: exports_external.array(edgeSchema2),
+  definitions: exports_external.array(nodeManifestSchema2),
+  bindings: exports_external.array(bindingSchema).optional(),
+  variables: v1_3WorkflowVariablesSchema.optional(),
+  connection: workflowConnectionSchema.optional(),
+  subflows: exports_external.record(exports_external.string(), subflowFileSchema3).optional(),
+  layout: layoutSchema.optional()
+});
+var fileFormatNodeSchema4 = exports_external.lazy(() => nodeSchema2.extend({
+  ui: nodeSchema2.shape.ui.optional()
+}));
+var v1_4VariableUpdateSchema = exports_external.object({
+  variableId: exports_external.string(),
+  expression: expressionValueSchema
+});
+var v1_4WorkflowVariablesSchema = exports_external.object({
+  globals: exports_external.array(workflowVariableSchema).optional(),
+  nodes: exports_external.array(nodeVariableSchema).optional(),
+  variableUpdates: exports_external.record(exports_external.string(), exports_external.array(v1_4VariableUpdateSchema)).optional()
+});
+var subflowFileSchema4 = exports_external.object({
+  nodes: exports_external.array(fileFormatNodeSchema4),
+  edges: exports_external.array(edgeSchema2),
+  variables: v1_4WorkflowVariablesSchema.optional(),
+  layout: layoutSchema.optional()
+});
+var workflowSchemaV1_4 = exports_external.object({
+  id: idSchema,
+  version: exports_external.literal("1.4"),
+  name: exports_external.string().min(1),
+  description: exports_external.string().optional(),
+  runtime: workflowRuntimeSchema.optional(),
+  nodes: exports_external.array(fileFormatNodeSchema4),
+  edges: exports_external.array(edgeSchema2),
+  definitions: exports_external.array(nodeManifestSchema2),
+  bindings: exports_external.array(bindingSchema).optional(),
+  variables: v1_4WorkflowVariablesSchema.optional(),
+  connection: workflowConnectionSchema.optional(),
+  subflows: exports_external.record(exports_external.string(), subflowFileSchema4).optional(),
+  layout: layoutSchema.optional()
+});
+var workflowSchemaV1_5 = workflowSchemaV1_4.extend({
+  version: exports_external.literal("1.5")
+});
+var workflowSchemaV1_6 = workflowSchemaV1_5.extend({
+  version: exports_external.literal("1.6")
+});
+var workflowSchemaV1_7 = workflowSchemaV1_6.extend({
+  version: exports_external.literal("1.7")
+});
+var workflowSchemaV1_8 = workflowSchemaV1_7.extend({
+  version: exports_external.literal("1.8")
+});
+var workflowSchemaV1_9 = workflowSchemaV1_8.extend({
+  version: exports_external.literal("1.9")
+});
+var workflowSchemaV1_10 = workflowSchemaV1_9.extend({
+  version: exports_external.literal("1.10")
+});
+var MINIMUM_SUPPORTED_SCHEMA_VERSION = "1.9";
+var workflowFileSchema = workflowSchemaV1_9;
+var fileFormatNodeSchema5 = exports_external.lazy(() => nodeSchema2.extend({
+  ui: nodeSchema2.shape.ui.optional()
+}));
+var subflowFileSchema5 = exports_external.object({
+  nodes: exports_external.array(fileFormatNodeSchema5),
+  edges: exports_external.array(edgeSchema2),
+  variables: workflowVariablesSchema.optional(),
+  layout: layoutSchema.optional()
+});
+var workflowManifestSchema = exports_external.object({
+  version: exports_external.string().min(1),
+  categories: exports_external.array(categoryManifestSchema2),
+  nodes: exports_external.array(nodeManifestSchema2)
+});
+var manifestResponseSchema = exports_external.object({
+  success: exports_external.boolean(),
+  data: workflowManifestSchema.optional(),
+  error: exports_external.string().optional(),
+  timestamp: exports_external.string().optional()
+});
+var handleTargetSchema2 = exports_external.object({
+  nodeType: exports_external.string(),
+  handleId: exports_external.string().optional()
+});
+var addNodePanelSearchScopeSchema = exports_external.enum(["global", "direct", "deep"]);
+var addNodePanelCreateActionSchema = exports_external.object({
+  label: exports_external.string(),
+  icon: exports_external.string().optional(),
+  description: exports_external.string().optional(),
+  urlTemplate: exports_external.string(),
+  categoryId: exports_external.string()
+});
+var addNodePanelConfigSchema = exports_external.object({
+  searchScope: addNodePanelSearchScopeSchema.optional(),
+  searchProviders: exports_external.array(exports_external.enum(["connector-events", "connector-triggers"])).optional(),
+  refreshOnFocus: exports_external.string().optional(),
+  createNewActions: exports_external.array(addNodePanelCreateActionSchema).optional()
+});
+var connectionConstraintSchema2 = exports_external.object({
+  maxConnections: exports_external.number().int().positive().optional(),
+  minConnections: exports_external.number().int().nonnegative().optional(),
+  allowedTargets: exports_external.array(handleTargetSchema2).optional(),
+  forbiddenTargets: exports_external.array(handleTargetSchema2).optional(),
+  allowedSources: exports_external.array(handleTargetSchema2).optional(),
+  forbiddenSources: exports_external.array(handleTargetSchema2).optional(),
+  allowedTargetCategories: exports_external.array(exports_external.string()).optional(),
+  forbiddenTargetCategories: exports_external.array(exports_external.string()).optional(),
+  allowedSourceCategories: exports_external.array(exports_external.string()).optional(),
+  forbiddenSourceCategories: exports_external.array(exports_external.string()).optional(),
+  customValidation: exports_external.string().optional(),
+  validationMessage: exports_external.string().optional(),
+  addNodePanel: addNodePanelConfigSchema.optional()
+});
+function constraintWithAddNodePanel(constraint) {
+  return constraint;
+}
+jsep.plugins.register(import_object.default);
+function resolveRelativePath(baseUri, relativePath) {
+  if (relativePath.startsWith("#")) {
+    throw new Error(`Same-document fragment refs are not file paths and must not be resolved as $ref files: "${relativePath}"`);
+  }
+  if (relativePath.startsWith("/") || /^[a-zA-Z]:/.test(relativePath)) {
+    throw new Error(`Absolute paths are not allowed in $ref: "${relativePath}"`);
+  }
+  if (relativePath.includes("://")) {
+    throw new Error(`Protocol-based URIs are not allowed in $ref: "${relativePath}"`);
+  }
+  const normalizedBase = baseUri.replace(/\\/g, "/");
+  const lastSlash = normalizedBase.lastIndexOf("/");
+  const baseDir = lastSlash >= 0 ? normalizedBase.slice(0, lastSlash + 1) : "";
+  const resolved = normalizePath(`${baseDir}${relativePath}`);
+  const isAbsoluteBase = normalizedBase.startsWith("/") || /^[a-zA-Z]:\//.test(normalizedBase);
+  if (!isAbsoluteBase && resolved.startsWith("..")) {
+    throw new Error(`$ref path "${relativePath}" escapes the project root`);
+  }
+  return resolved;
+}
+function normalizePath(path) {
+  const isAbsolute = path.startsWith("/");
+  const segments = path.split("/");
+  const result = [];
+  for (const segment of segments) {
+    if (segment === "" || segment === ".")
+      continue;
+    if (segment === ".." && result.length > 0 && result[result.length - 1] !== "..") {
+      result.pop();
+    } else {
+      result.push(segment);
+    }
+  }
+  const normalized = result.join("/") || ".";
+  return isAbsolute ? `/${normalized}` : normalized;
+}
+var DEFAULT_MAX_DEPTH = 10;
+async function resolveRefs(doc, resolver, options) {
+  const ctx = {
+    resolver,
+    refMap: /* @__PURE__ */ new Map,
+    errors: [],
+    visiting: /* @__PURE__ */ new Set,
+    maxDepth: options.maxDepth ?? DEFAULT_MAX_DEPTH
+  };
+  const resolved = await walk(doc, options.baseUri, [], 0, ctx);
+  return { resolved, refMap: ctx.refMap, errors: ctx.errors };
+}
+function isRefObject(node) {
+  if (node === null || typeof node !== "object" || Array.isArray(node)) {
+    return false;
+  }
+  const keys = Object.keys(node);
+  return keys.length === 1 && keys[0] === "$ref" && typeof node["$ref"] === "string";
+}
+function applyJsonPointer(doc, pointer) {
+  if (pointer === "")
+    return doc;
+  if (!pointer.startsWith("/")) {
+    throw new Error(`Invalid JSON Pointer: "${pointer}" (must be empty or start with "/")`);
+  }
+  const tokens = parsePointerTokens(pointer);
+  let current = doc;
+  for (const token of tokens) {
+    if (current === null || current === undefined || typeof current !== "object") {
+      throw new Error(`Cannot navigate into non-object at token "${token}" in pointer "${pointer}"`);
+    }
+    if (Array.isArray(current)) {
+      const index = Number(token);
+      if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+        throw new Error(`Invalid array index "${token}" in pointer "${pointer}"`);
+      }
+      current = current[index];
+    } else {
+      const obj = current;
+      if (!(token in obj)) {
+        throw new Error(`Key "${token}" not found in pointer "${pointer}"`);
+      }
+      current = obj[token];
+    }
+  }
+  return current;
+}
+function parsePointerTokens(pointer) {
+  return pointer.split("/").slice(1).map((t13) => t13.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function toJsonPointer(segments) {
+  if (segments.length === 0)
+    return "";
+  return "/" + segments.map((s) => s.replace(/~/g, "~0").replace(/\//g, "~1")).join("/");
+}
+async function walk(node, baseUri, pathSegments, refDepth, ctx) {
+  if (node === null || node === undefined || typeof node !== "object") {
+    return node;
+  }
+  if (Array.isArray(node)) {
+    const result2 = [];
+    for (let i = 0;i < node.length; i++) {
+      result2.push(await walk(node[i], baseUri, [...pathSegments, String(i)], refDepth, ctx));
+    }
+    return result2;
+  }
+  if (isRefObject(node)) {
+    return resolveRefObject(node, baseUri, pathSegments, refDepth, ctx);
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    result[key] = await walk(value, baseUri, [...pathSegments, key], refDepth, ctx);
+  }
+  return result;
+}
+async function resolveRefObject(node, baseUri, pathSegments, refDepth, ctx) {
+  const pointer = toJsonPointer(pathSegments);
+  const refPath = node.$ref;
+  if (refPath.startsWith("#")) {
+    return node;
+  }
+  if (refDepth >= ctx.maxDepth) {
+    ctx.errors.push({ pointer, ref: refPath, message: `Max resolution depth (${ctx.maxDepth}) exceeded` });
+    return node;
+  }
+  const resolvedPath = resolveRelativePath(baseUri, refPath);
+  if (ctx.visiting.has(resolvedPath)) {
+    ctx.errors.push({ pointer, ref: refPath, message: `Circular $ref detected: ${refPath}` });
+    return node;
+  }
+  ctx.visiting.add(resolvedPath);
+  try {
+    const resolved = await ctx.resolver(refPath, baseUri);
+    const originalValue = structuredClone(resolved);
+    const isOuterRef = !ctx.refMap.has(pointer);
+    if (isOuterRef) {
+      ctx.refMap.set(pointer, {
+        ref: refPath,
+        originalValue,
+        resolvedValue: originalValue,
+        sourceBaseUri: baseUri
+      });
+    }
+    const walked = await walk(resolved, resolvedPath, pathSegments, refDepth + 1, ctx);
+    if (isOuterRef) {
+      const entry = ctx.refMap.get(pointer);
+      if (entry) {
+        entry.resolvedValue = structuredClone(walked);
+      }
+    }
+    return walked;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown resolution error";
+    ctx.errors.push({ pointer, ref: refPath, message: msg });
+    return node;
+  } finally {
+    ctx.visiting.delete(resolvedPath);
+  }
+}
+function fileFormatToInMemoryWorkflow(file) {
+  const { layout: _, subflows: __, ...rest } = file;
+  return {
+    ...rest,
+    runtime: file.runtime ?? DEFAULT_WORKFLOW_RUNTIME,
+    nodes: file.nodes ? mergeLayout(file.nodes, file.layout?.nodes) : [],
+    ...file.edges && { edges: mergeEdgeLayout(file.edges, file.layout?.edges) },
+    subflows: file.subflows ? mapValues(file.subflows, subflowFileToMemory) : undefined
+  };
+}
+async function resolveAndConvertWorkflow(raw, resolver, options) {
+  const { resolved, refMap, errors } = await resolveRefs(raw, resolver, options);
+  if (errors.length > 0) {
+    const messages = errors.map((e) => `${e.pointer}: ${e.message}`).join("; ");
+    throw new Error(`Failed to resolve $ref(s): ${messages}`);
+  }
+  const workflow = fileFormatToInMemoryWorkflow(resolved);
+  return { workflow, refMap };
+}
+function inMemoryWorkflowToFileFormat(workflow) {
+  if (workflow.version && workflow.version !== MINIMUM_SUPPORTED_SCHEMA_VERSION) {
+    throw new Error(`[inMemoryWorkflowToFileFormat] Refusing to serialize a v${workflow.version} workflow to the v${MINIMUM_SUPPORTED_SCHEMA_VERSION} file format. Run the workflow migration pipeline before serializing.`);
+  }
+  const { subflows: _, ...rest } = workflow;
+  const { layout: nodeLayout, nodes } = extractLayout(workflow.nodes);
+  const { layout: edgeLayout, edges } = extractEdgeLayout(workflow.edges);
+  return {
+    ...rest,
+    version: rest.version,
+    nodes,
+    ...workflow.edges && { edges },
+    layout: { nodes: nodeLayout, ...edgeLayout && { edges: edgeLayout } },
+    subflows: workflow.subflows ? mapValues(workflow.subflows, subflowMemoryToFile) : undefined
+  };
+}
+var DEFAULT_UI = { position: { x: 0, y: 0 } };
+function mergeLayout(nodes, layoutNodes) {
+  return nodes.map((node) => {
+    const layoutEntry = node.id && layoutNodes ? layoutNodes[node.id] : undefined;
+    const ui = layoutEntry ? { ...node.ui, ...layoutEntry } : node.ui ?? DEFAULT_UI;
+    return { ...node, ui };
+  });
+}
+function mergeEdgeLayout(edges, layoutEdges) {
+  if (!layoutEdges)
+    return edges;
+  return edges.map((edge) => {
+    const layoutEntry = edge.id ? layoutEdges[edge.id] : undefined;
+    return layoutEntry ? { ...edge, ui: { ...edge.ui, ...layoutEntry } } : edge;
+  });
+}
+function extractEdgeLayout(edges) {
+  if (!edges)
+    return { layout: undefined, edges: [] };
+  const hasLayout = (edge) => Boolean(edge.id && edge.ui && Object.keys(edge.ui).length > 0);
+  if (!edges.some(hasLayout))
+    return { layout: undefined, edges };
+  const layout = {};
+  const strippedEdges = edges.map((edge) => {
+    if (hasLayout(edge)) {
+      layout[edge.id] = edge.ui;
+    }
+    const { ui: _, ...rest } = edge;
+    return rest;
+  });
+  return { layout, edges: strippedEdges };
+}
+function extractLayout(nodes) {
+  const layout = {};
+  const strippedNodes = nodes.map((node) => {
+    if (node.id && node.ui) {
+      layout[node.id] = node.ui;
+    }
+    const { ui: _, ...rest } = node;
+    return rest;
+  });
+  return { layout, nodes: strippedNodes };
+}
+function subflowFileToMemory(subflow) {
+  const { layout: _, ...rest } = subflow;
+  return {
+    ...rest,
+    nodes: mergeLayout(subflow.nodes, subflow.layout?.nodes),
+    ...subflow.edges && { edges: mergeEdgeLayout(subflow.edges, subflow.layout?.edges) }
+  };
+}
+function subflowMemoryToFile(subflow) {
+  const { layout: nodeLayout, nodes } = extractLayout(subflow.nodes);
+  const { layout: edgeLayout, edges } = extractEdgeLayout(subflow.edges);
+  return {
+    ...subflow,
+    nodes,
+    ...subflow.edges && { edges },
+    layout: { nodes: nodeLayout, ...edgeLayout && { edges: edgeLayout } }
+  };
+}
+function mapValues(record, fn) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      continue;
+    }
+    result[key] = fn(value);
+  }
+  return result;
+}
+var ASSET_BINDING_RESOURCE = "asset";
+var CONNECTION_BINDING_RESOURCE = "connection";
+var ASSETS_PREFIX = "$assets";
+var ASSET_NAME_PATTERN = String.raw`[a-zA-Z_]\w*`;
+var ASSETS_REF_PATTERN = String.raw`(?<!\w)` + ASSETS_PREFIX.replace("$", String.raw`\$`) + String.raw`\.(${ASSET_NAME_PATTERN})(?![\w\x80-\uFFFF])`;
+var CONNECTOR_NODE_PREFIX = "uipath.connector.";
+function buildConnectorNodeType(connectorKey, sanitizedName, surface = "action") {
+  const marker = surface === "trigger" ? "trigger." : surface === "event" ? "event." : "";
+  return `${CONNECTOR_NODE_PREFIX}${marker}${connectorKey}.${sanitizedName}`;
+}
+var CRON_TOKEN = "(?:\\d+[LW]?|[A-Z]{3}|LW|L|W|\\?|\\*)";
+var CRON_FIELD = `${CRON_TOKEN}(?:[,/#-]${CRON_TOKEN})*`;
+var QUARTZ_CRON_RE = new RegExp(`^\\s*${CRON_FIELD}(?:\\s+${CRON_FIELD}){5,6}\\s*$`);
+var RESOURCE_CONFIG = {
+  process: {
+    nameField: "name",
+    displayName: "Process name"
+  },
+  "process.Agent": {
+    nameField: "name",
+    displayName: "Process name",
+    resource: "process",
+    subType: "Agent"
+  },
+  BusinessRule: {
+    nameField: "name",
+    displayName: "Business rule"
+  },
+  queue: {
+    nameField: "queueName",
+    displayName: "Queue"
+  },
+  app: {
+    nameField: "name",
+    displayName: "App name"
+  },
+  ixpDeployment: {
+    nameField: "name",
+    displayName: "IXP model"
+  },
+  [ASSET_BINDING_RESOURCE]: {
+    nameField: "name",
+    displayName: "Orchestrator asset"
+  },
+  Entity: {
+    nameField: "name",
+    displayName: "Entity"
+  }
+};
+var JOB_ATTACHMENT_DEFINITION_KEY = "job-attachment";
+var JOB_ATTACHMENT_REF = `#/definitions/${JOB_ATTACHMENT_DEFINITION_KEY}`;
+var CONVERSATIONAL_AGENT_SETTINGS = {
+  model: "anthropic.claude-sonnet-5",
+  maxTokens: 8192,
+  maxIterations: 8,
+  temperature: 0,
+  engine: "conversational-v1"
+};
+var GEMINI_PERSONAS = ["Aoede", "Charon", "Fenrir", "Kore", "Leda", "Orus", "Puck", "Zephyr"];
+var OPENAI_PERSONAS = ["alloy", "ash", "ballad", "coral", "echo", "sage", "shimmer", "verse"];
+var DEFAULT_CONVERSATIONAL_VOICE_MODEL = "gemini-3.1-flash-live-preview";
+var VOICE_MODELS = [
+  {
+    name: DEFAULT_CONVERSATIONAL_VOICE_MODEL,
+    maxTokens: 65536,
+    isPreview: true,
+    personas: GEMINI_PERSONAS
+  },
+  {
+    name: "gpt-realtime-2",
+    maxTokens: 32000,
+    isPreview: true,
+    personas: OPENAI_PERSONAS
+  }
+];
+var defaultVoiceModel = VOICE_MODELS.find((m) => m.name === DEFAULT_CONVERSATIONAL_VOICE_MODEL);
+if (!defaultVoiceModel) {
+  throw new Error(`Default conversational voice model "${DEFAULT_CONVERSATIONAL_VOICE_MODEL}" is missing from the catalog`);
+}
+var DEFAULT_CONVERSATIONAL_VOICE_MODEL_ENTRY = defaultVoiceModel;
+var VOICE_TURN_DETECTION_SENSITIVITIES = ["low", "high"];
+var VOICE_TURN_DETECTION_LIMITS = {
+  silenceDurationMs: { min: 0, max: 5000 },
+  prefixPaddingMs: { min: 0, max: 5000 }
+};
+var DEFAULT_VOICE_AGENT_SPEAKS_FIRST = true;
+var DEFAULT_CONVERSATIONAL_VOICE_SETTINGS = {
+  model: DEFAULT_CONVERSATIONAL_VOICE_MODEL,
+  maxTokens: DEFAULT_CONVERSATIONAL_VOICE_MODEL_ENTRY.maxTokens,
+  temperature: 0,
+  persona: DEFAULT_CONVERSATIONAL_VOICE_MODEL_ENTRY.personas[0],
+  agentSpeaksFirst: DEFAULT_VOICE_AGENT_SPEAKS_FIRST
+};
+function createRefResolver(readFile) {
+  return async (refPath, baseUri) => {
+    const resolvedPath = resolveRelativePath(baseUri, refPath);
+    const content = await readFile(resolvedPath);
+    return JSON.parse(content);
+  };
+}
+function planWriteThrough(doc, refMap) {
+  if (refMap.size === 0) {
+    return { safeSnapshot: doc, fileWrites: [], finalDocument: doc, inlinedRefs: [], orphanedRefs: [] };
+  }
+  const safeSnapshot = structuredClone(doc);
+  let finalDoc = structuredClone(doc);
+  const allEntries = [...refMap.entries()].map(([pointer, entry]) => {
+    const absolutePath = resolveRelativePath(entry.sourceBaseUri, entry.ref);
+    const currentValue = getAtPointer(finalDoc, pointer);
+    const pathExists = pointerExists(finalDoc, pointer);
+    const isChanged = !deepEqual(currentValue, entry.resolvedValue);
+    return { pointer, entry, absolutePath, currentValue, isChanged, pathExists };
+  });
+  const orphanedRefs = allEntries.filter((e) => !e.pathExists).map((e) => ({ pointer: e.pointer, ref: e.entry.ref }));
+  const entries = allEntries.filter((e) => e.pathExists);
+  entries.sort((a, b) => pointerDepth2(a.pointer) - pointerDepth2(b.pointer));
+  const targetGroups = /* @__PURE__ */ new Map;
+  for (const e of entries) {
+    const group = targetGroups.get(e.absolutePath) ?? [];
+    group.push(e);
+    targetGroups.set(e.absolutePath, group);
+  }
+  const fileWrites = [];
+  const inlinedRefs = [];
+  const restoredPrefixes = [];
+  for (const [, rawGroup] of targetGroups) {
+    const group = rawGroup.filter((e2) => !restoredPrefixes.some((p) => isNestedUnder(e2.pointer, p)));
+    if (group.length === 0)
+      continue;
+    const isSharedTarget = group.length > 1;
+    const changedEntries = group.filter((e2) => e2.isChanged);
+    const unchangedEntries = group.filter((e2) => !e2.isChanged);
+    if (changedEntries.length === 0) {
+      for (const e2 of group) {
+        finalDoc = setRef(finalDoc, e2.pointer, e2.entry.ref);
+        restoredPrefixes.push(e2.pointer);
+      }
+      continue;
+    }
+    if (isSharedTarget) {
+      const allChangedMatch = changedEntries.every((e2) => deepEqual(e2.currentValue, changedEntries[0].currentValue));
+      if (allChangedMatch) {
+        fileWrites.push({ refPath: changedEntries[0].entry.ref, content: changedEntries[0].currentValue });
+        for (const e2 of group) {
+          finalDoc = setRef(finalDoc, e2.pointer, e2.entry.ref);
+          restoredPrefixes.push(e2.pointer);
+        }
+      } else {
+        for (const e2 of changedEntries) {
+          inlinedRefs.push(e2.pointer);
+        }
+        for (const e2 of unchangedEntries) {
+          finalDoc = setRef(finalDoc, e2.pointer, e2.entry.ref);
+          restoredPrefixes.push(e2.pointer);
+        }
+      }
+      continue;
+    }
+    const e = changedEntries[0];
+    fileWrites.push({ refPath: e.entry.ref, content: e.currentValue });
+    finalDoc = setRef(finalDoc, e.pointer, e.entry.ref);
+    restoredPrefixes.push(e.pointer);
+  }
+  return { safeSnapshot, fileWrites, finalDocument: finalDoc, inlinedRefs, orphanedRefs };
+}
+function setRef(doc, pointer, ref) {
+  if (pointer === "")
+    return { $ref: ref };
+  setAtPointer(doc, pointer, { $ref: ref });
+  return doc;
+}
+function pointerDepth2(pointer) {
+  if (pointer === "")
+    return 0;
+  return pointer.split("/").length - 1;
+}
+function isNestedUnder(child, parent) {
+  if (parent === "")
+    return child !== "";
+  return child.startsWith(parent + "/");
+}
+function getAtPointer(doc, pointer) {
+  if (pointer === "")
+    return doc;
+  try {
+    return applyJsonPointer(doc, pointer);
+  } catch {
+    return;
+  }
+}
+function pointerExists(doc, pointer) {
+  return getAtPointer(doc, pointer) !== undefined || pointer === "";
+}
+function setAtPointer(doc, pointer, value) {
+  const tokens = parsePointerTokens(pointer);
+  if (tokens.length === 0)
+    return;
+  const parentTokens = tokens.slice(0, -1);
+  const parent = parentTokens.length === 0 ? doc : getAtPointer(doc, "/" + parentTokens.map((t13) => t13.replace(/~/g, "~0").replace(/\//g, "~1")).join("/"));
+  if (parent === null || parent === undefined || typeof parent !== "object")
+    return;
+  const key = tokens[tokens.length - 1];
+  if (Array.isArray(parent)) {
+    const index = Number(key);
+    if (Number.isInteger(index) && index >= 0 && index < parent.length) {
+      parent[index] = value;
+    }
+  } else {
+    parent[key] = value;
+  }
+}
+async function executeWritePlan(plan, callbacks) {
+  const { writeMainFile, writeRefFile } = callbacks;
+  if (plan.fileWrites.length === 0) {
+    await writeMainFile(JSON.stringify(plan.finalDocument, null, 2));
+    return {
+      chunkFilesWritten: 0,
+      orphanedRefs: plan.orphanedRefs,
+      inlinedRefs: plan.inlinedRefs
+    };
+  }
+  await writeMainFile(JSON.stringify(plan.safeSnapshot, null, 2));
+  await Promise.all(plan.fileWrites.map((fileWrite) => writeRefFile(fileWrite.refPath, JSON.stringify(fileWrite.content, null, 2))));
+  await writeMainFile(JSON.stringify(plan.finalDocument, null, 2));
+  return {
+    chunkFilesWritten: plan.fileWrites.length,
+    orphanedRefs: plan.orphanedRefs,
+    inlinedRefs: plan.inlinedRefs
+  };
+}
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-LCWGFOYN.js
+var ARRAY_WILDCARD_RE = /\[\*\]/g;
+function stripWildcard(name) {
+  return name.replace(ARRAY_WILDCARD_RE, "");
+}
+function hasWildcardKey(record) {
+  return record ? Object.keys(record).some((key) => key.includes("[*]")) : false;
+}
+function hasWildcard(schema) {
+  return hasWildcardKey(schema.properties) || hasWildcardKey(schema.definitions) || hasWildcardKey(schema.$defs);
+}
+function rewriteKeyedSchemas(record) {
+  const result = {};
+  for (const [key, value] of Object.entries(record)) {
+    result[stripWildcard(key)] = sanitizeNode(value);
+  }
+  return result;
+}
+function sanitizeNode(node) {
+  const result = { ...node };
+  if (typeof result.$ref === "string" && result.$ref.includes("[*]")) {
+    result.$ref = stripWildcard(result.$ref);
+  }
+  if (node.properties) {
+    result.properties = rewriteKeyedSchemas(node.properties);
+  }
+  if (node.items && !Array.isArray(node.items)) {
+    result.items = sanitizeNode(node.items);
+  }
+  for (const combinator of ["oneOf", "anyOf", "allOf"]) {
+    if (node[combinator]) {
+      result[combinator] = node[combinator].map(sanitizeNode);
+    }
+  }
+  return result;
+}
+function sanitizeConnectorSchema(schema) {
+  if (!schema || !hasWildcard(schema))
+    return schema;
+  const result = sanitizeNode(schema);
+  if (schema.definitions)
+    result.definitions = rewriteKeyedSchemas(schema.definitions);
+  if (schema.$defs)
+    result.$defs = rewriteKeyedSchemas(schema.$defs);
+  return result;
+}
+var JSON_STRING_PREFIX = "=jsonString:";
+var JIT_OBJECT_INPUT_MODE = "jitObject";
+function flattenSplitConfiguration(config) {
+  if ("essentialConfiguration" in config || "optionalConfiguration" in config) {
+    return {
+      ...config.optionalConfiguration,
+      ...config.essentialConfiguration
+    };
+  }
+  return config;
+}
+function normalizeTransientProperties(config) {
+  const result = { ...config };
+  const fc = result.fieldsContainer;
+  const inputMode = result.savedInputMode ?? fc?.inputMode;
+  const jitFieldName = result.savedJitInputFieldId ?? fc?.jitInputField?.name;
+  if (inputMode === JIT_OBJECT_INPUT_MODE || jitFieldName === "body") {
+    result.isJitObjectInputMode = true;
+  }
+  return result;
+}
+function parseConfigurationJson(configuration) {
+  if (!configuration)
+    return null;
+  try {
+    if (typeof configuration === "object") {
+      return normalizeTransientProperties(flattenSplitConfiguration(configuration));
+    }
+    let str = configuration;
+    if (str.startsWith(JSON_STRING_PREFIX))
+      str = str.substring(JSON_STRING_PREFIX.length);
+    const parsed = JSON.parse(str);
+    return typeof parsed === "object" && parsed !== null ? normalizeTransientProperties(flattenSplitConfiguration(parsed)) : null;
+  } catch {
+    return null;
+  }
+}
+function resolveJsonSchema(schema, options = {}) {
+  const { maxDepth = 25 } = options;
+  const definitions = schema.definitions || schema.$defs || {};
+  function resolveRef(ref) {
+    const match = ref.match(/^#\/(?:definitions|\$defs)\/(.+)$/);
+    if (!match)
+      return {};
+    return definitions[match[1]] || {};
+  }
+  function resolve(node, visited, depth) {
+    if (depth > maxDepth)
+      return node;
+    if (node.$ref) {
+      if (visited.has(node.$ref))
+        return { type: "any" };
+      visited.add(node.$ref);
+      return resolve(resolveRef(node.$ref), visited, depth + 1);
+    }
+    const result = { ...node };
+    if (node.properties) {
+      result.properties = {};
+      for (const [key, prop] of Object.entries(node.properties)) {
+        result.properties[key] = resolve(prop, new Set(visited), depth + 1);
+      }
+    }
+    if (node.items && !Array.isArray(node.items)) {
+      result.items = resolve(node.items, new Set(visited), depth + 1);
+    }
+    for (const combinator of ["oneOf", "anyOf", "allOf"]) {
+      if (node[combinator]) {
+        result[combinator] = node[combinator].map((s) => resolve(s, new Set(visited), depth + 1));
+      }
+    }
+    return result;
+  }
+  const isArray = schema.type === "array";
+  let rootSchema = schema;
+  if (isArray && schema.items && !Array.isArray(schema.items)) {
+    rootSchema = schema.items;
+  }
+  return {
+    schema: resolve(rootSchema, /* @__PURE__ */ new Set, 0),
+    isArray
+  };
+}
+function resolveLocalRef(root, node) {
+  if (!node || typeof node.$ref !== "string")
+    return node;
+  const match = node.$ref.match(/^#\/(definitions|\$defs)\/(.+)$/);
+  if (!match)
+    return node;
+  const bucket = root[match[1]];
+  return bucket?.[match[2]] ?? node;
+}
+function resolveConnectorOutputSchema(rawOutputJsonSchema, fieldsContainer) {
+  if (!rawOutputJsonSchema || typeof rawOutputJsonSchema !== "object")
+    return;
+  const schema = sanitizeConnectorSchema(rawOutputJsonSchema);
+  if (!schema.type && !schema.properties && !schema.$ref && !schema.definitions && !schema.$defs)
+    return;
+  const jsonSchemaType = typeof schema.type === "string" ? schema.type : "object";
+  const formatFields = fieldsContainer ? collectResponseFieldFormats(fieldsContainer) : [];
+  if (formatFields.length > 0) {
+    const stamped = structuredClone(schema);
+    for (const field of formatFields) {
+      const target = findSchemaNodeByFieldPath(stamped, field.name.split("."));
+      if (target)
+        applyStringFormat(target, field.format);
+    }
+    return { jsonSchemaType, schema: stamped };
+  }
+  return { jsonSchemaType, schema };
+}
+function resolveConnectorOutputTypeSchema(inputsDetail) {
+  if (!inputsDetail || typeof inputsDetail !== "object")
+    return;
+  const configuration = parseConfigurationJson(inputsDetail.configuration);
+  const fieldsContainer = configuration?.fieldsContainer;
+  return resolveConnectorOutputSchema(fieldsContainer?.outputJsonSchema, fieldsContainer);
+}
+function collectResponseFieldFormats(fieldsContainer) {
+  const raw = [
+    ...Array.isArray(fieldsContainer.inputFields) ? fieldsContainer.inputFields : [],
+    ...Array.isArray(fieldsContainer.outputFields) ? fieldsContainer.outputFields : []
+  ];
+  const fields = [];
+  for (const field of raw) {
+    if (typeof field?.name !== "string" || !field.name)
+      continue;
+    if (typeof field.format !== "string" || !field.format)
+      continue;
+    if (field.response !== true)
+      continue;
+    fields.push({ name: field.name, format: field.format });
+  }
+  return fields;
+}
+function applyStringFormat(node, format) {
+  if (node.format)
+    return;
+  if (node.type === "string" || Array.isArray(node.type) && node.type.includes("string")) {
+    node.format = format;
+  } else if (node.type === "array" && node.items && !Array.isArray(node.items)) {
+    applyStringFormat(node.items, format);
+  }
+}
+function findSchemaNodeByFieldPath(root, segments) {
+  let node = root;
+  for (const segment of segments) {
+    node = resolveLocalRef(root, node);
+    const properties = node?.properties;
+    node = properties?.[segment];
+    if (!node)
+      return;
+  }
+  return resolveLocalRef(root, node);
+}
+function resolveNodeOutputTypeSchema(nodeType, inputsDetail, outputKey) {
+  if (outputKey !== "output")
+    return;
+  if (nodeType.startsWith(CONNECTOR_NODE_PREFIX)) {
+    return resolveConnectorOutputTypeSchema(inputsDetail);
+  }
+  return;
+}
+function createWorkflowVariable(options) {
+  return {
+    id: options.id,
+    direction: options.direction,
+    type: options.type ?? "string",
+    ...options.subType && { subType: options.subType },
+    ...options.schema && { schema: options.schema },
+    ...options.defaultValue !== undefined && { defaultValue: options.defaultValue },
+    ...options.description && { description: options.description }
+  };
+}
+function createNodeVariable(options) {
+  return {
+    id: `${options.nodeId}.${options.outputId}`,
+    type: options.type ?? "string",
+    ...options.subType && { subType: options.subType },
+    ...options.description && { description: options.description },
+    ...options.schema && { schema: options.schema },
+    binding: {
+      nodeId: options.nodeId,
+      outputId: options.outputId
+    }
+  };
+}
+function generateNodeVariables(nodes, definitions) {
+  const generatedVariables = [];
+  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.outputs ?? {};
+    const outputs = Object.keys(nodeOutputs).length > 0 ? nodeOutputs : definitionOutputs.get(node.type) ?? {};
+    for (const [outputKey, outputDef] of Object.entries(outputs)) {
+      if (outputDef && typeof outputDef === "object") {
+        const def = outputDef;
+        const resolved = resolveNodeOutputTypeSchema(node.type, node.inputs?.detail, outputKey);
+        generatedVariables.push(createNodeVariable({
+          nodeId: node.id,
+          outputId: outputKey,
+          type: resolved?.jsonSchemaType ?? def.type,
+          subType: def.subType,
+          description: def.description,
+          schema: def.schema
+        }));
+      }
+    }
+  }
+  return generatedVariables;
+}
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-N57HRLCW.js
+var globImport_locales_json2 = __glob2({
+  "../../locales/de.json": () => import("./de-FGHEJRCI-rv513mfh.js"),
+  "../../locales/en.json": () => import("./en-BWGKA5OE-1qkvb9rn.js"),
+  "../../locales/es-MX.json": () => import("./es-MX-XXZJGC4R-2mr8jtgm.js"),
+  "../../locales/es.json": () => import("./es-KR3ZSNMP-84zphx0x.js"),
+  "../../locales/fr.json": () => import("./fr-Y6NPVODW-8vr1ja4b.js"),
+  "../../locales/ja.json": () => import("./ja-Q5PXKJ2V-p4msxzjd.js"),
+  "../../locales/ko.json": () => import("./ko-AYBDSRZG-41mdmsg1.js"),
+  "../../locales/pt-BR.json": () => import("./pt-BR-TKHNHMET-sn91xyq0.js"),
+  "../../locales/pt.json": () => import("./pt-ROXU257Y-2f6bxev4.js"),
+  "../../locales/ro.json": () => import("./ro-AVAWPKOO-b89pw79r.js"),
+  "../../locales/ru.json": () => import("./ru-GSCT4ARZ-1sa9wbr8.js"),
+  "../../locales/tr.json": () => import("./tr-JMIP7ZSL-c39b6pe4.js"),
+  "../../locales/zh-CN.json": () => import("./zh-CN-IFFXSEJS-9wm9gmrv.js"),
+  "../../locales/zh-TW.json": () => import("./zh-TW-IYBNYAMG-8727c7v2.js")
+});
+var MANIFEST_NAMESPACE = "manifest";
+var registerFlowCoreI18n = createI18nRegistrar({
+  namespace: MANIFEST_NAMESPACE,
+  englishBundle: en_default2,
+  loadCatalog: (lng) => globImport_locales_json2(`../../locales/${lng}.json`)
+});
+
+export { isExpressionValue, coerceToExpressionValue, coerceInputsViaSchema, RESERVED_WORDS, VALID_IDENTIFIER_PATTERN, generateRandomId, generateNextId, isTriggerNodeType, isEndNodeType, DOWHILE_NODE_TYPE, CONVERSATIONAL_AGENT_ICON, CONVERSATIONAL_VOICE_END_CALL_NODE_TYPE, ESCALATION_QUICK_FORM_NODE_TYPE, getDefaultAgentContent, HITL_NODE_TYPE, HITL_QUICK_FORM_NODE_TYPE, HITL_CODED_ACTION_NODE_TYPE, HITL_DOC_VALIDATION_NODE_TYPE, DYNAMIC_EXTRACT_NODE_TYPE, isHitlNodeType, argumentBindingSchema, workflowVariableSchema, variableUpdateSchema, nodeVariableSchema, workflowVariablesSchema, EMPTY_VARIABLES, workflowConnectionSchema, nodeDisplayManifestSchema, nodeManifestSchema, idSchema, edgeSchema2, nodeSchema2, nodeManifestSchema2, versionSchema2, subflowEntrySchema, workflowSchema, MINIMUM_SUPPORTED_SCHEMA_VERSION, workflowFileSchema, workflowManifestSchema, constraintWithAddNodePanel, fileFormatToInMemoryWorkflow, resolveAndConvertWorkflow, inMemoryWorkflowToFileFormat, CONNECTION_BINDING_RESOURCE, CONNECTOR_NODE_PREFIX, buildConnectorNodeType, CONVERSATIONAL_AGENT_SETTINGS, VOICE_TURN_DETECTION_SENSITIVITIES, VOICE_TURN_DETECTION_LIMITS, DEFAULT_VOICE_AGENT_SPEAKS_FIRST, DEFAULT_CONVERSATIONAL_VOICE_SETTINGS, createRefResolver, planWriteThrough, executeWritePlan, resolveJsonSchema, createWorkflowVariable, createNodeVariable, generateNodeVariables, MANIFEST_NAMESPACE, registerFlowCoreI18n };
+
+//# debugId=292D5916D007997264756E2164756E21