@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/runtime-codegen.ts

@@ -1,211 +0,0 @@
-// src/compiler/runtime-codegen.ts
-// Compile-time code generation utilities for loading generated marshaling and validation code
-
-import { CompilationError, ErrorCode } from './errors';
-
-/**
- * Type definitions for marshal and unmarshal functions.
- */
-export type MarshalFn = (data: Record<string, unknown>, memory: WebAssembly.Memory) => number;
-
-export type UnmarshalFn = (ptr: number, memory: WebAssembly.Memory) => Record<string, unknown>;
-
-export type ValidateFn = (data: unknown) => void;
-
-/**
- * Load generated marshaling code as executable functions.
- *
- * @internal This function uses Function constructor to execute generated code.
- * The code is generated by the compiler and is trusted, but users should be
- * aware that this executes arbitrary JavaScript in the current context.
- *
- * @param code - The generated marshaling code
- * @returns Object with marshal and unmarshal functions
- */
-export function loadGeneratedMarshaling(code: string): {
-  marshal: MarshalFn;
-  unmarshal: UnmarshalFn;
-} {
-  // Create a function from the generated code
-
-  // We use string replacement instead of ES module loading because: (1) generated code
-  // uses ES6 exports which Function() doesn't support, (2) avoiding eval() for security,
-  // (3) provides isolated scope for generated code. Convert export syntax to regular functions.
-  const cleanedCode = code
-    .replace(/^export function marshalInput/gm, 'function marshalInputHelper')
-    .replace(/^export function unmarshalOutput/gm, 'function unmarshalOutputHelper')
-    .replace(/^export const SCHEMA_HASH/gm, 'const SCHEMA_HASH')
-    .replace(/^export const INPUT_FIXED_SIZE/gm, 'const INPUT_FIXED_SIZE')
-    .replace(/^export const OUTPUT_FIXED_SIZE/gm, 'const OUTPUT_FIXED_SIZE')
-    .replace(/^export function writeString/gm, 'function writeStringHelper')
-    .replace(/^export function readString/gm, 'function readStringHelper')
-    .replace(/^export function writeArray/gm, 'function writeArrayHelper')
-    .replace(/^export function readArray/gm, 'function readArrayHelper')
-    .replace(/^export function calculateInputSize/gm, 'function calculateInputSizeHelper');
-
-  // Helper function to extract nested values
-  const helperCode = `
-    function getNestedValue(obj, path) {
-      const parts = path.split('.');
-      let current = obj;
-      for (const part of parts) {
-        if (current == null) return undefined;
-        if (typeof current !== 'object') return undefined;
-        current = current[part];
-      }
-      return current;
-    }
-  `;
-
-  // Type for the raw 3-argument marshal function
-  type RawMarshalFn = (
-    data: Record<string, unknown>,
-    memory: WebAssembly.Memory,
-    allocate: (size: number) => number,
-  ) => number;
-
-  const module: { marshalInput?: RawMarshalFn; unmarshalOutput?: UnmarshalFn } = {};
-
-  const setupFn = new Function(
-    'module',
-    helperCode +
-      cleanedCode +
-      `
-      module.marshalInput = marshalInputHelper;
-      module.unmarshalOutput = unmarshalOutputHelper;
-    `,
-  );
-
-  setupFn(module);
-
-  if (!module.marshalInput || !module.unmarshalOutput) {
-    throw new CompilationError(
-      'Generated marshaling code did not export required functions',
-      ErrorCode.INVALID_NODE_STRUCTURE,
-      { field: 'marshalCode' },
-    );
-  }
-
-  // Create a 2-argument wrapper that provides an internal allocator
-  // The allocator starts at 192KB to avoid collision with:
-  //   - AssemblyScript static data (0 - ~50KB)
-  //   - AssemblyScript runtime heap (~50KB - ~192KB, grows during evaluation)
-  // This matches the memory layout expected by the WASM module.
-  const rawMarshal = module.marshalInput;
-  const INPUT_BUFFER_START = 192 * 1024; // 192KB
-  const REQUIRED_MEMORY = 768 * 1024; // 768KB minimum to fit input + output buffers
-
-  const wrappedMarshal: MarshalFn = (data, memory) => {
-    // Ensure memory is large enough for the expected layout
-    if (memory.buffer.byteLength < REQUIRED_MEMORY) {
-      const pagesNeeded = Math.ceil((REQUIRED_MEMORY - memory.buffer.byteLength) / 65536);
-      memory.grow(pagesNeeded);
-    }
-
-    // Simple bump allocator starting at 192KB (after AS runtime heap region)
-    let heapOffset = INPUT_BUFFER_START;
-    const allocate = (size: number): number => {
-      const ptr = heapOffset;
-      heapOffset += size;
-      // Grow memory if needed
-      if (heapOffset > memory.buffer.byteLength) {
-        const pagesNeeded = Math.ceil((heapOffset - memory.buffer.byteLength) / 65536);
-        memory.grow(pagesNeeded);
-      }
-      return ptr;
-    };
-    return rawMarshal(data, memory, allocate);
-  };
-
-  return {
-    marshal: wrappedMarshal,
-    unmarshal: module.unmarshalOutput,
-  };
-}
-
-// Cache TypeCompiler to avoid repeated dynamic imports
-let cachedTypeCompiler: unknown = null;
-
-/**
- * Load generated validation code as executable function.
- *
- * @param code - The generated validation code
- * @returns Validation function
- */
-export async function loadGeneratedValidation(code: string): Promise<ValidateFn> {
-  // The generated validation code uses ES6 import/export syntax and TypeScript syntax
-  // We need to:
-  // 1. Strip import statements
-  // 2. Strip TypeScript type annotations
-  // 3. Convert exports to regular function/class definitions
-  // 4. Pass TypeCompiler as a dependency
-  // 5. Return the validateInput function
-
-  let cleanedCode = code;
-
-  // Remove import statements
-  const importRegex = /^import\s+.*from\s+['"].*['"];?\s*$/gm;
-  cleanedCode = cleanedCode.replace(importRegex, '');
-
-  // Strip TypeScript parameter type annotations
-  // Matches: function foo(param: Type, other: Type)
-  cleanedCode = cleanedCode.replace(/(\w+)\s*:\s*\w+(?:<[^>]+>)?(?=[,)])/g, '$1');
-
-  // Strip TypeScript "asserts" return type annotations
-  // Matches: ): asserts data is Type {
-  cleanedCode = cleanedCode.replace(/\):\s+asserts\s+\w+\s+is\s+\w+\s*(<[^>]+>)?\s*\{/g, ') {');
-
-  // Strip TypeScript class property modifiers
-  // Matches: public readonly errors: Type {
-  cleanedCode = cleanedCode.replace(/public\s+readonly\s+/g, '');
-  cleanedCode = cleanedCode.replace(/public\s+/g, '');
-
-  // Strip generic type annotations from Array
-  // Matches: Array<{...}> and Array<Type>
-  cleanedCode = cleanedCode.replace(/Array<([^>]+)>/g, 'Array');
-
-  // Strip TSchema type reference (from @sinclair/typebox)
-  cleanedCode = cleanedCode.replace(/:\s*TSchema/g, '');
-
-  // Convert exports to regular definitions
-  cleanedCode = cleanedCode
-    .replace(/^export function validateInput/gm, 'function validateInput')
-    .replace(/^export class ValidationError/gm, 'class ValidationError')
-    .replace(/^export function checkInput/gm, 'function checkInput');
-
-  // Import TypeCompiler dynamically (cached for performance)
-  if (!cachedTypeCompiler) {
-    const module = await import('@sinclair/typebox/compiler');
-    cachedTypeCompiler = module.TypeCompiler;
-  }
-  const TypeCompiler = cachedTypeCompiler;
-
-  // Create a module object to hold the validator (no type annotation for Function context)
-  const module: any = {};
-
-  const setupFn = new Function(
-    'TypeCompiler',
-    'module',
-    `
-      ${cleanedCode}
-      module.validateInput = validateInput;
-    `,
-  );
-
-  setupFn(TypeCompiler, module);
-
-  if (!module.validateInput) {
-    throw new CompilationError(
-      'Generated validation code did not export validateInput function',
-      ErrorCode.INVALID_NODE_STRUCTURE,
-      { field: 'validationCode' },
-    );
-  }
-
-  return module.validateInput;
-}
-
-/**
- * Re-export validation code generation functions from marshal-gen
- */
-export { generateValidationCode } from './marshal-gen';

