@fiducian/spec 0.4.0

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+export interface InteractionSignature {
+    from: string;
+    to: string;
+    op: string;
+    fields: string[];
+}
+export interface Constraint {
+    kind: "true" | "eq" | "fieldEq";
+    left?: string;
+    right?: string | boolean | number;
+}
+export interface ChainStep {
+    signature: InteractionSignature;
+    constraint: Constraint;
+    optional?: boolean;
+}
+export interface PropertySpec {
+    modal: "omega" | "theta" | "diamond" | "none";
+    steps: ChainStep[];
+}
+export declare class ParseError extends Error {
+    constructor(message: string);
+}
+export declare function parseProperty(source: string): PropertySpec;
+export declare function parseWaltzFile(source: string): PropertySpec;

package/dist/index.js

@@ -0,0 +1,131 @@
+export class ParseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ParseError";
+    }
+}
+function tokenize(source) {
+    const tokens = [];
+    let i = 0;
+    while (i < source.length) {
+        const ch = source[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if ("();:{},".includes(ch)) {
+            tokens.push(ch);
+            i++;
+            continue;
+        }
+        if (ch === "-" && source[i + 1] === ">") {
+            tokens.push("->");
+            i += 2;
+            continue;
+        }
+        if (ch === "=" && source[i + 1] === "=") {
+            tokens.push("==");
+            i += 2;
+            continue;
+        }
+        const match = source.slice(i).match(/^[A-Za-z_][A-Za-z0-9_]*/);
+        if (match) {
+            tokens.push(match[0]);
+            i += match[0].length;
+            continue;
+        }
+        throw new ParseError(`Unexpected character '${ch}' at ${i}`);
+    }
+    return tokens;
+}
+export function parseProperty(source) {
+    const tokens = tokenize(source.replace(/\/\/[^\n]*/g, ""));
+    let index = 0;
+    const peek = () => tokens[index];
+    const consume = (expected) => {
+        const tok = tokens[index++];
+        if (expected && tok !== expected) {
+            throw new ParseError(`Expected '${expected}' but got '${tok ?? "EOF"}'`);
+        }
+        return tok;
+    };
+    let modal = "none";
+    if (peek() === "Omega" || peek() === "O") {
+        consume();
+        consume("(");
+        modal = "omega";
+    }
+    else if (peek() === "Theta" || peek() === "T") {
+        consume();
+        consume("(");
+        modal = "theta";
+    }
+    else if (peek() === "Diamond" || peek() === "D") {
+        consume();
+        consume("(");
+        modal = "diamond";
+    }
+    const steps = [];
+    while (index < tokens.length) {
+        if (peek() === ")")
+            break;
+        if (peek() === ";") {
+            consume(";");
+            continue;
+        }
+        let optional = false;
+        if (peek() === "optional") {
+            consume("optional");
+            optional = true;
+        }
+        consume("send");
+        const from = consume();
+        consume("->");
+        const to = consume();
+        consume("{");
+        const fields = [];
+        while (peek() !== "}") {
+            if (peek() === ",")
+                consume(",");
+            fields.push(consume());
+        }
+        consume("}");
+        consume(":");
+        const constraint = parseConstraint(tokens, () => consume(), () => peek());
+        steps.push({
+            signature: { from, to, op: "send", fields },
+            constraint,
+            ...(optional ? { optional: true } : {}),
+        });
+    }
+    if (modal !== "none") {
+        consume(")");
+    }
+    if (steps.length === 0) {
+        throw new ParseError("Property must contain at least one chain step");
+    }
+    return { modal, steps };
+}
+function parseConstraint(_tokens, consume, peek) {
+    const first = peek();
+    if (first === "true") {
+        consume();
+        return { kind: "true" };
+    }
+    const left = consume();
+    if (peek() === "==") {
+        consume();
+        const rightTok = consume();
+        if (rightTok === "true" || rightTok === "false") {
+            return { kind: "eq", left, right: rightTok === "true" };
+        }
+        if (/^\d+$/.test(rightTok)) {
+            return { kind: "eq", left, right: Number(rightTok) };
+        }
+        return { kind: "fieldEq", left, right: rightTok };
+    }
+    throw new ParseError(`Invalid constraint starting with '${first}'`);
+}
+export function parseWaltzFile(source) {
+    return parseProperty(source.trim());
+}

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.test.js

@@ -0,0 +1,31 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseWaltzFile } from "./index.js";
+test("parseWaltzFile parses chained property", () => {
+    const spec = parseWaltzFile(`
+    Omega(
+      send client->order{orderId} : true
+      ;
+      send order->kitchen{orderId, accepted} : accepted == true
+      ;
+      send order->billing{orderId, charged} : charged == true
+    )
+  `);
+    assert.equal(spec.modal, "omega");
+    assert.equal(spec.steps.length, 3);
+    assert.equal(spec.steps[0].signature.from, "client");
+    assert.equal(spec.steps[1].signature.to, "kitchen");
+});
+test("parseWaltzFile parses optional steps", () => {
+    const spec = parseWaltzFile(`
+    Omega(
+      send client->order{orderId} : true
+      ;
+      optional send order->audit{orderId} : true
+      ;
+      send order->kitchen{orderId, accepted} : accepted == true
+    )
+  `);
+    assert.equal(spec.steps[1].optional, true);
+    assert.equal(spec.steps[2].optional, undefined);
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@fiducian/spec",
+  "version": "0.4.0",
+  "description": "Minimal WALTZ spec parser for FiduciaTrace",
+  "license": "AGPL-3.0-or-later",
+  "keywords": ["fiducia", "fiducia", "waltz", "spec", "verification"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thesnmc/Fiducian.git",
+    "directory": "trace/packages/spec"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": ["dist"],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "node --test dist/**/*.test.js",
+    "prepublishOnly": "npm run build"
+  }
+}