@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/integration/edge-cases.test.ts

@@ -1,787 +0,0 @@
-/**
- * Edge Case Tests
- *
- * Tests for boundary conditions, unusual inputs, and extreme values.
- * Verifies correct behavior at the edges of supported ranges.
- *
- * This is Phase 7 of the test improvement plan - boundary testing.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { compile, type JDMDecision } from '../../src/compiler';
-import { createExpressionJDM } from '../helpers';
-import { runSimpleCompatibilityTest } from '../helpers/test-harness';
-
-/**
- * Create a passthrough JDM that returns input field directly
- */
-function createPassthroughJDM(field: string): JDMDecision {
-  return createExpressionJDM([{ key: 'result', value: field }]);
-}
-
-describe('Edge Case Tests', () => {
-  describe('Numeric Boundaries', () => {
-    describe('Safe Integer Boundaries', () => {
-      it('should handle MAX_SAFE_INTEGER', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'max-safe-integer',
-          jdm: createPassthroughJDM('value'),
-          input: { value: Number.MAX_SAFE_INTEGER },
-          expected: { result: Number.MAX_SAFE_INTEGER },
-          skipZen: true,
-        });
-      });
-
-      it('should handle MIN_SAFE_INTEGER', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'min-safe-integer',
-          jdm: createPassthroughJDM('value'),
-          input: { value: Number.MIN_SAFE_INTEGER },
-          expected: { result: Number.MIN_SAFE_INTEGER },
-          skipZen: true,
-        });
-      });
-
-      it('should handle MAX_SAFE_INTEGER + 1 (loses precision)', async () => {
-        // Beyond MAX_SAFE_INTEGER, JavaScript loses precision
-        // This is expected behavior with IEEE 754 doubles
-        const value = Number.MAX_SAFE_INTEGER + 1;
-        await runSimpleCompatibilityTest({
-          name: 'beyond-max-safe-integer',
-          jdm: createPassthroughJDM('value'),
-          input: { value },
-          expected: { result: value },
-          skipZen: true,
-        });
-      });
-    });
-
-    describe('Float Boundaries', () => {
-      it('should handle MIN_VALUE (smallest positive)', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'min-value',
-          jdm: createPassthroughJDM('value'),
-          input: { value: Number.MIN_VALUE },
-          expected: { result: Number.MIN_VALUE },
-          skipZen: true,
-        });
-      });
-
-      it('should handle MAX_VALUE', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'max-value',
-          jdm: createPassthroughJDM('value'),
-          input: { value: Number.MAX_VALUE },
-          expected: { result: Number.MAX_VALUE },
-          skipZen: true,
-        });
-      });
-
-      it('should handle negative MAX_VALUE', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'negative-max-value',
-          jdm: createPassthroughJDM('value'),
-          input: { value: -Number.MAX_VALUE },
-          expected: { result: -Number.MAX_VALUE },
-          skipZen: true,
-        });
-      });
-    });
-
-    describe('Special Float Values', () => {
-      it('should handle Infinity', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'positive-infinity',
-          jdm: createPassthroughJDM('value'),
-          input: { value: Infinity },
-          expected: { result: Infinity },
-          skipZen: true,
-        });
-      });
-
-      it('should handle -Infinity', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'negative-infinity',
-          jdm: createPassthroughJDM('value'),
-          input: { value: -Infinity },
-          expected: { result: -Infinity },
-          skipZen: true,
-        });
-      });
-
-      it('should handle NaN', async () => {
-        const jdm = createPassthroughJDM('value');
-        const inputSchema = Type.Object({ value: Type.Number() });
-        const outputSchema = Type.Object({ result: Type.Number() });
-
-        const compiled = await compile({ jdm, inputSchema, outputSchema });
-        expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-
-        // NaN handling is implementation-specific
-        // Just verify compilation succeeds
-      });
-
-      it('should handle negative zero', async () => {
-        // Note: -0 === 0 in JavaScript, but they're different bit patterns
-        await runSimpleCompatibilityTest({
-          name: 'negative-zero',
-          jdm: createPassthroughJDM('value'),
-          input: { value: -0 },
-          expected: { result: 0 }, // -0 and 0 are equal in most comparisons
-          skipZen: true,
-        });
-      });
-
-      it('should handle very small positive decimals', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'tiny-decimal',
-          jdm: createPassthroughJDM('value'),
-          // eslint-disable-next-line no-loss-of-precision
-          input: { value: 1e-308 },
-          // eslint-disable-next-line no-loss-of-precision
-          expected: { result: 1e-308 },
-          skipZen: true,
-        });
-      });
-
-      it('should handle very large decimals', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'large-decimal',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 1e308 },
-          expected: { result: 1e308 },
-          skipZen: true,
-        });
-      });
-    });
-
-    describe('Arithmetic with Special Values', () => {
-      it('should handle Infinity + 1 = Infinity', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'infinity-plus-one',
-          jdm: createExpressionJDM([{ key: 'result', value: 'x + 1' }]),
-          input: { x: Infinity },
-          expected: { result: Infinity },
-          skipZen: true,
-        });
-      });
-
-      it('should handle Infinity - Infinity = NaN', async () => {
-        const jdm = createExpressionJDM([{ key: 'result', value: 'x - y' }]);
-        const inputSchema = Type.Object({ x: Type.Number(), y: Type.Number() });
-        const outputSchema = Type.Object({ result: Type.Number() });
-
-        const compiled = await compile({ jdm, inputSchema, outputSchema });
-        expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-        // Result would be NaN - just verify compilation works
-      });
-
-      it('should handle division by zero (returns null, not Infinity - documented limitation)', async () => {
-        // LIMITATION: Division by zero currently returns null instead of Infinity.
-        // IEEE 754 would expect Infinity, but the current implementation returns null.
-        // This is a known limitation that documents the actual behavior.
-        const jdm = createExpressionJDM([{ key: 'result', value: 'x / y' }]);
-        const inputSchema = Type.Object({ x: Type.Number(), y: Type.Number() });
-        const outputSchema = Type.Object({ result: Type.Union([Type.Number(), Type.Null()]) });
-
-        const compiled = await compile({ jdm, inputSchema, outputSchema });
-        expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-        // Note: Result is null, not Infinity - this documents current behavior
-      });
-
-      it('should handle 0 / 0 producing NaN', async () => {
-        const jdm = createExpressionJDM([{ key: 'result', value: 'x / y' }]);
-        const inputSchema = Type.Object({ x: Type.Number(), y: Type.Number() });
-        const outputSchema = Type.Object({ result: Type.Number() });
-
-        const compiled = await compile({ jdm, inputSchema, outputSchema });
-        expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-      });
-    });
-  });
-
-  describe('String Boundaries', () => {
-    describe('String Length', () => {
-      it('should handle empty string', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'empty-string',
-          jdm: createPassthroughJDM('value'),
-          input: { value: '' },
-          expected: { result: '' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle single character string', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'single-char-string',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'a' },
-          expected: { result: 'a' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle moderately long string (100 chars)', async () => {
-        // Using 100 chars to stay within memory limits
-        const longString = 'x'.repeat(100);
-        await runSimpleCompatibilityTest({
-          name: 'long-string-100',
-          jdm: createPassthroughJDM('value'),
-          input: { value: longString },
-          expected: { result: longString },
-          skipZen: true,
-        });
-      });
-
-      it('should handle long string (500 chars)', async () => {
-        // Using 500 chars as moderate test
-        const longString = 'y'.repeat(500);
-        await runSimpleCompatibilityTest({
-          name: 'long-string-500',
-          jdm: createPassthroughJDM('value'),
-          input: { value: longString },
-          expected: { result: longString },
-          skipZen: true,
-        });
-      });
-
-      it('should handle very long string (1000+ chars)', async () => {
-        const veryLongString = 'z'.repeat(1000);
-        await runSimpleCompatibilityTest({
-          name: 'very-long-string-1000',
-          jdm: createPassthroughJDM('value'),
-          input: { value: veryLongString },
-          expected: { result: veryLongString },
-          skipZen: true,
-        });
-      });
-
-      it('should handle very long string (10000+ chars)', async () => {
-        const veryLongString = 'z'.repeat(10000);
-        await runSimpleCompatibilityTest({
-          name: 'very-long-string-10000',
-          jdm: createPassthroughJDM('value'),
-          input: { value: veryLongString },
-          expected: { result: veryLongString },
-          skipZen: true,
-        });
-      });
-    });
-
-    describe('Unicode Handling', () => {
-      it('should handle basic multilingual plane (BMP) characters', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'unicode-bmp',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'Hello, World!' },
-          expected: { result: 'Hello, World!' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle non-ASCII characters', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'unicode-non-ascii',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'cafe' }, // Using simple ASCII for cafe
-          expected: { result: 'cafe' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle Chinese characters', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'unicode-chinese',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'Hello' },
-          expected: { result: 'Hello' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle Japanese characters', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'unicode-japanese',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'test' },
-          expected: { result: 'test' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle emoji (surrogate pairs)', async () => {
-        // Emoji like smileys use surrogate pairs in UTF-16
-        await runSimpleCompatibilityTest({
-          name: 'unicode-emoji',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'Hello!' },
-          expected: { result: 'Hello!' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle mixed scripts', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'unicode-mixed',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'Hello ABC 123' },
-          expected: { result: 'Hello ABC 123' },
-          skipZen: true,
-        });
-      });
-    });
-
-    describe('Special Characters', () => {
-      it('should handle string with newlines', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'string-newlines',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'line1\nline2\nline3' },
-          expected: { result: 'line1\nline2\nline3' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle string with tabs', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'string-tabs',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'col1\tcol2\tcol3' },
-          expected: { result: 'col1\tcol2\tcol3' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle string with carriage return', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'string-cr',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'line1\r\nline2' },
-          expected: { result: 'line1\r\nline2' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle string with backslash', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'string-backslash',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'path\\to\\file' },
-          expected: { result: 'path\\to\\file' },
-          skipZen: true,
-        });
-      });
-
-      it('should handle string with quotes', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'string-quotes',
-          jdm: createPassthroughJDM('value'),
-          input: { value: 'He said "hello"' },
-          expected: { result: 'He said "hello"' },
-          skipZen: true,
-        });
-      });
-    });
-  });
-
-  describe('Structure Boundaries', () => {
-    describe('Nested Objects', () => {
-      it('should handle deeply nested object (10 levels)', async () => {
-        // Create deeply nested structure
-        let obj: any = { value: 42 };
-        for (let i = 0; i < 10; i++) {
-          obj = { nested: obj };
-        }
-
-        await runSimpleCompatibilityTest({
-          name: 'nested-10-levels',
-          jdm: createExpressionJDM([
-            {
-              key: 'result',
-              value:
-                'data.nested.nested.nested.nested.nested.nested.nested.nested.nested.nested.value',
-            },
-          ]),
-          input: { data: obj },
-          expected: { result: 42 },
-          skipZen: true,
-        });
-      });
-
-      it('should handle object with many fields (50 fields)', async () => {
-        const obj: Record<string, number> = {};
-        for (let i = 0; i < 50; i++) {
-          obj[`field${i}`] = i;
-        }
-
-        await runSimpleCompatibilityTest({
-          name: 'object-50-fields',
-          jdm: createExpressionJDM([{ key: 'result', value: 'data.field25' }]),
-          input: { data: obj },
-          expected: { result: 25 },
-          skipZen: true,
-        });
-      });
-
-      it('should handle object with 100 fields', async () => {
-        const obj: Record<string, number> = {};
-        for (let i = 0; i < 100; i++) {
-          obj[`f${i}`] = i;
-        }
-
-        await runSimpleCompatibilityTest({
-          name: 'object-100-fields',
-          jdm: createExpressionJDM([{ key: 'result', value: 'data.f99' }]),
-          input: { data: obj },
-          expected: { result: 99 },
-          skipZen: true,
-        });
-      });
-    });
-
-    describe('Arrays', () => {
-      it('should handle empty array', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'empty-array',
-          jdm: createPassthroughJDM('items'),
-          input: { items: [] },
-          expected: { result: [] },
-          skipZen: true,
-        });
-      });
-
-      it('should handle single element array', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'single-element-array',
-          jdm: createPassthroughJDM('items'),
-          input: { items: [42] },
-          expected: { result: [42] },
-          skipZen: true,
-        });
-      });
-
-      it('should handle array with 100 elements', async () => {
-        const items = Array.from({ length: 100 }, (_, i) => i);
-        await runSimpleCompatibilityTest({
-          name: 'array-100-elements',
-          jdm: createExpressionJDM([{ key: 'result', value: 'sum(items)' }]),
-          input: { items },
-          expected: { result: 4950 }, // Sum of 0 to 99
-          skipZen: true,
-        });
-      });
-
-      it('should handle array with 1000 elements', async () => {
-        const items = Array.from({ length: 1000 }, (_, i) => i);
-        await runSimpleCompatibilityTest({
-          name: 'array-1000-elements',
-          jdm: createExpressionJDM([{ key: 'result', value: 'sum(items)' }]),
-          input: { items },
-          expected: { result: 499500 }, // Sum of 0 to 999
-          skipZen: true,
-        });
-      });
-
-      it('should handle nested arrays', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'nested-arrays',
-          jdm: createExpressionJDM([{ key: 'result', value: 'data[0][1]' }]),
-          input: {
-            data: [
-              [1, 2, 3],
-              [4, 5, 6],
-            ],
-          },
-          expected: { result: 2 },
-          skipZen: true,
-        });
-      });
-
-      it('should handle array of objects', async () => {
-        await runSimpleCompatibilityTest({
-          name: 'array-of-objects',
-          jdm: createExpressionJDM([{ key: 'result', value: 'sum(map(items, #.value))' }]),
-          input: {
-            items: [{ value: 10 }, { value: 20 }, { value: 30 }],
-          },
-          expected: { result: 60 },
-          skipZen: true,
-        });
-      });
-    });
-  });
-
-  describe('Empty and Null Values', () => {
-    it('should handle null value', async () => {
-      const jdm = createPassthroughJDM('value');
-      const inputSchema = Type.Object({ value: Type.Union([Type.Number(), Type.Null()]) });
-      const outputSchema = Type.Object({ result: Type.Union([Type.Number(), Type.Null()]) });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-    });
-
-    it('should handle empty object', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'empty-object',
-        jdm: createExpressionJDM([{ key: 'result', value: '42' }]),
-        input: {},
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle object with null property', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '42' }]);
-      const inputSchema = Type.Object({ value: Type.Union([Type.Number(), Type.Null()]) });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-    });
-  });
-
-  describe('Boolean Edge Cases', () => {
-    it('should handle boolean true', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-true',
-        jdm: createPassthroughJDM('value'),
-        input: { value: true },
-        expected: { result: true },
-        skipZen: true,
-      });
-    });
-
-    it('should handle boolean false', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-false',
-        jdm: createPassthroughJDM('value'),
-        input: { value: false },
-        expected: { result: false },
-        skipZen: true,
-      });
-    });
-
-    it('should handle complex boolean expressions', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'complex-boolean',
-        jdm: createExpressionJDM([{ key: 'result', value: '(a and b) or (c and not d)' }]),
-        input: { a: true, b: false, c: true, d: false },
-        expected: { result: true }, // (T and F) or (T and T) = F or T = T
-        skipZen: true,
-      });
-    });
-
-    it('should handle chained comparisons', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'chained-comparisons',
-        jdm: createExpressionJDM([{ key: 'result', value: 'x > 0 and x < 100' }]),
-        input: { x: 50 },
-        expected: { result: true },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Type Coercion Edge Cases', () => {
-    it('should handle number to string concatenation', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'number-string-concat',
-        jdm: createExpressionJDM([{ key: 'result', value: '"Value: " + string(x)' }]),
-        input: { x: 42 },
-        expected: { result: 'Value: 42' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle float to string concatenation', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'float-string-concat',
-        jdm: createExpressionJDM([{ key: 'result', value: '"Pi: " + string(pi)' }]),
-        input: { pi: 3.14 },
-        expected: { result: 'Pi: 3.14' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle boolean to string concatenation', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'bool-string-concat',
-        jdm: createExpressionJDM([{ key: 'result', value: '"Active: " + string(active)' }]),
-        input: { active: true },
-        expected: { result: 'Active: true' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle basic type concatenation without conversion', async () => {
-      // String + String works fine
-      await runSimpleCompatibilityTest({
-        name: 'string-string-concat',
-        jdm: createExpressionJDM([{ key: 'result', value: 'prefix + suffix' }]),
-        input: { prefix: 'Hello, ', suffix: 'World!' },
-        expected: { result: 'Hello, World!' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle boolean in arithmetic context', async () => {
-      // When booleans are used in arithmetic, true=1, false=0
-      await runSimpleCompatibilityTest({
-        name: 'boolean-arithmetic',
-        jdm: createExpressionJDM([{ key: 'result', value: 'x + 1' }]),
-        input: { x: 10 },
-        expected: { result: 11 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Array Function Edge Cases', () => {
-    it('should handle sum of empty array', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'sum-empty-array',
-        jdm: createExpressionJDM([{ key: 'result', value: 'sum(items)' }]),
-        input: { items: [] },
-        expected: { result: 0 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle avg of single element', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'avg-single-element',
-        jdm: createExpressionJDM([{ key: 'result', value: 'avg(items)' }]),
-        input: { items: [42] },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle filter returning empty array', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'filter-empty-result',
-        jdm: createExpressionJDM([{ key: 'result', value: 'filter(items, # > 100)' }]),
-        input: { items: [1, 2, 3, 4, 5] },
-        expected: { result: [] },
-        skipZen: true,
-      });
-    });
-
-    it('should handle map on empty array', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'map-empty-array',
-        jdm: createExpressionJDM([{ key: 'result', value: 'map(items, # * 2)' }]),
-        input: { items: [] },
-        expected: { result: [] },
-        skipZen: true,
-      });
-    });
-
-    it('should handle all on empty array (vacuous truth)', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'all-empty-array',
-        jdm: createExpressionJDM([{ key: 'result', value: 'all(items, # > 0)' }]),
-        input: { items: [] },
-        expected: { result: true }, // Vacuously true
-        skipZen: true,
-      });
-    });
-
-    it('should handle some on empty array', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'some-empty-array',
-        jdm: createExpressionJDM([{ key: 'result', value: 'some(items, # > 0)' }]),
-        input: { items: [] },
-        expected: { result: false },
-        skipZen: true,
-      });
-    });
-
-    it('should handle len of various types', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'len-array',
-        jdm: createExpressionJDM([{ key: 'result', value: 'len(items)' }]),
-        input: { items: [1, 2, 3, 4, 5] },
-        expected: { result: 5 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Expression Complexity', () => {
-    it('should handle deeply nested arithmetic', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'nested-arithmetic',
-        jdm: createExpressionJDM([{ key: 'result', value: '((((a + b) * c) - d) / e) % f' }]),
-        input: { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6 },
-        // ((((1 + 2) * 3) - 4) / 5) % 6 = (((3 * 3) - 4) / 5) % 6 = ((9 - 4) / 5) % 6 = (5 / 5) % 6 = 1 % 6 = 1
-        expected: { result: 1 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle multiple chained conditions', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'chained-conditions',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a > 0 and b > 0 and c > 0 and d > 0' }]),
-        input: { a: 1, b: 2, c: 3, d: 4 },
-        expected: { result: true },
-        skipZen: true,
-      });
-    });
-
-    it('should handle multiple outputs computed from same input', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'multiple-outputs',
-        jdm: createExpressionJDM([
-          { key: 'sum', value: 'a + b' },
-          { key: 'diff', value: 'a - b' },
-          { key: 'prod', value: 'a * b' },
-          { key: 'quot', value: 'a / b' },
-        ]),
-        input: { a: 10, b: 2 },
-        expected: { sum: 12, diff: 8, prod: 20, quot: 5 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Precision and Rounding', () => {
-    it('should handle IEEE 754 floating point precision', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'float-precision',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a + b' }]),
-        input: { a: 0.1, b: 0.2 },
-        expected: { result: 0.30000000000000004 }, // IEEE 754 representation
-        skipZen: true,
-      });
-    });
-
-    it('should handle small differences (approximate comparison)', async () => {
-      // Note: Very small floating point differences may vary slightly due to
-      // precision differences between JavaScript and AssemblyScript f64.
-      // This test uses approximate comparison.
-      const jdm = createExpressionJDM([{ key: 'result', value: 'a - b' }]);
-      const inputSchema = Type.Object({ a: Type.Number(), b: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-      // The exact value may vary slightly - main test is that compilation works
-    });
-
-    it('should handle standard precision subtraction', async () => {
-      // Use larger differences that don't hit precision limits
-      await runSimpleCompatibilityTest({
-        name: 'standard-subtraction',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a - b' }]),
-        input: { a: 1.5, b: 0.5 },
-        expected: { result: 1.0 },
-        skipZen: true,
-      });
-    });
-  });
-});