@xxrandr/conecta-diagram 0.0.0-stage → 0.1.4

package/dist/chunk-GXOBW2BK.js

@@ -0,0 +1,290 @@
+import {
+  FlowError,
+  assertFlow,
+  assertJson,
+  clone,
+  equal,
+  freeze
+} from "./chunk-Q62JPMJH.js";
+
+// 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 equal(actual, condition.value);
+    case "neq":
+      return !equal(actual, condition.value);
+    case "in":
+      return Array.isArray(condition.value) && condition.value.some((item) => equal(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 {
+  constructor(document, observationLimit = 200) {
+    this.observationLimit = observationLimit;
+    assertFlow(document);
+    if (!Number.isSafeInteger(observationLimit) || observationLimit < 1 || observationLimit > 1e4)
+      throw new FlowError(
+        "INVALID_LIMIT",
+        "observationLimit must be between 1 and 10000."
+      );
+    this.document = freeze(clone(document));
+  }
+  observationLimit;
+  document;
+  commands = /* @__PURE__ */ new Map();
+  latest = /* @__PURE__ */ new Map();
+  decisions = /* @__PURE__ */ new Map();
+  signals = [];
+  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 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 FlowError(
+          "COMMAND_BINDING_CONFLICT",
+          "A command cannot move to a different node."
+        );
+      return;
+    }
+    if (this.commands.size >= 1e4)
+      throw new 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) {
+    assertJson(input);
+    if (!input || typeof input !== "object" || Array.isArray(input))
+      throw new 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 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 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 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 FlowError(
+        "INVALID_TRANSFER",
+        "Expected valid uint64 transfer metadata without binary data."
+      );
+    const command = this.commands.get(input.commandId);
+    if (!command)
+      throw new 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: clone(input.progress) } : {},
+      ...transfer ? { transfer: clone(transfer) } : {}
+    };
+    const previous = command.result;
+    if (previous && BigInt(result.sequence) <= BigInt(previous.sequence)) {
+      if (result.sequence === previous.sequence && !equal(result, previous))
+        throw new FlowError(
+          "RESULT_CONFLICT",
+          "Conflicting results at the same command sequence."
+        );
+      return false;
+    }
+    if (previous?.final)
+      throw new 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) {
+    assertJson(observation);
+    if (!observation || typeof observation !== "object")
+      throw new 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 FlowError(
+        "INVALID_SIGNAL_OBSERVATION",
+        "Invalid observed signal."
+      );
+    if (!this.remember(observation)) return;
+    this.signals.push(clone(observation));
+    if (this.signals.length > this.observationLimit) this.signals.shift();
+  }
+  observeDecision(observation) {
+    assertJson(observation);
+    if (!observation || typeof observation !== "object")
+      throw new FlowError(
+        "INVALID_DECISION_OBSERVATION",
+        "Expected an observation object."
+      );
+    const node = this.document.nodes.find(
+      (node2) => node2.id === observation.nodeId
+    );
+    if (node?.type !== "decision" || !validText(observation.id) || typeof observation.reason !== "string" || !this.document.edges.some(
+      (edge) => edge.id === observation.edgeId && edge.source === node.id
+    ))
+      throw new FlowError(
+        "INVALID_DECISION_OBSERVATION",
+        "Decision observation must select an output edge of that decision."
+      );
+    if (!this.remember(observation)) return;
+    this.decisions.set(observation.nodeId, clone(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: clone(result.progress) } : {},
+        ...result.transfer ? { transfer: clone(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] = clone(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 freeze({ nodes, edges, decisions, signals: clone(this.signals) });
+  }
+  remember(observation) {
+    const previous = this.seen.get(observation.id);
+    if (previous) {
+      if (!equal(previous, observation))
+        throw new FlowError(
+          "OBSERVATION_CONFLICT",
+          "An observation id was reused with different content."
+        );
+      return false;
+    }
+    this.seen.set(observation.id, clone(observation));
+    if (this.seen.size > this.observationLimit)
+      this.seen.delete(this.seen.keys().next().value);
+    return true;
+  }
+};
+
+export {
+  evaluateCondition,
+  visibleElements,
+  simulationOverlay,
+  RunnerDisplay
+};