pi-pstack-native 0.0.0-stage → 1.0.0

package/vendor/upstream/0.15.36/pstack/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/vendor/upstream/0.15.36/pstack/skills/statechart/scripts/frontends/verdict.ts

@@ -0,0 +1,40 @@
+import { EC, type Part } from "../ir.ts";
+import { textOf } from "./messages.ts";
+
+export type Break =
+  | { kind: "deadlock" }
+  | { kind: "temporal" }
+  | { kind: "invariant" | "property"; name: string };
+
+const NAMED = new Map<number, ["invariant" | "property", RegExp]>([
+  [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<number, RegExp>([
+  [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: Iterable<Part>) {
+  let broke: Break | undefined;
+  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 };
+}

package/vendor/upstream/0.15.36/pstack/skills/statechart/scripts/frontends/view.ts

@@ -0,0 +1,119 @@
+import { type CheckedView, checked, list, type Value, type Vars } from "../ir.ts";
+
+type Json = boolean | number | string | Json[] | { [key: string]: Json };
+
+const projected = new WeakMap<object, Json>();
+
+export const json = (v: Value): Json => {
+  if (typeof v !== "object") return v;
+  if (v.kind === "model") return v.name;
+  let j = projected.get(v);
+  if (j === undefined) {
+    if (v.kind === "interval") {
+      const members: Json[] = [];
+      for (let k = v.lo; k <= v.hi; k++) members.push(k);
+      j = members;
+    } else if (v.kind === "set") {
+      const members: Json[] = [];
+      for (const m of v.members) members.push(json(m));
+      j = members;
+    } else {
+      const fields: [string, Json][] = [];
+      for (let i = 0; i < v.keys.length; i++) {
+        const k = json(v.keys[i]);
+        fields.push([typeof k === "object" ? JSON.stringify(k) : String(k), json(v.values[i])]);
+      }
+      j = Object.fromEntries(fields);
+    }
+    projected.set(v, j);
+  }
+  return j;
+};
+
+const projectedVars = new WeakMap<Vars, { [name: string]: Json }>();
+
+const jsonVars = (vars: Vars) => {
+  let j = projectedVars.get(vars);
+  if (j === undefined) {
+    const fields: [string, Json][] = [];
+    for (const [name, v] of Object.entries(vars)) fields.push([name, json(v)]);
+    j = Object.fromEntries(fields);
+    projectedVars.set(vars, j);
+  }
+  return j;
+};
+
+const THEME_COLORS = ["blue", "orange", "purple", "yellow", "teal", "tan", "pink"];
+
+const isFunction = (v: unknown): v is (...args: unknown[]) => unknown => typeof v === "function";
+
+const isPlainObject = (v: unknown): v is { [key: string]: unknown } => {
+  if (typeof v !== "object" || v === null) return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+
+const isString = (v: unknown) => typeof v === "string";
+
+const VIEW_EXPORTS = ["state", "step", "group", "colors", "title"];
+
+type Inspect = (value: unknown, options: { breakLength: number }) => string;
+
+export function checkView(
+  view: { readonly [name: string]: unknown },
+  inspect: Inspect,
+): CheckedView {
+  const literal = (v: unknown) =>
+    typeof v === "string" ? JSON.stringify(v) : inspect(v, { breakLength: Infinity });
+  const extra: string[] = [];
+  for (const name of Object.keys(view)) if (!VIEW_EXPORTS.includes(name)) extra.push(name);
+  if (extra.length)
+    throw new Error(
+      `The view exports ${list(extra)}, which the command does not read. Export only ${list(VIEW_EXPORTS)}.`,
+    );
+  const wrong: string[] = [];
+  const pick = <T>(name: string, kind: string, fits: (v: unknown) => v is T) => {
+    const v = view[name];
+    if (v === undefined || fits(v)) return v;
+    wrong.push(`${name} must be ${kind}`);
+    return undefined;
+  };
+  const state = pick("state", "a function", isFunction);
+  const step = pick("step", "a function", isFunction);
+  const group = pick("group", "a function", isFunction);
+  const exported = pick("colors", "a plain object", isPlainObject);
+  const title = pick("title", "a string", isString);
+  if (wrong.length) throw new Error(`The view's ${list(wrong)}.`);
+  if (group !== undefined && exported === undefined)
+    throw new Error("The view exports group() but no colors. Give each group a color in colors.");
+  const colors: { [group: string]: string } = Object.create(null);
+  const bad: string[] = [];
+  for (const [name, color] of Object.entries(exported ?? {})) {
+    if (typeof color === "string" && THEME_COLORS.includes(color)) colors[name] = color;
+    else bad.push(`${JSON.stringify(name)} the color ${literal(color)}`);
+  }
+  if (bad.length)
+    throw new Error(
+      `The view's colors give ${list(bad)}. Give each group ${list(THEME_COLORS, "or")}.`,
+    );
+  const named =
+    group &&
+    ((vars: Vars) => {
+      const g = group(jsonVars(vars));
+      if (g !== undefined && !Object.hasOwn(colors, typeof g === "symbol" ? g : String(g)))
+        throw new Error(
+          `The view's group() returned ${literal(g)}, which colors does not name. Give each group a color in colors.`,
+        );
+      return g;
+    });
+  return {
+    state: state && ((vars: Vars) => state(jsonVars(vars))),
+    step:
+      step &&
+      ((action: string, from: Vars, to: Vars) => step(action, jsonVars(from), jsonVars(to))),
+    group: named,
+    colors,
+    title,
+    [checked]: true,
+  };
+}