@divmain/jdm-asm 0.2.0

package/src/compiler/runtime-codegen.ts

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

@@ -0,0 +1,294 @@
+/**
+ * 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,
+  };
+}