@divmain/jdm-asm 0.2.0 → 0.2.3

package/tests/integration/wasm-execution.test.ts

@@ -1,348 +0,0 @@
-/**
- * WASM Execution Integration Tests
- *
- * Core tests for compiling JDM to WASM and executing it.
- * Tests the full pipeline: JDM -> AssemblyScript -> WASM -> Execution
- *
- * This is Phase 6 of the test improvement plan - critical integration tests
- * that verify actual WASM compilation and execution.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { compile } from '../../src/compiler';
-import { createExpressionJDM } from '../helpers';
-import { runSimpleCompatibilityTest } from '../helpers/test-harness';
-
-describe('WASM Execution Integration Tests', () => {
-  describe('Compilation Pipeline', () => {
-    it('should compile a minimal JDM to valid WASM binary', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '42' }]);
-      const inputSchema = Type.Object({});
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({
-        jdm,
-        inputSchema,
-        outputSchema,
-        debug: true,
-      });
-
-      // Verify WASM binary is valid
-      expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-      expect(compiled.wasm.length).toBeGreaterThan(0);
-
-      // WASM magic number (0x00, 0x61, 0x73, 0x6D)
-      expect(compiled.wasm[0]).toBe(0x00);
-      expect(compiled.wasm[1]).toBe(0x61);
-      expect(compiled.wasm[2]).toBe(0x73);
-      expect(compiled.wasm[3]).toBe(0x6d);
-    });
-
-    it('should generate valid AssemblyScript code in debug mode', 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,
-        debug: true,
-      });
-
-      expect(compiled.assemblyScript).toBeDefined();
-      expect(compiled.assemblyScript).toContain('export function evaluate');
-    });
-
-    it('should generate marshaling code', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '1' }]);
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({
-        jdm,
-        inputSchema,
-        outputSchema,
-      });
-
-      expect(compiled.marshalCode).toBeDefined();
-      expect(compiled.marshalCode).toContain('marshalInput');
-      expect(compiled.marshalCode).toContain('unmarshalOutput');
-    });
-
-    it('should generate validation code', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '1' }]);
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({
-        jdm,
-        inputSchema,
-        outputSchema,
-      });
-
-      expect(compiled.validationCode).toBeDefined();
-      expect(compiled.validationCode).toContain('validateInput');
-    });
-
-    it('should compute schema hash', async () => {
-      const jdm = createExpressionJDM([{ key: 'result', value: '1' }]);
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({
-        jdm,
-        inputSchema,
-        outputSchema,
-      });
-
-      expect(compiled.schemaHash).toBeDefined();
-      expect(typeof compiled.schemaHash).toBe('bigint');
-    });
-  });
-
-  describe('Arithmetic Expression Evaluation', () => {
-    it('should evaluate simple addition', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'addition',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a + b' }]),
-        input: { a: 5, b: 3 },
-        expected: { result: 8 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate subtraction', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'subtraction',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a - b' }]),
-        input: { a: 10, b: 4 },
-        expected: { result: 6 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate multiplication', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'multiplication',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a * b' }]),
-        input: { a: 6, b: 7 },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate division', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'division',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a / b' }]),
-        input: { a: 20, b: 4 },
-        expected: { result: 5 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate complex arithmetic expressions', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'complex-arithmetic',
-        jdm: createExpressionJDM([{ key: 'result', value: '(a + b) * c - d / e' }]),
-        input: { a: 2, b: 3, c: 4, d: 10, e: 2 },
-        // (2 + 3) * 4 - 10 / 2 = 5 * 4 - 5 = 20 - 5 = 15
-        expected: { result: 15 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate floating point arithmetic', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'float-arithmetic',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a + b' }]),
-        input: { a: 0.1, b: 0.2 },
-        expected: { result: 0.30000000000000004 }, // IEEE 754 floating point
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate modulo operation', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'modulo',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a % b' }]),
-        input: { a: 17, b: 5 },
-        expected: { result: 2 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate negative numbers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'negative',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a + b' }]),
-        input: { a: -10, b: 3 },
-        expected: { result: -7 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Boolean Operations', () => {
-    it('should evaluate boolean and', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-and',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a and b' }]),
-        input: { a: true, b: true },
-        expected: { result: true },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate boolean or', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-or',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a or b' }]),
-        input: { a: false, b: true },
-        expected: { result: true },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate boolean not', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-not',
-        jdm: createExpressionJDM([{ key: 'result', value: 'not a' }]),
-        input: { a: true },
-        expected: { result: false },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate comparison operators', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'comparison',
-        jdm: createExpressionJDM([
-          { key: 'isGreater', value: 'x > y' },
-          { key: 'isEqual', value: 'x == y' },
-          { key: 'isLessOrEqual', value: 'x <= y' },
-        ]),
-        input: { x: 10, y: 5 },
-        expected: { isGreater: true, isEqual: false, isLessOrEqual: false },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Array Operations', () => {
-    it('should evaluate sum() function', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'sum',
-        jdm: createExpressionJDM([{ key: 'total', value: 'sum(numbers)' }]),
-        input: { numbers: [1, 2, 3, 4, 5] },
-        expected: { total: 15 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate avg() function', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'avg',
-        jdm: createExpressionJDM([{ key: 'average', value: 'avg(numbers)' }]),
-        input: { numbers: [10, 20, 30] },
-        expected: { average: 20 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate filter() function', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'filter',
-        jdm: createExpressionJDM([{ key: 'filtered', value: 'filter(numbers, # > 5)' }]),
-        input: { numbers: [1, 3, 5, 7, 9, 11] },
-        expected: { filtered: [7, 9, 11] },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate map() function', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'map',
-        jdm: createExpressionJDM([{ key: 'doubled', value: 'map(numbers, # * 2)' }]),
-        input: { numbers: [1, 2, 3] },
-        expected: { doubled: [2, 4, 6] },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate all() function', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'all',
-        jdm: createExpressionJDM([{ key: 'allPositive', value: 'all(numbers, # > 0)' }]),
-        input: { numbers: [1, 2, 3] },
-        expected: { allPositive: true },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate some() function', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'some',
-        jdm: createExpressionJDM([{ key: 'hasNegative', value: 'some(numbers, # < 0)' }]),
-        input: { numbers: [1, -2, 3] },
-        expected: { hasNegative: true },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('String Operations', () => {
-    it('should evaluate string concatenation', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'string-concat',
-        jdm: createExpressionJDM([{ key: 'result', value: 'firstName + " " + lastName' }]),
-        input: { firstName: 'John', lastName: 'Doe' },
-        expected: { result: 'John Doe' },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Nested Property Access', () => {
-    it('should evaluate nested property access', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'nested-property',
-        jdm: createExpressionJDM([{ key: 'result', value: 'user.profile.age + 10' }]),
-        input: { user: { profile: { age: 25 } } },
-        expected: { result: 35 },
-        skipZen: true,
-      });
-    });
-
-    it('should evaluate deeply nested properties', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'deeply-nested',
-        jdm: createExpressionJDM([{ key: 'result', value: 'a.b.c.d.e' }]),
-        input: { a: { b: { c: { d: { e: 42 } } } } },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Multiple Outputs', () => {
-    it('should evaluate multiple expressions to multiple outputs', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'multiple-outputs',
-        jdm: createExpressionJDM([
-          { key: 'sum', value: 'a + b' },
-          { key: 'product', value: 'a * b' },
-          { key: 'difference', value: 'a - b' },
-        ]),
-        input: { a: 10, b: 3 },
-        expected: { sum: 13, product: 30, difference: 7 },
-        skipZen: true,
-      });
-    });
-  });
-});

package/tests/integration/wasm-memory.test.ts

@@ -1,228 +0,0 @@
-/**
- * WASM Memory Management Tests
- *
- * Tests for memory allocation, growth, and lifecycle management in compiled WASM modules.
- * Verifies that memory is properly allocated, doesn't leak, and handles growth correctly.
- *
- * This is Phase 6 of the test improvement plan - testing memory management behavior.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { compile, type JDMDecision } from '../../src/compiler';
-import { ensureMemory } from '../../src/compiler/runtime';
-import { runSimpleCompatibilityTest } from '../helpers/test-harness';
-import type { CompilationResult } from '../../src/compiler/types';
-
-/**
- * Create a minimal JDM decision for testing
- */
-function createTestJDM(expression: string): JDMDecision {
-  return {
-    nodes: [
-      {
-        id: 'input-1',
-        type: 'inputNode' as any,
-        position: { x: 0, y: 0 },
-        name: 'Request',
-      },
-      {
-        id: 'expr-1',
-        type: 'expressionNode' as any,
-        position: { x: 200, y: 0 },
-        name: 'Expression',
-        content: {
-          expressions: [{ id: 'e1', key: 'result', value: expression }],
-        },
-      },
-      {
-        id: 'output-1',
-        type: 'outputNode' as any,
-        position: { x: 400, y: 0 },
-        name: 'Response',
-      },
-    ],
-    edges: [
-      { id: 'edge-1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-      { id: 'edge-2', sourceId: 'expr-1', targetId: 'output-1', type: 'edge' },
-    ],
-  };
-}
-
-/**
- * Helper to instantiate WASM and get memory instance
- */
-async function instantiateWasm(compiled: CompilationResult): Promise<{
-  instance: WebAssembly.Instance;
-  memory: WebAssembly.Memory;
-  evaluate: (ptr: number) => number;
-}> {
-  const wasmArray = new Uint8Array(compiled.wasm);
-  const buffer = wasmArray.buffer.slice(
-    wasmArray.byteOffset,
-    wasmArray.byteOffset + wasmArray.byteLength,
-  );
-  const wasmModule = await WebAssembly.compile(buffer as ArrayBuffer);
-  const instance = await WebAssembly.instantiate(wasmModule, {
-    env: {
-      abort: () => {
-        throw new Error('WASM abort called');
-      },
-      'Date.now': () => Date.now(),
-    },
-  });
-
-  return {
-    instance,
-    memory: instance.exports.memory as WebAssembly.Memory,
-    evaluate: instance.exports.evaluate as (ptr: number) => number,
-  };
-}
-
-describe('WASM Memory Management Tests', () => {
-  describe('Memory Initialization', () => {
-    it('should create WASM instance with initial memory', async () => {
-      const jdm = createTestJDM('42');
-      const inputSchema = Type.Object({});
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      const { memory } = await instantiateWasm(compiled);
-
-      // Initial memory should be at least 4 pages (256KB) based on build.ts config
-      expect(memory.buffer.byteLength).toBeGreaterThanOrEqual(4 * 65536);
-    });
-
-    it('should export memory from WASM module', async () => {
-      const jdm = createTestJDM('x + 1');
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      const { instance } = await instantiateWasm(compiled);
-
-      expect(instance.exports.memory).toBeDefined();
-      expect(instance.exports.memory).toBeInstanceOf(WebAssembly.Memory);
-    });
-
-    it('should export evaluate function from WASM module', async () => {
-      const jdm = createTestJDM('x + 1');
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      const { instance } = await instantiateWasm(compiled);
-
-      expect(instance.exports.evaluate).toBeDefined();
-      expect(typeof instance.exports.evaluate).toBe('function');
-    });
-  });
-
-  describe('Memory Growth', () => {
-    it('should grow memory when ensureMemory is called with larger size', async () => {
-      const jdm = createTestJDM('1');
-      const inputSchema = Type.Object({});
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      const { memory } = await instantiateWasm(compiled);
-
-      const initialSize = memory.buffer.byteLength;
-
-      // Request more memory than currently available
-      const requiredSize = initialSize + 65536 * 2; // 2 extra pages
-      ensureMemory(memory, requiredSize);
-
-      expect(memory.buffer.byteLength).toBeGreaterThanOrEqual(requiredSize);
-    });
-
-    it('should not grow memory when sufficient is available', async () => {
-      const jdm = createTestJDM('1');
-      const inputSchema = Type.Object({});
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      const { memory } = await instantiateWasm(compiled);
-
-      const initialSize = memory.buffer.byteLength;
-
-      // Request less memory than available
-      ensureMemory(memory, initialSize - 1);
-
-      // Size should remain the same
-      expect(memory.buffer.byteLength).toBe(initialSize);
-    });
-
-    it('should handle memory growth for large inputs', async () => {
-      const jdm = createTestJDM('sum(numbers)');
-      const inputSchema = Type.Object({ numbers: Type.Array(Type.Number()) });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema });
-      const { memory } = await instantiateWasm(compiled);
-
-      // Grow to handle a large array
-      const largeSize = 1024 * 1024; // 1MB
-      ensureMemory(memory, largeSize);
-
-      expect(memory.buffer.byteLength).toBeGreaterThanOrEqual(largeSize);
-    });
-  });
-
-  describe('Large Data Handling', () => {
-    it('should handle arrays with many elements', async () => {
-      // Create array with 1000 elements
-      const numbers = Array.from({ length: 1000 }, (_, i) => i + 1);
-
-      await runSimpleCompatibilityTest({
-        name: 'large-array-sum',
-        jdm: createTestJDM('sum(numbers)'),
-        input: { numbers },
-        // Sum of 1 to 1000 = 500500
-        expected: { result: 500500 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle deeply nested objects', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'deeply-nested',
-        jdm: createTestJDM('a.b.c.d.e'),
-        input: { a: { b: { c: { d: { e: 42 } } } } },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle object with many properties', async () => {
-      // Create object with many properties
-      const input: Record<string, number> = {};
-      for (let i = 0; i < 100; i++) {
-        input[`prop${i}`] = i;
-      }
-
-      await runSimpleCompatibilityTest({
-        name: 'many-properties',
-        jdm: createTestJDM('prop50 + prop51'),
-        input,
-        expected: { result: 101 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Memory Stability', () => {
-    it('should handle multiple evaluations without issues', async () => {
-      // Run multiple evaluations with different inputs
-      for (let i = 1; i <= 10; i++) {
-        await runSimpleCompatibilityTest({
-          name: `stability-test-${i}`,
-          jdm: createTestJDM('x * 2'),
-          input: { x: i },
-          expected: { result: i * 2 },
-          skipZen: true,
-        });
-      }
-    });
-  });
-});