dsh-super-code 0.3.10 → 0.4.0

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/messages.ts

@@ -0,0 +1,52 @@
+import type { Message, Part } from "../ir.ts";
+import { linesOf, parseState } from "./dot.ts";
+
+const START = /@!@!@STARTMSG (\d+):(\d+) @!@!@$/;
+const END = /^@!@!@ENDMSG \d+ @!@!@$/;
+
+const isCutMarker = (lastLine: string) => lastLine.startsWith("@!@!@");
+
+function cutMessage(open: Message[]) {
+  for (let i = open.length - 1; i > 0 && !open[i].body.length; i--) open[i - 1].body.pop();
+  return open[0]?.body.length ? open[0] : undefined;
+}
+
+export function* readMessages(tlcOut: string | Iterable<string>): Generator<Part> {
+  const lines = linesOf(tlcOut)[Symbol.iterator]();
+  const open: Message[] = [];
+  try {
+    for (let next = lines.next(); !next.done;) {
+      const line = next.value;
+      next = lines.next();
+      if (next.done && (!line || isCutMarker(line))) break;
+      const start = START.exec(line);
+      if (start) {
+        const message: Message = { code: Number(start[1]), level: Number(start[2]), body: [] };
+        if (start.index) message.beforeMarker = line.slice(0, start.index);
+        open.at(-1)?.body.push(message);
+        open.push(message);
+      } else if (END.test(line)) {
+        const done = open.pop();
+        if (done && !open.length) yield done;
+      } else if (open.length) open[open.length - 1].body.push(line);
+      else yield line;
+    }
+  } finally {
+    lines.return?.();
+  }
+  const cut = cutMessage(open);
+  if (cut) yield cut;
+}
+
+export const textOf = ({ body }: Message) =>
+  body.filter((part) => typeof part === "string").join("\n");
+
+export const actionOf = (m: Message) =>
+  /^\d+: (?:Back to state: )?<([^\s>]+)/.exec(textOf(m))?.[1];
+
+export const messageState = (m: Message) => {
+  const lines = textOf(m).split("\n");
+  const body: string[] = [];
+  for (let i = 1; i < lines.length && lines[i].trim(); i++) body.push(lines[i]);
+  return parseState(body.join("\n"));
+};

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/spec.mjs

