dsh-super-code 0.3.10 → 0.4.0

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

@@ -0,0 +1,276 @@
+import { CHECK_DEADLOCK, type Config } from "../ir.ts";
+
+type ListField = "invariants" | "properties" | "constraints" | "actionConstraints";
+type Section = {
+  key: string;
+  plural?: string;
+  field?:
+    | ListField
+    | "checkDeadlock"
+    | "init"
+    | "next"
+    | "spec"
+    | "view"
+    | "symmetry"
+    | "type"
+    | "typeConstraint";
+  undefinedNoun?: string;
+};
+const isListField = (field: Section["field"]): field is ListField =>
+  field === "invariants" ||
+  field === "properties" ||
+  field === "constraints" ||
+  field === "actionConstraints";
+
+const SECTIONS = new Map<string, Section>();
+for (const section of [
+  { key: "CONSTANT", plural: "CONSTANTS" },
+  { key: CHECK_DEADLOCK, field: "checkDeadlock" },
+  { key: "INIT", field: "init", undefinedNoun: "initial predicate" },
+  { key: "NEXT", field: "next", undefinedNoun: "next state action" },
+  { key: "SPECIFICATION", field: "spec", undefinedNoun: "name" },
+  { key: "VIEW", field: "view", undefinedNoun: "view function" },
+  { key: "SYMMETRY", field: "symmetry", undefinedNoun: "symmetry function" },
+  { key: "TYPE", field: "type" },
+  { key: "TYPE_CONSTRAINT", field: "typeConstraint" },
+  { key: "INVARIANT", plural: "INVARIANTS", field: "invariants", undefinedNoun: "invariant" },
+  { key: "PROPERTY", plural: "PROPERTIES", field: "properties", undefinedNoun: "property" },
+  { key: "CONSTRAINT", plural: "CONSTRAINTS", field: "constraints", undefinedNoun: "constraint" },
+  {
+    key: "ACTION_CONSTRAINT",
+    plural: "ACTION_CONSTRAINTS",
+    field: "actionConstraints",
+    undefinedNoun: "action constraint",
+  },
+] satisfies Section[]) {
+  SECTIONS.set(section.key, section);
+  if (section.plural) SECTIONS.set(section.plural, section);
+}
+export const NAME = /^\w*[A-Za-z]\w*$/;
+const WORD = /\w+/y;
+const CONFIG_HOLDS =
+  "A config can hold only names, numbers, strings, comments, and the symbols { } ( ) [ ] , = ! <-.";
+const shown = (c: string) => {
+  const code = c.codePointAt(0) ?? 0;
+  const hex = `U+${code.toString(16).toUpperCase().padStart(4, "0")}`;
+  if (code < 0x20 || code === 0x7f) return hex;
+  return code < 0x7f ? `"${c}"` : `"${c}" (${hex})`;
+};
+
+type Token = { image: string; line: number };
+
+function tokenizeConfig(text: string, cannot: (line: number, words: string) => Error) {
+  if (text.startsWith("\uFEFF"))
+    throw cannot(1, "The file starts with a byte order mark. Save it as UTF-8 without one.");
+  const tokens: Token[] = [];
+  let line = 1;
+  let last = 1;
+  let i = 0;
+  const skip = (to: number) => {
+    for (; i < to; i++) {
+      last = line;
+      if (text[i] === "\n" || (text[i] === "\r" && text[i + 1] !== "\n")) line++;
+    }
+  };
+  const push = (image: string) => {
+    tokens.push({ image, line });
+    skip(i + image.length);
+  };
+  while (i < text.length) {
+    const c = text[i];
+    const two = text.slice(i, i + 2);
+    const start = line;
+    if (c === " " || c === "\t" || c === "\n" || c === "\r") skip(i + 1);
+    else if (two === "\\*") {
+      const end = text.slice(i).search(/[\n\r]/);
+      skip(end < 0 ? text.length : i + end);
+    } else if (two === "(*") {
+      const marks = /\(\*|\*\)/g;
+      let depth = 0;
+      do {
+        marks.lastIndex = i;
+        const m = marks.exec(text);
+        if (!m) throw cannot(start, "A comment starts here and does not end.");
+        depth += m[0] === "(*" ? 1 : -1;
+        skip(m.index + 2);
+      } while (depth);
+    } else if (c === '"') {
+      let j = i + 1;
+      while (text[j] !== '"') {
+        const ch = text[j];
+        if (ch === undefined) throw cannot(start, "A string starts here and does not end.");
+        if (ch === "\n" || ch === "\r")
+          throw cannot(
+            start,
+            "A string starts here and does not end on its line. Write \\n for a line break in a string.",
+          );
+        if (ch === "\0") throw cannot(start, "A string has the character U+0000.");
+        if (ch === "\\" && text[j + 1] !== undefined && !'"\\ntrf'.includes(text[j + 1]))
+          throw cannot(
+            start,
+            `A string has a backslash before ${shown(text[j + 1])}. A string can use only the escapes \\" \\\\ \\n \\t \\r \\f.`,
+          );
+        j += ch === "\\" ? 2 : 1;
+      }
+      push(text.slice(i, j + 1));
+    } else if (/\w/.test(c)) {
+      WORD.lastIndex = i;
+      const word = WORD.exec(text)?.[0] ?? c;
+      if (/^[WS]F_/.test(word))
+        throw cannot(
+          start,
+          `TLC reads ${word.slice(0, 3)} at the start of a word as a TLA+ keyword, so it cannot read ${word} as a name.`,
+        );
+      if (!/[A-Za-z]/.test(word) && word !== "_") {
+        if (/\D/.test(word))
+          throw cannot(
+            start,
+            `TLC splits ${word} into ${word.match(/\d+|_/g)?.join(" ")}, because a name needs a letter.`,
+          );
+        if (Number(word) > 2147483647)
+          throw cannot(start, `TLC cannot read a number above 2147483647, such as ${word}.`);
+      }
+      push(word);
+    } else if (two === "<-") push(two);
+    else if (["[]", "]_", "==", "=<", "!!"].includes(two))
+      throw cannot(start, `TLC reads ${two} as one TLA+ symbol, and a config cannot hold it.`);
+    else if ("{}()[],=!".includes(c)) push(c);
+    else {
+      const ch = String.fromCodePoint(text.codePointAt(i) ?? 0);
+      const where = ch > "\x7f" ? " outside a string" : "";
+      throw cannot(start, `It cannot read the character ${shown(ch)}${where}. ${CONFIG_HOLDS}`);
+    }
+  }
+  return { tokens, end: last };
+}
+
+export function readConfig({ file, text }: { file: string; text: string }): Config {
+  const refuse = (line: number, words: string) =>
+    new Error(`TLC refuses the config ${file} at line ${line}. ${words}`);
+  const cannot = (line: number, words: string) =>
+    new Error(`The command cannot read the config ${file} at line ${line}. ${words}`);
+  const { tokens, end } = tokenizeConfig(text, cannot);
+  const eof: Token = { image: "", line: end };
+  let at = 0;
+  const next = () => tokens[at++] ?? eof;
+  let deferred: Error | undefined;
+  const defer = (error: Error) => (deferred ??= error);
+  const defined = (t: Token, undefinedNoun: string | undefined) => {
+    if (!NAME.test(t.image))
+      defer(
+        refuse(
+          t.line,
+          `The ${undefinedNoun} ${t.image} specified in the configuration file is not defined in the specification.`,
+        ),
+      );
+  };
+  const name = (t: Token, what: string) => {
+    if (SECTIONS.has(t.image))
+      defer(cannot(t.line, `TLC would read the keyword ${t.image} as ${what}.`));
+    else if (!NAME.test(t.image))
+      defer(cannot(t.line, `TLC would read ${t.image} as ${what}, and it is not a name.`));
+  };
+  const value = (t: Token): void => {
+    if (t === eof) throw refuse(t.line, "It was expecting a value, but did not find it.");
+    if (t.image === "{") {
+      t = next();
+      if (t.image === "}") return;
+      value(t);
+      while ((t = next()).image === ",") value(next());
+      if (t.image !== "}") throw refuse(t.line, "It was expecting }, but did not find it.");
+    } else if (SECTIONS.has(t.image))
+      defer(cannot(t.line, `TLC would read the keyword ${t.image} as a value.`));
+    else if (!NAME.test(t.image) && !/^(\d+|".*")$/.test(t.image))
+      defer(
+        cannot(
+          t.line,
+          `TLC would read ${t.image} as a value. A value is a name, a number, a string, or a set in braces.`,
+        ),
+      );
+  };
+  const constant = (t: Token, loc: number) => {
+    name(t, "a constant name");
+    for (t = next(); t.image === "!"; t = next()) name((t = next()), "a constant name");
+    if (t.image === "<-") {
+      t = next();
+      if (t.image === "[") {
+        t = next();
+        if (t === eof) throw refuse(t.line, "Expected an identifier after <-[.");
+        name(t, "a module name");
+        t = next();
+        if (t.image !== "]") throw refuse(t.line, "It was expecting ], but did not find it.");
+        t = next();
+        if (t === eof) throw refuse(t.line, "Expected an identifier after <-[mod].");
+      } else if (t === eof) throw refuse(t.line, "Expected an identifier after <-.");
+      name(t, "the name after <-");
+      return;
+    }
+    if (t.image === "(") {
+      value(next());
+      while ((t = next()).image === ",") value(next());
+      if (t.image !== ")")
+        throw refuse(
+          loc,
+          "TLC gives no reason here. An operator's arguments are one or more values in ( ), with commas between them.",
+        );
+      t = next();
+    }
+    if (t.image !== "=") throw refuse(t.line, "It was expecting = or <-, but did not find it.");
+    t = next();
+    if (t.image === "[") {
+      t = next();
+      if (t === eof) throw refuse(t.line, "Expected an identifier after =[.");
+      name(t, "a module name");
+      t = next();
+      if (t.image !== "]") throw refuse(t.line, "It was expecting ], but did not find it.");
+      t = next();
+    }
+    value(t);
+  };
+  const config: Config = {
+    sections: [],
+    invariants: [],
+    properties: [],
+    constraints: [],
+    actionConstraints: [],
+  };
+  for (let t = next(); t !== eof;) {
+    const keyword = t;
+    const section = SECTIONS.get(keyword.image);
+    if (!section) throw refuse(t.line, "It was expecting a keyword, but did not find it.");
+    const { key, field, undefinedNoun } = section;
+    const begin = at;
+    if (field === undefined) {
+      for (t = next(); t !== eof && !SECTIONS.has(t.image); t = next()) constant(t, keyword.line);
+    } else if (isListField(field)) {
+      for (t = next(); t !== eof && !SECTIONS.has(t.image); t = next()) {
+        config[field].push(t.image);
+        defined(t, undefinedNoun);
+      }
+    } else {
+      t = next();
+      if (t === eof)
+        throw refuse(
+          keyword.line,
+          `The keyword ${keyword.image} was not followed by an identifier.`,
+        );
+      if (field === "checkDeadlock" && t.image !== "TRUE" && t.image !== "FALSE")
+        throw refuse(t.line, "It was expecting TRUE or FALSE, but did not find it.");
+      if (config[field] !== undefined)
+        throw refuse(keyword.line, `The keyword ${keyword.image} appeared twice.`);
+      if (field === "checkDeadlock") config[field] = t.image === "TRUE";
+      else {
+        config[field] = t.image;
+        if (SECTIONS.has(t.image))
+          defer(cannot(t.line, `TLC would read the keyword ${t.image} as the name after ${key}.`));
+        else if (undefinedNoun) defined(t, undefinedNoun);
+      }
+      t = next();
+    }
+    const images: string[] = [];
+    for (let k = begin; k < (t === eof ? tokens.length : at - 1); k++) images.push(tokens[k].image);
+    config.sections.push({ key, line: keyword.line, tokens: images });
+  }
+  if (deferred) throw deferred;
+  return config;
+}

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

