@xxrandr/conecta-diagram 0.0.0-stage → 0.1.4

package/dist/chunk-6ADTOXBT.cjs

@@ -0,0 +1,626 @@
+"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; } var _class; var _class2; var _class3;
+
+var _chunkQI4NNFRQcjs = require('./chunk-QI4NNFRQ.cjs');
+
+
+
+
+
+
+
+var _chunk3QGSCPWLcjs = require('./chunk-3QGSCPWL.cjs');
+
+// src/core/globals.ts
+function globalValueType(value) {
+  return Array.isArray(value) ? "array" : typeof value === "boolean" ? "boolean" : typeof value === "number" && Number.isSafeInteger(value) ? "integer" : "json";
+}
+function flowCreationOrder(document) {
+  return document.creationOrder ? [...document.creationOrder] : [
+    ...document.nodes.map((node) => ({
+      type: "node",
+      id: node.id
+    })),
+    ...document.edges.map((edge) => ({
+      type: "edge",
+      id: edge.id
+    }))
+  ];
+}
+function orderedFlowItems(document) {
+  return [
+    ...(_nullishCoalesce(document.globals, () => ( []))).map((variable) => ({
+      type: "global",
+      id: variable.id
+    })),
+    ...flowCreationOrder(document)
+  ];
+}
+
+// src/core/store.ts
+var FlowStore = (_class = class {
+  constructor(document, options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+    this.options = options;
+    _chunk3QGSCPWLcjs.assertFlow.call(void 0, document);
+    this.limit = _nullishCoalesce(options.historyLimit, () => ( 100));
+    if (!Number.isSafeInteger(this.limit) || this.limit < 0)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_LIMIT",
+        "historyLimit must be a nonnegative integer."
+      );
+    this.document = _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, document));
+  }
+  
+  
+  __init() {this.past = []}
+  __init2() {this.future = []}
+  __init3() {this.listeners = /* @__PURE__ */ new Set()}
+  __init4() {this.revision = 0}
+  __init5() {this.editing = false}
+  __init6() {this.notifying = false}
+  
+  /** Frozen at runtime; mutate through transaction() instead. */
+  getSnapshot() {
+    return this.document;
+  }
+  getRevision() {
+    return this.revision;
+  }
+  get canUndo() {
+    return this.past.length > 0;
+  }
+  get canRedo() {
+    return this.future.length > 0;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  transaction(reason, edit) {
+    this.guard();
+    this.editing = true;
+    let next;
+    try {
+      next = _chunk3QGSCPWLcjs.clone.call(void 0, this.document);
+      const result = edit(next);
+      if (result && typeof result.then === "function") {
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "ASYNC_TRANSACTION",
+          "Transactions must be synchronous."
+        );
+      }
+      const before = [
+        ...this.document.nodes.map((node) => ["node", node.id]),
+        ...this.document.edges.map((edge) => ["edge", edge.id])
+      ];
+      const after = [
+        ...next.nodes.map((node) => ["node", node.id]),
+        ...next.edges.map((edge) => ["edge", edge.id])
+      ];
+      if (!_chunk3QGSCPWLcjs.equal.call(void 0, before, after) && _chunk3QGSCPWLcjs.equal.call(void 0, next.creationOrder, this.document.creationOrder)) {
+        const current = new Set(
+          after.map((reference) => JSON.stringify(reference))
+        );
+        const order = flowCreationOrder(this.document).filter(
+          (reference) => current.has(JSON.stringify([reference.type, reference.id]))
+        );
+        const recorded = new Set(
+          order.map(
+            (reference) => JSON.stringify([reference.type, reference.id])
+          )
+        );
+        for (const [type, id] of after)
+          if (!recorded.has(JSON.stringify([type, id])))
+            order.push({ type, id });
+        next.creationOrder = order;
+      }
+      _chunk3QGSCPWLcjs.assertFlow.call(void 0, next);
+      next = _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, next));
+    } finally {
+      this.editing = false;
+    }
+    if (_chunk3QGSCPWLcjs.equal.call(void 0, next, this.document)) return;
+    if (this.limit)
+      this.past = [...this.past, this.document].slice(-this.limit);
+    this.future = [];
+    this.document = next;
+    this.emit(reason);
+  }
+  replace(document) {
+    _chunk3QGSCPWLcjs.assertFlow.call(void 0, document);
+    this.transaction("replace", (draft) => {
+      for (const key of Object.keys(draft))
+        delete draft[key];
+      Object.assign(draft, _chunk3QGSCPWLcjs.clone.call(void 0, document));
+    });
+  }
+  addNode(node) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, node);
+    this.transaction("add-node", (draft) => {
+      draft.nodes.push(_chunk3QGSCPWLcjs.clone.call(void 0, node));
+    });
+  }
+  addGlobal(variable) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, variable);
+    this.transaction("add-global", (draft) => {
+      (draft.globals ??= []).push(_chunk3QGSCPWLcjs.clone.call(void 0, variable));
+    });
+  }
+  updateGlobal(id, update) {
+    this.transaction("update-global", (draft) => {
+      const index = _nullishCoalesce(_optionalChain([draft, 'access', _ => _.globals, 'optionalAccess', _2 => _2.findIndex, 'call', _3 => _3((variable2) => variable2.id === id)]), () => ( -1));
+      if (index < 0)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)("GLOBAL_NOT_FOUND", `Unknown global ${id}.`);
+      const variable = update(draft.globals[index]);
+      if (variable.id !== id)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "ID_CHANGE",
+          "Global ids cannot be changed by updateGlobal."
+        );
+      draft.globals[index] = variable;
+    });
+  }
+  removeGlobal(id) {
+    this.transaction("remove-global", (draft) => {
+      if (draft.globals)
+        draft.globals = draft.globals.filter((variable) => variable.id !== id);
+    });
+  }
+  updateNode(id, update) {
+    this.transaction("update-node", (draft) => {
+      const index = draft.nodes.findIndex((node) => node.id === id);
+      if (index < 0)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)("NODE_NOT_FOUND", `Unknown node ${id}.`);
+      const next = update(draft.nodes[index]);
+      if (next.id !== id)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "ID_CHANGE",
+          "Node ids cannot be changed by updateNode."
+        );
+      draft.nodes[index] = next;
+    });
+  }
+  moveNode(id, position) {
+    this.updateNode(id, (node) => ({ ...node, position }));
+  }
+  removeNode(id) {
+    this.transaction("remove-node", (draft) => {
+      draft.nodes = draft.nodes.filter((node) => node.id !== id);
+      draft.edges = draft.edges.filter(
+        (edge) => edge.source !== id && edge.target !== id
+      );
+    });
+  }
+  addEdge(edge) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, edge);
+    this.transaction("add-edge", (draft) => {
+      draft.edges.push(_chunk3QGSCPWLcjs.clone.call(void 0, edge));
+    });
+  }
+  updateEdge(id, update) {
+    this.transaction("update-edge", (draft) => {
+      const index = draft.edges.findIndex((edge) => edge.id === id);
+      if (index < 0)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)("EDGE_NOT_FOUND", `Unknown edge ${id}.`);
+      const next = update(draft.edges[index]);
+      if (next.id !== id)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "ID_CHANGE",
+          "Edge ids cannot be changed by updateEdge."
+        );
+      draft.edges[index] = next;
+    });
+  }
+  removeEdge(id) {
+    this.transaction("remove-edge", (draft) => {
+      draft.edges = draft.edges.filter((edge) => edge.id !== id);
+    });
+  }
+  undo() {
+    this.guard();
+    const previous = this.past.pop();
+    if (!previous) return;
+    this.future.push(this.document);
+    this.document = previous;
+    this.emit("undo");
+  }
+  redo() {
+    this.guard();
+    const next = this.future.pop();
+    if (!next) return;
+    this.past.push(this.document);
+    this.document = next;
+    this.emit("redo");
+  }
+  guard() {
+    if (this.editing || this.notifying)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "REENTRANT_EDIT",
+        "Nested edits and edits during notification are not supported."
+      );
+  }
+  emit(reason) {
+    this.revision++;
+    this.notifying = true;
+    try {
+      for (const listener of [...this.listeners]) {
+        try {
+          listener({
+            document: this.document,
+            reason,
+            revision: this.revision
+          });
+        } catch (error) {
+          try {
+            _optionalChain([this, 'access', _4 => _4.options, 'access', _5 => _5.onListenerError, 'optionalCall', _6 => _6(error)]);
+          } catch (e) {
+          }
+        }
+      }
+    } finally {
+      this.notifying = false;
+    }
+  }
+}, _class);
+
+// src/core/simulation.ts
+var FlowSimulator = (_class2 = class {
+  
+  
+  __init7() {this.nextId = 1}
+  __init8() {this.sequence = 0}
+  
+  
+  constructor(document, context = {}, options = {}) {;_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);
+    _chunk3QGSCPWLcjs.assertFlow.call(void 0, document, "executable");
+    this.checkContext(context);
+    this.traceLimit = _nullishCoalesce(options.traceLimit, () => ( 1e3));
+    this.maxTokens = _nullishCoalesce(options.maxTokens, () => ( 1e4));
+    if (!Number.isSafeInteger(this.traceLimit) || this.traceLimit < 0 || !Number.isSafeInteger(this.maxTokens) || this.maxTokens < 1) {
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_LIMIT",
+        "traceLimit must be nonnegative and maxTokens positive integers."
+      );
+    }
+    this.document = _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, document));
+    this.state = {
+      status: "running",
+      context: _chunk3QGSCPWLcjs.clone.call(void 0, context),
+      tokens: [
+        {
+          id: this.id(),
+          nodeId: document.nodes.find((node) => node.type === "start").id,
+          status: "ready",
+          frames: []
+        }
+      ],
+      completedNodes: [],
+      traversedEdges: [],
+      events: [],
+      steps: 0
+    };
+  }
+  getSnapshot() {
+    return _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, this.state));
+  }
+  /** Process one ready token, using stable FIFO order. */
+  step() {
+    if (this.terminal()) return this.getSnapshot();
+    const token = this.state.tokens.find((item) => item.status === "ready");
+    if (!token) {
+      this.refresh();
+      return this.getSnapshot();
+    }
+    const node = this.document.nodes.find((item) => item.id === token.nodeId);
+    const outputs = this.document.edges.filter(
+      (edge) => edge.source === node.id
+    );
+    this.state.steps++;
+    this.event({ type: "entered", nodeId: node.id, tokenId: token.id });
+    if (node.type === "task" && node.mode === "async") {
+      token.status = "async";
+      this.event({ type: "waiting", nodeId: node.id, tokenId: token.id });
+    } else if (node.type === "wait") {
+      token.status = "signal";
+      this.event({
+        type: "waiting",
+        nodeId: node.id,
+        tokenId: token.id,
+        message: node.signal
+      });
+    } else if (node.type === "end") {
+      this.completed(token);
+      this.remove(token);
+    } else if (node.type === "decision") {
+      const edge = _nullishCoalesce(outputs.filter((item) => !item.default).sort(
+        (a, b) => (_nullishCoalesce(a.priority, () => ( 0))) - (_nullishCoalesce(b.priority, () => ( 0))) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+      ).find(
+        (item) => item.condition && _chunkQI4NNFRQcjs.evaluateCondition.call(void 0, item.condition, this.state.context)
+      ), () => ( outputs.find((item) => item.default)));
+      this.advance(token, edge);
+    } else if (node.type === "fork") {
+      if (this.state.tokens.length - 1 + outputs.length > this.maxTokens) {
+        this.failToken(token, "Active token limit exceeded.");
+      } else {
+        const group = this.id();
+        this.completed(token);
+        this.remove(token);
+        for (const edge of outputs) {
+          const child = {
+            id: this.id(),
+            nodeId: node.id,
+            status: "ready",
+            frames: [
+              ..._chunk3QGSCPWLcjs.clone.call(void 0, token.frames),
+              {
+                group,
+                fork: node.id,
+                join: node.join,
+                branch: edge.id,
+                expected: outputs.length
+              }
+            ]
+          };
+          this.state.tokens.push(child);
+          this.traverse(child, edge);
+        }
+      }
+    } else if (node.type === "join") {
+      const frame = token.frames.at(-1);
+      if (!frame || frame.join !== node.id || frame.fork !== node.fork) {
+        this.failToken(token, "Token reached a join outside its fork scope.");
+      } else {
+        token.status = "joining";
+        const siblings = this.state.tokens.filter(
+          (item) => item.nodeId === node.id && item.status === "joining" && _optionalChain([item, 'access', _7 => _7.frames, 'access', _8 => _8.at, 'call', _9 => _9(-1), 'optionalAccess', _10 => _10.group]) === frame.group
+        );
+        const branches = new Set(
+          siblings.map((item) => item.frames.at(-1).branch)
+        );
+        if (branches.size !== siblings.length)
+          this.failToken(
+            token,
+            "A parallel branch arrived at the join more than once."
+          );
+        else if (siblings.length === frame.expected) {
+          for (const sibling of siblings) this.remove(sibling);
+          token.frames.pop();
+          token.status = "ready";
+          this.state.tokens.push(token);
+          this.advance(token, outputs[0]);
+        } else
+          this.event({ type: "waiting", nodeId: node.id, tokenId: token.id });
+      }
+    } else this.advance(token, outputs[0]);
+    this.refresh();
+    return this.getSnapshot();
+  }
+  run(maxSteps = 1e3) {
+    if (!Number.isSafeInteger(maxSteps) || maxSteps < 1)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_LIMIT",
+        "maxSteps must be a positive integer."
+      );
+    for (let index = 0; index < maxSteps && this.state.status === "running"; index++)
+      this.step();
+    return {
+      reason: this.state.status === "running" ? "step-limit" : this.state.status,
+      snapshot: this.getSnapshot()
+    };
+  }
+  /** Complete one async activation, not every activation of the same node. */
+  complete(tokenId, patch = {}) {
+    return this.resume(tokenId, "async", patch);
+  }
+  /** External applications collect user input and explicitly deliver it here. */
+  signal(tokenId, signal, patch = {}) {
+    const token = this.findWaiting(tokenId, "signal");
+    const node = this.document.nodes.find((item) => item.id === token.nodeId);
+    if (node.type !== "wait" || node.signal !== signal)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)("SIGNAL_MISMATCH", `Unexpected signal ${signal}.`);
+    return this.resume(tokenId, "signal", patch);
+  }
+  fail(tokenId, message) {
+    if (this.terminal())
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "TERMINAL_SIMULATION",
+        "The simulation has finished."
+      );
+    const token = this.state.tokens.find((item) => item.id === tokenId);
+    if (!token)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)("TOKEN_NOT_FOUND", `Unknown token ${tokenId}.`);
+    this.failToken(token, message);
+    return this.getSnapshot();
+  }
+  cancel() {
+    if (!this.terminal()) {
+      this.state.status = "cancelled";
+      this.state.tokens = [];
+      this.event({ type: "cancelled" });
+    }
+    return this.getSnapshot();
+  }
+  resume(tokenId, status, patch) {
+    const token = this.findWaiting(tokenId, status);
+    this.checkContext(patch);
+    this.state.context = { ...this.state.context, ..._chunk3QGSCPWLcjs.clone.call(void 0, patch) };
+    this.advance(
+      token,
+      this.document.edges.find((edge) => edge.source === token.nodeId)
+    );
+    this.refresh();
+    return this.getSnapshot();
+  }
+  findWaiting(id, status) {
+    if (this.terminal())
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "TERMINAL_SIMULATION",
+        "The simulation has finished."
+      );
+    const token = this.state.tokens.find((item) => item.id === id);
+    if (!token || token.status !== status)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "TOKEN_NOT_WAITING",
+        `Token ${id} is not waiting for ${status}.`
+      );
+    return token;
+  }
+  advance(token, edge) {
+    this.completed(token);
+    this.traverse(token, edge);
+    this.remove(token);
+    this.state.tokens.push(token);
+  }
+  traverse(token, edge) {
+    this.event({ type: "traversed", edgeId: edge.id, tokenId: token.id });
+    if (!this.state.traversedEdges.includes(edge.id))
+      this.state.traversedEdges.push(edge.id);
+    token.nodeId = edge.target;
+    token.status = "ready";
+  }
+  completed(token) {
+    if (!this.state.completedNodes.includes(token.nodeId))
+      this.state.completedNodes.push(token.nodeId);
+    this.event({ type: "completed", nodeId: token.nodeId, tokenId: token.id });
+  }
+  failToken(token, message) {
+    this.state.status = "failed";
+    this.state.error = message;
+    this.event({
+      type: "failed",
+      nodeId: token.nodeId,
+      tokenId: token.id,
+      message
+    });
+  }
+  remove(token) {
+    this.state.tokens = this.state.tokens.filter(
+      (item) => item.id !== token.id
+    );
+  }
+  id() {
+    return `t${this.nextId++}`;
+  }
+  terminal() {
+    return ["completed", "failed", "cancelled"].includes(this.state.status);
+  }
+  refresh() {
+    if (this.terminal()) return;
+    if (!this.state.tokens.length) this.state.status = "completed";
+    else if (this.state.tokens.some((token) => token.status === "ready"))
+      this.state.status = "running";
+    else if (this.state.tokens.every((token) => token.status === "joining")) {
+      this.failToken(this.state.tokens[0], "Parallel join deadlock.");
+    } else this.state.status = "waiting";
+  }
+  event(event) {
+    this.sequence++;
+    if (this.traceLimit) {
+      this.state.events.push({ ...event, sequence: this.sequence });
+      if (this.state.events.length > this.traceLimit) this.state.events.shift();
+    }
+  }
+  checkContext(context) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, context);
+    if (!context || typeof context !== "object" || Array.isArray(context))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)("INVALID_CONTEXT", "Context must be a JSON object.");
+  }
+}, _class2);
+
+// src/core/layout.ts
+function layoutFlow(document, options = {}) {
+  _chunk3QGSCPWLcjs.assertFlow.call(void 0, document);
+  const columnGap = _nullishCoalesce(options.columnGap, () => ( 220));
+  const rowGap = _nullishCoalesce(options.rowGap, () => ( 120));
+  if (!Number.isFinite(columnGap) || columnGap <= 0 || !Number.isFinite(rowGap) || rowGap <= 0)
+    throw new RangeError("Layout gaps must be positive finite numbers.");
+  const result = _chunk3QGSCPWLcjs.clone.call(void 0, document);
+  const levels = /* @__PURE__ */ new Map();
+  const queue = result.nodes.filter(
+    (node) => node.type === "start" || !result.edges.some((edge) => edge.target === node.id)
+  ).map((node) => node.id);
+  for (const id of queue) levels.set(id, 0);
+  for (let index = 0; index < queue.length; index++) {
+    const id = queue[index];
+    for (const edge of result.edges.filter((edge2) => edge2.source === id)) {
+      if (!levels.has(edge.target)) {
+        levels.set(edge.target, levels.get(id) + 1);
+        queue.push(edge.target);
+      }
+    }
+  }
+  let fallback = Math.max(0, ...levels.values()) + 1;
+  const rows = /* @__PURE__ */ new Map();
+  for (const node of result.nodes) {
+    const level = _nullishCoalesce(levels.get(node.id), () => ( fallback++));
+    const row = _nullishCoalesce(rows.get(level), () => ( 0));
+    rows.set(level, row + 1);
+    node.position = options.direction === "down" ? { x: 100 + row * columnGap, y: 80 + level * rowGap } : { x: 100 + level * columnGap, y: 80 + row * rowGap };
+  }
+  return result;
+}
+
+// src/core/performance.ts
+var finite = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+var text = (value) => typeof value === "string" && value.trim().length > 0;
+var uint64 = (value) => typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value) && value.length <= 20 && BigInt(value) <= 18446744073709551615n;
+var PerformanceTimeline = (_class3 = class {constructor() { _class3.prototype.__init9.call(this); }
+  __init9() {this.runs = /* @__PURE__ */ new Map()}
+  record(sample) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, sample);
+    if (!sample || ![sample.runId, sample.nodeId, sample.commandId, sample.process].every(
+      text
+    ) || !finite(sample.startMs) || !finite(sample.durationMs) || !Number.isSafeInteger(sample.cost) || sample.cost < 0 || !Number.isFinite(sample.startMs + sample.durationMs))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_PERFORMANCE",
+        "Expected backend run identity, finite times and a nonnegative safe integer cost."
+      );
+    if (sample.network !== void 0 && (!Array.isArray(sample.network) || sample.network.some(
+      (item) => !item || !finite(item.startMs) || !finite(item.durationMs) || !Number.isFinite(item.startMs + item.durationMs) || !text(item.label) || item.bytes !== void 0 && !uint64(item.bytes)
+    )))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_PERFORMANCE",
+        "Invalid backend network interval."
+      );
+    if (sample.memory !== void 0 && (!Array.isArray(sample.memory) || sample.memory.some(
+      (item) => !item || !finite(item.timeMs) || !uint64(item.bytes)
+    )))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_PERFORMANCE",
+        "Invalid backend memory sample."
+      );
+    const previous = this.runs.get(sample.runId);
+    if (previous) {
+      if (!_chunk3QGSCPWLcjs.equal.call(void 0, previous, sample))
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "PERFORMANCE_CONFLICT",
+          "A node-run metric id cannot be reused with different data."
+        );
+      return false;
+    }
+    if (this.runs.size >= 1e4)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "PERFORMANCE_LIMIT",
+        "Start a new performance view after 10000 node runs."
+      );
+    this.runs.set(sample.runId, _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, sample)));
+    return true;
+  }
+  getSnapshot() {
+    return _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, [...this.runs.values()]));
+  }
+  clear() {
+    this.runs.clear();
+  }
+}, _class3);
+
+
+
+
+
+
+
+
+
+exports.globalValueType = globalValueType; exports.flowCreationOrder = flowCreationOrder; exports.orderedFlowItems = orderedFlowItems; exports.FlowStore = FlowStore; exports.FlowSimulator = FlowSimulator; exports.layoutFlow = layoutFlow; exports.PerformanceTimeline = PerformanceTimeline;