@@ -0,0 +1,89 @@
+import { NAME } from "./config.mjs";
+export function readChecks({ configFile, config }) {
+    const refuse = (words) => new Error(`TLC refuses the config ${configFile}. ${words}`);
+    if (config.spec && (config.init || config.next))
+        throw refuse("The configuration file cannot specify both INIT/NEXT and SPECIFICATION fields.");
+    if (!config.spec && !config.init)
+        throw refuse("The configuration file did not specify the initial state predicate.");
+    const written = [];
+    for (const s of config.sections)
+        if (!["INVARIANT", "PROPERTY", "CHECK_DEADLOCK"].includes(s.key))
+            written.push(s);
+    return {
+        invariants: config.invariants,
+        properties: config.properties,
+        deadlock: config.checkDeadlock !== false,
+        written,
+    };
+}
+const ENTITIES = { amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' };
+const decode = (text) => text.replace(/&(#x?)?(\w+);/g, (_, number, name) => number
+    ? String.fromCodePoint(Number.parseInt(name, number === "#x" ? 16 : 10))
+    : ENTITIES[name]);
+function parseXml(xml) {
+    const document = { tag: "", text: "", children: [] };
+    const open = [document];
+    for (const [, close, tag, empty, text] of xml.matchAll(/<(\/?)([^\s/>?!]+)[^>]*?(\/?)>|<[?!][^>]*>|([^<]+)/g)) {
+        const parent = open[open.length - 1];
+        if (text !== undefined)
+            parent.text += decode(text);
+        else if (close)
+            open.pop();
+        else if (tag) {
+            const node = { tag, text: "", children: [] };
+            parent.children.push(node);
+            if (!empty)
+                open.push(node);
+        }
+    }
+    return document;
+}
+const child = (node, tag) => node?.children.find((c) => c.tag === tag);
+const textOf = (node, tag) => child(node, tag)?.text ?? "";
+const VARIABLE_KIND = "3";
+export function readSany(xml) {
+    const modules = child(parseXml(xml), "modules");
+    const symbols = new Map();
+    for (const entry of child(modules, "context")?.children ?? [])
+        symbols.set(textOf(entry, "UID"), entry.children[1]);
+    const root = textOf(modules, "RootModule");
+    let module;
+    for (const node of symbols.values())
+        if (node.tag === "ModuleNode" && textOf(node, "uniquename") === root)
+            module = node;
+    const definitions = new Map();
+    const variables = [];
+    for (const ref of module?.children ?? []) {
+        if (ref.tag !== "OpDeclNodeRef" && ref.tag !== "UserDefinedOpKindRef")
+            continue;
+        const uid = textOf(ref, "UID");
+        const node = symbols.get(uid);
+        if (!node)
+            continue;
+        const name = textOf(node, "uniquename");
+        definitions.set(name, node);
+        if (node.tag === "OpDeclNode" && textOf(node, "kind") === VARIABLE_KIND)
+            variables.push({ uid: Number(uid), name });
+    }
+    variables.sort((a, b) => a.uid - b.uid);
+    return { variables: variables.map((v) => v.name), definitions };
+}
+export function readSpec({ module, sany, checks, }) {
+    return { module, variables: sany.variables, ...checks };
+}
+const STATE_LEVEL = 1;
+export function initialOnlyProperties({ definitions }, { written, properties }) {
+    const replaced = new Map();
+    for (const s of written)
+        if (s.key === "CONSTANT")
+            for (let i = 1; i + 1 < s.tokens.length; i++)
+                if (s.tokens[i] === "<-" && NAME.test(s.tokens[i + 1]))
+                    replaced.set(s.tokens[i - 1], s.tokens[i + 1]);
+    const names = new Set();
+    for (const name of properties) {
+        const definition = definitions.get(replaced.get(name) ?? name);
+        if (definition && Number(textOf(definition, "level")) <= STATE_LEVEL)
+            names.add(name);
+    }
+    return names;
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/spec.ts

@@ -0,0 +1,114 @@
+import type { Config, ConfigSection, Spec } from "../ir.ts";
+import { NAME } from "./config.ts";
+
+export type Checks = Pick<Spec, "invariants" | "properties" | "deadlock" | "written">;
+
+export function readChecks({ configFile, config }: { configFile: string; config: Config }): Checks {
+  const refuse = (words: string) => new Error(`TLC refuses the config ${configFile}. ${words}`);
+  if (config.spec && (config.init || config.next))
+    throw refuse("The configuration file cannot specify both INIT/NEXT and SPECIFICATION fields.");
+  if (!config.spec && !config.init)
+    throw refuse("The configuration file did not specify the initial state predicate.");
+  const written: ConfigSection[] = [];
+  for (const s of config.sections)
+    if (!["INVARIANT", "PROPERTY", "CHECK_DEADLOCK"].includes(s.key)) written.push(s);
+  return {
+    invariants: config.invariants,
+    properties: config.properties,
+    deadlock: config.checkDeadlock !== false,
+    written,
+  };
+}
+
+type XmlNode = { tag: string; text: string; children: XmlNode[] };
+
+const ENTITIES: { [name: string]: string } = { amp: "&", apos: "'", gt: ">", lt: "<", quot: '"' };
+
+const decode = (text: string) =>
+  text.replace(/&(#x?)?(\w+);/g, (_, number: string | undefined, name: string) =>
+    number
+      ? String.fromCodePoint(Number.parseInt(name, number === "#x" ? 16 : 10))
+      : ENTITIES[name],
+  );
+
+function parseXml(xml: string) {
+  const document: XmlNode = { tag: "", text: "", children: [] };
+  const open = [document];
+  for (const [, close, tag, empty, text] of xml.matchAll(
+    /<(\/?)([^\s/>?!]+)[^>]*?(\/?)>|<[?!][^>]*>|([^<]+)/g,
+  )) {
+    const parent = open[open.length - 1];
+    if (text !== undefined) parent.text += decode(text);
+    else if (close) open.pop();
+    else if (tag) {
+      const node: XmlNode = { tag, text: "", children: [] };
+      parent.children.push(node);
+      if (!empty) open.push(node);
+    }
+  }
+  return document;
+}
+
+const child = (node: XmlNode | undefined, tag: string) => node?.children.find((c) => c.tag === tag);
+const textOf = (node: XmlNode | undefined, tag: string) => child(node, tag)?.text ?? "";
+
+export type Sany = {
+  variables: string[];
+  definitions: Map<string, XmlNode>;
+};
+
+const VARIABLE_KIND = "3";
+
+export function readSany(xml: string): Sany {
+  const modules = child(parseXml(xml), "modules");
+  const symbols = new Map<string, XmlNode>();
+  for (const entry of child(modules, "context")?.children ?? [])
+    symbols.set(textOf(entry, "UID"), entry.children[1]);
+  const root = textOf(modules, "RootModule");
+  let module: XmlNode | undefined;
+  for (const node of symbols.values())
+    if (node.tag === "ModuleNode" && textOf(node, "uniquename") === root) module = node;
+  const definitions = new Map<string, XmlNode>();
+  const variables: { uid: number; name: string }[] = [];
+  for (const ref of module?.children ?? []) {
+    if (ref.tag !== "OpDeclNodeRef" && ref.tag !== "UserDefinedOpKindRef") continue;
+    const uid = textOf(ref, "UID");
+    const node = symbols.get(uid);
+    if (!node) continue;
+    const name = textOf(node, "uniquename");
+    definitions.set(name, node);
+    if (node.tag === "OpDeclNode" && textOf(node, "kind") === VARIABLE_KIND)
+      variables.push({ uid: Number(uid), name });
+  }
+  variables.sort((a, b) => a.uid - b.uid);
+  return { variables: variables.map((v) => v.name), definitions };
+}
+
+export function readSpec({
+  module,
+  sany,
+  checks,
+}: {
+  module: string;
+  sany: Sany;
+  checks: Checks;
+}): Spec {
+  return { module, variables: sany.variables, ...checks };
+}
+
+const STATE_LEVEL = 1;
+
+export function initialOnlyProperties({ definitions }: Sany, { written, properties }: Spec) {
+  const replaced = new Map<string, string>();
+  for (const s of written)
+    if (s.key === "CONSTANT")
+      for (let i = 1; i + 1 < s.tokens.length; i++)
+        if (s.tokens[i] === "<-" && NAME.test(s.tokens[i + 1]))
+          replaced.set(s.tokens[i - 1], s.tokens[i + 1]);
+  const names = new Set<string>();
+  for (const name of properties) {
+    const definition = definitions.get(replaced.get(name) ?? name);
+    if (definition && Number(textOf(definition, "level")) <= STATE_LEVEL) names.add(name);
+  }
+  return names;
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/trace.mjs

@@ -0,0 +1,24 @@
+import { EC } from "../ir.mjs";
+import { actionOf, messageState, textOf } from "./messages.mjs";
+export function readTrace(messages) {
+    const seq = [];
+    for (const m of messages) {
+        if (typeof m === "string")
+            continue;
+        if (m.code === EC.TLC_STATE_PRINT3)
+            return { seq, loop: seq.length - 1 };
+        const back = m.code === EC.TLC_BACK_TO_STATE && /^(\d+): Back to state: /.exec(textOf(m));
+        if (back) {
+            const loop = Number(back[1]) - 1;
+            seq.push({ action: actionOf(m) ?? "", vars: seq[loop]?.vars });
+            return { seq, loop };
+        }
+        const action = m.code === EC.TLC_STATE_PRINT2 ? actionOf(m) : undefined;
+        if (action !== undefined)
+            seq.push({ action, vars: messageState(m) });
+        else if (m.code === EC.TLC_INVARIANT_VIOLATED_INITIAL ||
+            m.code === EC.TLC_PROPERTY_VIOLATED_INITIAL)
+            seq.push({ action: "", vars: messageState(m) });
+    }
+    return { seq, loop: undefined };
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/trace.ts

@@ -0,0 +1,24 @@
+import { EC, type Part, type Trace } from "../ir.ts";
+import { actionOf, messageState, textOf } from "./messages.ts";
+
+export function readTrace(messages: Iterable<Part>): Trace {
+  const seq: Trace["seq"] = [];
+  for (const m of messages) {
+    if (typeof m === "string") continue;
+    if (m.code === EC.TLC_STATE_PRINT3) return { seq, loop: seq.length - 1 };
+    const back = m.code === EC.TLC_BACK_TO_STATE && /^(\d+): Back to state: /.exec(textOf(m));
+    if (back) {
+      const loop = Number(back[1]) - 1;
+      seq.push({ action: actionOf(m) ?? "", vars: seq[loop]?.vars });
+      return { seq, loop };
+    }
+    const action = m.code === EC.TLC_STATE_PRINT2 ? actionOf(m) : undefined;
+    if (action !== undefined) seq.push({ action, vars: messageState(m) });
+    else if (
+      m.code === EC.TLC_INVARIANT_VIOLATED_INITIAL ||
+      m.code === EC.TLC_PROPERTY_VIOLATED_INITIAL
+    )
+      seq.push({ action: "", vars: messageState(m) });
+  }
+  return { seq, loop: undefined };
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/value.mjs

@@ -0,0 +1,181 @@
+export const BRACKET = new Int8Array(128);
+for (const c of "<{[(")
+    BRACKET[c.charCodeAt(0)] = 1;
+for (const c of ">}])")
+    BRACKET[c.charCodeAt(0)] = -1;
+const PUNCT = new Map([
+    [60, "<<"],
+    [62, ">>"],
+    [124, "|->"],
+    [58, ":>"],
+    [64, "@@"],
+    [46, ".."],
+]);
+const SPACE = /\s/;
+export const isSpace = (c) => c === 32 || (c >= 9 && c <= 13) || (c > 127 && SPACE.test(String.fromCharCode(c)));
+const isDigit = (c) => c >= 48 && c <= 57;
+const isWord = (c) => isDigit(c) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+const isLineEnd = (c) => c === 10 || c === 13 || c === 0x2028 || c === 0x2029;
+export const tokenEnd = (s, i) => {
+    const c = s.charCodeAt(i);
+    if (c === 34) {
+        for (let j = i + 1; j < s.length; j++) {
+            const d = s.charCodeAt(j);
+            if (d === 34)
+                return j + 1;
+            if (d === 92 && (++j >= s.length || isLineEnd(s.charCodeAt(j))))
+                return -1;
+        }
+        return -1;
+    }
+    const punct = PUNCT.get(c);
+    if (punct)
+        return s.startsWith(punct, i) ? i + punct.length : -1;
+    if (BRACKET[c] || c === 44)
+        return i + 1;
+    let j = i + 1;
+    if (c === 45 || isDigit(c)) {
+        while (isDigit(s.charCodeAt(j)))
+            j++;
+        return c === 45 && j === i + 1 ? -1 : j;
+    }
+    if (!isWord(c))
+        return -1;
+    while (isWord(s.charCodeAt(j)))
+        j++;
+    return j;
+};
+export const unreadable = (text, pos) => new Error(`cannot read TLA+ value at "${text.slice(pos, pos + 20)}"`);
+const INT = /^-?\d+$/;
+const NAME = /^\w*[A-Za-z]\w*$/;
+const UNESCAPED = {
+    '"': '"',
+    "\\": "\\",
+    n: "\n",
+    t: "\t",
+    r: "\r",
+    f: "\f",
+};
+const models = new Map();
+const model = (name) => {
+    let v = models.get(name);
+    if (v === undefined)
+        models.set(name, (v = { kind: "model", name }));
+    return v;
+};
+export function parseValue(text) {
+    const tokens = [];
+    const starts = [];
+    for (let pos = 0;;) {
+        while (pos < text.length && isSpace(text.charCodeAt(pos)))
+            pos++;
+        if (pos === text.length)
+            break;
+        const end = tokenEnd(text, pos);
+        if (end === -1)
+            throw unreadable(text, pos);
+        tokens.push(text.slice(pos, end));
+        starts.push(pos);
+        pos = end;
+    }
+    let i = 0;
+    const fail = () => {
+        throw unreadable(text, i < starts.length ? starts[Math.max(i - 1, 0)] : text.length);
+    };
+    const next = () => (i < tokens.length ? tokens[i++] : fail());
+    const eat = (t) => {
+        if (next() !== t)
+            fail();
+    };
+    const items = (close, item) => {
+        const out = [];
+        if (tokens[i] === close) {
+            i++;
+            return out;
+        }
+        for (;;) {
+            out.push(item());
+            const t = next();
+            if (t === close)
+                return out;
+            if (t !== ",")
+                fail();
+        }
+    };
+    const string = (t) => {
+        let s = "";
+        for (let j = 1, from = 1;;) {
+            const k = t.indexOf("\\", j);
+            if (k === -1 || k >= t.length - 1)
+                return s + t.slice(from, -1);
+            const c = UNESCAPED[t[k + 1]];
+            if (c === undefined)
+                fail();
+            s += t.slice(from, k) + c;
+            j = from = k + 2;
+        }
+    };
+    const value = () => {
+        const t = next();
+        switch (t) {
+            case "TRUE":
+                return true;
+            case "FALSE":
+                return false;
+            case "{":
+                return { kind: "set", members: items("}", value) };
+            case "<<": {
+                const values = items(">>", value);
+                const keys = [];
+                for (let k = 1; k <= values.length; k++)
+                    keys.push(k);
+                return { kind: "function", printedAs: "tuple", keys, values };
+            }
+            case "[": {
+                const keys = [];
+                const values = [];
+                items("]", () => {
+                    const name = next();
+                    if (!NAME.test(name))
+                        fail();
+                    eat("|->");
+                    keys.push(name);
+                    values.push(value());
+                });
+                return { kind: "function", printedAs: "record", keys, values };
+            }
+            case "(": {
+                const keys = [];
+                const values = [];
+                do {
+                    keys.push(value());
+                    eat(":>");
+                    values.push(value());
+                } while (next() === "@@");
+                if (tokens[i - 1] !== ")")
+                    fail();
+                return { kind: "function", printedAs: "pairs", keys, values };
+            }
+        }
+        if (t.charCodeAt(0) === 34)
+            return string(t);
+        if (INT.test(t)) {
+            if (tokens[i] !== "..")
+                return Number(t);
+            i++;
+            const hi = next();
+            if (!INT.test(hi))
+                fail();
+            return { kind: "interval", lo: Number(t), hi: Number(hi) };
+        }
+        if (NAME.test(t))
+            return model(t);
+        return fail();
+    };
+    const out = value();
+    if (i < tokens.length) {
+        i++;
+        fail();
+    }
+    return out;
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/value.ts

@@ -0,0 +1,166 @@
+import type { Value } from "../ir.ts";
+
+export const BRACKET = new Int8Array(128);
+for (const c of "<{[(") BRACKET[c.charCodeAt(0)] = 1;
+for (const c of ">}])") BRACKET[c.charCodeAt(0)] = -1;
+const PUNCT = new Map([
+  [60, "<<"],
+  [62, ">>"],
+  [124, "|->"],
+  [58, ":>"],
+  [64, "@@"],
+  [46, ".."],
+]);
+const SPACE = /\s/;
+export const isSpace = (c: number) =>
+  c === 32 || (c >= 9 && c <= 13) || (c > 127 && SPACE.test(String.fromCharCode(c)));
+const isDigit = (c: number) => c >= 48 && c <= 57;
+const isWord = (c: number) =>
+  isDigit(c) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122) || c === 95;
+const isLineEnd = (c: number) => c === 10 || c === 13 || c === 0x2028 || c === 0x2029;
+
+export const tokenEnd = (s: string, i: number) => {
+  const c = s.charCodeAt(i);
+  if (c === 34) {
+    for (let j = i + 1; j < s.length; j++) {
+      const d = s.charCodeAt(j);
+      if (d === 34) return j + 1;
+      if (d === 92 && (++j >= s.length || isLineEnd(s.charCodeAt(j)))) return -1;
+    }
+    return -1;
+  }
+  const punct = PUNCT.get(c);
+  if (punct) return s.startsWith(punct, i) ? i + punct.length : -1;
+  if (BRACKET[c] || c === 44) return i + 1;
+  let j = i + 1;
+  if (c === 45 || isDigit(c)) {
+    while (isDigit(s.charCodeAt(j))) j++;
+    return c === 45 && j === i + 1 ? -1 : j;
+  }
+  if (!isWord(c)) return -1;
+  while (isWord(s.charCodeAt(j))) j++;
+  return j;
+};
+
+export const unreadable = (text: string, pos: number) =>
+  new Error(`cannot read TLA+ value at "${text.slice(pos, pos + 20)}"`);
+
+const INT = /^-?\d+$/;
+const NAME = /^\w*[A-Za-z]\w*$/;
+const UNESCAPED: { [c: string]: string } = {
+  '"': '"',
+  "\\": "\\",
+  n: "\n",
+  t: "\t",
+  r: "\r",
+  f: "\f",
+};
+
+const models = new Map<string, Value>();
+const model = (name: string) => {
+  let v = models.get(name);
+  if (v === undefined) models.set(name, (v = { kind: "model", name }));
+  return v;
+};
+
+export function parseValue(text: string): Value {
+  const tokens: string[] = [];
+  const starts: number[] = [];
+  for (let pos = 0; ;) {
+    while (pos < text.length && isSpace(text.charCodeAt(pos))) pos++;
+    if (pos === text.length) break;
+    const end = tokenEnd(text, pos);
+    if (end === -1) throw unreadable(text, pos);
+    tokens.push(text.slice(pos, end));
+    starts.push(pos);
+    pos = end;
+  }
+  let i = 0;
+  const fail = (): never => {
+    throw unreadable(text, i < starts.length ? starts[Math.max(i - 1, 0)] : text.length);
+  };
+  const next = () => (i < tokens.length ? tokens[i++] : fail());
+  const eat = (t: string) => {
+    if (next() !== t) fail();
+  };
+  const items = <T>(close: string, item: () => T) => {
+    const out: T[] = [];
+    if (tokens[i] === close) {
+      i++;
+      return out;
+    }
+    for (;;) {
+      out.push(item());
+      const t = next();
+      if (t === close) return out;
+      if (t !== ",") fail();
+    }
+  };
+  const string = (t: string) => {
+    let s = "";
+    for (let j = 1, from = 1; ;) {
+      const k = t.indexOf("\\", j);
+      if (k === -1 || k >= t.length - 1) return s + t.slice(from, -1);
+      const c = UNESCAPED[t[k + 1]];
+      if (c === undefined) fail();
+      s += t.slice(from, k) + c;
+      j = from = k + 2;
+    }
+  };
+  const value = (): Value => {
+    const t = next();
+    switch (t) {
+      case "TRUE":
+        return true;
+      case "FALSE":
+        return false;
+      case "{":
+        return { kind: "set", members: items("}", value) };
+      case "<<": {
+        const values = items(">>", value);
+        const keys: Value[] = [];
+        for (let k = 1; k <= values.length; k++) keys.push(k);
+        return { kind: "function", printedAs: "tuple", keys, values };
+      }
+      case "[": {
+        const keys: Value[] = [];
+        const values: Value[] = [];
+        items("]", () => {
+          const name = next();
+          if (!NAME.test(name)) fail();
+          eat("|->");
+          keys.push(name);
+          values.push(value());
+        });
+        return { kind: "function", printedAs: "record", keys, values };
+      }
+      case "(": {
+        const keys: Value[] = [];
+        const values: Value[] = [];
+        do {
+          keys.push(value());
+          eat(":>");
+          values.push(value());
+        } while (next() === "@@");
+        if (tokens[i - 1] !== ")") fail();
+        return { kind: "function", printedAs: "pairs", keys, values };
+      }
+    }
+    if (t.charCodeAt(0) === 34) return string(t);
+    if (INT.test(t)) {
+      if (tokens[i] !== "..") return Number(t);
+      i++;
+      const hi = next();
+      if (!INT.test(hi)) fail();
+      return { kind: "interval", lo: Number(t), hi: Number(hi) };
+    }
+    if (NAME.test(t)) return model(t);
+    return fail();
+  };
+  const out = value();
+  if (i < tokens.length) {
+    i++;
+    fail();
+  }
+  return out;
+}

package/builtin/skills/pstack/dsh/skills/statechart/scripts/frontends/verdict.mjs

@@ -0,0 +1,38 @@
+import { EC } from "../ir.mjs";
+import { textOf } from "./messages.mjs";
+const NAMED = new Map([
+    [EC.TLC_INVARIANT_VIOLATED_INITIAL, ["invariant", /^Invariant (.+) is violated by the initial/]],
+    [EC.TLC_INVARIANT_VIOLATED_BEHAVIOR, ["invariant", /^Invariant (.+) is violated\.$/m]],
+    [EC.TLC_PROPERTY_VIOLATED_INITIAL, ["property", /^Property (.+) is violated by the initial/]],
+    [EC.TLC_ACTION_PROPERTY_VIOLATED_BEHAVIOR, ["property", /^Action property (.+) is violated\.$/m]],
+]);
+const DISTINCT = new Map([
+    [EC.TLC_INIT_GENERATED1, /(\d+) distinct states? generated/],
+    [EC.TLC_INIT_GENERATED2, /with (\d+) of them distinct/],
+    [EC.TLC_STATS, /(\d+) distinct states found/],
+]);
+export function readVerdict(messages) {
+    let broke;
+    let distinct = 0;
+    let initial = 0;
+    for (const m of messages) {
+        if (typeof m === "string")
+            continue;
+        const count = DISTINCT.get(m.code)?.exec(textOf(m));
+        if (count)
+            distinct = Math.max(distinct, Number(count[1]));
+        if (m.code === EC.TLC_INIT_GENERATED1 || m.code === EC.TLC_INIT_GENERATED2)
+            initial = Number(/(\d+) (?:distinct )?states? generated/.exec(textOf(m))?.[1] ?? 0);
+        if (broke)
+            continue;
+        if (m.code === EC.TLC_DEADLOCK_REACHED)
+            broke = { kind: "deadlock" };
+        else if (m.code === EC.TLC_TEMPORAL_PROPERTY_VIOLATED)
+            broke = { kind: "temporal" };
+        const named = NAMED.get(m.code);
+        const name = named?.[1].exec(textOf(m))?.[1];
+        if (named && name)
+            broke = { kind: named[0], name };
+    }
+    return { broke, distinct, initial };
+}