@@ -0,0 +1,68 @@
+import { parseValue } from "./value.mjs";
+const unescapeDot = (s) => {
+    let i = s.indexOf("\\");
+    if (i === -1)
+        return s;
+    let out = "";
+    let from = 0;
+    for (; i !== -1 && i + 1 < s.length; i = s.indexOf("\\", i)) {
+        const c = s[i + 1];
+        if (c === "\n" || c === "\r" || c === "\u2028" || c === "\u2029") {
+            i++;
+            continue;
+        }
+        out += s.slice(from, i) + (c === "n" ? "\n" : c);
+        i += 2;
+        from = i;
+    }
+    return out + s.slice(from);
+};
+export const parseState = (label, parsed = new Map()) => {
+    const pairs = [];
+    for (const part of (label.startsWith("/\\ ") ? label.slice(3) : label).split("\n/\\ ")) {
+        let pair = parsed.get(part);
+        if (!pair) {
+            const [, name, value] = /^(\w+)\s*=\s*([\s\S]*)$/.exec(part) ?? [];
+            if (!name)
+                throw new Error(`cannot read the TLC state line "${part}"`);
+            parsed.set(part, (pair = [name, parseValue(value)]));
+        }
+        pairs.push(pair);
+    }
+    return Object.fromEntries(pairs);
+};
+export const linesOf = (input) => (typeof input === "string" ? input.split("\n") : input);
+export function parseDot(input) {
+    const states = new Map();
+    const steps = new Map();
+    const parsed = new Map();
+    const owned = new Map();
+    const own = (s) => {
+        let copy = owned.get(s);
+        if (copy === undefined)
+            owned.set((copy = String(JSON.parse(JSON.stringify(s)))), copy);
+        return copy;
+    };
+    for (const line of linesOf(input)) {
+        const edge = /^(-?\d+) -> (-?\d+) \[label="([^"]*)"/.exec(line);
+        if (edge) {
+            steps.set(edge.slice(1).join(" "), {
+                from: own(edge[1]),
+                to: own(edge[2]),
+                action: own(edge[3]),
+            });
+            continue;
+        }
+        const node = /^(-?\d+) \[label="((?:[^"\\]|\\.)*)"(,style = filled)?/.exec(line);
+        if (node)
+            states.set(own(node[1]), {
+                vars: parseState(unescapeDot(node[2]), parsed),
+                start: !!node[3],
+                breaks: [],
+            });
+    }
+    for (const loose of steps.values())
+        if (!states.has(loose.from) || !states.has(loose.to))
+            throw new Error(`The TLC graph dump has a step ${loose.action} to or from a state that it does not list.`);
+    return { states, steps: [...steps.values()] };
+}

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

