@atsumell/trace-weave 0.1.0

package/dist/fast-check/index.js

@@ -0,0 +1,64 @@
+import {
+  runOracle
+} from "../chunk-EICHUHZH.js";
+import "../chunk-AS6LZLUH.js";
+import "../chunk-WIW3TVEK.js";
+import "../chunk-B4SEKVLL.js";
+
+// src/fast-check/trace-arbitrary.ts
+import * as fc from "fast-check";
+function traceArbitrary(config) {
+  return fc.array(config.eventArbitrary, {
+    minLength: config.minLength ?? 1,
+    maxLength: config.maxLength ?? 50
+  });
+}
+
+// src/fast-check/command-adapter.ts
+import * as fc2 from "fast-check";
+function commandAdapter(config) {
+  return fc2.commands(config.commands).map((cmds) => {
+    const events = [];
+    const model = config.initialModel();
+    const real = config.initialReal();
+    for (const cmd of cmds) {
+      if (cmd.check(model)) {
+        const modelBefore = JSON.parse(JSON.stringify(model));
+        cmd.run(model, real);
+        const modelAfter = JSON.parse(JSON.stringify(model));
+        events.push({
+          type: cmd.toString(),
+          modelBefore,
+          modelAfter
+        });
+      }
+    }
+    return events;
+  });
+}
+
+// src/fast-check/properties.ts
+import * as fc3 from "fast-check";
+function traceProperty(config) {
+  return fc3.property(config.traceArbitrary, (trace) => {
+    const result = runOracle(config.formula, config.runtime, trace);
+    if (result.verdict === "violated") {
+      const msg = result.report?.summary ?? "Formula violated";
+      throw new Error(msg);
+    }
+  });
+}
+function commandProperty(formula, runtime, commandArbitrary) {
+  return traceProperty({
+    formula,
+    runtime,
+    traceArbitrary: commandArbitrary
+  });
+}
+export {
+  commandAdapter,
+  commandProperty,
+  traceArbitrary,
+  traceProperty
+};
+//# sourceMappingURL=index.js.map

package/dist/fast-check/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fast-check/trace-arbitrary.ts","../../src/fast-check/command-adapter.ts","../../src/fast-check/properties.ts"],"sourcesContent":["import * as fc from \"fast-check\";\n\nexport interface TraceConfig<TEvent> {\n\treadonly eventArbitrary: fc.Arbitrary<TEvent>;\n\treadonly minLength?: number;\n\treadonly maxLength?: number;\n}\n\nexport function traceArbitrary<TEvent>(config: TraceConfig<TEvent>): fc.Arbitrary<TEvent[]> {\n\treturn fc.array(config.eventArbitrary, {\n\t\tminLength: config.minLength ?? 1,\n\t\tmaxLength: config.maxLength ?? 50,\n\t});\n}\n","import * as fc from \"fast-check\";\n\nexport interface TraceEvent<TModel> {\n\treadonly type: string;\n\treadonly payload?: unknown;\n\treadonly modelBefore?: TModel;\n\treadonly modelAfter?: TModel;\n}\n\nexport interface CommandAdapterConfig<TModel extends object, TReal> {\n\treadonly commands: fc.Arbitrary<fc.Command<TModel, TReal>>[];\n\treadonly initialModel: () => TModel;\n\treadonly initialReal: () => TReal;\n}\n\nexport function commandAdapter<TModel extends object, TReal>(\n\tconfig: CommandAdapterConfig<TModel, TReal>,\n): fc.Arbitrary<TraceEvent<TModel>[]> {\n\treturn fc.commands(config.commands).map((cmds) => {\n\t\tconst events: TraceEvent<TModel>[] = [];\n\t\tconst model = config.initialModel();\n\t\tconst real = config.initialReal();\n\n\t\tfor (const cmd of cmds) {\n\t\t\tif (cmd.check(model)) {\n\t\t\t\tconst modelBefore = JSON.parse(JSON.stringify(model)) as TModel;\n\t\t\t\tcmd.run(model, real);\n\t\t\t\tconst modelAfter = JSON.parse(JSON.stringify(model)) as TModel;\n\n\t\t\t\tevents.push({\n\t\t\t\t\ttype: cmd.toString(),\n\t\t\t\t\tmodelBefore,\n\t\t\t\t\tmodelAfter,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\treturn events;\n\t});\n}\n","import * as fc from \"fast-check\";\nimport type { FormulaExpr } from \"../core/formula-expr.js\";\nimport type { MonitorRuntime } from \"../core/runtime.js\";\nimport { runOracle } from \"../monitor/run-oracle.js\";\n\nexport interface TracePropertyConfig<TEvent> {\n\treadonly formula: FormulaExpr;\n\treadonly runtime: MonitorRuntime<TEvent>;\n\treadonly traceArbitrary: fc.Arbitrary<TEvent[]>;\n}\n\nexport function traceProperty<TEvent>(\n\tconfig: TracePropertyConfig<TEvent>,\n): fc.IPropertyWithHooks<[TEvent[]]> {\n\treturn fc.property(config.traceArbitrary, (trace) => {\n\t\tconst result = runOracle(config.formula, config.runtime, trace);\n\t\tif (result.verdict === \"violated\") {\n\t\t\tconst msg = result.report?.summary ?? \"Formula violated\";\n\t\t\tthrow new Error(msg);\n\t\t}\n\t});\n}\n\nexport function commandProperty<TEvent>(\n\tformula: FormulaExpr,\n\truntime: MonitorRuntime<TEvent>,\n\tcommandArbitrary: fc.Arbitrary<TEvent[]>,\n): fc.IPropertyWithHooks<[TEvent[]]> {\n\treturn traceProperty({\n\t\tformula,\n\t\truntime,\n\t\ttraceArbitrary: commandArbitrary,\n\t});\n}\n"],"mappings":";;;;;;;;AAAA,YAAY,QAAQ;AAQb,SAAS,eAAuB,QAAqD;AAC3F,SAAU,SAAM,OAAO,gBAAgB;AAAA,IACtC,WAAW,OAAO,aAAa;AAAA,IAC/B,WAAW,OAAO,aAAa;AAAA,EAChC,CAAC;AACF;;;ACbA,YAAYA,SAAQ;AAeb,SAAS,eACf,QACqC;AACrC,SAAU,aAAS,OAAO,QAAQ,EAAE,IAAI,CAAC,SAAS;AACjD,UAAM,SAA+B,CAAC;AACtC,UAAM,QAAQ,OAAO,aAAa;AAClC,UAAM,OAAO,OAAO,YAAY;AAEhC,eAAW,OAAO,MAAM;AACvB,UAAI,IAAI,MAAM,KAAK,GAAG;AACrB,cAAM,cAAc,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AACpD,YAAI,IAAI,OAAO,IAAI;AACnB,cAAM,aAAa,KAAK,MAAM,KAAK,UAAU,KAAK,CAAC;AAEnD,eAAO,KAAK;AAAA,UACX,MAAM,IAAI,SAAS;AAAA,UACnB;AAAA,UACA;AAAA,QACD,CAAC;AAAA,MACF;AAAA,IACD;AAEA,WAAO;AAAA,EACR,CAAC;AACF;;;ACvCA,YAAYC,SAAQ;AAWb,SAAS,cACf,QACoC;AACpC,SAAU,aAAS,OAAO,gBAAgB,CAAC,UAAU;AACpD,UAAM,SAAS,UAAU,OAAO,SAAS,OAAO,SAAS,KAAK;AAC9D,QAAI,OAAO,YAAY,YAAY;AAClC,YAAM,MAAM,OAAO,QAAQ,WAAW;AACtC,YAAM,IAAI,MAAM,GAAG;AAAA,IACpB;AAAA,EACD,CAAC;AACF;AAEO,SAAS,gBACf,SACA,SACA,kBACoC;AACpC,SAAO,cAAc;AAAA,IACpB;AAAA,IACA;AAAA,IACA,gBAAgB;AAAA,EACjB,CAAC;AACF;","names":["fc","fc"]}

