@xxrandr/conecta-diagram 0.0.0-stage → 0.1.4

package/dist/chunk-QI4NNFRQ.cjs

@@ -0,0 +1,290 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunk3QGSCPWLcjs = require('./chunk-3QGSCPWL.cjs');
+
+// src/core/conditions.ts
+function evaluateCondition(condition, context) {
+  if (condition.op === "all" || condition.op === "any") {
+    return condition.op === "all" ? condition.conditions.every((item) => evaluateCondition(item, context)) : condition.conditions.some((item) => evaluateCondition(item, context));
+  }
+  if (condition.op === "not")
+    return !evaluateCondition(condition.condition, context);
+  if (!("path" in condition)) return false;
+  let actual = context;
+  for (const key of condition.path) {
+    if (actual === null || typeof actual !== "object" || !Object.hasOwn(actual, key)) {
+      actual = void 0;
+      break;
+    }
+    actual = actual[key];
+  }
+  if (condition.op === "exists") return actual !== void 0;
+  if (actual === void 0) return false;
+  switch (condition.op) {
+    case "eq":
+      return _chunk3QGSCPWLcjs.equal.call(void 0, actual, condition.value);
+    case "neq":
+      return !_chunk3QGSCPWLcjs.equal.call(void 0, actual, condition.value);
+    case "in":
+      return Array.isArray(condition.value) && condition.value.some((item) => _chunk3QGSCPWLcjs.equal.call(void 0, actual, item));
+    case "gt":
+      return typeof actual === "number" && typeof condition.value === "number" && actual > condition.value;
+    case "gte":
+      return typeof actual === "number" && typeof condition.value === "number" && actual >= condition.value;
+    case "lt":
+      return typeof actual === "number" && typeof condition.value === "number" && actual < condition.value;
+    case "lte":
+      return typeof actual === "number" && typeof condition.value === "number" && actual <= condition.value;
+  }
+}
+function visibleElements(document, context) {
+  const nodes = document.nodes.filter(
+    (node) => !node.visibleWhen || evaluateCondition(node.visibleWhen, context)
+  );
+  const ids = new Set(nodes.map((node) => node.id));
+  const edges = document.edges.filter(
+    (edge) => ids.has(edge.source) && ids.has(edge.target) && (!edge.visibleWhen || evaluateCondition(edge.visibleWhen, context))
+  );
+  return { nodes, edges };
+}
+
+// src/core/runner-display.ts
+var statuses = [
+  "ACCEPTED",
+  "RUNNING",
+  "STREAMING",
+  "SUCCEEDED",
+  "FAILED",
+  "CANCELLED",
+  "TIMED_OUT",
+  "REJECTED"
+];
+var terminals = [
+  "SUCCEEDED",
+  "FAILED",
+  "CANCELLED",
+  "TIMED_OUT",
+  "REJECTED"
+];
+var uint64 = (value) => typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value) && value.length <= 20 && BigInt(value) <= 18446744073709551615n;
+var validText = (value) => typeof value === "string" && value.trim().length > 0;
+function simulationOverlay(snapshot) {
+  const nodes = /* @__PURE__ */ Object.create(null);
+  for (const id of snapshot.completedNodes) nodes[id] = { status: "completed" };
+  for (const token of snapshot.tokens) {
+    const status = snapshot.status === "failed" ? "failed" : token.status === "ready" ? "active" : "waiting";
+    nodes[token.nodeId] = {
+      status,
+      detail: token.status === "signal" ? "Awaiting external signal" : token.status === "async" ? "Awaiting async result" : token.status === "joining" ? "Waiting for parallel branches" : ""
+    };
+  }
+  const edges = /* @__PURE__ */ Object.create(null);
+  for (const id of snapshot.traversedEdges) edges[id] = "taken";
+  return { nodes, edges };
+}
+var RunnerDisplay = (_class = class {
+  constructor(document, observationLimit = 200) {;_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);
+    this.observationLimit = observationLimit;
+    _chunk3QGSCPWLcjs.assertFlow.call(void 0, document);
+    if (!Number.isSafeInteger(observationLimit) || observationLimit < 1 || observationLimit > 1e4)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_LIMIT",
+        "observationLimit must be between 1 and 10000."
+      );
+    this.document = _chunk3QGSCPWLcjs.freeze.call(void 0, _chunk3QGSCPWLcjs.clone.call(void 0, document));
+  }
+  
+  
+  __init() {this.commands = /* @__PURE__ */ new Map()}
+  __init2() {this.latest = /* @__PURE__ */ new Map()}
+  __init3() {this.decisions = /* @__PURE__ */ new Map()}
+  __init4() {this.signals = []}
+  __init5() {this.seen = /* @__PURE__ */ new Map()}
+  /** Register correlation only. This does not dispatch, accept or execute a command. */
+  track(commandId, nodeId) {
+    const node = this.document.nodes.find((node2) => node2.id === nodeId);
+    if (!validText(commandId) || !node || !["task", "decision"].includes(node.type))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_COMMAND_BINDING",
+        "A command id must target an existing task or decision."
+      );
+    const existing = this.commands.get(commandId);
+    if (existing) {
+      if (existing.nodeId !== nodeId)
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "COMMAND_BINDING_CONFLICT",
+          "A command cannot move to a different node."
+        );
+      return;
+    }
+    if (this.commands.size >= 1e4)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "DISPLAY_LIMIT",
+        "Create a new display projection after 10000 tracked commands."
+      );
+    this.commands.set(commandId, { commandId, nodeId });
+    this.latest.set(nodeId, commandId);
+  }
+  applyResult(input) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, input);
+    if (!input || typeof input !== "object" || Array.isArray(input))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_RESULT",
+        "Expected a result preview object."
+      );
+    const status = typeof input.status === "number" ? statuses[input.status - 1] : input.status;
+    if (!status || !statuses.includes(status) || !uint64(input.sequence) || typeof input.success !== "boolean" || typeof input.final !== "boolean" || [input.summary, input.error].some(
+      (item) => item !== void 0 && typeof item !== "string"
+    ))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_RESULT",
+        "Invalid result status, sequence, finality or display summary."
+      );
+    const terminal = terminals.includes(status);
+    if (input.final !== terminal || terminal && input.success !== (status === "SUCCEEDED"))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_RESULT",
+        "Terminal status, final and success must agree; intermediate success=false is not a failure."
+      );
+    if (input.progress !== void 0 && (!input.progress || !uint64(input.progress.current) || input.progress.total !== void 0 && (!uint64(input.progress.total) || BigInt(input.progress.current) > BigInt(input.progress.total)) || !["bytes", "rows", "items"].includes(input.progress.unit)))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_PROGRESS",
+        "Expected bounded uint64 decimal progress values and a known unit."
+      );
+    const transfer = input.transfer;
+    if (transfer !== void 0 && (!transfer || !validText(transfer.id) || !uint64(transfer.offset) || !uint64(transfer.chunkSequence) || !uint64(transfer.size) || typeof transfer.final !== "boolean" || BigInt(transfer.offset) + BigInt(transfer.size) > 18446744073709551615n || transfer.totalSize !== void 0 && (!uint64(transfer.totalSize) || BigInt(transfer.offset) + BigInt(transfer.size) > BigInt(transfer.totalSize))))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_TRANSFER",
+        "Expected valid uint64 transfer metadata without binary data."
+      );
+    const command = this.commands.get(input.commandId);
+    if (!command)
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "UNKNOWN_COMMAND",
+        `No display binding for command ${input.commandId}.`
+      );
+    const result = {
+      commandId: input.commandId,
+      status,
+      sequence: input.sequence,
+      success: input.success,
+      final: input.final,
+      ...input.summary !== void 0 ? { summary: input.summary } : {},
+      ...input.error !== void 0 ? { error: input.error } : {},
+      ...input.progress ? { progress: _chunk3QGSCPWLcjs.clone.call(void 0, input.progress) } : {},
+      ...transfer ? { transfer: _chunk3QGSCPWLcjs.clone.call(void 0, transfer) } : {}
+    };
+    const previous = command.result;
+    if (previous && BigInt(result.sequence) <= BigInt(previous.sequence)) {
+      if (result.sequence === previous.sequence && !_chunk3QGSCPWLcjs.equal.call(void 0, result, previous))
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "RESULT_CONFLICT",
+          "Conflicting results at the same command sequence."
+        );
+      return false;
+    }
+    if (_optionalChain([previous, 'optionalAccess', _ => _.final]))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "COMMAND_FINISHED",
+        "A final command result cannot be overwritten; track a new command id for a retry."
+      );
+    command.result = result;
+    return true;
+  }
+  observeSignal(observation) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, observation);
+    if (!observation || typeof observation !== "object")
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_SIGNAL_OBSERVATION",
+        "Expected an observation object."
+      );
+    const node = this.document.nodes.find(
+      (node2) => node2.id === observation.nodeId
+    );
+    if (!node || !validText(observation.id) || !validText(observation.name) || !["in", "out"].includes(observation.direction) || observation.summary !== void 0 && typeof observation.summary !== "string")
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_SIGNAL_OBSERVATION",
+        "Invalid observed signal."
+      );
+    if (!this.remember(observation)) return;
+    this.signals.push(_chunk3QGSCPWLcjs.clone.call(void 0, observation));
+    if (this.signals.length > this.observationLimit) this.signals.shift();
+  }
+  observeDecision(observation) {
+    _chunk3QGSCPWLcjs.assertJson.call(void 0, observation);
+    if (!observation || typeof observation !== "object")
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_DECISION_OBSERVATION",
+        "Expected an observation object."
+      );
+    const node = this.document.nodes.find(
+      (node2) => node2.id === observation.nodeId
+    );
+    if (_optionalChain([node, 'optionalAccess', _2 => _2.type]) !== "decision" || !validText(observation.id) || typeof observation.reason !== "string" || !this.document.edges.some(
+      (edge) => edge.id === observation.edgeId && edge.source === node.id
+    ))
+      throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+        "INVALID_DECISION_OBSERVATION",
+        "Decision observation must select an output edge of that decision."
+      );
+    if (!this.remember(observation)) return;
+    this.decisions.set(observation.nodeId, _chunk3QGSCPWLcjs.clone.call(void 0, observation));
+  }
+  getOverlay() {
+    const nodes = /* @__PURE__ */ Object.create(null);
+    for (const [nodeId, commandId] of this.latest) {
+      const result = this.commands.get(commandId).result;
+      nodes[nodeId] = result ? {
+        status: String(result.status).toLowerCase(),
+        commandId,
+        sequence: result.sequence,
+        final: result.final,
+        detail: result.error || result.summary || String(result.status),
+        ...result.progress ? { progress: _chunk3QGSCPWLcjs.clone.call(void 0, result.progress) } : {},
+        ...result.transfer ? { transfer: _chunk3QGSCPWLcjs.clone.call(void 0, result.transfer) } : {}
+      } : { status: "idle", commandId, detail: "Awaiting runner observation" };
+    }
+    const edges = /* @__PURE__ */ Object.create(null);
+    const decisions = /* @__PURE__ */ Object.create(null);
+    for (const [nodeId, observation] of this.decisions) {
+      decisions[nodeId] = _chunk3QGSCPWLcjs.clone.call(void 0, observation);
+      nodes[nodeId] = {
+        ...nodes[nodeId],
+        status: "succeeded",
+        detail: observation.reason
+      };
+      for (const edge of this.document.edges.filter(
+        (edge2) => edge2.source === nodeId
+      ))
+        edges[edge.id] = edge.id === observation.edgeId ? "taken" : "skipped";
+    }
+    return _chunk3QGSCPWLcjs.freeze.call(void 0, { nodes, edges, decisions, signals: _chunk3QGSCPWLcjs.clone.call(void 0, this.signals) });
+  }
+  remember(observation) {
+    const previous = this.seen.get(observation.id);
+    if (previous) {
+      if (!_chunk3QGSCPWLcjs.equal.call(void 0, previous, observation))
+        throw new (0, _chunk3QGSCPWLcjs.FlowError)(
+          "OBSERVATION_CONFLICT",
+          "An observation id was reused with different content."
+        );
+      return false;
+    }
+    this.seen.set(observation.id, _chunk3QGSCPWLcjs.clone.call(void 0, observation));
+    if (this.seen.size > this.observationLimit)
+      this.seen.delete(this.seen.keys().next().value);
+    return true;
+  }
+}, _class);
+
+
+
+
+
+
+exports.evaluateCondition = evaluateCondition; exports.visibleElements = visibleElements; exports.simulationOverlay = simulationOverlay; exports.RunnerDisplay = RunnerDisplay;