@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/integration/compilation-errors.test.ts

@@ -1,864 +0,0 @@
-/**
- * Compilation Error Tests
- *
- * Tests that the compiler fails appropriately for invalid JDM structures.
- * Verifies error messages, error codes, and source location information.
- *
- * This is Phase 7 of the test improvement plan - negative test cases.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { compile, type JDMDecision } from '../../src/compiler';
-import { CompilationError, ErrorCode } from '../../src/compiler/errors';
-import { buildGraph, validateGraph } from '../../src/compiler/graph';
-import { parseJDM, NodeType } from '../../src/compiler/parser';
-import { createExpressionJDM } from '../helpers';
-
-const defaultInputSchema = Type.Object({ x: Type.Number() });
-const defaultOutputSchema = Type.Object({ result: Type.Number() });
-
-describe('Compilation Error Tests', () => {
-  describe('Missing Required Nodes', () => {
-    it('should throw error when input node is missing', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 0, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/input node/i);
-    });
-
-    it('should throw error when output node is missing', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/output node/i);
-    });
-
-    it('should throw error when multiple input nodes exist', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request1',
-          },
-          {
-            id: 'input-2',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 100 },
-            name: 'Request2',
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 200, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'output-1', type: 'edge' },
-          { id: 'e2', sourceId: 'input-2', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/input node.*found 2/i);
-    });
-  });
-
-  describe('Circular Dependencies', () => {
-    it('should throw error for simple cycle between two nodes', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            position: { x: 100, y: 0 },
-            name: 'ExprA',
-            content: { expressions: [] },
-          },
-          {
-            id: 'expr-2',
-            type: NodeType.EXPRESSION,
-            position: { x: 200, y: 0 },
-            name: 'ExprB',
-            content: { expressions: [] },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 300, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-          { id: 'e2', sourceId: 'expr-1', targetId: 'expr-2', type: 'edge' },
-          { id: 'e3', sourceId: 'expr-2', targetId: 'expr-1', type: 'edge' }, // Creates cycle
-        ],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/circular/i);
-    });
-
-    it('should throw error for self-referencing node', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            position: { x: 100, y: 0 },
-            name: 'SelfRef',
-            content: { expressions: [] },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 200, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-          { id: 'e2', sourceId: 'expr-1', targetId: 'expr-1', type: 'edge' }, // Self-reference
-          { id: 'e3', sourceId: 'expr-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      expect(() => buildGraph(jdm)).toThrow(CompilationError);
-      expect(() => buildGraph(jdm)).toThrow(/self-reference/i);
-    });
-
-    it('should throw error for longer cycle (A -> B -> C -> A)', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'expr-a',
-            type: NodeType.EXPRESSION,
-            position: { x: 100, y: 0 },
-            name: 'NodeA',
-            content: { expressions: [] },
-          },
-          {
-            id: 'expr-b',
-            type: NodeType.EXPRESSION,
-            position: { x: 200, y: 0 },
-            name: 'NodeB',
-            content: { expressions: [] },
-          },
-          {
-            id: 'expr-c',
-            type: NodeType.EXPRESSION,
-            position: { x: 300, y: 0 },
-            name: 'NodeC',
-            content: { expressions: [] },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'expr-a', type: 'edge' },
-          { id: 'e2', sourceId: 'expr-a', targetId: 'expr-b', type: 'edge' },
-          { id: 'e3', sourceId: 'expr-b', targetId: 'expr-c', type: 'edge' },
-          { id: 'e4', sourceId: 'expr-c', targetId: 'expr-a', type: 'edge' }, // Creates cycle
-        ],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/circular/i);
-    });
-  });
-
-  describe('Invalid Expression Syntax', () => {
-    it('should throw error for invalid arithmetic syntax', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: 'x + + y' }]);
-
-      await expect(
-        compile({
-          jdm,
-          inputSchema: Type.Object({ x: Type.Number(), y: Type.Number() }),
-          outputSchema: defaultOutputSchema,
-        }),
-      ).rejects.toThrow();
-    });
-
-    it('should throw error for unclosed parentheses', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '(x + y' }]);
-
-      await expect(
-        compile({
-          jdm,
-          inputSchema: Type.Object({ x: Type.Number(), y: Type.Number() }),
-          outputSchema: defaultOutputSchema,
-        }),
-      ).rejects.toThrow();
-    });
-
-    it('should throw error for unclosed string literal', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '"hello' }]);
-
-      await expect(
-        compile({
-          jdm,
-          inputSchema: Type.Object({}),
-          outputSchema: Type.Object({ result: Type.String() }),
-        }),
-      ).rejects.toThrow();
-    });
-
-    it('should throw error for empty expression', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '' }]);
-
-      await expect(
-        compile({
-          jdm,
-          inputSchema: defaultInputSchema,
-          outputSchema: defaultOutputSchema,
-        }),
-      ).rejects.toThrow();
-    });
-
-    it('should throw error for whitespace-only expression', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '   ' }]);
-
-      await expect(
-        compile({
-          jdm,
-          inputSchema: defaultInputSchema,
-          outputSchema: defaultOutputSchema,
-        }),
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('Invalid Edges', () => {
-    it('should throw error for edge referencing non-existent source node', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 200, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          {
-            id: 'edge-1',
-            sourceId: 'nonexistent-node',
-            targetId: 'output-1',
-            type: 'edge',
-          },
-        ],
-      };
-
-      expect(() => buildGraph(jdm)).toThrow(CompilationError);
-      expect(() => buildGraph(jdm)).toThrow(/non-existent node/i);
-    });
-
-    it('should throw error for edge referencing non-existent target node', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 200, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          {
-            id: 'edge-1',
-            sourceId: 'input-1',
-            targetId: 'nonexistent-node',
-            type: 'edge',
-          },
-        ],
-      };
-
-      expect(() => buildGraph(jdm)).toThrow(CompilationError);
-      expect(() => buildGraph(jdm)).toThrow(/non-existent node/i);
-    });
-  });
-
-  describe('Function Node Parsing', () => {
-    it('should parse function nodes successfully', () => {
-      const jdm = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: 'inputNode',
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'func-1',
-            type: 'functionNode',
-            position: { x: 200, y: 0 },
-            name: 'CustomFunction',
-            content: { source: 'export const handler = (input) => ({ result: input.x * 2 });' },
-          },
-          {
-            id: 'output-1',
-            type: 'outputNode',
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'edge-1', sourceId: 'input-1', targetId: 'func-1', type: 'edge' },
-          { id: 'edge-2', sourceId: 'func-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      // Should parse without error
-      const parsed = parseJDM(jdm);
-      expect(parsed.nodes.length).toBe(3);
-      expect(parsed.nodes[1].type).toBe('functionNode');
-      expect(parsed.nodes[1].parsedContent).toBeDefined();
-    });
-
-    it('should throw error for function node with invalid JavaScript syntax', () => {
-      const jdm = {
-        nodes: [
-          {
-            id: 'func-1',
-            type: 'functionNode',
-            position: { x: 200, y: 0 },
-            name: 'CustomFunction',
-            content: { source: 'this is not valid javascript {{{' },
-          },
-        ],
-        edges: [],
-      };
-
-      expect(() => parseJDM(jdm)).toThrow();
-      expect(() => parseJDM(jdm)).toThrow('Failed to parse function code');
-    });
-  });
-
-  describe('Empty or Malformed JDM Structure', () => {
-    it('should throw error for empty nodes array', () => {
-      const jdm: JDMDecision = {
-        nodes: [],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-    });
-
-    it('should throw error for invalid JSON string', () => {
-      expect(() => parseJDM('{ invalid json }')).toThrow();
-    });
-
-    it('should handle JDM with only input node (no output)', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/output node/i);
-    });
-
-    it('should handle JDM with only output node (no input)', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 0, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      expect(() => validateGraph(graph)).toThrow(CompilationError);
-      expect(() => validateGraph(graph)).toThrow(/input node/i);
-    });
-  });
-
-  describe('Source Location in Errors', () => {
-    it('should include node information in structural errors', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            position: { x: 0, y: 0 },
-            name: 'OrphanExpression',
-            content: { expressions: [] },
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      try {
-        validateGraph(graph);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        // Error should mention missing input/output nodes
-        expect((e as Error).message).toMatch(/node/i);
-      }
-    });
-
-    it('should include node name in cycle detection errors', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            position: { x: 100, y: 0 },
-            name: 'CycleNodeA',
-            content: { expressions: [] },
-          },
-          {
-            id: 'expr-2',
-            type: NodeType.EXPRESSION,
-            position: { x: 200, y: 0 },
-            name: 'CycleNodeB',
-            content: { expressions: [] },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 300, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-          { id: 'e2', sourceId: 'expr-1', targetId: 'expr-2', type: 'edge' },
-          { id: 'e3', sourceId: 'expr-2', targetId: 'expr-1', type: 'edge' },
-        ],
-      };
-
-      const graph = buildGraph(jdm);
-      try {
-        validateGraph(graph);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        const message = (e as Error).message;
-        // Should include node names in cycle path
-        expect(message).toMatch(/CycleNodeA|CycleNodeB/);
-      }
-    });
-  });
-
-  describe('Error Code Classification', () => {
-    it('should use MULTIPLE_INPUT_NODES code for missing or wrong number of inputs', () => {
-      // Note: The graph validation uses MULTIPLE_INPUT_NODES code when input count != 1
-      // This includes both 0 inputs and 2+ inputs
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 0, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      try {
-        validateGraph(graph);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        // When input count != 1, MULTIPLE_INPUT_NODES is used (includes 0 case)
-        expect((e as CompilationError).code).toBe(ErrorCode.MULTIPLE_INPUT_NODES);
-      }
-    });
-
-    it('should use MISSING_OUTPUT_NODE code for missing output', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      try {
-        validateGraph(graph);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        expect((e as CompilationError).code).toBe(ErrorCode.MISSING_OUTPUT_NODE);
-      }
-    });
-
-    it('should use MULTIPLE_INPUT_NODES code for multiple inputs', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request1',
-          },
-          {
-            id: 'input-2',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 100 },
-            name: 'Request2',
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 200, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [],
-      };
-
-      const graph = buildGraph(jdm);
-      try {
-        validateGraph(graph);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        expect((e as CompilationError).code).toBe(ErrorCode.MULTIPLE_INPUT_NODES);
-      }
-    });
-
-    it('should use CYCLE_DETECTED code for cycles', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'expr-1',
-            type: NodeType.EXPRESSION,
-            position: { x: 100, y: 0 },
-            name: 'NodeA',
-            content: { expressions: [] },
-          },
-          {
-            id: 'expr-2',
-            type: NodeType.EXPRESSION,
-            position: { x: 200, y: 0 },
-            name: 'NodeB',
-            content: { expressions: [] },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 300, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-          { id: 'e2', sourceId: 'expr-1', targetId: 'expr-2', type: 'edge' },
-          { id: 'e3', sourceId: 'expr-2', targetId: 'expr-1', type: 'edge' },
-        ],
-      };
-
-      const graph = buildGraph(jdm);
-      try {
-        validateGraph(graph);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        expect((e as CompilationError).code).toBe(ErrorCode.CYCLE_DETECTED);
-      }
-    });
-
-    it('should use INVALID_EDGE code for invalid edges', () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-        ],
-        edges: [
-          {
-            id: 'edge-1',
-            sourceId: 'input-1',
-            targetId: 'nonexistent',
-            type: 'edge',
-          },
-        ],
-      };
-
-      try {
-        buildGraph(jdm);
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(CompilationError);
-        expect((e as CompilationError).code).toBe(ErrorCode.INVALID_EDGE);
-      }
-    });
-  });
-
-  describe('Decision Table Validation', () => {
-    it('should handle decision table with no rules (currently a limitation)', async () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            position: { x: 200, y: 0 },
-            name: 'EmptyTable',
-            content: {
-              hitPolicy: 'first',
-              inputs: [{ id: 'in1', field: 'x', name: 'X' }],
-              outputs: [{ id: 'out1', field: 'result', name: 'Result' }],
-              rules: [],
-            },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'dt-1', type: 'edge' },
-          { id: 'e2', sourceId: 'dt-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      // LIMITATION: Empty decision tables currently fail to compile due to code generation
-      // producing invalid AssemblyScript (dangling 'else' clause).
-      // This documents the current behavior - future improvements could handle this case.
-      await expect(
-        compile({
-          jdm,
-          inputSchema: Type.Object({ x: Type.Number() }),
-          outputSchema: Type.Object({ result: Type.Optional(Type.Number()) }),
-        }),
-      ).rejects.toThrow();
-    });
-
-    it('should handle decision table with at least one rule', async () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'dt-1',
-            type: NodeType.DECISION_TABLE,
-            position: { x: 200, y: 0 },
-            name: 'SimpleTable',
-            content: {
-              hitPolicy: 'first',
-              inputs: [{ id: 'in1', field: 'x', name: 'X' }],
-              outputs: [{ id: 'out1', field: 'result', name: 'Result' }],
-              rules: [
-                {
-                  _id: 'rule1',
-                  in1: '', // Empty condition = always matches
-                  out1: '42',
-                },
-              ],
-            },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'dt-1', type: 'edge' },
-          { id: 'e2', sourceId: 'dt-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      const result = await compile({
-        jdm,
-        inputSchema: Type.Object({ x: Type.Number() }),
-        outputSchema: Type.Object({ result: Type.Number() }),
-      });
-
-      expect(result.wasm).toBeInstanceOf(Uint8Array);
-    });
-  });
-
-  describe('Switch Node Validation', () => {
-    it('should handle switch with no conditions', async () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: NodeType.INPUT,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'switch-1',
-            type: NodeType.SWITCH,
-            position: { x: 200, y: 0 },
-            name: 'EmptySwitch',
-            content: {
-              hitPolicy: 'first',
-              statements: [],
-            },
-          },
-          {
-            id: 'output-1',
-            type: NodeType.OUTPUT,
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'e1', sourceId: 'input-1', targetId: 'switch-1', type: 'edge' },
-          { id: 'e2', sourceId: 'switch-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      // Empty switch should compile but produce no output or use default
-      const result = await compile({
-        jdm,
-        inputSchema: Type.Object({ x: Type.Number() }),
-        outputSchema: Type.Object({}),
-      });
-
-      expect(result.wasm).toBeInstanceOf(Uint8Array);
-    });
-  });
-
-  describe('Compilation Pipeline Errors', () => {
-    it('should provide useful error for complex nested expression errors', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '((x + y) * (z -))' }]); // Missing operand
-
-      try {
-        await compile({
-          jdm,
-          inputSchema: Type.Object({ x: Type.Number(), y: Type.Number(), z: Type.Number() }),
-          outputSchema: defaultOutputSchema,
-        });
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeDefined();
-        // The error should be thrown, exact message depends on parser
-      }
-    });
-
-    it('should handle invalid ternary expression', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: 'x > 0 ? "yes"' }]); // Missing else branch
-
-      try {
-        await compile({
-          jdm,
-          inputSchema: defaultInputSchema,
-          outputSchema: Type.Object({ result: Type.String() }),
-        });
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeDefined();
-      }
-    });
-  });
-});