package/dist/formula-document-ChXznpvJ.d.ts

@@ -0,0 +1,99 @@
+import { N as NodeId, C as CaptureName, S as SelectorId, P as PredicateId, V as ValueExprArg, a as NodeProvenance } from './values-CEF1lKTL.js';
+
+interface LiteralNode {
+    readonly kind: "literal";
+    readonly value: boolean;
+}
+interface PredicateNode {
+    readonly kind: "predicate";
+    readonly predicateId: PredicateId;
+    readonly args?: readonly ValueExprArg[];
+}
+interface WhenNode {
+    readonly kind: "when";
+    readonly captureName: CaptureName;
+    readonly selectorId: SelectorId;
+    readonly child: NodeId;
+}
+interface CaptureNode {
+    readonly kind: "capture";
+    readonly captureName: CaptureName;
+    readonly selectorId: SelectorId;
+    readonly child: NodeId;
+}
+interface NotNode {
+    readonly kind: "not";
+    readonly child: NodeId;
+}
+interface AndNode {
+    readonly kind: "and";
+    readonly children: readonly NodeId[];
+}
+interface OrNode {
+    readonly kind: "or";
+    readonly children: readonly NodeId[];
+}
+interface ImpliesNode {
+    readonly kind: "implies";
+    readonly left: NodeId;
+    readonly right: NodeId;
+}
+interface AlwaysNode {
+    readonly kind: "always";
+    readonly child: NodeId;
+}
+interface EventuallyNode {
+    readonly kind: "eventually";
+    readonly child: NodeId;
+}
+interface NextNode {
+    readonly kind: "next";
+    readonly child: NodeId;
+}
+interface WeakNextNode {
+    readonly kind: "weakNext";
+    readonly child: NodeId;
+}
+interface UntilNode {
+    readonly kind: "until";
+    readonly left: NodeId;
+    readonly right: NodeId;
+}
+interface ReleaseNode {
+    readonly kind: "release";
+    readonly left: NodeId;
+    readonly right: NodeId;
+}
+interface OnceNode {
+    readonly kind: "once";
+    readonly child: NodeId;
+}
+interface HistoricallyNode {
+    readonly kind: "historically";
+    readonly child: NodeId;
+}
+interface SinceNode {
+    readonly kind: "since";
+    readonly left: NodeId;
+    readonly right: NodeId;
+}
+interface WithinStepsNode {
+    readonly kind: "withinSteps";
+    readonly steps: number;
+    readonly child: NodeId;
+}
+interface WithinMsNode {
+    readonly kind: "withinMs";
+    readonly ms: number;
+    readonly child: NodeId;
+}
+type FormulaNode = LiteralNode | PredicateNode | WhenNode | CaptureNode | NotNode | AndNode | OrNode | ImpliesNode | AlwaysNode | EventuallyNode | NextNode | WeakNextNode | UntilNode | ReleaseNode | OnceNode | HistoricallyNode | SinceNode | WithinStepsNode | WithinMsNode;
+
+interface FormulaDocument {
+    readonly schemaVersion: 1;
+    readonly root: NodeId;
+    readonly nodes: Readonly<Record<NodeId, FormulaNode>>;
+    readonly provenance?: Readonly<Record<NodeId, NodeProvenance>>;
+}
+
+export type { AlwaysNode as A, CaptureNode as C, EventuallyNode as E, FormulaDocument as F, HistoricallyNode as H, ImpliesNode as I, LiteralNode as L, NextNode as N, OnceNode as O, PredicateNode as P, ReleaseNode as R, SinceNode as S, UntilNode as U, WeakNextNode as W, AndNode as a, FormulaNode as b, NotNode as c, OrNode as d, WhenNode as e, WithinMsNode as f, WithinStepsNode as g };

