@atsumell/trace-weave 0.1.0

package/dist/chunk-EICHUHZH.js

@@ -0,0 +1,689 @@
+import {
+  andV,
+  impliesV,
+  notV,
+  orV
+} from "./chunk-AS6LZLUH.js";
+import {
+  compile,
+  print,
+  validate
+} from "./chunk-WIW3TVEK.js";
+import {
+  activationId
+} from "./chunk-B4SEKVLL.js";
+
+// src/monitor/eval-common.ts
+function envKey(env) {
+  const entries = [...env.entries()].sort(([left], [right]) => left.localeCompare(right));
+  return JSON.stringify(entries);
+}
+function cacheKey(nodeId, pos, env) {
+  return `${nodeId}:${pos}:${envKey(env)}`;
+}
+function resolveArg(arg, event, runtime) {
+  if (arg.kind === "literal") {
+    return arg.value;
+  }
+  const selectorFn = runtime.selectors[arg.selectorId];
+  if (!selectorFn) {
+    return null;
+  }
+  return selectorFn(event);
+}
+function jsonEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null) {
+    return a === b;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (typeof a !== "object") {
+    return a === b;
+  }
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) {
+      return false;
+    }
+    return a.every((value, index) => jsonEqual(value, b[index]));
+  }
+  if (Array.isArray(b)) {
+    return false;
+  }
+  const aObject = a;
+  const bObject = b;
+  const aKeys = Object.keys(aObject).sort();
+  const bKeys = Object.keys(bObject).sort();
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  return aKeys.every(
+    (key, index) => key === bKeys[index] && jsonEqual(aObject[key], bObject[key])
+  );
+}
+
+// src/monitor/unsupported.ts
+var WITHIN_MS_RUNTIME_MESSAGE = "withinMs requires MonitorRuntime.timestamp to be defined and return event timestamps in milliseconds.";
+var WITHIN_MS_TIMESTAMP_MESSAGE = "MonitorRuntime.timestamp must return a finite number of milliseconds for every event.";
+var WITHIN_MS_NON_MONOTONIC_MESSAGE = "MonitorRuntime.timestamp must be non-decreasing across the trace when using withinMs.";
+function usesWithinMs(doc) {
+  for (const node of Object.values(doc.nodes)) {
+    if (node.kind === "withinMs") {
+      return true;
+    }
+  }
+  return false;
+}
+function assertWithinMsRuntimeSupport(doc, runtime) {
+  if (usesWithinMs(doc) && !runtime.timestamp) {
+    throw new Error(WITHIN_MS_RUNTIME_MESSAGE);
+  }
+}
+
+// src/monitor/time.ts
+function getTimestamp(runtime, event) {
+  const timestamp = runtime.timestamp?.(event);
+  if (timestamp === void 0 || !Number.isFinite(timestamp)) {
+    throw new Error(WITHIN_MS_TIMESTAMP_MESSAGE);
+  }
+  return timestamp;
+}
+function assertTimeSupportForTrace(doc, runtime, trace) {
+  if (!usesWithinMs(doc)) return;
+  assertWithinMsRuntimeSupport(doc, runtime);
+  let previous = Number.NEGATIVE_INFINITY;
+  for (const event of trace) {
+    const current = getTimestamp(runtime, event);
+    if (current < previous) {
+      throw new Error(WITHIN_MS_NON_MONOTONIC_MESSAGE);
+    }
+    previous = current;
+  }
+}
+
+// src/monitor/evaluate-finite.ts
+function createFiniteEvalContext(doc, runtime, trace) {
+  assertTimeSupportForTrace(doc, runtime, trace);
+  return {
+    doc,
+    runtime,
+    trace,
+    cache: /* @__PURE__ */ new Map()
+  };
+}
+function evaluateFiniteFormula(doc, runtime, trace) {
+  const ctx = createFiniteEvalContext(doc, runtime, trace);
+  return evaluateFiniteNode(ctx, doc.root, 0, /* @__PURE__ */ new Map());
+}
+function evaluateFiniteNode(ctx, nodeId, pos, env) {
+  const entryKey = cacheKey(nodeId, pos, env);
+  const cached = ctx.cache.get(entryKey);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const node = ctx.doc.nodes[nodeId];
+  if (!node) {
+    return "violated";
+  }
+  ctx.cache.set(entryKey, "pending");
+  const verdict = evaluateFiniteNodeInner(ctx, node, pos, env);
+  ctx.cache.set(entryKey, verdict);
+  return verdict;
+}
+function evaluateFiniteNodeInner(ctx, node, pos, env) {
+  const len = ctx.trace.length;
+  switch (node.kind) {
+    case "literal":
+      return node.value ? "satisfied" : "violated";
+    case "predicate": {
+      if (pos >= len) {
+        return "violated";
+      }
+      const predicateFn = ctx.runtime.predicates[node.predicateId];
+      if (!predicateFn) {
+        return "violated";
+      }
+      const event = ctx.trace[pos];
+      const args = (node.args ?? []).map((arg) => resolveArg(arg, event, ctx.runtime));
+      return predicateFn(event, args) ? "satisfied" : "violated";
+    }
+    case "when": {
+      if (pos >= len) {
+        return "violated";
+      }
+      const captured = env.get(node.captureName);
+      if (captured === void 0) {
+        return "violated";
+      }
+      const selectorFn = ctx.runtime.selectors[node.selectorId];
+      if (!selectorFn) {
+        return "violated";
+      }
+      const currentValue = selectorFn(ctx.trace[pos]);
+      if (!jsonEqual(captured, currentValue)) {
+        return "violated";
+      }
+      return evaluateFiniteNode(ctx, node.child, pos, env);
+    }
+    case "capture": {
+      if (pos >= len) {
+        return "violated";
+      }
+      const selectorFn = ctx.runtime.selectors[node.selectorId];
+      if (!selectorFn) {
+        return "violated";
+      }
+      const nextEnv = new Map(env);
+      nextEnv.set(node.captureName, selectorFn(ctx.trace[pos]));
+      return evaluateFiniteNode(ctx, node.child, pos, nextEnv);
+    }
+    case "not":
+      return notV(evaluateFiniteNode(ctx, node.child, pos, env));
+    case "and": {
+      let result = "satisfied";
+      for (const childId of node.children) {
+        result = andV(result, evaluateFiniteNode(ctx, childId, pos, env));
+        if (result === "violated") {
+          break;
+        }
+      }
+      return result;
+    }
+    case "or": {
+      let result = "violated";
+      for (const childId of node.children) {
+        result = orV(result, evaluateFiniteNode(ctx, childId, pos, env));
+        if (result === "satisfied") {
+          break;
+        }
+      }
+      return result;
+    }
+    case "implies":
+      return impliesV(
+        evaluateFiniteNode(ctx, node.left, pos, env),
+        evaluateFiniteNode(ctx, node.right, pos, env)
+      );
+    case "always": {
+      if (pos >= len) {
+        return "satisfied";
+      }
+      let result = "satisfied";
+      for (let step = pos; step < len; step++) {
+        result = andV(result, evaluateFiniteNode(ctx, node.child, step, env));
+        if (result === "violated") {
+          break;
+        }
+      }
+      return result;
+    }
+    case "eventually": {
+      if (pos >= len) {
+        return "violated";
+      }
+      let result = "violated";
+      for (let step = pos; step < len; step++) {
+        result = orV(result, evaluateFiniteNode(ctx, node.child, step, env));
+        if (result === "satisfied") {
+          break;
+        }
+      }
+      return result;
+    }
+    case "next":
+      return pos + 1 >= len ? "violated" : evaluateFiniteNode(ctx, node.child, pos + 1, env);
+    case "weakNext":
+      return pos + 1 >= len ? "satisfied" : evaluateFiniteNode(ctx, node.child, pos + 1, env);
+    case "until": {
+      if (pos >= len) {
+        return "violated";
+      }
+      let leftAccumulator = "satisfied";
+      for (let step = pos; step < len; step++) {
+        const rightVerdict = evaluateFiniteNode(ctx, node.right, step, env);
+        if (rightVerdict === "satisfied" && leftAccumulator === "satisfied") {
+          return "satisfied";
+        }
+        const leftVerdict = evaluateFiniteNode(ctx, node.left, step, env);
+        leftAccumulator = step === pos ? leftVerdict : andV(leftAccumulator, leftVerdict);
+        if (leftAccumulator === "violated") {
+          break;
+        }
+      }
+      return "violated";
+    }
+    case "release": {
+      if (pos >= len) {
+        return "satisfied";
+      }
+      let allRight = "satisfied";
+      for (let step = pos; step < len; step++) {
+        allRight = andV(allRight, evaluateFiniteNode(ctx, node.right, step, env));
+        const leftVerdict = evaluateFiniteNode(ctx, node.left, step, env);
+        if (leftVerdict === "satisfied" && allRight === "satisfied") {
+          return "satisfied";
+        }
+        if (allRight === "violated") {
+          break;
+        }
+      }
+      return allRight === "satisfied" ? "satisfied" : "violated";
+    }
+    case "once": {
+      if (pos >= len) {
+        return "violated";
+      }
+      for (let step = pos; step >= 0; step--) {
+        if (evaluateFiniteNode(ctx, node.child, step, env) === "satisfied") {
+          return "satisfied";
+        }
+      }
+      return "violated";
+    }
+    case "historically": {
+      if (pos >= len) {
+        return "satisfied";
+      }
+      for (let step = 0; step <= pos; step++) {
+        if (evaluateFiniteNode(ctx, node.child, step, env) === "violated") {
+          return "violated";
+        }
+      }
+      return "satisfied";
+    }
+    case "since": {
+      if (pos >= len) {
+        return "violated";
+      }
+      for (let witness = pos; witness >= 0; witness--) {
+        if (evaluateFiniteNode(ctx, node.right, witness, env) !== "satisfied") {
+          continue;
+        }
+        let leftOk = "satisfied";
+        for (let step = witness + 1; step <= pos; step++) {
+          leftOk = andV(leftOk, evaluateFiniteNode(ctx, node.left, step, env));
+          if (leftOk === "violated") {
+            break;
+          }
+        }
+        if (leftOk === "satisfied") {
+          return "satisfied";
+        }
+      }
+      return "violated";
+    }
+    case "withinSteps": {
+      const upper = Math.min(pos + node.steps, len);
+      for (let step = pos; step < upper; step++) {
+        if (evaluateFiniteNode(ctx, node.child, step, env) === "satisfied") {
+          return "satisfied";
+        }
+      }
+      return "violated";
+    }
+    case "withinMs": {
+      if (pos >= len) {
+        return "violated";
+      }
+      const startTs = getTimestamp(ctx.runtime, ctx.trace[pos]);
+      for (let step = pos; step < len; step++) {
+        const currentTs = getTimestamp(ctx.runtime, ctx.trace[step]);
+        if (currentTs - startTs > node.ms) {
+          break;
+        }
+        if (evaluateFiniteNode(ctx, node.child, step, env) === "satisfied") {
+          return "satisfied";
+        }
+      }
+      return "violated";
+    }
+  }
+}
+
+// src/monitor/evaluate.ts
+function evaluateFormula(doc, runtime, trace) {
+  return evaluateFiniteFormula(doc, runtime, trace);
+}
+
+// src/monitor/diagnostics.ts
+function buildCounterexampleReport(doc, runtime, trace) {
+  const ctx = createFiniteEvalContext(doc, runtime, trace);
+  const env = /* @__PURE__ */ new Map();
+  const verdict = evaluateFiniteNode(ctx, doc.root, 0, env);
+  if (verdict !== "violated") {
+    return null;
+  }
+  const failurePath = [];
+  collectFailurePath(ctx, doc.root, 0, env, failurePath);
+  return {
+    verdict: "violated",
+    failurePath,
+    traceSlice: trace.map((event, i) => ({ step: i + 1, event })),
+    summary: `Formula violated: ${print(doc)}`
+  };
+}
+function collectFailurePath(ctx, nodeId, pos, env, path) {
+  const verdict = evaluateFiniteNode(ctx, nodeId, pos, env);
+  path.push({
+    nodeId,
+    activationId: toActivationId(nodeId, pos, env),
+    verdict,
+    step: pos
+  });
+  const node = ctx.doc.nodes[nodeId];
+  if (!node) {
+    return;
+  }
+  switch (node.kind) {
+    case "literal":
+    case "predicate":
+      return;
+    case "when": {
+      if (pos >= ctx.trace.length) {
+        return;
+      }
+      const captured = env.get(node.captureName);
+      if (captured === void 0) {
+        return;
+      }
+      const selectorFn = ctx.runtime.selectors[node.selectorId];
+      if (!selectorFn) {
+        return;
+      }
+      const currentVal = selectorFn(ctx.trace[pos]);
+      if (!jsonEqual(captured, currentVal)) {
+        return;
+      }
+      collectFailurePath(ctx, node.child, pos, env, path);
+      return;
+    }
+    case "capture": {
+      if (pos >= ctx.trace.length) {
+        return;
+      }
+      const selectorFn = ctx.runtime.selectors[node.selectorId];
+      if (!selectorFn) {
+        return;
+      }
+      const nextEnv = new Map(env);
+      nextEnv.set(node.captureName, selectorFn(ctx.trace[pos]));
+      collectFailurePath(ctx, node.child, pos, nextEnv, path);
+      return;
+    }
+    case "not":
+      collectFailurePath(ctx, node.child, pos, env, path);
+      return;
+    case "and":
+    case "or": {
+      const childId = pickBooleanChild(ctx, node, pos, env, verdict);
+      if (childId) {
+        collectFailurePath(ctx, childId, pos, env, path);
+      }
+      return;
+    }
+    case "implies": {
+      const leftVerdict = evaluateFiniteNode(ctx, node.left, pos, env);
+      const rightVerdict = evaluateFiniteNode(ctx, node.right, pos, env);
+      if (verdict === "violated") {
+        collectFailurePath(ctx, node.right, pos, env, path);
+        return;
+      }
+      if (rightVerdict === "satisfied") {
+        collectFailurePath(ctx, node.right, pos, env, path);
+        return;
+      }
+      if (leftVerdict !== verdict || rightVerdict === "pending") {
+        collectFailurePath(ctx, node.left, pos, env, path);
+        return;
+      }
+      return;
+    }
+    case "always": {
+      const childPos = verdict === "violated" ? findFirstPosition(ctx, node.child, pos, ctx.trace.length - 1, env, "violated") : pos < ctx.trace.length ? pos : null;
+      if (childPos !== null) {
+        collectFailurePath(ctx, node.child, childPos, env, path);
+      }
+      return;
+    }
+    case "eventually": {
+      const childPos = verdict === "satisfied" ? findFirstPosition(ctx, node.child, pos, ctx.trace.length - 1, env, "satisfied") : findLastPosition(ctx, node.child, pos, ctx.trace.length - 1, env, "violated");
+      if (childPos !== null) {
+        collectFailurePath(ctx, node.child, childPos, env, path);
+      }
+      return;
+    }
+    case "next":
+    case "weakNext":
+      if (pos + 1 < ctx.trace.length) {
+        collectFailurePath(ctx, node.child, pos + 1, env, path);
+      }
+      return;
+    case "until": {
+      const witness = findUntilFailureOrWitness(ctx, node, pos, env, verdict);
+      if (witness) {
+        collectFailurePath(ctx, witness.nodeId, witness.pos, env, path);
+      }
+      return;
+    }
+    case "release": {
+      const witness = findReleaseFailureOrWitness(ctx, node, pos, env, verdict);
+      if (witness) {
+        collectFailurePath(ctx, witness.nodeId, witness.pos, env, path);
+      }
+      return;
+    }
+    case "once": {
+      const childPos = verdict === "satisfied" ? findLastPosition(ctx, node.child, 0, pos, env, "satisfied") : pos < ctx.trace.length ? pos : null;
+      if (childPos !== null) {
+        collectFailurePath(ctx, node.child, childPos, env, path);
+      }
+      return;
+    }
+    case "historically": {
+      const childPos = verdict === "violated" ? findFirstPosition(ctx, node.child, 0, pos, env, "violated") : pos < ctx.trace.length ? pos : null;
+      if (childPos !== null) {
+        collectFailurePath(ctx, node.child, childPos, env, path);
+      }
+      return;
+    }
+    case "since": {
+      const witness = findSinceFailureOrWitness(ctx, node, pos, env, verdict);
+      if (witness) {
+        collectFailurePath(ctx, witness.nodeId, witness.pos, env, path);
+      }
+      return;
+    }
+    case "withinSteps": {
+      const upper = Math.min(pos + node.steps - 1, ctx.trace.length - 1);
+      const childPos = verdict === "satisfied" ? findFirstPosition(ctx, node.child, pos, upper, env, "satisfied") : findLastPosition(ctx, node.child, pos, upper, env, "violated");
+      if (childPos !== null) {
+        collectFailurePath(ctx, node.child, childPos, env, path);
+      }
+      return;
+    }
+    case "withinMs": {
+      if (pos >= ctx.trace.length) {
+        return;
+      }
+      const startTs = getTimestamp(ctx.runtime, ctx.trace[pos]);
+      let lastInBudget = null;
+      for (let i = pos; i < ctx.trace.length; i++) {
+        const currentTs = getTimestamp(ctx.runtime, ctx.trace[i]);
+        if (currentTs - startTs > node.ms) {
+          break;
+        }
+        lastInBudget = i;
+        if (verdict === "satisfied" && evaluateFiniteNode(ctx, node.child, i, env) === "satisfied") {
+          collectFailurePath(ctx, node.child, i, env, path);
+          return;
+        }
+      }
+      if (verdict === "violated" && lastInBudget !== null) {
+        const childPos = findLastPosition(ctx, node.child, pos, lastInBudget, env, "violated");
+        if (childPos !== null) {
+          collectFailurePath(ctx, node.child, childPos, env, path);
+        }
+      }
+    }
+  }
+}
+function pickBooleanChild(ctx, node, pos, env, verdict) {
+  for (const childId of node.children) {
+    const childVerdict = evaluateFiniteNode(ctx, childId, pos, env);
+    if (verdict === "violated" && childVerdict === "violated") {
+      return childId;
+    }
+    if (verdict === "satisfied" && childVerdict === "satisfied") {
+      return childId;
+    }
+    if (verdict === "pending" && childVerdict === "pending") {
+      return childId;
+    }
+  }
+  return node.children[0] ?? null;
+}
+function findUntilFailureOrWitness(ctx, node, pos, env, verdict) {
+  if (pos >= ctx.trace.length) {
+    return null;
+  }
+  let leftAcc = "satisfied";
+  for (let j = pos; j < ctx.trace.length; j++) {
+    const rightVerdict = evaluateFiniteNode(ctx, node.right, j, env);
+    if (rightVerdict === "satisfied" && leftAcc === "satisfied") {
+      return verdict === "satisfied" ? { nodeId: node.right, pos: j } : null;
+    }
+    const leftVerdict = evaluateFiniteNode(ctx, node.left, j, env);
+    if (verdict === "violated" && leftAcc === "satisfied" && leftVerdict === "violated") {
+      return { nodeId: node.left, pos: j };
+    }
+    leftAcc = j === pos ? leftVerdict : andV(leftAcc, leftVerdict);
+    if (leftAcc === "violated") {
+      break;
+    }
+  }
+  if (verdict === "violated") {
+    const rightPos = findLastPosition(ctx, node.right, pos, ctx.trace.length - 1, env, "violated");
+    if (rightPos !== null) {
+      return { nodeId: node.right, pos: rightPos };
+    }
+  }
+  return null;
+}
+function findReleaseFailureOrWitness(ctx, node, pos, env, verdict) {
+  if (pos >= ctx.trace.length) {
+    return null;
+  }
+  let allRight = "satisfied";
+  for (let j = pos; j < ctx.trace.length; j++) {
+    const rightVerdict = evaluateFiniteNode(ctx, node.right, j, env);
+    if (verdict === "violated" && allRight === "satisfied" && rightVerdict === "violated") {
+      return { nodeId: node.right, pos: j };
+    }
+    allRight = andV(allRight, rightVerdict);
+    const leftVerdict = evaluateFiniteNode(ctx, node.left, j, env);
+    if (leftVerdict === "satisfied" && allRight === "satisfied") {
+      return verdict === "satisfied" ? { nodeId: node.left, pos: j } : null;
+    }
+    if (allRight === "violated") {
+      break;
+    }
+  }
+  if (verdict === "satisfied" && pos < ctx.trace.length) {
+    return { nodeId: node.right, pos };
+  }
+  return null;
+}
+function findSinceFailureOrWitness(ctx, node, pos, env, verdict) {
+  if (pos >= ctx.trace.length) {
+    return null;
+  }
+  for (let j = pos; j >= 0; j--) {
+    const rightVerdict = evaluateFiniteNode(ctx, node.right, j, env);
+    if (rightVerdict === "satisfied") {
+      let leftOk = "satisfied";
+      for (let i = j + 1; i <= pos; i++) {
+        const leftVerdict = evaluateFiniteNode(ctx, node.left, i, env);
+        if (verdict === "violated" && leftVerdict === "violated") {
+          return { nodeId: node.left, pos: i };
+        }
+        leftOk = andV(leftOk, leftVerdict);
+        if (leftOk === "violated") {
+          break;
+        }
+      }
+      if (leftOk === "satisfied") {
+        return verdict === "satisfied" ? { nodeId: node.right, pos: j } : null;
+      }
+    }
+  }
+  if (verdict === "violated") {
+    const rightPos = findFirstPosition(ctx, node.right, 0, pos, env, "violated");
+    if (rightPos !== null) {
+      return { nodeId: node.right, pos: rightPos };
+    }
+  }
+  return null;
+}
+function findFirstPosition(ctx, nodeId, start, end, env, verdict) {
+  if (start > end) {
+    return null;
+  }
+  for (let pos = start; pos <= end; pos++) {
+    if (evaluateFiniteNode(ctx, nodeId, pos, env) === verdict) {
+      return pos;
+    }
+  }
+  return null;
+}
+function findLastPosition(ctx, nodeId, start, end, env, verdict) {
+  if (start > end) {
+    return null;
+  }
+  for (let pos = end; pos >= start; pos--) {
+    if (evaluateFiniteNode(ctx, nodeId, pos, env) === verdict) {
+      return pos;
+    }
+  }
+  return null;
+}
+function toActivationId(nodeId, pos, env) {
+  return activationId(`${nodeId}:${pos}:${encodeURIComponent(envKey(env))}`);
+}
+
+// src/monitor/run-oracle.ts
+function runOracle(formula, runtime, trace) {
+  const doc = compile(formula);
+  const errors = validate(doc);
+  if (errors.length > 0) {
+    const messages = errors.map((e) => `${e.nodeId}: ${e.message}`).join("; ");
+    throw new Error(`Invalid formula: ${messages}`);
+  }
+  const verdict = evaluateFormula(doc, runtime, trace);
+  const report = verdict === "violated" ? buildCounterexampleReport(doc, runtime, trace) ?? {
+    verdict: "violated",
+    failurePath: [],
+    traceSlice: trace.map((event, i) => ({ step: i + 1, event })),
+    summary: `Formula violated: ${print(doc)}`
+  } : null;
+  return {
+    verdict,
+    steps: trace.length,
+    report
+  };
+}
+
+export {
+  assertWithinMsRuntimeSupport,
+  cacheKey,
+  resolveArg,
+  jsonEqual,
+  getTimestamp,
+  assertTimeSupportForTrace,
+  buildCounterexampleReport,
+  evaluateFormula,
+  runOracle
+};
+//# sourceMappingURL=chunk-EICHUHZH.js.map