FE-514: Reject var declarations and standalone expressions in SymPy compiler

Only const is allowed — both let and var are now rejected. Standalone
expression statements (not assigned or returned) produce a diagnostic.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: kube

libs/@hashintel/petrinaut/src/simulation/simulator/compile-to-sympy.test.ts

@@ -726,6 +726,19 @@ describe("compileToSymPy", () => {
       }
     });
 
+    it("should reject var declarations", () => {
+      const code = `export default Lambda(() => {
+          var x = 1;
+          return x;
+        })`;
+      const result = compileToSymPy(code, defaultContext);
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toContain("var");
+        expect(result.error).toContain("use 'const'");
+      }
+    });
+
     it("should reject string literals with position", () => {
       const code = `export default Lambda(() => "hello")`;
       const result = compileToSymPy(code, defaultContext);
@@ -748,6 +761,23 @@ describe("compileToSymPy", () => {
       }
     });
 
+    it("should reject standalone expression statements", () => {
+      const code = `export default Lambda((tokensByPlace, parameters) => {
+          const a = Boolean(1 + 2);
+          Boolean(1 + 2);
+          return Boolean(1 + 2);
+        })`;
+      const result = compileToSymPy(code, defaultContext);
+      expect(result.ok).toBe(false);
+      if (!result.ok) {
+        expect(result.error).toContain("Standalone expression has no effect");
+        // The standalone expression is the second line in the block
+        const standalonePos = code.indexOf("\n          Boolean(1 + 2);") + 11;
+        expect(result.start).toBe(standalonePos);
+        expect(result.length).toBe("Boolean(1 + 2);".length);
+      }
+    });
+
     it("should reject unsupported binary operator with position", () => {
       const code = `export default Lambda(() => 1 << 2)`;
       const result = compileToSymPy(code, defaultContext);

libs/@hashintel/petrinaut/src/simulation/simulator/compile-to-sympy.ts

@@ -226,9 +226,9 @@ function compileBlock(
             sourceFile,
           );
         }
-        if (stmt.declarationList.flags & ts.NodeFlags.Let) {
+        if (!(stmt.declarationList.flags & ts.NodeFlags.Const)) {
           return err(
-            "'let' declarations are not supported, use 'const'",
+            "'let' and 'var' declarations are not supported, use 'const'",
             stmt,
             sourceFile,
           );
@@ -259,8 +259,11 @@ function compileBlock(
       if (!result.ok) return result;
       lines.push(result.sympyCode);
     } else if (ts.isExpressionStatement(stmt)) {
-      // Allow comments parsed as expression statements, skip them
-      continue;
+      return err(
+        "Standalone expression has no effect — assign to a const or return it",
+        stmt,
+        sourceFile,
+      );
     } else {
       return err(
         `Unsupported statement: ${ts.SyntaxKind[stmt.kind]}`,