@divmain/jdm-asm 0.2.0 → 0.2.3

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

@@ -1,248 +0,0 @@
-/**
- * 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

@@ -1,245 +0,0 @@
-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

@@ -1,27 +0,0 @@
-{
-  "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

@@ -1,11 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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,
-  },
-});