@@ -0,0 +1,74 @@
+import { type Graph, type State, type Step, type Value, type Vars } from "../ir.ts";
+import { parseValue } from "./value.ts";
+
+const unescapeDot = (s: string) => {
+  let i = s.indexOf("\\");
+  if (i === -1) return s;
+  let out = "";
+  let from = 0;
+  for (; i !== -1 && i + 1 < s.length; i = s.indexOf("\\", i)) {
+    const c = s[i + 1];
+    if (c === "\n" || c === "\r" || c === "\u2028" || c === "\u2029") {
+      i++;
+      continue;
+    }
+    out += s.slice(from, i) + (c === "n" ? "\n" : c);
+    i += 2;
+    from = i;
+  }
+  return out + s.slice(from);
+};
+
+export const parseState = (label: string, parsed = new Map<string, [string, Value]>()): Vars => {
+  const pairs: [string, Value][] = [];
+  for (const part of (label.startsWith("/\\ ") ? label.slice(3) : label).split("\n/\\ ")) {
+    let pair = parsed.get(part);
+    if (!pair) {
+      const [, name, value] = /^(\w+)\s*=\s*([\s\S]*)$/.exec(part) ?? [];
+      if (!name) throw new Error(`cannot read the TLC state line "${part}"`);
+      parsed.set(part, (pair = [name, parseValue(value)]));
+    }
+    pairs.push(pair);
+  }
+  return Object.fromEntries(pairs);
+};
+
+export type Lines = string | Iterable<string>;
+
+export const linesOf = (input: Lines) => (typeof input === "string" ? input.split("\n") : input);
+
+export function parseDot(input: Lines): Graph {
+  const states = new Map<string, State>();
+  const steps = new Map<string, Step>();
+  const parsed = new Map<string, [string, Value]>();
+  const owned = new Map<string, string>();
+  const own = (s: string) => {
+    let copy = owned.get(s);
+    if (copy === undefined) owned.set((copy = String(JSON.parse(JSON.stringify(s)))), copy);
+    return copy;
+  };
+  for (const line of linesOf(input)) {
+    const edge = /^(-?\d+) -> (-?\d+) \[label="([^"]*)"/.exec(line);
+    if (edge) {
+      steps.set(edge.slice(1).join(" "), {
+        from: own(edge[1]),
+        to: own(edge[2]),
+        action: own(edge[3]),
+      });
+      continue;
+    }
+    const node = /^(-?\d+) \[label="((?:[^"\\]|\\.)*)"(,style = filled)?/.exec(line);
+    if (node)
+      states.set(own(node[1]), {
+        vars: parseState(unescapeDot(node[2]), parsed),
+        start: !!node[3],
+        breaks: [],
+      });
+  }
+  for (const loose of steps.values())
+    if (!states.has(loose.from) || !states.has(loose.to))
+      throw new Error(
+        `The TLC graph dump has a step ${loose.action} to or from a state that it does not list.`,
+      );
+  return { states, steps: [...steps.values()] };
+}

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