package/src/compiler/runtime-validation-codegen.ts

@@ -1,294 +0,0 @@
-/**
- * Runtime validation code generation for decision models.
- *
- * This module provides functions that generate or perform validation code
- * that executes at runtime. These functions validate actual data against
- * schemas when the decision is evaluated.
- *
- * For compile-time static analysis (checking references exist, etc.),
- * see compile-time-validation.ts.
- */
-
-import type { FlattenedLayout } from './types';
-
-/**
- * Validation error containing field path, expected type, and actual value.
- */
-export interface ValidationError {
-  /** The field path (e.g., "customer.age") */
-  path: string;
-  /** Error message describing the issue */
-  message: string;
-  /** The expected type */
-  expected?: string;
-  /** The actual value that failed validation */
-  actual?: unknown;
-}
-
-/**
- * Result of runtime validation.
- */
-export interface ValidationResult {
-  /** Whether validation passed */
-  valid: boolean;
-  /** Array of validation errors (empty if valid) */
-  errors: ValidationError[];
-}
-
-/**
- * Validate runtime input data against the input schema.
- *
- * This function checks that all required input fields from the schema
- * are present in the provided input data AND that they have correct types.
- * It returns a list of validation errors including missing fields and
- * type mismatches.
- *
- * Security note: This validation prevents malformed input with wrong types
- * (string instead of number, object instead of array) from being marshaled
- * to WASM, which could cause runtime errors or unexpected behavior.
- *
- * @param inputData - Runtime input data as a JavaScript object
- * @param inputLayout - Flattened layout from the input schema
- * @returns Array of missing/invalid input field paths (empty if all valid)
- */
-export function validateRuntimeInputs(
-  inputData: Record<string, any>,
-  inputLayout: FlattenedLayout,
-): string[] {
-  const result = validateRuntimeInputsDetailed(inputData, inputLayout);
-  // Return just the paths for backwards compatibility
-  return result.errors.map((e) => e.path);
-}
-
-/**
- * Validate runtime input data with detailed error information.
- *
- * This function performs comprehensive validation including:
- * - Presence checking: All required fields must be present
- * - Type checking: Values must match expected types
- * - Range checking: Numbers must be finite (not NaN/Infinity unless intended)
- *
- * @param inputData - Runtime input data as a JavaScript object
- * @param inputLayout - Flattened layout from the input schema
- * @returns Detailed validation result with errors
- */
-export function validateRuntimeInputsDetailed(
-  inputData: Record<string, any>,
-  inputLayout: FlattenedLayout,
-): ValidationResult {
-  const errors: ValidationError[] = [];
-
-  for (const field of inputLayout.fields) {
-    const path = field.path;
-    const parts = path.split('.');
-
-    let current: any = inputData;
-    let exists = true;
-
-    // Navigate to the nested value
-    for (const part of parts) {
-      if (current === null || current === undefined || current[part] === undefined) {
-        exists = false;
-        break;
-      }
-      current = current[part];
-    }
-
-    if (!exists) {
-      errors.push({
-        path,
-        message: 'Required field is missing',
-        expected: field.type,
-        actual: undefined,
-      });
-      continue;
-    }
-
-    // Now check type
-    const typeError = validateFieldType(current, field.type, path);
-    if (typeError) {
-      errors.push(typeError);
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
-}
-
-/**
- * Validate that a value matches the expected field type.
- *
- * @param value - The actual value to validate
- * @param expectedType - The expected type from the schema
- * @param path - The field path for error reporting
- * @returns ValidationError if type mismatch, null if valid
- */
-function validateFieldType(
-  value: unknown,
-  expectedType: 'f64' | 'i32' | 'i64' | 'bool' | 'string' | 'array',
-  path: string,
-): ValidationError | null {
-  const actualType = typeof value;
-
-  switch (expectedType) {
-    case 'f64':
-    case 'i32':
-    case 'i64': {
-      // Check for number type
-      if (actualType !== 'number' && actualType !== 'bigint') {
-        return {
-          path,
-          message: `Expected ${expectedType} (number), got ${actualType}`,
-          expected: expectedType,
-          actual: value,
-        };
-      }
-
-      // For number types, also check for NaN
-      if (actualType === 'number' && Number.isNaN(value)) {
-        return {
-          path,
-          message: `Invalid number: NaN is not allowed`,
-          expected: expectedType,
-          actual: value,
-        };
-      }
-
-      // For integer types, check that the value is actually an integer
-      if (expectedType === 'i32' || expectedType === 'i64') {
-        if (actualType === 'number' && !Number.isInteger(value)) {
-          return {
-            path,
-            message: `Expected integer, got floating-point number`,
-            expected: expectedType,
-            actual: value,
-          };
-        }
-      }
-      break;
-    }
-
-    case 'bool': {
-      if (actualType !== 'boolean') {
-        return {
-          path,
-          message: `Expected boolean, got ${actualType}`,
-          expected: 'boolean',
-          actual: value,
-        };
-      }
-      break;
-    }
-
-    case 'string': {
-      if (actualType !== 'string') {
-        return {
-          path,
-          message: `Expected string, got ${actualType}`,
-          expected: 'string',
-          actual: value,
-        };
-      }
-      break;
-    }
-
-    case 'array': {
-      if (!Array.isArray(value)) {
-        return {
-          path,
-          message: `Expected array, got ${actualType}`,
-          expected: 'array',
-          actual: value,
-        };
-      }
-      break;
-    }
-
-    default: {
-      // Unknown type - this shouldn't happen with a valid schema
-      // but we'll accept any value for forward compatibility
-      break;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Validate runtime output data against the output schema.
- *
- * This function checks that all required output fields from the schema
- * are present in the provided output data AND that they have correct types.
- * It returns a list of validation errors including missing fields and
- * type mismatches.
- *
- * @param outputData - Runtime output data as a JavaScript object
- * @param outputLayout - Flattened layout from the output schema
- * @returns Array of missing/invalid output field paths (empty if all valid)
- */
-export function validateRuntimeOutputs(
-  outputData: Record<string, any>,
-  outputLayout: FlattenedLayout,
-): string[] {
-  const result = validateRuntimeOutputsDetailed(outputData, outputLayout);
-  return result.errors.map((e) => e.path);
-}
-
-/**
- * Validate runtime output data with detailed error information.
- *
- * This function performs comprehensive validation including:
- * - Presence checking: All required output fields must be present
- * - Type checking: Values must match expected types
- *
- * @param outputData - Runtime output data as a JavaScript object
- * @param outputLayout - Flattened layout from the output schema
- * @returns Detailed validation result with errors
- */
-export function validateRuntimeOutputsDetailed(
-  outputData: Record<string, any>,
-  outputLayout: FlattenedLayout,
-): ValidationResult {
-  const errors: ValidationError[] = [];
-
-  for (const field of outputLayout.fields) {
-    const path = field.path;
-    const parts = path.split('.');
-
-    // Allows objects to be built incrementally (e.g., output.customer.name and
-    // output.customer.age) instead of requiring the entire object at once.
-    let current: any = outputData;
-    let exists = true;
-
-    for (const part of parts) {
-      if (current === null || current === undefined || current[part] === undefined) {
-        exists = false;
-        break;
-      }
-      current = current[part];
-    }
-
-    if (!exists) {
-      errors.push({
-        path,
-        message: 'Required output field is missing',
-        expected: field.type,
-        actual: undefined,
-      });
-      continue;
-    }
-
-    // Now check type
-    const typeError = validateFieldType(current, field.type, path);
-    if (typeError) {
-      errors.push(typeError);
-    }
-  }
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  };
-}