Go/JS/Solidity execution parity for Petri net runtime

Rewrites state.js to match Go metamodel.Runtime semantics:
- Arc weights from bindings (was hardcoded to 1)
- Keyed arc data transformations (single and nested maps)
- Read-arc detection (skip input decrements for read-then-write)
- Literal arc weight parsing (Value="1" → integer 1)
- executeWithBindings() for full colored Petri net execution

Adds parity_test.mjs with three test cases run in both Go and JS:
- ERC20: mint(1000) → transfer(300) → burn(100) — verifies balances and totalSupply
- Counter: increment(5) → decrement(2) — verifies scalar arc weights
- Allowances: mint → approve → transferFrom — verifies nested map access

The Go test suite now shells out to Node.js to verify JS produces
identical state, and CI runs the same test in the js-parity job.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: stackdump

.github/workflows/ci.yml

@@ -113,6 +113,10 @@ jobs:
           });
           "
 
+      - name: Petri net execution parity
+        run: |
+          node --experimental-vm-modules public/parity_test.mjs
+
       - name: JS syntax check
         run: |
           for f in public/mimc.js public/merkle.js public/witness-builder.js public/safemath.js public/model.js public/state.js public/bridge.js public/bitwrap.js; do

internal/server/runtime_parity_test.go

@@ -1,6 +1,9 @@
 package server
 
 import (
+	"os"
+	"os/exec"
+	"path/filepath"
 	"testing"
 
 	"github.com/stackdump/bitwrap-io/dsl"
@@ -154,6 +157,118 @@ schema Counter {
 			t.Errorf("after decrement(2): COUNT=%d, want 3", rt.Tokens("COUNT"))
 		}
 	})
