@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/schema/schema.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Schema Flattening Tests
+ *
+ * Tests for the schema-driven typed serialization system:
+ * - Schema flattening to memory layouts
+ * - Schema hash computation
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Type } from '@sinclair/typebox';
+import { flattenSchema, computeSchemaHash } from '../../../../src/compiler/schema';
+
+describe('Schema Flattening', () => {
+  describe('flattenSchema', () => {
+    it('should flatten a simple object with numeric fields', () => {
+      const schema = Type.Object({
+        age: Type.Number(),
+        count: Type.Integer(),
+      });
+
+      const layout = flattenSchema(schema);
+
+      expect(layout.fields).toHaveLength(2);
+
+      expect(layout.fields[0]).toMatchObject({
+        path: 'age',
+        flatName: 'age',
+        type: 'f64',
+        size: 8,
+      });
+      expect(layout.fields[0].offset).toBe(0);
+
+      expect(layout.fields[1]).toMatchObject({
+        path: 'count',
+        flatName: 'count',
+        type: 'i32',
+        size: 4,
+      });
+      expect(layout.fields[1].offset).toBe(8);
+    });
+
+    it('should flatten a schema with boolean fields', () => {
+      const schema = Type.Object({
+        active: Type.Boolean(),
+        verified: Type.Boolean(),
+      });
+
+      const layout = flattenSchema(schema);
+
+      expect(layout.fields).toHaveLength(2);
+
+      expect(layout.fields[0]).toMatchObject({
+        path: 'active',
+        flatName: 'active',
+        type: 'bool',
+        size: 4,
+      });
+
+      expect(layout.fields[1]).toMatchObject({
+        path: 'verified',
+        flatName: 'verified',
+        type: 'bool',
+        size: 4,
+      });
+    });
+
+    it('should flatten a schema with enum fields', () => {
+      const schema = Type.Object({
+        tier: Type.Union([Type.Literal('bronze'), Type.Literal('silver'), Type.Literal('gold')]),
+      });
+
+      const layout = flattenSchema(schema);
+
+      expect(layout.fields).toHaveLength(1);
+
+      expect(layout.fields[0]).toMatchObject({
+        path: 'tier',
+        flatName: 'tier',
+        type: 'i32',
+        size: 4,
+      });
+    });
+
+    it('should handle nested objects', () => {
+      const schema = Type.Object({
+        customer: Type.Object({
+          age: Type.Number(),
+          name: Type.String(),
+        }),
+      });
+
+      const layout = flattenSchema(schema);
+
+      // Should have customer.age (f64) and customer.name (string pointer)
+      expect(layout.fields.length).toBeGreaterThanOrEqual(1);
+
+      const ageField = layout.fields.find((f) => f.path === 'customer.age');
+      expect(ageField).toBeDefined();
+      expect(ageField).toMatchObject({
+        path: 'customer.age',
+        flatName: 'customer_age',
+        type: 'f64',
+        size: 8,
+      });
+
+      const nameField = layout.fields.find((f) => f.path === 'customer.name');
+      expect(nameField).toBeDefined();
+      expect(nameField).toMatchObject({
+        path: 'customer.name',
+        flatName: 'customer_name',
+        type: 'string',
+        size: -1,
+      });
+    });
+
+    it('should handle string fields', () => {
+      const schema = Type.Object({
+        name: Type.String(),
+      });
+
+      const layout = flattenSchema(schema);
+
+      expect(layout.fields).toHaveLength(1);
+      expect(layout.fields[0]).toMatchObject({
+        path: 'name',
+        flatName: 'name',
+        type: 'string',
+        size: -1, // Variable size
+      });
+    });
+
+    it('should handle array fields', () => {
+      const schema = Type.Object({
+        items: Type.Array(Type.Number()),
+      });
+
+      const layout = flattenSchema(schema);
+
+      expect(layout.fields).toHaveLength(1);
+      expect(layout.fields[0]).toMatchObject({
+        path: 'items',
+        flatName: 'items',
+        type: 'array',
+        size: -1, // Variable size
+      });
+    });
+
+    it('should calculate correct field offsets for mixed types', () => {
+      const schema = Type.Object({
+        age: Type.Number(), // 8 bytes, offset 0
+        active: Type.Boolean(), // 4 bytes, offset 8
+        name: Type.String(), // pointer at offset 16 ( after fixed types)
+        count: Type.Integer(), // 4 bytes, offset 12
+      });
+
+      const layout = flattenSchema(schema);
+
+      // Fixed types come first in layout
+      const ageField = layout.fields.find((f) => f.path === 'age');
+      expect(ageField?.offset).toBe(0);
+
+      const activeField = layout.fields.find((f) => f.path === 'active');
+      expect(activeField?.offset).toBe(8);
+
+      const countField = layout.fields.find((f) => f.path === 'count');
+      expect(countField?.offset).toBe(12);
+
+      // String pointers come after all fixed types
+      const nameField = layout.fields.find((f) => f.path === 'name');
+      expect(nameField?.offset).toBe(16);
+    });
+
+    it('should use prefix for flat names', () => {
+      const schema = Type.Object({
+        value: Type.Number(),
+      });
+
+      const layout1 = flattenSchema(schema);
+      const layout2 = flattenSchema(schema);
+
+      expect(layout1.fields[0].flatName).toBe('value');
+      expect(layout2.fields[0].flatName).toBe('value');
+    });
+  });
+
+  describe('computeSchemaHash', () => {
+    it('should compute the same hash for identical schemas', () => {
+      const schema = Type.Object({
+        age: Type.Number(),
+        name: Type.String(),
+      });
+
+      const hash1 = computeSchemaHash(schema, schema);
+      const hash2 = computeSchemaHash(schema, schema);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it('should compute different hashes for different schemas', () => {
+      const schema1 = Type.Object({
+        age: Type.Number(),
+      });
+
+      const schema2 = Type.Object({
+        age: Type.Integer(),
+      });
+
+      const hash1 = computeSchemaHash(schema1, schema1);
+      const hash2 = computeSchemaHash(schema2, schema2);
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('should use SHA256 and return a bigint', () => {
+      const schema = Type.Object({ value: Type.Number() });
+
+      const hash = computeSchemaHash(schema, schema);
+
+      expect(typeof hash).toBe('bigint');
+      expect(hash).toBeGreaterThan(0n);
+    });
+
+    it('should include both input and output schemas in hash', () => {
+      const inputSchema = Type.Object({ value: Type.Number() });
+      const outputSchema = Type.Object({ result: Type.Number() });
+
+      const hash1 = computeSchemaHash(inputSchema, outputSchema);
+      const hash2 = computeSchemaHash(inputSchema, inputSchema);
+      const hash3 = computeSchemaHash(outputSchema, outputSchema);
+
+      expect(hash1).not.toBe(hash2);
+      expect(hash2).not.toBe(hash3);
+      expect(hash1).not.toBe(hash3);
+    });
+
+    it('should be deterministic', () => {
+      const schema = Type.Object({
+        name: Type.String(),
+        age: Type.Number(),
+        active: Type.Boolean(),
+      });
+
+      const hashes = Array.from({ length: 3 }, () => computeSchemaHash(schema, schema));
+
+      expect(hashes).toEqual([hashes[0], hashes[0], hashes[0]]);
+    });
+  });
+});

package/tests/unit/compiler/unary-ast-transforms.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect } from 'vitest';
+import {
+  convertIdentifierToStringLiteral,
+  wrapWithDollarComparison,
+  createEqualityComparison,
+  createIntervalCheck,
+  createArrayMembershipCheck,
+  combineWithOr,
+  combineWithAnd,
+} from '../../../src/compiler/unary-ast-transforms';
+import type { ExpressionAST } from '../../../src/compiler/ast-types';
+
+/**
+ * Unit tests for unary AST transformation utilities.
+ *
+ * These tests verify the semantic transformations applied to ASTs in unary context,
+ * which is separate from the parsing logic in unary-parser.ts.
+ */
+describe('Unary AST Transforms', () => {
+  describe('convertIdentifierToStringLiteral', () => {
+    it('should convert an Identifier to a StringLiteral', () => {
+      const input: ExpressionAST = { type: 'Identifier', name: 'premium' };
+      const result = convertIdentifierToStringLiteral(input);
+
+      expect(result).toEqual({ type: 'StringLiteral', value: 'premium' });
+    });
+
+    it('should leave non-Identifier nodes unchanged', () => {
+      const stringLiteral: ExpressionAST = { type: 'StringLiteral', value: 'test' };
+      expect(convertIdentifierToStringLiteral(stringLiteral)).toBe(stringLiteral);
+
+      const numberLiteral: ExpressionAST = { type: 'NumberLiteral', value: 42 };
+      expect(convertIdentifierToStringLiteral(numberLiteral)).toBe(numberLiteral);
+
+      const booleanLiteral: ExpressionAST = { type: 'BooleanLiteral', value: true };
+      expect(convertIdentifierToStringLiteral(booleanLiteral)).toBe(booleanLiteral);
+    });
+
+    it('should preserve the identifier name as the string value', () => {
+      const input: ExpressionAST = { type: 'Identifier', name: 'myIdentifier123' };
+      const result = convertIdentifierToStringLiteral(input);
+
+      expect(result).toEqual({ type: 'StringLiteral', value: 'myIdentifier123' });
+    });
+  });
+
+  describe('wrapWithDollarComparison', () => {
+    it('should wrap a value in a comparison with DollarRef', () => {
+      const value: ExpressionAST = { type: 'NumberLiteral', value: 100 };
+      const result = wrapWithDollarComparison(value, '>');
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: '>',
+        left: { type: 'DollarRef' },
+        right: { type: 'NumberLiteral', value: 100 },
+      });
+    });
+
+    it('should work with different operators', () => {
+      const value: ExpressionAST = { type: 'NumberLiteral', value: 50 };
+
+      expect(wrapWithDollarComparison(value, '>=').op).toBe('>=');
+      expect(wrapWithDollarComparison(value, '<').op).toBe('<');
+      expect(wrapWithDollarComparison(value, '<=').op).toBe('<=');
+      expect(wrapWithDollarComparison(value, '==').op).toBe('==');
+      expect(wrapWithDollarComparison(value, '!=').op).toBe('!=');
+      expect(wrapWithDollarComparison(value, 'in').op).toBe('in');
+    });
+  });
+
+  describe('createEqualityComparison', () => {
+    it('should create equality comparison with identifier conversion', () => {
+      const identifier: ExpressionAST = { type: 'Identifier', name: 'premium' };
+      const result = createEqualityComparison(identifier, '==');
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: '==',
+        left: { type: 'DollarRef' },
+        right: { type: 'StringLiteral', value: 'premium' },
+      });
+    });
+
+    it('should create inequality comparison with identifier conversion', () => {
+      const identifier: ExpressionAST = { type: 'Identifier', name: 'basic' };
+      const result = createEqualityComparison(identifier, '!=');
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: '!=',
+        left: { type: 'DollarRef' },
+        right: { type: 'StringLiteral', value: 'basic' },
+      });
+    });
+
+    it('should preserve non-identifier values', () => {
+      const stringLiteral: ExpressionAST = { type: 'StringLiteral', value: 'test' };
+      const result = createEqualityComparison(stringLiteral, '==');
+
+      expect(result.right).toEqual({ type: 'StringLiteral', value: 'test' });
+    });
+
+    it('should preserve number literals', () => {
+      const numberLiteral: ExpressionAST = { type: 'NumberLiteral', value: 42 };
+      const result = createEqualityComparison(numberLiteral, '==');
+
+      expect(result.right).toEqual({ type: 'NumberLiteral', value: 42 });
+    });
+  });
+
+  describe('createIntervalCheck', () => {
+    it('should create an interval membership check', () => {
+      const interval: ExpressionAST = {
+        type: 'Interval',
+        start: { type: 'NumberLiteral', value: 1 },
+        end: { type: 'NumberLiteral', value: 10 },
+        startInclusive: true,
+        endInclusive: true,
+      };
+      const result = createIntervalCheck(interval);
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: 'in',
+        left: { type: 'DollarRef' },
+        right: interval,
+      });
+    });
+  });
+
+  describe('createArrayMembershipCheck', () => {
+    it('should create an array membership check', () => {
+      const array: ExpressionAST = {
+        type: 'ArrayLiteral',
+        elements: [
+          { type: 'StringLiteral', value: 'gold' },
+          { type: 'StringLiteral', value: 'platinum' },
+        ],
+      };
+      const result = createArrayMembershipCheck(array);
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: 'in',
+        left: { type: 'DollarRef' },
+        right: array,
+      });
+    });
+  });
+
+  describe('combineWithOr', () => {
+    it('should return a single expression unchanged', () => {
+      const expr: ExpressionAST = { type: 'BooleanLiteral', value: true };
+      const result = combineWithOr([expr]);
+
+      expect(result).toBe(expr);
+    });
+
+    it('should combine two expressions with OR', () => {
+      const expr1: ExpressionAST = { type: 'BooleanLiteral', value: true };
+      const expr2: ExpressionAST = { type: 'BooleanLiteral', value: false };
+      const result = combineWithOr([expr1, expr2]);
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: 'or',
+        left: expr1,
+        right: expr2,
+      });
+    });
+
+    it('should chain multiple expressions left-associatively', () => {
+      const expr1: ExpressionAST = { type: 'NumberLiteral', value: 1 };
+      const expr2: ExpressionAST = { type: 'NumberLiteral', value: 2 };
+      const expr3: ExpressionAST = { type: 'NumberLiteral', value: 3 };
+      const result = combineWithOr([expr1, expr2, expr3]);
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: 'or',
+        left: {
+          type: 'BinaryOp',
+          op: 'or',
+          left: expr1,
+          right: expr2,
+        },
+        right: expr3,
+      });
+    });
+
+    it('should return true for empty array', () => {
+      const result = combineWithOr([]);
+
+      expect(result).toEqual({ type: 'BooleanLiteral', value: true });
+    });
+  });
+
+  describe('combineWithAnd', () => {
+    it('should return a single expression unchanged', () => {
+      const expr: ExpressionAST = { type: 'BooleanLiteral', value: true };
+      const result = combineWithAnd([expr]);
+
+      expect(result).toBe(expr);
+    });
+
+    it('should combine two expressions with AND', () => {
+      const expr1: ExpressionAST = { type: 'BooleanLiteral', value: true };
+      const expr2: ExpressionAST = { type: 'BooleanLiteral', value: true };
+      const result = combineWithAnd([expr1, expr2]);
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: 'and',
+        left: expr1,
+        right: expr2,
+      });
+    });
+
+    it('should chain multiple expressions left-associatively', () => {
+      const expr1: ExpressionAST = { type: 'NumberLiteral', value: 1 };
+      const expr2: ExpressionAST = { type: 'NumberLiteral', value: 2 };
+      const expr3: ExpressionAST = { type: 'NumberLiteral', value: 3 };
+      const result = combineWithAnd([expr1, expr2, expr3]);
+
+      expect(result).toEqual({
+        type: 'BinaryOp',
+        op: 'and',
+        left: {
+          type: 'BinaryOp',
+          op: 'and',
+          left: expr1,
+          right: expr2,
+        },
+        right: expr3,
+      });
+    });
+
+    it('should return true for empty array', () => {
+      const result = combineWithAnd([]);
+
+      expect(result).toEqual({ type: 'BooleanLiteral', value: true });
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "skipLibCheck": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "declaration": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": [
+    "src/index.ts",
+    "src/compiler/**/*.ts",
+    "src/tests/**/*.ts",
+    "tests/**/*.ts"
+  ],
+  "exclude": ["node_modules", "dist", "build"]
+}

package/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/compiler/index.ts', 'tests/helpers/test-harness.ts', 'tests/scripts/coverage-analysis.ts'],
+  format: ['esm'],
+  target: 'es2022',
+  clean: true,
+  dts: true,
+  sourcemap: true,
+  external: ['assemblyscript', '@gorules/zen-engine'],
+});

package/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    testTimeout: 15000,
+    hookTimeout: 15000,
+    // Use 'forks' pool since tests include `zen-engine`, a Node native addon.
+    // Native addons can cause hangs/segfaults in worker_threads.
+    pool: 'forks',
+    maxConcurrency: 1,
+  },
+});