package/dist/formula-expr-DAHklv9S.d.ts

@@ -0,0 +1,111 @@
+import { F as FormulaMeta, P as PredicateId, V as ValueExprArg, C as CaptureName, S as SelectorId } from './values-CEF1lKTL.js';
+
+interface LiteralExpr {
+    readonly kind: "literal";
+    readonly value: boolean;
+    readonly meta?: FormulaMeta;
+}
+interface PredicateExpr {
+    readonly kind: "predicate";
+    readonly predicateId: PredicateId;
+    readonly args?: readonly ValueExprArg[];
+    readonly meta?: FormulaMeta;
+}
+interface WhenExpr {
+    readonly kind: "when";
+    readonly captureName: CaptureName;
+    readonly selectorId: SelectorId;
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface CaptureExpr {
+    readonly kind: "capture";
+    readonly captureName: CaptureName;
+    readonly selectorId: SelectorId;
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface NotExpr {
+    readonly kind: "not";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface AndExpr {
+    readonly kind: "and";
+    readonly children: readonly FormulaExpr[];
+    readonly meta?: FormulaMeta;
+}
+interface OrExpr {
+    readonly kind: "or";
+    readonly children: readonly FormulaExpr[];
+    readonly meta?: FormulaMeta;
+}
+interface ImpliesExpr {
+    readonly kind: "implies";
+    readonly left: FormulaExpr;
+    readonly right: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface AlwaysExpr {
+    readonly kind: "always";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface EventuallyExpr {
+    readonly kind: "eventually";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface NextExpr {
+    readonly kind: "next";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface WeakNextExpr {
+    readonly kind: "weakNext";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface UntilExpr {
+    readonly kind: "until";
+    readonly left: FormulaExpr;
+    readonly right: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface ReleaseExpr {
+    readonly kind: "release";
+    readonly left: FormulaExpr;
+    readonly right: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface OnceExpr {
+    readonly kind: "once";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface HistoricallyExpr {
+    readonly kind: "historically";
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface SinceExpr {
+    readonly kind: "since";
+    readonly left: FormulaExpr;
+    readonly right: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface WithinStepsExpr {
+    readonly kind: "withinSteps";
+    readonly steps: number;
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+interface WithinMsExpr {
+    readonly kind: "withinMs";
+    readonly ms: number;
+    readonly child: FormulaExpr;
+    readonly meta?: FormulaMeta;
+}
+type FormulaExpr = LiteralExpr | PredicateExpr | WhenExpr | CaptureExpr | NotExpr | AndExpr | OrExpr | ImpliesExpr | AlwaysExpr | EventuallyExpr | NextExpr | WeakNextExpr | UntilExpr | ReleaseExpr | OnceExpr | HistoricallyExpr | SinceExpr | WithinStepsExpr | WithinMsExpr;
+
+export type { AlwaysExpr as A, CaptureExpr as C, EventuallyExpr as E, FormulaExpr as F, HistoricallyExpr as H, ImpliesExpr as I, LiteralExpr as L, NextExpr as N, OnceExpr as O, PredicateExpr as P, ReleaseExpr as R, SinceExpr as S, UntilExpr as U, WeakNextExpr as W, AndExpr as a, NotExpr as b, OrExpr as c, WhenExpr as d, WithinMsExpr as e, WithinStepsExpr as f };

package/dist/monitor/index.d.ts

@@ -0,0 +1,23 @@
+import { M as MonitorState, O as OracleRunResult, C as CounterexampleReport } from '../types-xatgZlwH.js';
+export { a as ObligationSnapshot } from '../types-xatgZlwH.js';
+import { C as CompiledFormula } from '../prepare-CrKEArDt.js';
+import { M as MonitorRuntime } from '../runtime-Do1rQFhQ.js';
+import { V as Verdict } from '../verdict-DYG0WE3o.js';
+import { F as FormulaDocument } from '../formula-document-ChXznpvJ.js';
+import { F as FormulaExpr } from '../formula-expr-DAHklv9S.js';
+import '../values-CEF1lKTL.js';
+
+declare function createMonitor<TEvent>(compiled: CompiledFormula, runtime: MonitorRuntime<TEvent>): MonitorState<TEvent>;
+
+declare function evaluateStep<TEvent>(state: MonitorState<TEvent>, event: TEvent): Verdict;
+
+declare function finalize<TEvent>(state: MonitorState<TEvent>, lastEvent: TEvent): Verdict;
+declare function finalizeEmpty<TEvent>(state: MonitorState<TEvent>): Verdict;
+
+declare function evaluateFormula<TEvent>(doc: FormulaDocument, runtime: MonitorRuntime<TEvent>, trace: readonly TEvent[]): Verdict;
+
+declare function runOracle<TEvent>(formula: FormulaExpr, runtime: MonitorRuntime<TEvent>, trace: readonly TEvent[]): OracleRunResult;
+
+declare function buildReport<TEvent>(state: MonitorState<TEvent>, trace: readonly TEvent[]): CounterexampleReport | null;
+
+export { CounterexampleReport, MonitorState, OracleRunResult, buildReport, createMonitor, evaluateFormula, evaluateStep, finalize, finalizeEmpty, runOracle };

package/dist/monitor/index.js

@@ -0,0 +1,251 @@
+import {
+  assertTimeSupportForTrace,
+  assertWithinMsRuntimeSupport,
+  buildCounterexampleReport,
+  cacheKey,
+  evaluateFormula,
+  getTimestamp,
+  jsonEqual,
+  resolveArg,
+  runOracle
+} from "../chunk-EICHUHZH.js";
+import {
+  andV,
+  impliesV,
+  notV,
+  orV
+} from "../chunk-AS6LZLUH.js";
+import {
+  print
+} from "../chunk-WIW3TVEK.js";
+import "../chunk-B4SEKVLL.js";
+
+// src/monitor/create.ts
+function createMonitor(compiled, runtime) {
+  assertWithinMsRuntimeSupport(compiled.document, runtime);
+  const state = {
+    compiled,
+    runtime,
+    step: 0,
+    trace: [],
+    currentVerdict: "pending",
+    finalized: false,
+    finalVerdict: null,
+    finalReport: null
+  };
+  return state;
+}
+
+// src/monitor/evaluate-prefix.ts
+function evalNode(ctx, nodeId, pos) {
+  const ck = cacheKey(nodeId, pos, ctx.envStack);
+  const cached = ctx.cache.get(ck);
+  if (cached !== void 0) return cached;
+  const node = ctx.doc.nodes[nodeId];
+  if (!node) return "violated";
+  ctx.cache.set(ck, "pending");
+  const result = evalNodeInner(ctx, node, pos);
+  ctx.cache.set(ck, result);
+  return result;
+}
+function evalNodeInner(ctx, node, pos) {
+  const len = ctx.trace.length;
+  switch (node.kind) {
+    case "literal":
+      return node.value ? "satisfied" : "violated";
+    case "predicate": {
+      if (pos >= len) return "pending";
+      const event = ctx.trace[pos];
+      const predicateFn = ctx.runtime.predicates[node.predicateId];
+      if (!predicateFn) return "violated";
+      const args = (node.args ?? []).map((arg) => resolveArg(arg, event, ctx.runtime));
+      return predicateFn(event, args) ? "satisfied" : "violated";
+    }
+    case "when": {
+      if (pos >= len) return "pending";
+      const event = ctx.trace[pos];
+      const captured = ctx.envStack.get(node.captureName);
+      if (captured === void 0) return "violated";
+      const selectorFn = ctx.runtime.selectors[node.selectorId];
+      if (!selectorFn) return "violated";
+      const currentVal = selectorFn(event);
+      if (!jsonEqual(captured, currentVal)) return "violated";
+      return evalNode(ctx, node.child, pos);
+    }
+    case "capture": {
+      if (pos >= len) return "pending";
+      const event = ctx.trace[pos];
+      const selectorFn = ctx.runtime.selectors[node.selectorId];
+      if (!selectorFn) return "violated";
+      const value = selectorFn(event);
+      const newEnv = new Map(ctx.envStack);
+      newEnv.set(node.captureName, value);
+      return evalNode({ ...ctx, envStack: newEnv }, node.child, pos);
+    }
+    case "not":
+      return notV(evalNode(ctx, node.child, pos));
+    case "and":
+      return node.children.reduce(
+        (result, childId) => andV(result, evalNode(ctx, childId, pos)),
+        "satisfied"
+      );
+    case "or":
+      return node.children.reduce(
+        (result, childId) => orV(result, evalNode(ctx, childId, pos)),
+        "violated"
+      );
+    case "implies":
+      return impliesV(evalNode(ctx, node.left, pos), evalNode(ctx, node.right, pos));
+    case "always":
+      if (pos >= len) return "pending";
+      return andV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos + 1));
+    case "eventually":
+      if (pos >= len) return "pending";
+      return orV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos + 1));
+    case "next":
+      if (pos + 1 >= len) return "pending";
+      return evalNode(ctx, node.child, pos + 1);
+    case "weakNext":
+      if (pos + 1 >= len) return "pending";
+      return evalNode(ctx, node.child, pos + 1);
+    case "until":
+      if (pos >= len) return "pending";
+      return orV(
+        evalNode(ctx, node.right, pos),
+        andV(evalNode(ctx, node.left, pos), evalNodeInner(ctx, node, pos + 1))
+      );
+    case "release":
+      if (pos >= len) return "pending";
+      return andV(
+        evalNode(ctx, node.right, pos),
+        orV(evalNode(ctx, node.left, pos), evalNodeInner(ctx, node, pos + 1))
+      );
+    case "once":
+      if (pos < 0) return "violated";
+      return orV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos - 1));
+    case "historically":
+      if (pos < 0) return "satisfied";
+      return andV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos - 1));
+    case "since":
+      if (pos < 0) return "violated";
+      return orV(
+        evalNode(ctx, node.right, pos),
+        andV(evalNode(ctx, node.left, pos), evalNodeInner(ctx, node, pos - 1))
+      );
+    case "withinSteps": {
+      if (pos >= len) return "pending";
+      const bound = pos + node.steps;
+      let sawPending = false;
+      for (let i = pos; i < Math.min(bound, len); i++) {
+        const verdict = evalNode(ctx, node.child, i);
+        if (verdict === "satisfied") return "satisfied";
+        if (verdict === "pending") sawPending = true;
+      }
+      if (sawPending) return "pending";
+      return len >= bound ? "violated" : "pending";
+    }
+    case "withinMs": {
+      if (pos >= len) return "pending";
+      const startTs = getTimestamp(ctx.runtime, ctx.trace[pos]);
+      let sawPending = false;
+      let sawPastDeadline = false;
+      for (let i = pos; i < len; i++) {
+        const currentTs = getTimestamp(ctx.runtime, ctx.trace[i]);
+        if (currentTs - startTs > node.ms) {
+          sawPastDeadline = true;
+          break;
+        }
+        const verdict = evalNode(ctx, node.child, i);
+        if (verdict === "satisfied") return "satisfied";
+        if (verdict === "pending") sawPending = true;
+      }
+      if (sawPending) return "pending";
+      return sawPastDeadline ? "violated" : "pending";
+    }
+  }
+}
+function evaluateObservedPrefix(doc, runtime, trace) {
+  assertTimeSupportForTrace(doc, runtime, trace);
+  const ctx = {
+    doc,
+    runtime,
+    trace,
+    envStack: /* @__PURE__ */ new Map(),
+    cache: /* @__PURE__ */ new Map()
+  };
+  return evalNode(ctx, doc.root, 0);
+}
+
+// src/monitor/evaluate-step.ts
+function evaluateStep(state, event) {
+  if (state.finalized) {
+    throw new Error("Cannot evaluate step on a finalized monitor");
+  }
+  state.trace.push(event);
+  state.step++;
+  state.currentVerdict = evaluateObservedPrefix(
+    state.compiled.document,
+    state.runtime,
+    state.trace
+  );
+  return state.currentVerdict;
+}
+
+// src/monitor/finalize.ts
+function finalize(state, lastEvent) {
+  if (state.finalized) {
+    return getFinalizedVerdict(state);
+  }
+  if (state.trace.length === 0) {
+    state.trace.push(lastEvent);
+  }
+  return finalizeObservedTrace(state);
+}
+function finalizeEmpty(state) {
+  if (state.finalized) {
+    return getFinalizedVerdict(state);
+  }
+  if (state.trace.length > 0) {
+    throw new Error("Cannot finalize a non-empty monitor with finalizeEmpty(); use finalize()");
+  }
+  return finalizeObservedTrace(state);
+}
+function getFinalizedVerdict(state) {
+  const internalState = state;
+  return internalState.finalVerdict ?? state.currentVerdict;
+}
+function finalizeObservedTrace(state) {
+  const internalState = state;
+  state.finalized = true;
+  const verdict = evaluateFormula(state.compiled.document, state.runtime, state.trace);
+  state.currentVerdict = verdict;
+  internalState.finalVerdict = verdict;
+  internalState.finalReport = verdict === "violated" ? buildCounterexampleReport(state.compiled.document, state.runtime, state.trace) ?? {
+    verdict: "violated",
+    failurePath: [],
+    traceSlice: state.trace.map((event, i) => ({ step: i + 1, event })),
+    summary: `Formula violated: ${print(state.compiled.document)}`
+  } : null;
+  return verdict;
+}
+
+// src/monitor/report.ts
+function buildReport(state, trace) {
+  if (state.finalized) {
+    return state.finalReport;
+  }
+  if (state.currentVerdict !== "violated") {
+    return null;
+  }
+  return buildCounterexampleReport(state.compiled.document, state.runtime, trace);
+}
+export {
+  buildReport,
+  createMonitor,
+  evaluateFormula,
+  evaluateStep,
+  finalize,
+  finalizeEmpty,
+  runOracle
+};
+//# sourceMappingURL=index.js.map

package/dist/monitor/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/monitor/create.ts","../../src/monitor/evaluate-prefix.ts","../../src/monitor/evaluate-step.ts","../../src/monitor/finalize.ts","../../src/monitor/report.ts"],"sourcesContent":["import type { CompiledFormula } from \"../compiler/prepare.js\";\nimport type { MonitorRuntime } from \"../core/runtime.js\";\nimport type { InternalMonitorState, MonitorState } from \"./types.js\";\nimport { assertWithinMsRuntimeSupport } from \"./unsupported.js\";\n\nexport function createMonitor<TEvent>(\n\tcompiled: CompiledFormula,\n\truntime: MonitorRuntime<TEvent>,\n): MonitorState<TEvent> {\n\tassertWithinMsRuntimeSupport(compiled.document, runtime);\n\n\tconst state: InternalMonitorState<TEvent> = {\n\t\tcompiled,\n\t\truntime,\n\t\tstep: 0,\n\t\ttrace: [],\n\t\tcurrentVerdict: \"pending\",\n\t\tfinalized: false,\n\t\tfinalVerdict: null,\n\t\tfinalReport: null,\n\t};\n\n\treturn state;\n}\n","import type { FormulaDocument } from \"../core/formula-document.js\";\nimport type { FormulaNode } from \"../core/formula-node.js\";\nimport type { NodeId } from \"../core/ids.js\";\nimport type { MonitorRuntime } from \"../core/runtime.js\";\nimport type { JsonValue } from \"../core/values.js\";\nimport type { Verdict } from \"../core/verdict.js\";\nimport { andV, impliesV, notV, orV } from \"../core/verdict.js\";\nimport { type EvalEnv, cacheKey, jsonEqual, resolveArg } from \"./eval-common.js\";\nimport { assertTimeSupportForTrace, getTimestamp } from \"./time.js\";\n\ninterface EvalContext<TEvent> {\n\treadonly doc: FormulaDocument;\n\treadonly runtime: MonitorRuntime<TEvent>;\n\treadonly trace: readonly TEvent[];\n\treadonly envStack: EvalEnv;\n\treadonly cache: Map<string, Verdict>;\n}\n\nfunction evalNode<TEvent>(ctx: EvalContext<TEvent>, nodeId: NodeId, pos: number): Verdict {\n\tconst ck = cacheKey(nodeId, pos, ctx.envStack);\n\tconst cached = ctx.cache.get(ck);\n\tif (cached !== undefined) return cached;\n\n\tconst node = ctx.doc.nodes[nodeId];\n\tif (!node) return \"violated\";\n\n\tctx.cache.set(ck, \"pending\");\n\tconst result = evalNodeInner(ctx, node, pos);\n\tctx.cache.set(ck, result);\n\treturn result;\n}\n\nfunction evalNodeInner<TEvent>(ctx: EvalContext<TEvent>, node: FormulaNode, pos: number): Verdict {\n\tconst len = ctx.trace.length;\n\n\tswitch (node.kind) {\n\t\tcase \"literal\":\n\t\t\treturn node.value ? \"satisfied\" : \"violated\";\n\n\t\tcase \"predicate\": {\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\tconst event = ctx.trace[pos]!;\n\t\t\tconst predicateFn = ctx.runtime.predicates[node.predicateId];\n\t\t\tif (!predicateFn) return \"violated\";\n\t\t\tconst args = (node.args ?? []).map((arg) => resolveArg(arg, event, ctx.runtime));\n\t\t\treturn predicateFn(event, args) ? \"satisfied\" : \"violated\";\n\t\t}\n\n\t\tcase \"when\": {\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\tconst event = ctx.trace[pos]!;\n\t\t\tconst captured = ctx.envStack.get(node.captureName as string);\n\t\t\tif (captured === undefined) return \"violated\";\n\t\t\tconst selectorFn = ctx.runtime.selectors[node.selectorId];\n\t\t\tif (!selectorFn) return \"violated\";\n\t\t\tconst currentVal = selectorFn(event);\n\t\t\tif (!jsonEqual(captured, currentVal)) return \"violated\";\n\t\t\treturn evalNode(ctx, node.child, pos);\n\t\t}\n\n\t\tcase \"capture\": {\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\tconst event = ctx.trace[pos]!;\n\t\t\tconst selectorFn = ctx.runtime.selectors[node.selectorId];\n\t\t\tif (!selectorFn) return \"violated\";\n\t\t\tconst value = selectorFn(event);\n\t\t\tconst newEnv = new Map(ctx.envStack);\n\t\t\tnewEnv.set(node.captureName as string, value);\n\t\t\treturn evalNode({ ...ctx, envStack: newEnv }, node.child, pos);\n\t\t}\n\n\t\tcase \"not\":\n\t\t\treturn notV(evalNode(ctx, node.child, pos));\n\n\t\tcase \"and\":\n\t\t\treturn node.children.reduce<Verdict>(\n\t\t\t\t(result, childId) => andV(result, evalNode(ctx, childId, pos)),\n\t\t\t\t\"satisfied\",\n\t\t\t);\n\n\t\tcase \"or\":\n\t\t\treturn node.children.reduce<Verdict>(\n\t\t\t\t(result, childId) => orV(result, evalNode(ctx, childId, pos)),\n\t\t\t\t\"violated\",\n\t\t\t);\n\n\t\tcase \"implies\":\n\t\t\treturn impliesV(evalNode(ctx, node.left, pos), evalNode(ctx, node.right, pos));\n\n\t\tcase \"always\":\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\treturn andV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos + 1));\n\n\t\tcase \"eventually\":\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\treturn orV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos + 1));\n\n\t\tcase \"next\":\n\t\t\tif (pos + 1 >= len) return \"pending\";\n\t\t\treturn evalNode(ctx, node.child, pos + 1);\n\n\t\tcase \"weakNext\":\n\t\t\tif (pos + 1 >= len) return \"pending\";\n\t\t\treturn evalNode(ctx, node.child, pos + 1);\n\n\t\tcase \"until\":\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\treturn orV(\n\t\t\t\tevalNode(ctx, node.right, pos),\n\t\t\t\tandV(evalNode(ctx, node.left, pos), evalNodeInner(ctx, node, pos + 1)),\n\t\t\t);\n\n\t\tcase \"release\":\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\treturn andV(\n\t\t\t\tevalNode(ctx, node.right, pos),\n\t\t\t\torV(evalNode(ctx, node.left, pos), evalNodeInner(ctx, node, pos + 1)),\n\t\t\t);\n\n\t\tcase \"once\":\n\t\t\tif (pos < 0) return \"violated\";\n\t\t\treturn orV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos - 1));\n\n\t\tcase \"historically\":\n\t\t\tif (pos < 0) return \"satisfied\";\n\t\t\treturn andV(evalNode(ctx, node.child, pos), evalNodeInner(ctx, node, pos - 1));\n\n\t\tcase \"since\":\n\t\t\tif (pos < 0) return \"violated\";\n\t\t\treturn orV(\n\t\t\t\tevalNode(ctx, node.right, pos),\n\t\t\t\tandV(evalNode(ctx, node.left, pos), evalNodeInner(ctx, node, pos - 1)),\n\t\t\t);\n\n\t\tcase \"withinSteps\": {\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\tconst bound = pos + node.steps;\n\t\t\tlet sawPending = false;\n\t\t\tfor (let i = pos; i < Math.min(bound, len); i++) {\n\t\t\t\tconst verdict = evalNode(ctx, node.child, i);\n\t\t\t\tif (verdict === \"satisfied\") return \"satisfied\";\n\t\t\t\tif (verdict === \"pending\") sawPending = true;\n\t\t\t}\n\t\t\tif (sawPending) return \"pending\";\n\t\t\treturn len >= bound ? \"violated\" : \"pending\";\n\t\t}\n\n\t\tcase \"withinMs\": {\n\t\t\tif (pos >= len) return \"pending\";\n\t\t\tconst startTs = getTimestamp(ctx.runtime, ctx.trace[pos]!);\n\t\t\tlet sawPending = false;\n\t\t\tlet sawPastDeadline = false;\n\t\t\tfor (let i = pos; i < len; i++) {\n\t\t\t\tconst currentTs = getTimestamp(ctx.runtime, ctx.trace[i]!);\n\t\t\t\tif (currentTs - startTs > node.ms) {\n\t\t\t\t\tsawPastDeadline = true;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tconst verdict = evalNode(ctx, node.child, i);\n\t\t\t\tif (verdict === \"satisfied\") return \"satisfied\";\n\t\t\t\tif (verdict === \"pending\") sawPending = true;\n\t\t\t}\n\t\t\tif (sawPending) return \"pending\";\n\t\t\treturn sawPastDeadline ? \"violated\" : \"pending\";\n\t\t}\n\t}\n}\n\nexport function evaluateObservedPrefix<TEvent>(\n\tdoc: FormulaDocument,\n\truntime: MonitorRuntime<TEvent>,\n\ttrace: readonly TEvent[],\n): Verdict {\n\tassertTimeSupportForTrace(doc, runtime, trace);\n\tconst ctx: EvalContext<TEvent> = {\n\t\tdoc,\n\t\truntime,\n\t\ttrace,\n\t\tenvStack: new Map(),\n\t\tcache: new Map(),\n\t};\n\treturn evalNode(ctx, doc.root, 0);\n}\n","import type { Verdict } from \"../core/verdict.js\";\nimport { evaluateObservedPrefix } from \"./evaluate-prefix.js\";\nimport type { MonitorState } from \"./types.js\";\n\nexport function evaluateStep<TEvent>(state: MonitorState<TEvent>, event: TEvent): Verdict {\n\tif (state.finalized) {\n\t\tthrow new Error(\"Cannot evaluate step on a finalized monitor\");\n\t}\n\n\tstate.trace.push(event);\n\tstate.step++;\n\n\tstate.currentVerdict = evaluateObservedPrefix(\n\t\tstate.compiled.document,\n\t\tstate.runtime,\n\t\tstate.trace,\n\t);\n\treturn state.currentVerdict;\n}\n","import { print } from \"../compiler/printer.js\";\nimport type { Verdict } from \"../core/verdict.js\";\nimport { buildCounterexampleReport } from \"./diagnostics.js\";\nimport { evaluateFormula } from \"./evaluate.js\";\nimport type { InternalMonitorState, MonitorState } from \"./types.js\";\n\nexport function finalize<TEvent>(state: MonitorState<TEvent>, lastEvent: TEvent): Verdict {\n\tif (state.finalized) {\n\t\treturn getFinalizedVerdict(state);\n\t}\n\n\tif (state.trace.length === 0) {\n\t\tstate.trace.push(lastEvent);\n\t}\n\n\treturn finalizeObservedTrace(state);\n}\n\nexport function finalizeEmpty<TEvent>(state: MonitorState<TEvent>): Verdict {\n\tif (state.finalized) {\n\t\treturn getFinalizedVerdict(state);\n\t}\n\n\tif (state.trace.length > 0) {\n\t\tthrow new Error(\"Cannot finalize a non-empty monitor with finalizeEmpty(); use finalize()\");\n\t}\n\n\treturn finalizeObservedTrace(state);\n}\n\nfunction getFinalizedVerdict<TEvent>(state: MonitorState<TEvent>): Verdict {\n\tconst internalState = state as InternalMonitorState<TEvent>;\n\treturn internalState.finalVerdict ?? state.currentVerdict;\n}\n\nfunction finalizeObservedTrace<TEvent>(state: MonitorState<TEvent>): Verdict {\n\tconst internalState = state as InternalMonitorState<TEvent>;\n\tstate.finalized = true;\n\n\tconst verdict = evaluateFormula(state.compiled.document, state.runtime, state.trace);\n\tstate.currentVerdict = verdict;\n\tinternalState.finalVerdict = verdict;\n\tinternalState.finalReport =\n\t\tverdict === \"violated\"\n\t\t\t? (buildCounterexampleReport(state.compiled.document, state.runtime, state.trace) ?? {\n\t\t\t\t\tverdict: \"violated\",\n\t\t\t\t\tfailurePath: [],\n\t\t\t\t\ttraceSlice: state.trace.map((event, i) => ({ step: i + 1, event })),\n\t\t\t\t\tsummary: `Formula violated: ${print(state.compiled.document)}`,\n\t\t\t\t})\n\t\t\t: null;\n\n\treturn verdict;\n}\n","import { buildCounterexampleReport } from \"./diagnostics.js\";\nimport type { CounterexampleReport, InternalMonitorState, MonitorState } from \"./types.js\";\n\nexport function buildReport<TEvent>(\n\tstate: MonitorState<TEvent>,\n\ttrace: readonly TEvent[],\n): CounterexampleReport | null {\n\tif (state.finalized) {\n\t\treturn (state as InternalMonitorState<TEvent>).finalReport;\n\t}\n\n\tif (state.currentVerdict !== \"violated\") {\n\t\treturn null;\n\t}\n\n\treturn buildCounterexampleReport(state.compiled.document, state.runtime, trace);\n}\n"],"mappings":"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","names":[]}

package/dist/patterns/index.d.ts

@@ -0,0 +1,61 @@
+import { F as FormulaExpr } from '../formula-expr-DAHklv9S.js';
+import '../values-CEF1lKTL.js';
+
+/**
+ * Absence: p never holds globally.
+ * LTLf: G(!p)
+ */
+declare function absence(p: FormulaExpr): FormulaExpr;
+/**
+ * Response: every p is eventually followed by q.
+ * LTLf: G(p -> F q)
+ */
+declare function response(p: FormulaExpr, q: FormulaExpr): FormulaExpr;
+/**
+ * Bounded Response: every p is followed by q within N steps (N positions from current).
+ * LTLf: G(p -> withinSteps(n, q))
+ * Consistent with withinSteps semantics: checks positions [pos, pos+n).
+ */
+declare function boundedResponse(p: FormulaExpr, q: FormulaExpr, steps: number): FormulaExpr;
+/**
+ * Precedence: q can only occur after p has occurred.
+ * LTLf: (!q) U p  (or equivalently, G(!q) if p never happens)
+ * Weak until variant: !q W p = ((!q) U p) | G(!q)
+ */
+declare function precedence(p: FormulaExpr, q: FormulaExpr): FormulaExpr;
+/**
+ * Persistence: once p holds, it holds forever after.
+ * LTLf: G(p -> G p)
+ */
+declare function persistence(p: FormulaExpr): FormulaExpr;
+/**
+ * Stability: once p holds, q holds forever after.
+ * LTLf: G(p -> G q)
+ */
+declare function stability(p: FormulaExpr, q: FormulaExpr): FormulaExpr;
+
+/**
+ * Globally scope — the pattern holds at every step.
+ * Just wraps the pattern in always(). Included for API completeness.
+ */
+declare function globally(pattern: FormulaExpr): FormulaExpr;
+/**
+ * After scope — the pattern holds at every step after q has occurred.
+ * LTLf: G(once(q) -> pattern)
+ */
+declare function after(q: FormulaExpr, pattern: FormulaExpr): FormulaExpr;
+/**
+ * Before scope — the pattern holds at every step before r occurs.
+ * LTLf: G(!once(r) -> pattern) which simplifies to: pattern holds until r.
+ * We use historically(!r) -> pattern for each step.
+ */
+declare function before(r: FormulaExpr, pattern: FormulaExpr): FormulaExpr;
+/**
+ * Between scope — the pattern holds between every occurrence of q and the next r.
+ * LTLf: G( (not(r) S q) -> pattern )
+ * "not(r) since q" is true when q has occurred and r has not occurred since the last q.
+ * This correctly handles re-entry: q→r→q reactivates the scope.
+ */
+declare function between(q: FormulaExpr, r: FormulaExpr, pattern: FormulaExpr): FormulaExpr;
+
+export { absence, after, before, between, boundedResponse, globally, persistence, precedence, response, stability };