@@ -0,0 +1,102 @@
+import { EC, memo } from "../ir.mjs";
+import { actionOf, messageState } from "./messages.mjs";
+import { BRACKET, isSpace, parseValue, tokenEnd, unreadable } from "./value.mjs";
+const markTexts = (chunk, top, inner) => {
+    if (top.length !== 2)
+        return undefined;
+    const [a, b] = top;
+    const open = chunk.indexOf("<<", a);
+    const close = chunk.lastIndexOf(">>", b);
+    const end = chunk.trimEnd().length - 2;
+    if (open < 0 || chunk.slice(a + 1, open).trim() || chunk.slice(close + 2, b).trim())
+        return undefined;
+    if (!chunk.startsWith(">>", end))
+        return undefined;
+    const cuts = [open + 1];
+    for (const k of inner)
+        if (k > open && k < close)
+            cuts.push(k);
+    cuts.push(close);
+    const texts = [];
+    for (let k = 1; k < cuts.length; k++)
+        texts.push(chunk.slice(cuts[k - 1] + 1, cuts[k]));
+    return { values: texts, rules: chunk.slice(b + 1, end) };
+};
+const ruleNames = (v) => {
+    if (typeof v !== "object" || v.kind !== "set")
+        return undefined;
+    const names = [];
+    for (const m of v.members) {
+        if (typeof m !== "string")
+            return undefined;
+        names.push(m);
+    }
+    return names;
+};
+export function* readMarks(messages, tag) {
+    const read = memo(parseValue);
+    const start = `"${tag}",`;
+    let chunk = "";
+    let depth = 0;
+    let top = [];
+    let inner = [];
+    for (const line of messages) {
+        if (typeof line !== "string")
+            continue;
+        if (!chunk) {
+            if (!line.startsWith("<<") || !line.slice(2).trimStart().startsWith(start))
+                continue;
+            depth = 0;
+            top = [];
+            inner = [];
+        }
+        const base = chunk.length;
+        chunk += line + "\n";
+        let i = 0;
+        let last = 0;
+        while (i < line.length) {
+            const c = line.charCodeAt(i);
+            if (isSpace(c)) {
+                i++;
+                continue;
+            }
+            const j = tokenEnd(line, i);
+            if (j === -1)
+                throw unreadable(line + "\n", last);
+            if (c === 44 && depth === 1)
+                top.push(base + i);
+            else if (c === 44 && depth === 2)
+                inner.push(base + i);
+            depth += BRACKET[c];
+            i = last = j;
+        }
+        if (depth > 0)
+            continue;
+        const texts = markTexts(chunk, top, inner);
+        const values = [];
+        if (texts)
+            for (const v of texts.values)
+                values.push(read(v));
+        const broken = texts && ruleNames(read(texts.rules));
+        if (!broken)
+            throw new Error(`TLC printed a mark that the command cannot read:\n${chunk.slice(0, 2000)}`);
+        chunk = "";
+        yield { values, broken };
+    }
+    if (chunk)
+        throw new Error(`TLC's output ends inside a marked state, so the command cannot tell which rules it breaks:\n${chunk.slice(0, 2000)}`);
+}
+export function readCounterexample(messages) {
+    const trace = [];
+    for (const m of messages) {
+        if (typeof m === "string")
+            continue;
+        const action = m.code === EC.TLC_STATE_PRINT2 ? actionOf(m) : undefined;
+        if (action !== undefined)
+            trace.push({ action, vars: messageState(m) });
+        else if (m.code === EC.TLC_INVARIANT_VIOLATED_INITIAL ||
+            m.code === EC.TLC_PROPERTY_VIOLATED_INITIAL)
+            trace.push({ action: "", vars: messageState(m) });
+    }
+    return trace;
+}

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

