@divmain/jdm-asm 0.2.0

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

@@ -0,0 +1,864 @@
+/**
+ * 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();
+      }
+    });
+  });
+});