+
+	t.Run("allowances", func(t *testing.T) {
+		src := `
+schema ERC20Approve {
+  version "1.0.0"
+  register BALANCES map[address]uint256
+  register ALLOWANCES map[address]map[address]uint256
+
+  fn(mint) {
+    var to address
+    var amount amount
+    mint -|amount|> BALANCES[to]
+  }
+
+  fn(approve) {
+    var owner address
+    var spender address
+    var amount amount
+    approve -|amount|> ALLOWANCES[owner][spender]
+  }
+
+  fn(transferFrom) {
+    var from address
+    var spender address
+    var to address
+    var amount amount
+    BALANCES[from] -|amount|> transferFrom
+    ALLOWANCES[from][spender] -|amount|> transferFrom
+    transferFrom -|amount|> BALANCES[to]
+  }
+}
+`
+		ast, err := dsl.Parse(src)
+		if err != nil {
+			t.Fatal(err)
+		}
+		schema, err := dsl.Build(ast)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		rt := metamodel.NewRuntime(schema)
+		rt.CheckConstraints = false
+
+		// Mint 1000 to Alice
+		err = rt.ExecuteWithBindings("mint", metamodel.Bindings{"to": "Alice", "amount": int64(1000)})
+		if err != nil {
+			t.Fatalf("mint: %v", err)
+		}
+
+		// Alice approves Bob for 500
+		err = rt.ExecuteWithBindings("approve", metamodel.Bindings{"owner": "Alice", "spender": "Bob", "amount": int64(500)})
+		if err != nil {
+			t.Fatalf("approve: %v", err)
+		}
+		allowances := rt.DataMap("ALLOWANCES")
+		nested, ok := allowances["Alice"].(map[string]any)
+		if !ok {
+			t.Fatal("ALLOWANCES[Alice] is not a map")
+		}
+		if mapVal(nested, "Bob") != 500 {
+			t.Errorf("after approve: ALLOWANCES[Alice][Bob]=%v, want 500", nested["Bob"])
+		}
+
+		// Bob transfers 200 from Alice to Charlie
+		err = rt.ExecuteWithBindings("transferFrom", metamodel.Bindings{
+			"from": "Alice", "spender": "Bob", "to": "Charlie", "amount": int64(200),
+		})
+		if err != nil {
+			t.Fatalf("transferFrom: %v", err)
+		}
+
+		balances := rt.DataMap("BALANCES")
+		if mapVal(balances, "Alice") != 800 {
+			t.Errorf("after transferFrom: BALANCES[Alice]=%v, want 800", balances["Alice"])
+		}
+		if mapVal(balances, "Charlie") != 200 {
+			t.Errorf("after transferFrom: BALANCES[Charlie]=%v, want 200", balances["Charlie"])
+		}
+		allowances = rt.DataMap("ALLOWANCES")
+		nested = allowances["Alice"].(map[string]any)
+		if mapVal(nested, "Bob") != 300 {
+			t.Errorf("after transferFrom: ALLOWANCES[Alice][Bob]=%v, want 300", nested["Bob"])
+		}
+	})
+
+	// Verify JS parity by running the JS test
+	t.Run("js_parity", func(t *testing.T) {
+		cmd := exec.Command("node", "--experimental-vm-modules", "public/parity_test.mjs")
+		cmd.Dir = findProjectRoot(t)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Fatalf("JS parity test failed:\n%s\n%v", out, err)
+		}
+		t.Logf("%s", out)
+	})
+}
+
+func findProjectRoot(t *testing.T) string {
+	t.Helper()
+	// Walk up from the test binary's working directory to find go.mod
+	dir, _ := os.Getwd()
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			t.Fatal("could not find project root")
+		}
+		dir = parent
+	}
 }
 
 func mapVal(m map[string]any, key string) int64 {

public/parity_test.mjs

@@ -0,0 +1,125 @@
+// Petri net execution parity test — must match Go TestRuntimeSolidityParity.
+// Run: node --experimental-vm-modules public/parity_test.mjs
+
+import { Model } from './model.js';
+import { State } from './state.js';
+
+let failures = 0;
+
+function assert(condition, msg) {
+  if (!condition) {
+    console.error('FAIL:', msg);
+    failures++;
+  }
+}
+
+// ============ ERC20: mint → transfer → burn ============
+function testERC20() {
+  const m = new Model('ERC20');
+  m.addPlace({ id: 'BALANCES', schema: 'map[address]uint256', exported: true });
+  m.addPlace({ id: 'TOTAL_SUPPLY', schema: 'uint256', initial: 0 });
+  m.addTransition({ id: 'mint' });
+  m.addTransition({ id: 'transfer' });
+  m.addTransition({ id: 'burn' });
+
+  // mint arcs: mint -|amount|> BALANCES[to], mint -|amount|> TOTAL_SUPPLY
+  m.addArc({ source: 'mint', target: 'BALANCES', keys: ['to'], value: 'amount' });
+  m.addArc({ source: 'mint', target: 'TOTAL_SUPPLY', value: 'amount' });
+
+  // transfer arcs: BALANCES[from] -|amount|> transfer, transfer -|amount|> BALANCES[to]
+  m.addArc({ source: 'BALANCES', target: 'transfer', keys: ['from'], value: 'amount' });
+  m.addArc({ source: 'transfer', target: 'BALANCES', keys: ['to'], value: 'amount' });
+
+  // burn arcs: BALANCES[from] -|amount|> burn, TOTAL_SUPPLY -|amount|> burn
+  m.addArc({ source: 'BALANCES', target: 'burn', keys: ['from'], value: 'amount' });
+  m.addArc({ source: 'TOTAL_SUPPLY', target: 'burn', value: 'amount' });
+
+  const s = new State(m);
+
+  // Mint 1000 to Alice
+  s.executeWithBindings('mint', { to: 'Alice', amount: 1000 });
+  assert(s.getDataMap('BALANCES')['Alice'] === 1000, `ERC20 mint: BALANCES[Alice]=${s.getDataMap('BALANCES')['Alice']}, want 1000`);
+  assert(s.getTokens('TOTAL_SUPPLY') === 1000, `ERC20 mint: TOTAL_SUPPLY=${s.getTokens('TOTAL_SUPPLY')}, want 1000`);
+
+  // Transfer 300 from Alice to Bob
+  s.executeWithBindings('transfer', { from: 'Alice', to: 'Bob', amount: 300 });
+  assert(s.getDataMap('BALANCES')['Alice'] === 700, `ERC20 transfer: BALANCES[Alice]=${s.getDataMap('BALANCES')['Alice']}, want 700`);
+  assert(s.getDataMap('BALANCES')['Bob'] === 300, `ERC20 transfer: BALANCES[Bob]=${s.getDataMap('BALANCES')['Bob']}, want 300`);
+  assert(s.getTokens('TOTAL_SUPPLY') === 1000, `ERC20 transfer: TOTAL_SUPPLY=${s.getTokens('TOTAL_SUPPLY')}, want 1000`);
+
+  // Burn 100 from Alice
+  s.executeWithBindings('burn', { from: 'Alice', amount: 100 });
+  assert(s.getDataMap('BALANCES')['Alice'] === 600, `ERC20 burn: BALANCES[Alice]=${s.getDataMap('BALANCES')['Alice']}, want 600`);
+  assert(s.getTokens('TOTAL_SUPPLY') === 900, `ERC20 burn: TOTAL_SUPPLY=${s.getTokens('TOTAL_SUPPLY')}, want 900`);
+
+  console.log('ERC20 parity: OK');
+}
+
+// ============ Counter: increment → decrement ============
+function testCounter() {
+  const m = new Model('Counter');
+  m.addPlace({ id: 'COUNT', schema: 'uint256', initial: 0 });
+  m.addTransition({ id: 'increment' });
+  m.addTransition({ id: 'decrement' });
+
+  m.addArc({ source: 'increment', target: 'COUNT', value: 'amount' });
+  m.addArc({ source: 'COUNT', target: 'decrement', value: 'amount' });
+
+  const s = new State(m);
+
+  // Increment by 5
+  s.executeWithBindings('increment', { amount: 5 });
+  assert(s.getTokens('COUNT') === 5, `Counter increment: COUNT=${s.getTokens('COUNT')}, want 5`);
+
+  // Decrement by 2
+  s.executeWithBindings('decrement', { amount: 2 });
+  assert(s.getTokens('COUNT') === 3, `Counter decrement: COUNT=${s.getTokens('COUNT')}, want 3`);
+
+  console.log('Counter parity: OK');
+}
+
+// ============ Nested maps: approve + transferFrom ============
+function testAllowances() {
+  const m = new Model('ERC20Approve');
+  m.addPlace({ id: 'BALANCES', schema: 'map[address]uint256' });
+  m.addPlace({ id: 'ALLOWANCES', schema: 'map[address]map[address]uint256' });
+  m.addTransition({ id: 'mint' });
+  m.addTransition({ id: 'approve' });
+  m.addTransition({ id: 'transferFrom' });
+
+  m.addArc({ source: 'mint', target: 'BALANCES', keys: ['to'], value: 'amount' });
+  m.addArc({ source: 'approve', target: 'ALLOWANCES', keys: ['owner', 'spender'], value: 'amount' });
+  m.addArc({ source: 'BALANCES', target: 'transferFrom', keys: ['from'], value: 'amount' });
+  m.addArc({ source: 'ALLOWANCES', target: 'transferFrom', keys: ['from', 'spender'], value: 'amount' });
+  m.addArc({ source: 'transferFrom', target: 'BALANCES', keys: ['to'], value: 'amount' });
+
+  const s = new State(m);
+
+  // Mint 1000 to Alice
+  s.executeWithBindings('mint', { to: 'Alice', amount: 1000 });
+  assert(s.getDataMap('BALANCES')['Alice'] === 1000, 'mint balance');
+
+  // Alice approves Bob for 500
+  s.executeWithBindings('approve', { owner: 'Alice', spender: 'Bob', amount: 500 });
+  const allowances = s.getDataMap('ALLOWANCES');
+  assert(allowances['Alice'] && allowances['Alice']['Bob'] === 500, `approve: ALLOWANCES[Alice][Bob]=${allowances['Alice']?.['Bob']}, want 500`);
+
+  // Bob transfers 200 from Alice to Charlie
+  s.executeWithBindings('transferFrom', { from: 'Alice', spender: 'Bob', to: 'Charlie', amount: 200 });
+  assert(s.getDataMap('BALANCES')['Alice'] === 800, `transferFrom: BALANCES[Alice]=${s.getDataMap('BALANCES')['Alice']}, want 800`);
+  assert(s.getDataMap('BALANCES')['Charlie'] === 200, `transferFrom: BALANCES[Charlie]=${s.getDataMap('BALANCES')['Charlie']}, want 200`);
+  assert(s.getDataMap('ALLOWANCES')['Alice']['Bob'] === 300, `transferFrom: ALLOWANCES[Alice][Bob]=${s.getDataMap('ALLOWANCES')['Alice']['Bob']}, want 300`);
+
+  console.log('Allowances parity: OK');
+}
+
+testERC20();
+testCounter();
+testAllowances();
+
+if (failures > 0) {
+  console.error(`\n${failures} parity failures`);
+  process.exit(1);
+} else {
+  console.log('\nPetri net execution parity: all tests passed');
+}