@@ -0,0 +1,93 @@
+import { EC, type Mark, memo, type Part, type TraceState, type Value } from "../ir.ts";
+import { actionOf, messageState } from "./messages.ts";
+import { BRACKET, isSpace, parseValue, tokenEnd, unreadable } from "./value.ts";
+
+const markTexts = (chunk: string, top: number[], inner: number[]) => {
+  if (top.length !== 2) return undefined;
+  const [a, b] = top;
+  const open = chunk.indexOf("<<", a);
+  const close = chunk.lastIndexOf(">>", b);
+  const end = chunk.trimEnd().length - 2;
+  if (open < 0 || chunk.slice(a + 1, open).trim() || chunk.slice(close + 2, b).trim())
+    return undefined;
+  if (!chunk.startsWith(">>", end)) return undefined;
+  const cuts = [open + 1];
+  for (const k of inner) if (k > open && k < close) cuts.push(k);
+  cuts.push(close);
+  const texts: string[] = [];
+  for (let k = 1; k < cuts.length; k++) texts.push(chunk.slice(cuts[k - 1] + 1, cuts[k]));
+  return { values: texts, rules: chunk.slice(b + 1, end) };
+};
+
+const ruleNames = (v: Value) => {
+  if (typeof v !== "object" || v.kind !== "set") return undefined;
+  const names: string[] = [];
+  for (const m of v.members) {
+    if (typeof m !== "string") return undefined;
+    names.push(m);
+  }
+  return names;
+};
+
+export function* readMarks(messages: Iterable<Part>, tag: string): Generator<Mark> {
+  const read = memo(parseValue);
+  const start = `"${tag}",`;
+  let chunk = "";
+  let depth = 0;
+  let top: number[] = [];
+  let inner: number[] = [];
+  for (const line of messages) {
+    if (typeof line !== "string") continue;
+    if (!chunk) {
+      if (!line.startsWith("<<") || !line.slice(2).trimStart().startsWith(start)) continue;
+      depth = 0;
+      top = [];
+      inner = [];
+    }
+    const base = chunk.length;
+    chunk += line + "\n";
+    let i = 0;
+    let last = 0;
+    while (i < line.length) {
+      const c = line.charCodeAt(i);
+      if (isSpace(c)) {
+        i++;
+        continue;
+      }
+      const j = tokenEnd(line, i);
+      if (j === -1) throw unreadable(line + "\n", last);
+      if (c === 44 && depth === 1) top.push(base + i);
+      else if (c === 44 && depth === 2) inner.push(base + i);
+      depth += BRACKET[c];
+      i = last = j;
+    }
+    if (depth > 0) continue;
+    const texts = markTexts(chunk, top, inner);
+    const values: Value[] = [];
+    if (texts) for (const v of texts.values) values.push(read(v));
+    const broken = texts && ruleNames(read(texts.rules));
+    if (!broken)
+      throw new Error(`TLC printed a mark that the command cannot read:\n${chunk.slice(0, 2000)}`);
+    chunk = "";
+    yield { values, broken };
+  }
+  if (chunk)
+    throw new Error(
+      `TLC's output ends inside a marked state, so the command cannot tell which rules it breaks:\n${chunk.slice(0, 2000)}`,
+    );
+}
+
+export function readCounterexample(messages: Iterable<Part>) {
+  const trace: TraceState[] = [];
+  for (const m of messages) {
+    if (typeof m === "string") continue;
+    const action = m.code === EC.TLC_STATE_PRINT2 ? actionOf(m) : undefined;
+    if (action !== undefined) trace.push({ action, vars: messageState(m) });
+    else if (
+      m.code === EC.TLC_INVARIANT_VIOLATED_INITIAL ||
+      m.code === EC.TLC_PROPERTY_VIOLATED_INITIAL
+    )
+      trace.push({ action: "", vars: messageState(m) });
+  }
+  return trace;
+}

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

@@ -0,0 +1,53 @@
+import { linesOf, parseState } from "./dot.mjs";
+const START = /@!@!@STARTMSG (\d+):(\d+) @!@!@$/;
+const END = /^@!@!@ENDMSG \d+ @!@!@$/;
+const isCutMarker = (lastLine) => lastLine.startsWith("@!@!@");
+function cutMessage(open) {
+    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) {
+    const lines = linesOf(tlcOut)[Symbol.iterator]();
+    const open = [];
+    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 = { 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 }) => body.filter((part) => typeof part === "string").join("\n");
+export const actionOf = (m) => /^\d+: (?:Back to state: )?<([^\s>]+)/.exec(textOf(m))?.[1];
+export const messageState = (m) => {
+    const lines = textOf(m).split("\n");
+    const body = [];
+    for (let i = 1; i < lines.length && lines[i].trim(); i++)
+        body.push(lines[i]);
+    return parseState(body.join("\n"));
+};