pi-t3-pstack 0.0.0-stage → 0.1.0

package/pstack/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/pstack/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/pstack/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/pstack/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/pstack/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/pstack/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 };
+}