@xxrandr/conecta-diagram 0.0.0-stage → 0.1.4

package/dist/chunk-3QGSCPWL.cjs

@@ -0,0 +1,663 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/types.ts
+var FlowError = class extends Error {
+  constructor(code, message, diagnostics = []) {
+    super(message);
+    this.code = code;
+    this.diagnostics = diagnostics;
+    this.name = "FlowError";
+  }
+  
+  
+};
+function createFlow(id) {
+  return { schemaVersion: 1, id, nodes: [], edges: [] };
+}
+
+// src/core/actions.ts
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var strings = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var isCodePreview = (value) => object(value) && typeof value.language === "string" && typeof value.source === "string";
+function isTaskAction(value) {
+  if (!object(value) || typeof value.type !== "string" || !value.type.trim() || !object(value.body))
+    return false;
+  if (value.version !== void 0 && (!Number.isSafeInteger(value.version) || value.version < 0))
+    return false;
+  if ([value.streaming, value.expectsResult].some(
+    (item) => item !== void 0 && typeof item !== "boolean"
+  ))
+    return false;
+  const body = value.body;
+  const fields = {
+    api: ["method", "url"],
+    database: ["databaseType", "datasource", "operation", "statement"],
+    file: ["operation", "path"],
+    process: ["profile"],
+    ssh: ["connectionId", "command"],
+    sftp: ["connectionId", "operation", "remotePath"],
+    mail: ["connectionId", "operation"],
+    messaging: ["connectionId", "operation", "topic"],
+    event: ["operation", "topic"],
+    cancel: ["targetCommandId"],
+    generic: ["name"]
+  };
+  if (typeof body.kind !== "string" || !Object.hasOwn(fields, body.kind) || !fields[body.kind].every((key) => typeof body[key] === "string"))
+    return false;
+  const family = value.type.split(".")[0];
+  const expected = family === "command" ? value.type === "command.cancel" ? "cancel" : "generic" : [
+    "api",
+    "database",
+    "file",
+    "process",
+    "ssh",
+    "sftp",
+    "mail",
+    "messaging",
+    "event"
+  ].includes(family) ? family : "generic";
+  if (body.kind !== expected) return false;
+  if (body.code !== void 0 && !isCodePreview(body.code)) return false;
+  if (body.arguments !== void 0 && !strings(body.arguments)) return false;
+  if (body.to !== void 0 && !strings(body.to)) return false;
+  if (body.resumable !== void 0 && typeof body.resumable !== "boolean")
+    return false;
+  return [
+    "connectionId",
+    "bodyPreview",
+    "destination",
+    "transferId",
+    "localPath",
+    "subject",
+    "path",
+    "reason",
+    "preview"
+  ].every((key) => body[key] === void 0 || typeof body[key] === "string");
+}
+function capabilityState(type, advertised) {
+  if (advertised)
+    return advertised.includes(type) ? "available" : "unsupported";
+  return ["database.transaction", "database.metadata"].includes(type) ? "unsupported" : "unverified";
+}
+function displayUrl(value) {
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    url.hash = "";
+    for (const key of [...url.searchParams.keys()])
+      url.searchParams.set(key, "[redacted]");
+    return url.toString();
+  } catch (e) {
+    return value.replace(/([?&][^=&#]+)=([^&#]*)/g, "$1=[redacted]").split("#")[0];
+  }
+}
+function actionPresentation(action) {
+  const body = action.body;
+  switch (body.kind) {
+    case "api":
+      return {
+        title: `HTTP \xB7 ${body.method}`,
+        lines: [
+          displayUrl(body.url),
+          body.connectionId ? `Connection: ${body.connectionId}` : "Logical API target",
+          _nullishCoalesce(body.bodyPreview, () => ( ""))
+        ]
+      };
+    case "database":
+      return {
+        title: `${body.databaseType} \xB7 ${body.operation}`,
+        lines: [
+          `Datasource: ${body.datasource}`,
+          ...body.statement.split(/\r?\n/)
+        ],
+        code: { language: "sql", source: body.statement }
+      };
+    case "file":
+      return {
+        title: `File \xB7 ${body.operation}`,
+        lines: [
+          body.path,
+          body.destination ? `\u2192 ${body.destination}` : body.transferId ? `Transfer: ${body.transferId}` : "",
+          body.resumable ? "Resumable transfer" : ""
+        ]
+      };
+    case "process":
+      return {
+        title: body.code ? `${body.code.language} \xB7 process` : "Process",
+        lines: [
+          `Profile: ${body.profile}`,
+          ..._nullishCoalesce(_optionalChain([body, 'access', _ => _.code, 'optionalAccess', _2 => _2.source, 'access', _3 => _3.split, 'call', _4 => _4(/\r?\n/)]), () => ( [
+            _nullishCoalesce(_optionalChain([body, 'access', _5 => _5.arguments, 'optionalAccess', _6 => _6.join, 'call', _7 => _7(" ")]), () => ( ""))
+          ]))
+        ],
+        ...body.code ? { code: body.code } : {}
+      };
+    case "ssh":
+      return {
+        title: "SSH \xB7 exec",
+        lines: [`Connection: ${body.connectionId}`, body.command],
+        code: { language: "shell", source: body.command }
+      };
+    case "sftp":
+      return {
+        title: `SFTP \xB7 ${body.operation}`,
+        lines: [
+          `Connection: ${body.connectionId}`,
+          body.remotePath,
+          _nullishCoalesce(_nullishCoalesce(body.localPath, () => ( body.destination)), () => ( ""))
+        ]
+      };
+    case "mail":
+      return {
+        title: `Mail \xB7 ${body.operation}`,
+        lines: [
+          _nullishCoalesce(body.subject, () => ( "")),
+          _nullishCoalesce(_optionalChain([body, 'access', _8 => _8.to, 'optionalAccess', _9 => _9.join, 'call', _10 => _10(", ")]), () => ( "")),
+          `Connection: ${body.connectionId}`
+        ]
+      };
+    case "messaging":
+      return {
+        title: `Messaging \xB7 ${body.operation}`,
+        lines: [body.topic, `Connection: ${body.connectionId}`]
+      };
+    case "event":
+      return {
+        title: `Event \xB7 ${body.operation}`,
+        lines: [body.topic, _nullishCoalesce(body.path, () => ( ""))]
+      };
+    case "cancel":
+      return {
+        title: "Command \xB7 cancel",
+        lines: [`Target: ${body.targetCommandId}`, _nullishCoalesce(body.reason, () => ( ""))]
+      };
+    case "generic":
+      return { title: "Extension", lines: [body.name, _nullishCoalesce(body.preview, () => ( ""))] };
+  }
+}
+function formatCondition(condition2) {
+  if (condition2.op === "all" || condition2.op === "any")
+    return `(${condition2.conditions.map(formatCondition).join(condition2.op === "all" ? " AND " : " OR ")})`;
+  if (condition2.op === "not")
+    return `NOT ${formatCondition(condition2.condition)}`;
+  if (!("path" in condition2)) return "";
+  const path = condition2.path.join(".") || "$context";
+  if (condition2.op === "exists") return `exists(${path})`;
+  const operators = {
+    eq: "==",
+    neq: "!=",
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<=",
+    in: "IN"
+  };
+  return `${path} ${operators[condition2.op]} ${JSON.stringify(condition2.value)}`;
+}
+
+// src/core/json.ts
+function assertJson(value, ancestors = /* @__PURE__ */ new Set(), depth = 0) {
+  if (depth > 128)
+    throw new FlowError("INVALID_JSON", "JSON nesting exceeds 128 levels.");
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return;
+  if (typeof value === "number" && Number.isFinite(value)) return;
+  if (typeof value !== "object")
+    throw new FlowError(
+      "INVALID_JSON",
+      "Expected finite, serializable JSON data."
+    );
+  if (ancestors.has(value))
+    throw new FlowError("INVALID_JSON", "Circular data is not supported.");
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+    throw new FlowError(
+      "INVALID_JSON",
+      "Only plain JSON objects are supported."
+    );
+  }
+  if (Object.getOwnPropertySymbols(value).length)
+    throw new FlowError("INVALID_JSON", "Symbol properties are not supported.");
+  ancestors.add(value);
+  for (const [key, descriptor] of Object.entries(
+    Object.getOwnPropertyDescriptors(value)
+  )) {
+    if (!descriptor.enumerable && !(Array.isArray(value) && key === "length"))
+      throw new FlowError(
+        "INVALID_JSON",
+        "Non-enumerable properties are not supported."
+      );
+    if (!("value" in descriptor))
+      throw new FlowError("INVALID_JSON", "Accessors are not supported.");
+    assertJson(descriptor.value, ancestors, depth + 1);
+  }
+  if (Array.isArray(value) && Object.keys(value).length !== value.length) {
+    throw new FlowError(
+      "INVALID_JSON",
+      "Sparse or extended arrays are not supported."
+    );
+  }
+  ancestors.delete(value);
+}
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function freeze(value) {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value)) freeze(child);
+  }
+  return value;
+}
+function equal(a, b) {
+  if (a === b) return true;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every(
+    (key) => Object.hasOwn(b, key) && equal(
+      a[key],
+      b[key]
+    )
+  );
+}
+
+// src/core/validation.ts
+var record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var text = (value) => typeof value === "string" && value.trim().length > 0;
+var finite = (value) => typeof value === "number" && Number.isFinite(value);
+function condition(value) {
+  if (!record(value)) return false;
+  if (value.op === "all" || value.op === "any")
+    return Array.isArray(value.conditions) && value.conditions.every(condition);
+  if (value.op === "not") return condition(value.condition);
+  if (!Array.isArray(value.path) || !value.path.every((key) => typeof key === "string"))
+    return false;
+  if (value.op === "exists") return true;
+  if (!["eq", "neq", "gt", "gte", "lt", "lte", "in"].includes(String(value.op)) || !Object.hasOwn(value, "value"))
+    return false;
+  if (value.op === "in") return Array.isArray(value.value);
+  if (["gt", "gte", "lt", "lte"].includes(String(value.op)))
+    return finite(value.value);
+  return true;
+}
+function validateFlow(value, options = {}) {
+  const issues = [];
+  const add = (code, message, path, severity = "error") => issues.push({ code, message, path, severity });
+  try {
+    assertJson(value);
+  } catch (error) {
+    add(
+      "INVALID_JSON",
+      error instanceof Error ? error.message : "Invalid JSON.",
+      ""
+    );
+    return issues;
+  }
+  if (!record(value) || value.schemaVersion !== 1 || !text(value.id) || !Array.isArray(value.nodes) || !Array.isArray(value.edges)) {
+    add(
+      "INVALID_DOCUMENT",
+      "Expected schemaVersion 1, a nonempty id, nodes and edges arrays.",
+      ""
+    );
+    return issues;
+  }
+  if (value.data !== void 0 && !record(value.data))
+    add("INVALID_DATA", "data must be an object.", "data");
+  if (value.globals !== void 0) {
+    if (!Array.isArray(value.globals))
+      add("INVALID_GLOBAL", "globals must be an array.", "globals");
+    else {
+      const ids = /* @__PURE__ */ new Set(), names = /* @__PURE__ */ new Set();
+      for (const [index, variable] of value.globals.entries()) {
+        const path = `globals[${index}]`;
+        if (!record(variable) || !text(variable.id) || !text(variable.name) || !["array", "boolean", "integer", "json"].includes(
+          String(variable.type)
+        ) || !Object.hasOwn(variable, "value")) {
+          add(
+            "INVALID_GLOBAL",
+            "Expected a global id, name, explicit type and JSON value.",
+            path
+          );
+          continue;
+        }
+        if (variable.type === "array" && !Array.isArray(variable.value) || variable.type === "boolean" && typeof variable.value !== "boolean" || variable.type === "integer" && !Number.isSafeInteger(variable.value))
+          add(
+            "GLOBAL_TYPE_MISMATCH",
+            "Global value does not match its type badge.",
+            path
+          );
+        if (ids.has(variable.id) || names.has(variable.name))
+          add("DUPLICATE_GLOBAL", "Global ids and names must be unique.", path);
+        ids.add(variable.id);
+        names.add(variable.name);
+      }
+    }
+  }
+  for (const [index, node] of value.nodes.entries()) {
+    const path = `nodes[${index}]`;
+    if (!record(node) || !text(node.id) || typeof node.label !== "string" || !["start", "end", "task", "wait", "decision", "fork", "join"].includes(
+      String(node.type)
+    ) || !record(node.position) || !finite(node.position.x) || !finite(node.position.y)) {
+      add(
+        "INVALID_NODE",
+        "Expected node id, type, label and finite position.",
+        path
+      );
+      continue;
+    }
+    if (node.type === "task" && (node.mode !== void 0 && !["sync", "async"].includes(String(node.mode)) || node.handler !== void 0 && !text(node.handler)))
+      add("INVALID_TASK", "Invalid task mode or handler.", path);
+    if (node.type === "wait" && !text(node.signal))
+      add("INVALID_WAIT", "Wait nodes require a signal name.", path);
+    if (node.action !== void 0 && (!["task", "decision"].includes(String(node.type)) || !isTaskAction(node.action)))
+      add(
+        "INVALID_ACTION",
+        "Expected a display-only action with a matching command family and valid preview fields.",
+        `${path}.action`
+      );
+    if (node.decision !== void 0 && (node.type !== "decision" || !record(node.decision) || node.decision.description !== void 0 && typeof node.decision.description !== "string" || node.decision.expression !== void 0 && !isCodePreview(node.decision.expression)))
+      add(
+        "INVALID_DECISION_DISPLAY",
+        "Invalid decision display description or expression preview.",
+        `${path}.decision`
+      );
+    if (node.signals !== void 0 && (!record(node.signals) || ![node.signals.inputs, node.signals.outputs].every(
+      (items) => Array.isArray(items) && items.every(text)
+    )))
+      add(
+        "INVALID_SIGNALS",
+        "Signal inputs/outputs must be arrays of nonempty names.",
+        `${path}.signals`
+      );
+    if (node.type === "fork" && !text(node.join))
+      add("INVALID_FORK", "Fork nodes require a paired join id.", path);
+    if (node.type === "join" && !text(node.fork))
+      add("INVALID_JOIN", "Join nodes require a paired fork id.", path);
+    if (node.data !== void 0 && !record(node.data))
+      add("INVALID_DATA", "data must be an object.", `${path}.data`);
+    if (node.visibleWhen !== void 0 && !condition(node.visibleWhen))
+      add(
+        "INVALID_CONDITION",
+        "Invalid visibility condition.",
+        `${path}.visibleWhen`
+      );
+  }
+  for (const [index, edge] of value.edges.entries()) {
+    const path = `edges[${index}]`;
+    if (!record(edge) || !text(edge.id) || !text(edge.source) || !text(edge.target)) {
+      add("INVALID_EDGE", "Expected edge id, source and target.", path);
+      continue;
+    }
+    if (edge.label !== void 0 && typeof edge.label !== "string")
+      add("INVALID_EDGE", "Edge label must be text.", path);
+    if (edge.condition !== void 0 && !condition(edge.condition))
+      add(
+        "INVALID_CONDITION",
+        "Invalid routing condition.",
+        `${path}.condition`
+      );
+    if (edge.visibleWhen !== void 0 && !condition(edge.visibleWhen))
+      add(
+        "INVALID_CONDITION",
+        "Invalid visibility condition.",
+        `${path}.visibleWhen`
+      );
+    if (edge.default !== void 0 && typeof edge.default !== "boolean")
+      add("INVALID_EDGE", "default must be boolean.", path);
+    if (edge.priority !== void 0 && !Number.isSafeInteger(edge.priority))
+      add("INVALID_EDGE", "priority must be a safe integer.", path);
+    if (edge.data !== void 0 && !record(edge.data))
+      add("INVALID_DATA", "data must be an object.", `${path}.data`);
+  }
+  if (issues.length) return issues;
+  const document = value;
+  const nodes = new Map(document.nodes.map((node) => [node.id, node]));
+  const edgeIds = /* @__PURE__ */ new Set();
+  if (nodes.size !== document.nodes.length)
+    add("DUPLICATE_NODE", "Node ids must be unique.", "nodes");
+  for (const edge of document.edges) {
+    if (edgeIds.has(edge.id))
+      add("DUPLICATE_EDGE", `Duplicate edge ${edge.id}.`, "edges");
+    edgeIds.add(edge.id);
+    if (!nodes.has(edge.source) || !nodes.has(edge.target))
+      add(
+        "DANGLING_EDGE",
+        `Edge ${edge.id} references a missing node.`,
+        "edges"
+      );
+  }
+  if (document.creationOrder !== void 0) {
+    const seen = /* @__PURE__ */ new Set();
+    if (!Array.isArray(document.creationOrder))
+      add(
+        "INVALID_CREATION_ORDER",
+        "creationOrder must be an array.",
+        "creationOrder"
+      );
+    else {
+      for (const reference of document.creationOrder) {
+        if (!record(reference) || !["node", "edge"].includes(String(reference.type)) || !text(reference.id) || !(reference.type === "node" ? nodes.has(reference.id) : edgeIds.has(reference.id))) {
+          add(
+            "INVALID_CREATION_ORDER",
+            "Creation order references an unknown item.",
+            "creationOrder"
+          );
+          continue;
+        }
+        const key = JSON.stringify([reference.type, reference.id]);
+        if (seen.has(key))
+          add(
+            "INVALID_CREATION_ORDER",
+            "Creation order contains duplicates.",
+            "creationOrder"
+          );
+        seen.add(key);
+      }
+      if (seen.size !== document.nodes.length + document.edges.length)
+        add(
+          "INVALID_CREATION_ORDER",
+          "Creation order must include every node and edge exactly once.",
+          "creationOrder"
+        );
+    }
+  }
+  if (issues.length || options.mode === "draft") return issues;
+  const incoming = new Map(
+    document.nodes.map((node) => [
+      node.id,
+      document.edges.filter((edge) => edge.target === node.id)
+    ])
+  );
+  const outgoing = new Map(
+    document.nodes.map((node) => [
+      node.id,
+      document.edges.filter((edge) => edge.source === node.id)
+    ])
+  );
+  const starts = document.nodes.filter((node) => node.type === "start");
+  if (starts.length !== 1)
+    add(
+      "START_COUNT",
+      "An executable flow requires exactly one start node.",
+      "nodes"
+    );
+  if (!document.nodes.some((node) => node.type === "end"))
+    add("END_REQUIRED", "An executable flow requires an end node.", "nodes");
+  for (const [index, node] of document.nodes.entries()) {
+    const path = `nodes[${index}]`;
+    const inputs = incoming.get(node.id);
+    const outputs = outgoing.get(node.id);
+    if (node.type === "start" && inputs.length)
+      add("START_INPUT", "Start nodes cannot have incoming edges.", path);
+    if (node.type === "end" && outputs.length)
+      add("END_OUTPUT", "End nodes cannot have outgoing edges.", path);
+    if (!["end", "fork", "decision"].includes(node.type) && outputs.length !== 1) {
+      add(
+        "OUTPUT_COUNT",
+        "This node requires exactly one outgoing edge; use a fork for parallel work.",
+        path
+      );
+    }
+    if (node.type === "decision") {
+      if (outputs.length < 2)
+        add(
+          "DECISION_OUTPUTS",
+          "Decisions require at least two branches.",
+          path
+        );
+      if (outputs.filter((edge) => edge.default).length !== 1)
+        add(
+          "DECISION_DEFAULT",
+          "Decisions require exactly one fallback branch.",
+          path
+        );
+      if (outputs.some(
+        (edge) => edge.default ? edge.condition !== void 0 : !edge.condition
+      )) {
+        add(
+          "DECISION_CONDITION",
+          "Each non-default branch needs a condition; the fallback cannot have one.",
+          path
+        );
+      }
+    } else if (outputs.some(
+      (edge) => edge.condition !== void 0 || edge.default !== void 0 || edge.priority !== void 0
+    )) {
+      add(
+        "UNEXPECTED_ROUTING",
+        "Conditions, defaults and priorities are only allowed on decision outputs.",
+        path
+      );
+    }
+    if (node.type === "fork") {
+      const join = nodes.get(node.join);
+      if (outputs.length < 2)
+        add("FORK_OUTPUTS", "Forks require at least two branches.", path);
+      if (_optionalChain([join, 'optionalAccess', _11 => _11.type]) !== "join" || join.fork !== node.id)
+        add("FORK_PAIR", "Fork/join references must be reciprocal.", path);
+    }
+    if (node.type === "join") {
+      const fork = nodes.get(node.fork);
+      if (_optionalChain([fork, 'optionalAccess', _12 => _12.type]) !== "fork" || fork.join !== node.id)
+        add("JOIN_PAIR", "Fork/join references must be reciprocal.", path);
+    }
+  }
+  if (starts.length === 1) {
+    const visited = /* @__PURE__ */ new Set();
+    const reached = /* @__PURE__ */ new Set();
+    const queue = [
+      { id: starts[0].id, stack: [] }
+    ];
+    while (queue.length) {
+      const item = queue.pop();
+      const key = JSON.stringify([item.id, item.stack]);
+      if (visited.has(key)) continue;
+      visited.add(key);
+      if (visited.size > 1e5) {
+        add(
+          "VALIDATION_LIMIT",
+          "Parallel control-flow complexity exceeds the validation limit.",
+          "nodes"
+        );
+        break;
+      }
+      reached.add(item.id);
+      const node = nodes.get(item.id);
+      let stack = item.stack;
+      if (node.type === "fork") {
+        if (stack.includes(node.id)) {
+          add(
+            "PARALLEL_REENTRY",
+            `Fork ${node.id} re-enters before joining.`,
+            "nodes"
+          );
+          continue;
+        }
+        stack = [...stack, node.id];
+      } else if (node.type === "join") {
+        if (stack.at(-1) !== node.fork) {
+          add(
+            "PARALLEL_STRUCTURE",
+            `Join ${node.id} is entered outside its matching fork.`,
+            "nodes"
+          );
+          continue;
+        }
+        stack = stack.slice(0, -1);
+      } else if (node.type === "end" && stack.length) {
+        add(
+          "PARALLEL_ESCAPE",
+          `End ${node.id} bypasses a required join.`,
+          "nodes"
+        );
+      }
+      for (const edge of outgoing.get(node.id))
+        queue.push({ id: edge.target, stack });
+    }
+    for (const node of document.nodes)
+      if (!reached.has(node.id))
+        add(
+          "UNREACHABLE",
+          `Node ${node.id} is unreachable.`,
+          "nodes",
+          "warning"
+        );
+    const canEnd = new Set(
+      document.nodes.filter((node) => node.type === "end").map((node) => node.id)
+    );
+    const pending = [...canEnd];
+    while (pending.length)
+      for (const edge of incoming.get(pending.pop())) {
+        if (!canEnd.has(edge.source)) {
+          canEnd.add(edge.source);
+          pending.push(edge.source);
+        }
+      }
+    for (const node of document.nodes)
+      if (!canEnd.has(node.id))
+        add("NO_END_PATH", `Node ${node.id} has no path to an end.`, "nodes");
+  }
+  return issues;
+}
+function assertFlow(value, mode = "draft") {
+  const diagnostics = validateFlow(value, { mode });
+  if (diagnostics.some((item) => item.severity === "error"))
+    throw new FlowError("INVALID_FLOW", "Flow validation failed.", diagnostics);
+}
+function parseFlow(json) {
+  let value;
+  try {
+    value = JSON.parse(json);
+  } catch (e2) {
+    throw new FlowError("INVALID_JSON", "Invalid JSON document.");
+  }
+  assertFlow(value);
+  return value;
+}
+function serializeFlow(document) {
+  assertFlow(document);
+  return JSON.stringify(document, null, 2);
+}
+function copyFlow(document) {
+  assertFlow(document);
+  return clone(document);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FlowError = FlowError; exports.createFlow = createFlow; exports.assertJson = assertJson; exports.clone = clone; exports.freeze = freeze; exports.equal = equal; exports.isCodePreview = isCodePreview; exports.isTaskAction = isTaskAction; exports.capabilityState = capabilityState; exports.displayUrl = displayUrl; exports.actionPresentation = actionPresentation; exports.formatCondition = formatCondition; exports.validateFlow = validateFlow; exports.assertFlow = assertFlow; exports.parseFlow = parseFlow; exports.serializeFlow = serializeFlow; exports.copyFlow = copyFlow;