@divmain/jdm-asm 0.2.0 → 0.2.3

package/dist/index.js

@@ -8490,41 +8490,2239 @@ import { createHash } from "crypto";
 import {
   existsSync,
   mkdirSync,
-  readFileSync as readFileSync2,
+  readFileSync,
   writeFileSync,
   readdirSync,
   statSync,
   unlinkSync
 } from "fs";
-import { join, dirname as dirname2 } from "path";
-
-// src/compiler/runtime/index.ts
-import { readFileSync } from "fs";
-import { resolve, dirname } from "path";
-import { fileURLToPath } from "url";
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
-function getAssemblyRuntimePath() {
-  return resolve(__dirname2, "..", "..", "runtime");
-}
-function loadRuntime(filename) {
-  const runtimePath = getAssemblyRuntimePath();
-  return readFileSync(resolve(runtimePath, filename), "utf-8");
-}
-var RUNTIME_VALUES = loadRuntime("values.ts");
-var RUNTIME_CONTEXT = loadRuntime("context.ts");
-var RUNTIME_EXPRESSIONS = loadRuntime("expressions.ts");
-var RUNTIME_TABLES = loadRuntime("tables.ts");
-var RUNTIME_MEMORY = loadRuntime("memory.ts");
-var RUNTIME_STRINGS = loadRuntime("strings.ts");
-var RUNTIME_ARRAYS = loadRuntime("arrays.ts");
+import { join, dirname } from "path";
+
+// inline-runtime:inline-runtime
+var RUNTIME_VALUES = `// assembly/runtime/values.ts
+// Type tags for runtime type checking
+export const TYPE_NULL: i32 = 0;
+export const TYPE_BOOL: i32 = 1;
+export const TYPE_INT: i32 = 2;
+export const TYPE_FLOAT: i32 = 3;
+export const TYPE_STRING: i32 = 4;
+export const TYPE_ARRAY: i32 = 5;
+export const TYPE_OBJECT: i32 = 6;
+
+// Pre-allocated singleton values for frequently used immutable types.
+// This avoids allocations in hot paths for null/boolean/small integer/common float values.
+let _nullSingleton: Value | null = null;
+let _trueSingleton: Value | null = null;
+let _falseSingleton: Value | null = null;
+let _emptyStringSingleton: Value | null = null;
+let _zeroFloatSingleton: Value | null = null;
+let _oneFloatSingleton: Value | null = null;
+
+// Cache for small integers (-1 to 10) - covers common array indices, loop counters, etc.
+// Using 12-element array: index 0 = -1, index 1 = 0, ..., index 11 = 10
+const SMALL_INT_CACHE_MIN: i64 = -1;
+const SMALL_INT_CACHE_MAX: i64 = 10;
+const SMALL_INT_CACHE_SIZE: i32 = 12;
+let _smallIntCache: StaticArray<Value | null> | null = null;
+
+/**
+ * Tagged union for dynamic JSON-like values.
+ * Only one field is valid based on the \`type\` tag.
+ */
+export class Value {
+  type: i32 = TYPE_NULL;
+  boolVal: bool = false;
+  intVal: i64 = 0;
+  floatVal: f64 = 0.0;
+  stringVal: string | null = null;
+  arrayVal: Array<Value> | null = null;
+  objectVal: Map<string, Value> | null = null;
+
+  static Null(): Value {
+    // Return singleton null value to avoid allocations
+    if (_nullSingleton === null) {
+      const v = new Value();
+      v.type = TYPE_NULL;
+      _nullSingleton = v;
+    }
+    return _nullSingleton!;
+  }
+
+  static Bool(val: bool): Value {
+    // Return singleton boolean values to avoid allocations
+    if (val) {
+      if (_trueSingleton === null) {
+        const v = new Value();
+        v.type = TYPE_BOOL;
+        v.boolVal = true;
+        _trueSingleton = v;
+      }
+      return _trueSingleton!;
+    } else {
+      if (_falseSingleton === null) {
+        const v = new Value();
+        v.type = TYPE_BOOL;
+        v.boolVal = false;
+        _falseSingleton = v;
+      }
+      return _falseSingleton!;
+    }
+  }
+
+  static Int(val: i64): Value {
+    // Fast path for common small integers to avoid allocations
+    if (val >= SMALL_INT_CACHE_MIN && val <= SMALL_INT_CACHE_MAX) {
+      if (_smallIntCache === null) {
+        _smallIntCache = new StaticArray<Value | null>(SMALL_INT_CACHE_SIZE);
+      }
+      const idx = <i32>(val - SMALL_INT_CACHE_MIN);
+      if (unchecked(_smallIntCache![idx]) === null) {
+        const v = new Value();
+        v.type = TYPE_INT;
+        v.intVal = val;
+        unchecked((_smallIntCache![idx] = v));
+      }
+      return unchecked(_smallIntCache![idx])!;
+    }
+    const v = new Value();
+    v.type = TYPE_INT;
+    v.intVal = val;
+    return v;
+  }
+
+  static Float(val: f64): Value {
+    // Fast path for common float values (0.0, 1.0) to avoid allocations
+    if (val == 0.0) {
+      if (_zeroFloatSingleton === null) {
+        const v = new Value();
+        v.type = TYPE_FLOAT;
+        v.floatVal = 0.0;
+        _zeroFloatSingleton = v;
+      }
+      return _zeroFloatSingleton!;
+    }
+    if (val == 1.0) {
+      if (_oneFloatSingleton === null) {
+        const v = new Value();
+        v.type = TYPE_FLOAT;
+        v.floatVal = 1.0;
+        _oneFloatSingleton = v;
+      }
+      return _oneFloatSingleton!;
+    }
+    const v = new Value();
+    v.type = TYPE_FLOAT;
+    v.floatVal = val;
+    return v;
+  }
+
+  static String(val: string): Value {
+    // Fast path for empty string to avoid allocations
+    if (val.length == 0) {
+      if (_emptyStringSingleton === null) {
+        const v = new Value();
+        v.type = TYPE_STRING;
+        v.stringVal = '';
+        _emptyStringSingleton = v;
+      }
+      return _emptyStringSingleton!;
+    }
+    const v = new Value();
+    v.type = TYPE_STRING;
+    v.stringVal = val;
+    return v;
+  }
+
+  static Array(val: Array<Value>): Value {
+    const v = new Value();
+    v.type = TYPE_ARRAY;
+    v.arrayVal = val;
+    return v;
+  }
+
+  static Object(val: Map<string, Value>): Value {
+    const v = new Value();
+    v.type = TYPE_OBJECT;
+    v.objectVal = val;
+    return v;
+  }
+
+  // Type checking
+  isNull(): bool {
+    return this.type == TYPE_NULL;
+  }
+  isBool(): bool {
+    return this.type == TYPE_BOOL;
+  }
+  isNumber(): bool {
+    return this.type == TYPE_INT || this.type == TYPE_FLOAT;
+  }
+  isString(): bool {
+    return this.type == TYPE_STRING;
+  }
+  isArray(): bool {
+    return this.type == TYPE_ARRAY;
+  }
+  isObject(): bool {
+    return this.type == TYPE_OBJECT;
+  }
+
+  // Returning defaults (0, false, "") instead of throwing errors provides more
+  // forgiving evaluation semantics matching JavaScript's type coercion behavior.
+  asBool(): bool {
+    return this.type == TYPE_BOOL ? this.boolVal : false;
+  }
+  asInt(): i64 {
+    return this.type == TYPE_INT ? this.intVal : 0;
+  }
+  asFloat(): f64 {
+    if (this.type == TYPE_FLOAT) return this.floatVal;
+    if (this.type == TYPE_INT) return <f64>this.intVal;
+    return 0.0;
+  }
+  asString(): string {
+    // Convert value to string representation
+    if (this.type == TYPE_STRING && this.stringVal != null) return this.stringVal!;
+    if (this.type == TYPE_NULL) return '';
+    if (this.type == TYPE_BOOL) return this.boolVal ? 'true' : 'false';
+    if (this.type == TYPE_INT) return this.intVal.toString();
+    if (this.type == TYPE_FLOAT) {
+      // JavaScript developers expect "3" not "3.0" for integer-valued floats. We check if
+      // the float is exactly representable as i64 (no fractional part, within range) and
+      // format as integer in that case. Otherwise use AS's default float formatting.
+      const f = this.floatVal;
+      // Check if it's an integer
+      if (f == <f64>(<i64>f) && f >= <f64>i64.MIN_VALUE && f <= <f64>i64.MAX_VALUE) {
+        return (<i64>f).toString();
+      }
+      return f.toString();
+    }
+    return '';
+  }
+  asArray(): Array<Value> {
+    return this.arrayVal != null ? this.arrayVal! : new Array<Value>();
+  }
+  asObject(): Map<string, Value> {
+    return this.objectVal != null ? this.objectVal! : new Map<string, Value>();
+  }
+}
+
+export type Result = Map<string, Value>;
+`;
+var RUNTIME_CONTEXT = `// assembly/runtime/context.ts (AssemblyScript)
+import { Value, TYPE_OBJECT } from './values';
+
+/**
+ * Stores cached path resolution metadata to avoid redundant string splitting
+ * and prefix matching on frequently-accessed paths.
+ */
+class PathResolutionCache {
+  // Cache entry: stores the matched prefix key, its length, and the split parts for a given path
+  prefixKey: string;
+  prefixLen: i32;
+  parts: string[];
+
+  constructor(prefixKey: string, prefixLen: i32, parts: string[]) {
+    this.prefixKey = prefixKey;
+    this.prefixLen = prefixLen;
+    this.parts = parts;
+  }
+}
+
+/**
+ * Resolves a potentially dotted path against a data map with caching support.
+ *
+ * Keys like "$nodes.expression2" are stored as literal strings with dots in them,
+ * not as nested objects. This function handles both cases:
+ * 1. Exact key match (e.g., "$nodes.expression2")
+ * 2. Nested path (e.g., "$nodes.expression2.L1" where "$nodes.expression2" is a key
+ *    and "L1" is a property inside the object stored at that key)
+ *
+ * The algorithm finds the longest matching prefix in the data map, then navigates
+ * any remaining path segments through nested object properties.
+ *
+ * Performance: Uses an optional cache to avoid redundant path splitting and prefix
+ * matching for frequently-accessed paths within a single evaluation.
+ */
+export function resolvePathInData(
+  data: Map<string, Value>,
+  path: string,
+  cache: Map<string, PathResolutionCache> | null = null,
+): Value {
+  // Check for exact key match first
+  if (data.has(path)) {
+    return data.get(path);
+  }
+
+  // If no dot, the key doesn't exist
+  if (!path.includes('.')) {
+    return Value.Null();
+  }
+
+  // Check cache if available
+  let matchedPrefixLen: i32 = 0;
+  let prefixKey: string = '';
+  let parts: string[];
+
+  if (cache !== null && cache.has(path)) {
+    // Cache hit - use cached resolution metadata AND cached parts array
+    const cached = cache.get(path);
+    prefixKey = cached.prefixKey;
+    matchedPrefixLen = cached.prefixLen;
+    parts = cached.parts;
+  } else {
+    // Cache miss - perform full path resolution
+    parts = path.split('.');
+
+    // Try progressively longer prefixes to find a matching key
+    // e.g., for "$nodes.expression2.L1", try:
+    //   1. "$nodes" (no match)
+    //   2. "$nodes.expression2" (match! then access .L1 inside)
+    let currentPrefix = '';
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0) currentPrefix += '.';
+      currentPrefix += parts[i];
+      if (data.has(currentPrefix)) {
+        matchedPrefixLen = i + 1;
+        prefixKey = currentPrefix;
+      }
+    }
+
+    // Store in cache if available (including the parts array to avoid future splits)
+    if (cache !== null) {
+      cache.set(path, new PathResolutionCache(prefixKey, matchedPrefixLen, parts));
+    }
+  }
+
+  // If no prefix matched, path doesn't exist
+  if (matchedPrefixLen == 0) {
+    return Value.Null();
+  }
+
+  // Get the value at the matched prefix
+  let current = data.get(prefixKey);
+
+  // Navigate remaining parts as object properties
+  for (let i = matchedPrefixLen; i < parts.length; i++) {
+    if (!current.isObject()) return Value.Null();
+    const obj = current.asObject();
+    const key = parts[i];
+    if (!obj.has(key)) return Value.Null();
+    current = obj.get(key);
+  }
+  return current;
+}
+
+export class Context {
+  data: Map<string, Value>;
+  // Cache for decision node results to avoid redundant evaluation. Caching prevents
+  // exponential evaluation time for DAG structures where multiple nodes reference
+  // the same upstream computation.
+  decisionResults: Map<string, Value>;
+  // Stack to track currently evaluating decisions for recursion detection
+  decisionStack: string[];
+  // When merging results, we need to know which keys are original inputs (should be
+  // preserved) vs computed outputs (may be overwritten). This prevents input shadowing.
+  inputKeys: Set<string>;
+  // Cache for path resolution to avoid redundant string splitting and prefix matching.
+  // For decisions with many field accesses (e.g., 100-rule decision table with 5 inputs
+  // per rule = 500 path lookups), this eliminates most splitting overhead.
+  pathCache: Map<string, PathResolutionCache>;
+
+  constructor(input: Map<string, Value>) {
+    this.data = input;
+    this.decisionResults = new Map<string, Value>();
+    this.decisionStack = new Array<string>();
+    this.pathCache = new Map<string, PathResolutionCache>();
+    // Store original input keys
+    this.inputKeys = new Set<string>();
+    const keys = input.keys();
+    for (let i = 0; i < keys.length; i++) {
+      this.inputKeys.add(keys[i]);
+    }
+  }
+
+  // Unlike JS Map which returns undefined for missing keys, AS Map.get() throws.
+  // We must check has() first or handle dots carefully to avoid runtime errors.
+  get(path: string): Value {
+    return resolvePathInData(this.data, path, this.pathCache);
+  }
+
+  set(path: string, value: Value): void {
+    this.data.set(path, value);
+  }
+
+  // Merge another result into this context (for passthrough mode)
+  merge(other: Map<string, Value>): void {
+    const keys = other.keys();
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      this.data.set(key, other.get(key));
+    }
+  }
+
+  // Convert the context data to a Value (for passthrough sub-decisions)
+  toValue(): Value {
+    return Value.Object(this.data);
+  }
+}
+
+/**
+ * ScopedContext is a lightweight context wrapper for scoped expression evaluation.
+ * Scoped evaluation (loops, sub-object navigation) needs simple Map-based get/set
+ * without decision caching/recursion tracking. Separate class avoids polluting
+ * Context with unnecessary state and provides clearer semantics.
+ *
+ * Used for:
+ * - inputField scoping (expressions evaluated within a sub-object scope)
+ * - executionMode: "loop" (expressions evaluated for each array item)
+ *
+ * Performance: Includes path caching for loop-mode expressions where the same paths
+ * are accessed repeatedly across array items.
+ */
+export class ScopedContext {
+  data: Map<string, Value>;
+  // Path resolution cache for frequently-accessed paths in loops
+  pathCache: Map<string, PathResolutionCache>;
+
+  constructor(data: Map<string, Value>) {
+    this.data = data;
+    this.pathCache = new Map<string, PathResolutionCache>();
+  }
+
+  get(path: string): Value {
+    return resolvePathInData(this.data, path, this.pathCache);
+  }
+
+  set(path: string, value: Value): void {
+    this.data.set(path, value);
+  }
+}
+`;
+var RUNTIME_EXPRESSIONS = `// assembly/runtime/expressions.ts (AssemblyScript)
+import { Value, TYPE_ARRAY, TYPE_STRING, TYPE_FLOAT, TYPE_INT, TYPE_BOOL } from './values';
+
+/**
+ * Helper function to create an argument array.
+ * AssemblyScript doesn't support true variadic functions or rest parameters, so we provide
+ * fixed-arity helpers (makeArgs1, makeArgs2, makeArgs3) for common function arities.
+ *
+ * These use thread-local reusable arrays to avoid allocations in hot paths.
+ * Since WASM evaluation is single-threaded, reusing arrays is safe.
+ */
+
+// Reusable argument arrays - lazily initialized
+let _args1: Array<Value> | null = null;
+let _args2: Array<Value> | null = null;
+let _args3: Array<Value> | null = null;
+
+export function makeArgs(a: Value, b: Value, c: Value = Value.Null()): Array<Value> {
+  if (_args3 === null) {
+    _args3 = new Array<Value>(3);
+  }
+  unchecked((_args3![0] = a));
+  unchecked((_args3![1] = b));
+  unchecked((_args3![2] = c));
+  return _args3!;
+}
+
+export function makeArgs1(a: Value): Array<Value> {
+  if (_args1 === null) {
+    _args1 = new Array<Value>(1);
+  }
+  unchecked((_args1![0] = a));
+  return _args1!;
+}
+
+export function makeArgs2(a: Value, b: Value): Array<Value> {
+  if (_args2 === null) {
+    _args2 = new Array<Value>(2);
+  }
+  unchecked((_args2![0] = a));
+  unchecked((_args2![1] = b));
+  return _args2!;
+}
+
+export function makeArgs3(a: Value, b: Value, c: Value): Array<Value> {
+  if (_args3 === null) {
+    _args3 = new Array<Value>(3);
+  }
+  unchecked((_args3![0] = a));
+  unchecked((_args3![1] = b));
+  unchecked((_args3![2] = c));
+  return _args3!;
+}
+
+// Type alias for function handlers
+type FunctionHandler = (args: Array<Value>) => Value;
+
+// Global function registry - Map provides O(1) lookup instead of O(n) if-else chain
+const functionRegistry = new Map<string, FunctionHandler>();
+
+/**
+ * Initialize the function registry with all built-in functions.
+ * This is called once at module initialization.
+ */
+function initializeFunctionRegistry(): void {
+  // Array functions
+  functionRegistry.set('sum', (args: Array<Value>): Value => sumArray(args[0]));
+  functionRegistry.set('avg', (args: Array<Value>): Value => avgArray(args[0]));
+  functionRegistry.set('min', (args: Array<Value>): Value => minArray(args[0]));
+  functionRegistry.set('max', (args: Array<Value>): Value => maxArray(args[0]));
+  functionRegistry.set('sort', (args: Array<Value>): Value => sortArray(args[0]));
+
+  // Flatten has two aliases
+  const flatHandler = (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    return flatArray(args[0], arg1);
+  };
+  functionRegistry.set('flat', flatHandler);
+  functionRegistry.set('flatten', flatHandler);
+
+  // Count/length has two aliases
+  const lengthHandler = (args: Array<Value>): Value => lengthOf(args[0]);
+  functionRegistry.set('count', lengthHandler);
+  functionRegistry.set('len', lengthHandler);
+
+  functionRegistry.set('contains', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    return containsValue(args[0], arg1);
+  });
+
+  // Type conversion functions
+  functionRegistry.set('number', (args: Array<Value>): Value => numberValue(args[0]));
+  functionRegistry.set('string', (args: Array<Value>): Value => stringValue(args[0]));
+
+  // Math functions
+  functionRegistry.set('abs', (args: Array<Value>): Value => absValue(args[0]));
+  functionRegistry.set('floor', (args: Array<Value>): Value => floorValue(args[0]));
+  functionRegistry.set('ceil', (args: Array<Value>): Value => ceilValue(args[0]));
+  functionRegistry.set('round', (args: Array<Value>): Value => roundValue(args[0]));
+
+  // String functions
+  functionRegistry.set('upper', (args: Array<Value>): Value => upperString(args[0]));
+  functionRegistry.set('lower', (args: Array<Value>): Value => lowerString(args[0]));
+  functionRegistry.set('trim', (args: Array<Value>): Value => trimString(args[0]));
+
+  functionRegistry.set('substring', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    const arg2 = args.length >= 3 ? args[2] : Value.Null();
+    return substringString(args[0], arg1, arg2);
+  });
+
+  functionRegistry.set('indexOf', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    const arg2 = args.length >= 3 ? args[2] : Value.Null();
+    return indexOfString(args[0], arg1, arg2.isNull() ? Value.Int(<i64>0) : arg2);
+  });
+
+  functionRegistry.set('startsWith', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    return startsWithString(args[0], arg1);
+  });
+
+  functionRegistry.set('endsWith', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    return endsWithString(args[0], arg1);
+  });
+
+  functionRegistry.set('split', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    return splitString(args[0], arg1);
+  });
+
+  functionRegistry.set('join', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    return joinArray(args[0], arg1);
+  });
+
+  functionRegistry.set('replace', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    const arg2 = args.length >= 3 ? args[2] : Value.Null();
+    return replaceString(args[0], arg1, arg2);
+  });
+
+  functionRegistry.set('replaceAll', (args: Array<Value>): Value => {
+    const arg1 = args.length >= 2 ? args[1] : Value.Null();
+    const arg2 = args.length >= 3 ? args[2] : Value.Null();
+    return replaceAllString(args[0], arg1, arg2);
+  });
+
+  // Date/time functions
+  functionRegistry.set('date', (args: Array<Value>): Value => parseDate(args[0]));
+
+  // now() returns 0 because WASM doesn't have direct access to system time in a sandboxed way.
+  // To get the current timestamp, use date("now") instead, which uses Date.now().
+  functionRegistry.set('now', (args: Array<Value>): Value => Value.Float(0));
+
+  functionRegistry.set('time', (args: Array<Value>): Value => parseTime(args[0]));
+  functionRegistry.set('duration', (args: Array<Value>): Value => parseDuration(args[0]));
+
+  // Object functions
+  functionRegistry.set('values', (args: Array<Value>): Value => objectValues(args[0]));
+  functionRegistry.set('keys', (args: Array<Value>): Value => objectKeys(args[0]));
+}
+
+// Initialize the registry immediately
+initializeFunctionRegistry();
+
+/**
+ * Evaluate built-in functions.
+ * All inputs and outputs use the Value tagged union.
+ *
+ * Uses a Map-based registry for O(1) function lookup instead of O(n) if-else chain.
+ */
+export function evaluateFunction(name: string, args: Array<Value>): Value {
+  // Safety check for args array
+  if (args == null || args.length == 0) return Value.Null();
+
+  // Look up handler in the registry
+  if (functionRegistry.has(name)) {
+    const handler = functionRegistry.get(name);
+    return handler(args);
+  }
+
+  // Unknown function - return null
+  return Value.Null();
+}
+
+// === Object Functions ===
+
+/**
+ * Get all values from an object as an array.
+ * If the input is not an object, returns an empty array.
+ */
+export function objectValues(val: Value): Value {
+  if (!val.isObject()) return Value.Array(new Array<Value>(0));
+  const obj = val.asObject();
+  const keys = obj.keys();
+  const result = new Array<Value>(keys.length);
+  for (let i = 0; i < keys.length; i++) {
+    unchecked((result[i] = obj.get(unchecked(keys[i]))));
+  }
+  return Value.Array(result);
+}
+
+/**
+ * Get all keys from an object as an array of strings.
+ * If the input is not an object, returns an empty array.
+ */
+export function objectKeys(val: Value): Value {
+  if (!val.isObject()) return Value.Array(new Array<Value>(0));
+  const obj = val.asObject();
+  const keys = obj.keys();
+  const result = new Array<Value>(keys.length);
+  for (let i = 0; i < keys.length; i++) {
+    unchecked((result[i] = Value.String(unchecked(keys[i]))));
+  }
+  return Value.Array(result);
+}
+
+// === Array Functions ===
+
+export function sumArray(val: Value): Value {
+  if (!val.isArray()) return Value.Float(0.0);
+  const arr = val.asArray();
+  let total: f64 = 0.0;
+  for (let i = 0; i < arr.length; i++) {
+    total += unchecked(arr[i]).asFloat();
+  }
+  return Value.Float(total);
+}
+
+export function minArray(val: Value): Value {
+  if (!val.isArray()) return Value.Null();
+  const arr = val.asArray();
+  if (arr.length == 0) return Value.Null();
+  let min = arr[0].asFloat();
+  for (let i = 1; i < arr.length; i++) {
+    const v = unchecked(arr[i]).asFloat();
+    if (v < min) min = v;
+  }
+  return Value.Float(min);
+}
+
+export function maxArray(val: Value): Value {
+  if (!val.isArray()) return Value.Null();
+  const arr = val.asArray();
+  if (arr.length == 0) return Value.Null();
+  let max = arr[0].asFloat();
+  for (let i = 1; i < arr.length; i++) {
+    const v = unchecked(arr[i]).asFloat();
+    if (v > max) max = v;
+  }
+  return Value.Float(max);
+}
+
+export function avgArray(val: Value): Value {
+  if (!val.isArray()) return Value.Null();
+  const arr = val.asArray();
+  if (arr.length == 0) return Value.Null();
+  let total: f64 = 0.0;
+  for (let i = 0; i < arr.length; i++) {
+    total += unchecked(arr[i]).asFloat();
+  }
+  return Value.Float(total / <f64>arr.length);
+}
+
+/**
+ * Sort an array in ascending order.
+ *
+ * Supports sorting numbers and strings in ascending order.
+ * Creates and returns a new sorted array without modifying the original.
+ *
+ * Parameters:
+ * - val: The array value to sort
+ *
+ * Behavior:
+ * - Numbers: sorted in ascending numeric order
+ * - Strings: sorted in lexicographic (ASCII) order
+ * - Empty arrays: returns a new empty array
+ * - Non-array inputs: returns null
+ *
+ * Examples:
+ * - sortArray([3, 1, 2]) -> [1, 2, 3]
+ * - sortArray(["c", "a", "b"]) -> ["a", "b", "c"]
+ * - sortArray([]) -> []
+ *
+ * @param val - The array value to sort
+ * @returns A new sorted array, or null for invalid input
+ */
+export function sortArray(val: Value): Value {
+  if (!val.isArray()) return Value.Null();
+  const arr = val.asArray();
+
+  // Create a copy of the array to avoid mutating the original
+  const sorted = new Array<Value>(arr.length);
+  for (let i = 0; i < arr.length; i++) {
+    unchecked((sorted[i] = unchecked(arr[i])));
+  }
+
+  // Sort the copy using the compareValues function
+  sorted.sort((a: Value, b: Value): i32 => compareValues(a, b));
+
+  return Value.Array(sorted);
+}
+
+/**
+ * Flatten nested arrays into a single-level array.
+ *
+ * Parameters:
+ * - val: The array value to flatten
+ * - depthVal: Optional depth (default: 1). Specifies how many levels deep to flatten.
+ *
+ * Behavior:
+ * - If depth is 0, returns a shallow copy of the array
+ * - Flattens arrays recursively up to the specified depth
+ * - Empty arrays are returned as empty arrays
+ * - Non-array inputs return null
+ *
+ * Examples:
+ * - flatArray([[1, 2], [3, 4]]) -> [1, 2, 3, 4] (depth 1)
+ * - flatArray([1, [2, [3]]]) -> [1, 2, [3]] (depth 1)
+ * - flatArray([1, [2, [3]]], 2) -> [1, 2, 3] (depth 2)
+ * - flatArray([1, 2, 3]) -> [1, 2, 3] (no nesting, shallow copy)
+ * - flatArray([]) -> [] (empty array)
+ * - flatArray([[1], [2]], 0) -> [[1], [2]] (depth 0, no flattening)
+ *
+ * @param val - The array value to flatten
+ * @param depthVal - Optional depth for flattening (default: 1)
+ * @returns A new flattened array, or null for invalid input
+ */
+export function flatArray(val: Value, depthVal: Value = Value.Int(<i64>1)): Value {
+  if (!val.isArray()) return Value.Null();
+  const arr = val.asArray();
+
+  // Parse depth parameter matches JavaScript Array.flat() default behavior, which
+  // flattens one level deep unless specified otherwise. Most common use case.
+  let depth: i32 = 1;
+  if (!depthVal.isNull() && depthVal.isNumber()) {
+    depth = <i32>depthVal.asFloat(); // Use asFloat() since numbers may come as floats
+    // Clamp depth to non-negative values
+    if (depth < 0) depth = 1;
+  }
+
+  // Use a simple iterative approach that maintains order
+  let result = new Array<Value>();
+  flattenRecursive(arr, depth, result);
+  return Value.Array(result);
+}
+
+// Helper function for flatArray
+function flattenRecursive(arr: Array<Value>, currentDepth: i32, result: Array<Value>): void {
+  for (let i = 0; i < arr.length; i++) {
+    const element = unchecked(arr[i]);
+    if (element.isArray() && currentDepth > 0) {
+      // Recursively flatten nested array
+      flattenRecursive(element.asArray(), currentDepth - 1, result);
+    } else {
+      // Add element to results
+      result.push(element);
+    }
+  }
+}
+
+export function lengthOf(val: Value): Value {
+  if (val.isArray()) {
+    return Value.Int(<i64>val.asArray().length);
+  }
+  if (val.isString()) {
+    return Value.Int(<i64>val.asString().length);
+  }
+  return Value.Int(0);
+}
+
+/**
+ * Check if a value contains a subvalue.
+ *
+ * For strings: checks if the string contains a given substring.
+ * For arrays: checks if the array contains the given value.
+ *
+ * Parameters:
+ * - container: The string or array to search in
+ * - needle: The substring or value to search for
+ *
+ * Behavior:
+ * - If container is a string, checks if it contains the substring
+ * - If container is an array, checks if any element equals the needle
+ * - For strings, returns null if either argument is not a string
+ * - For arrays, always returns a boolean
+ *
+ * String Examples:
+ * - contains("hello world", "world") \u2192 true
+ * - contains("hello world", "xyz") \u2192 false
+ * - contains("abc", "abc") \u2192 true
+ * - contains("hello", "") \u2192 true (empty string is always contained)
+ * - contains("", "") \u2192 true
+ * - contains("", "x") \u2192 false
+ * - contains("Hello", "hello") \u2192 false (case-sensitive)
+ * - contains("hello", 123) \u2192 null (needle not a string)
+ * - contains(123, "hello") \u2192 null (container not a string)
+ *
+ * Array Examples:
+ * - contains([1, 2, 3], 2) \u2192 true
+ * - contains([1, 2, 3], 4) \u2192 false
+ * - contains(["a"], "a") \u2192 true
+ * - contains(123, 1) \u2192 false
+ *
+ * @param container - The string or array to search in
+ * @param needle - The substring or value to search for
+ * @returns true if contained, false if not, or null for invalid string arguments
+ */
+export function containsValue(container: Value, needle: Value): Value {
+  // Handle string containment
+  if (container.isString()) {
+    if (!needle.isString()) return Value.Null();
+    const str = container.asString();
+    const search = needle.asString();
+    // Use indexOf to check containment (returns -1 if not found)
+    const index = str.indexOf(search);
+    return Value.Bool(index >= 0);
+  }
+
+  // Handle array containment (original behavior)
+  if (!container.isArray()) return Value.Bool(false);
+  const arr = container.asArray();
+  for (let i = 0; i < arr.length; i++) {
+    if (valuesEqual(unchecked(arr[i]), needle)) return Value.Bool(true);
+  }
+  return Value.Bool(false);
+}
+
+// === Date/Time Functions ===
+
+/**
+ * Parse a date string into a numeric timestamp.
+ *
+ * Supports ISO 8601 date format: YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS[Z|+/-HH:MM]
+ * Returns Unix timestamp in seconds since epoch (1970-01-01 00:00:00 UTC).
+ * This matches zen-engine's behavior and allows date arithmetic operations.
+ *
+ * Examples:
+ * - date("2025-03-20T10:30:00Z") \u2192 1742466600 (seconds since epoch)
+ * - date("1970-01-01") \u2192 0
+ * - date("1970-01-01T00:00:00Z") \u2192 0
+ *
+ * @param val - A string value containing a date
+ * @returns A float Value representing seconds since epoch, or Null for invalid input
+ */
+export function parseDate(val: Value): Value {
+  if (!val.isString()) return Value.Null();
+
+  const str = val.asString();
+
+  // Handle special 'now' keyword - returns Unix timestamp in seconds
+  // Using Date.now() which returns milliseconds, convert to seconds
+  if (str == 'now') {
+    return Value.Float(<f64>Date.now() / 1000.0);
+  }
+
+  // Fast path for simple YYYY-MM-DD format (10 characters)
+  // This avoids string allocations from split() and substring() for common cases
+  if (str.length == 10) {
+    // Check dash positions at indices 4 and 7
+    const dashPos1 = unchecked(<i32>str.charCodeAt(4));
+    const dashPos2 = unchecked(<i32>str.charCodeAt(7));
+    if (dashPos1 == 45 && dashPos2 == 45) {
+      // Hyphen is ASCII 45, digits start at ASCII 48
+      // Parse year, month, day directly without split()
+      const year =
+        unchecked(<i32>str.charCodeAt(0) - 48) * 1000 +
+        unchecked(<i32>str.charCodeAt(1) - 48) * 100 +
+        unchecked(<i32>str.charCodeAt(2) - 48) * 10 +
+        unchecked(<i32>str.charCodeAt(3) - 48);
+      const month =
+        unchecked(<i32>str.charCodeAt(5) - 48) * 10 + unchecked(<i32>str.charCodeAt(6) - 48);
+      const day =
+        unchecked(<i32>str.charCodeAt(8) - 48) * 10 + unchecked(<i32>str.charCodeAt(9) - 48);
+
+      // Validate ranges
+      if (year >= 0 && month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+        const daysSinceEpoch = calculateDaysSinceEpoch(year, month, day);
+        return Value.Float(<f64>daysSinceEpoch * 86400.0);
+      }
+    }
+  }
+
+  // Parse ISO 8601 date format: YYYY-MM-DD
+  // Also handle datetime format: YYYY-MM-DDTHH:MM:SS[Z|+/-HH:MM]
+  let dateStr = str;
+  let timeStr = '';
+  let tzOffsetSeconds: i32 = 0; // Timezone offset in seconds (positive = ahead of UTC)
+
+  const tIndex = str.indexOf('T');
+  if (tIndex >= 0) {
+    dateStr = str.substring(0, tIndex);
+    let timePart = str.substring(tIndex + 1);
+
+    // Handle timezone: Z, +HH:MM, -HH:MM
+    const zIndex = timePart.indexOf('Z');
+    if (zIndex >= 0) {
+      timeStr = timePart.substring(0, zIndex);
+      tzOffsetSeconds = 0; // UTC
+    } else {
+      const plusIndex = timePart.indexOf('+');
+      const minusIndex = timePart.indexOf('-');
+      // Find timezone offset (look for +/- after the time part, not in middle of time)
+      let tzStartIndex = -1;
+      if (plusIndex >= 5) {
+        // At least HH:MM before timezone
+        tzStartIndex = plusIndex;
+      } else if (minusIndex >= 5) {
+        tzStartIndex = minusIndex;
+      }
+
+      if (tzStartIndex >= 0) {
+        timeStr = timePart.substring(0, tzStartIndex);
+        const tzStr = timePart.substring(tzStartIndex);
+        // Parse timezone offset (+/-HH:MM or +/-HH)
+        const isNegative = tzStr.charAt(0) == '-';
+        const tzParts = tzStr.substring(1).split(':');
+        if (tzParts.length >= 1) {
+          const tzHours = parseIntValue(tzParts[0]);
+          const tzMinutes = tzParts.length >= 2 ? parseIntValue(tzParts[1]) : 0;
+          if (tzHours >= 0 && tzMinutes >= 0) {
+            tzOffsetSeconds = tzHours * 3600 + tzMinutes * 60;
+            if (isNegative) tzOffsetSeconds = -tzOffsetSeconds;
+          }
+        }
+      } else {
+        timeStr = timePart;
+      }
+    }
+  }
+
+  // Split date by dash
+  const parts = dateStr.split('-');
+  if (parts.length < 3) return Value.Null();
+
+  // Parse year, month, day
+  const year = parseIntValue(parts[0]);
+  const month = parseIntValue(parts[1]);
+  const day = parseIntValue(parts[2]);
+
+  if (year < 0 || month < 1 || month > 12 || day < 1 || day > 31) {
+    return Value.Null();
+  }
+
+  // Calculate days since epoch
+  const daysSinceEpoch = calculateDaysSinceEpoch(year, month, day);
+
+  // Parse time if present (HH:MM:SS or HH:MM)
+  let hours: i32 = 0;
+  let minutes: i32 = 0;
+  let seconds: i32 = 0;
+
+  if (timeStr.length > 0) {
+    const timeParts = timeStr.split(':');
+    if (timeParts.length >= 2) {
+      hours = parseIntValue(timeParts[0]);
+      minutes = parseIntValue(timeParts[1]);
+      if (timeParts.length >= 3) {
+        // Handle fractional seconds (e.g., "10:30:00.123")
+        const secStr = timeParts[2];
+        const dotIndex = secStr.indexOf('.');
+        if (dotIndex >= 0) {
+          seconds = parseIntValue(secStr.substring(0, dotIndex));
+        } else {
+          seconds = parseIntValue(secStr);
+        }
+      }
+    }
+    if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59 || seconds < 0 || seconds > 59) {
+      // Invalid time - use 0
+      hours = 0;
+      minutes = 0;
+      seconds = 0;
+    }
+  }
+
+  // Calculate total seconds since epoch
+  // daysSinceEpoch * 86400 + hours * 3600 + minutes * 60 + seconds - tzOffsetSeconds
+  // We subtract tzOffsetSeconds to convert local time to UTC
+  const totalSeconds: f64 =
+    <f64>daysSinceEpoch * 86400.0 +
+    <f64>hours * 3600.0 +
+    <f64>minutes * 60.0 +
+    <f64>seconds -
+    <f64>tzOffsetSeconds;
+
+  return Value.Float(totalSeconds);
+}
+
+/**
+ * Parse a time string into a numeric value.
+ *
+ * Supports format: HH:MM:SS or HH:MM
+ * Returns the number of seconds since midnight.
+ *
+ * @param val - A string value containing a time
+ * @returns A float Value representing seconds since midnight
+ */
+export function parseTime(val: Value): Value {
+  if (!val.isString()) return Value.Null();
+
+  const str = val.asString();
+  const parts = str.split(':');
+
+  if (parts.length < 2) return Value.Null();
+
+  const hours = parseIntValue(parts[0]);
+  const minutes = parseIntValue(parts[1]);
+  const seconds = parts.length >= 3 ? parseIntValue(parts[2]) : 0;
+
+  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59 || seconds < 0 || seconds > 59) {
+    return Value.Null();
+  }
+
+  const totalSeconds = hours * 3600 + minutes * 60 + seconds;
+  return Value.Float(<f64>totalSeconds);
+}
+
+/**
+ * Parse a duration string into a numeric value.
+ *
+ * Supports ISO 8601 duration format: P[n]Y[n]M[n]DT[n]H[n]M[n]S
+ * Also supports simple formats like "30d", "24h", "60m", "3600s"
+ *
+ * @param val - A string value containing a duration
+ * @returns A float Value representing duration in seconds
+ */
+export function parseDuration(val: Value): Value {
+  if (!val.isString()) return Value.Null();
+
+  const str = val.asString();
+
+  // Handle simple formats: "30d", "24h", "60m", "3600s"
+  if (str.length > 1) {
+    const unit = str.charAt(str.length - 1);
+    const numStr = str.substring(0, str.length - 1);
+    const num = parseFloatValue(numStr);
+
+    if (num >= 0) {
+      if (unit == 's') return Value.Float(num);
+      if (unit == 'm') return Value.Float(num * 60);
+      if (unit == 'h') return Value.Float(num * 3600);
+      if (unit == 'd') return Value.Float(num * 86400);
+    }
+  }
+
+  // Full ISO 8601 duration format (P[n]Y[n]M[n]DT[n]H[n]M[n]S) not yet supported
+  return Value.Null();
+}
+
+/**
+ * Parse a string to an integer value.
+ */
+function parseIntValue(str: string): i32 {
+  let result: i32 = 0;
+  let negative = false;
+  let i = 0;
+
+  // Handle leading whitespace
+  while (i < str.length && str.charCodeAt(i) == 32) {
+    i++;
+  }
+
+  // Handle negative sign
+  if (i < str.length && str.charCodeAt(i) == 45) {
+    // '-'
+    negative = true;
+    i++;
+  }
+
+  // Parse digits
+  let hasDigits = false;
+  while (i < str.length) {
+    const c = str.charCodeAt(i);
+    if (c >= 48 && c <= 57) {
+      // '0'-'9'
+      result = result * 10 + (c - 48);
+      hasDigits = true;
+      i++;
+    } else {
+      break;
+    }
+  }
+
+  // AssemblyScript doesn't have optional types or Result<T,E>, so we use -1 as sentinel
+  // value for parse errors. Callers check for negative values to detect failures.
+  if (!hasDigits) return -1;
+
+  return negative ? -result : result;
+}
+
+/**
+ * Parse a string to a float value.
+ * Returns NaN for invalid input.
+ */
+function parseFloatValue(str: string): f64 {
+  return parseFloat(str);
+}
+
+/**
+ * Calculate days since Unix epoch (1970-01-01).
+ * Uses a simplified algorithm that handles leap years.
+ */
+function calculateDaysSinceEpoch(year: i32, month: i32, day: i32): i32 {
+  // Days in each month (non-leap year)
+  const daysInMonth: i32[] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+  // Calculate days from years
+  let days: i32 = 0;
+
+  // Calculate years from 1970 to target year
+  if (year >= 1970) {
+    for (let y = 1970; y < year; y++) {
+      days += isLeapYear(y) ? 366 : 365;
+    }
+  } else {
+    for (let y = year; y < 1970; y++) {
+      days -= isLeapYear(y) ? 366 : 365;
+    }
+  }
+
+  // Add days from months
+  for (let m = 1; m < month; m++) {
+    days += unchecked(daysInMonth[m - 1]);
+    // Add leap day for February in leap years
+    if (m == 2 && isLeapYear(year)) {
+      days += 1;
+    }
+  }
+
+  // Add days
+  days += day - 1; // day 1 is the first day, so subtract 1
+
+  return days;
+}
+
+/**
+ * Check if a year is a leap year.
+ */
+function isLeapYear(year: i32): bool {
+  return (year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
+}
+
+// === Math Functions ===
+
+export function absValue(val: Value): Value {
+  if (val.isNumber()) {
+    const n = val.asFloat();
+    return Value.Float(n < 0 ? -n : n);
+  }
+  return Value.Null();
+}
+
+export function floorValue(val: Value): Value {
+  if (val.isNumber()) {
+    return Value.Float(Math.floor(val.asFloat()));
+  }
+  return Value.Null();
+}
+
+export function ceilValue(val: Value): Value {
+  if (val.isNumber()) {
+    return Value.Float(Math.ceil(val.asFloat()));
+  }
+  return Value.Null();
+}
+
+export function roundValue(val: Value): Value {
+  if (val.isNumber()) {
+    return Value.Float(Math.round(val.asFloat()));
+  }
+  return Value.Null();
+}
+
+// === String Functions ===
+
+/**
+ * Convert a string to uppercase.
+ *
+ * Non-alphabetic characters (numbers, symbols, spaces) remain unchanged.
+ * If the input is not a string, returns null.
+ *
+ * Examples:
+ * - upper("hello") \u2192 "HELLO"
+ * - upper("Hello World") \u2192 "HELLO WORLD"
+ * - upper("123abc") \u2192 "123ABC"
+ * - upper("!@#") \u2192 "!@#"
+ * - upper(123) \u2192 null
+ * - upper(null) \u2192 null
+ *
+ * @param val - The value to convert to uppercase
+ * @returns The uppercase string, or null if input is not a string
+ */
+export function upperString(val: Value): Value {
+  if (!val.isString()) return Value.Null();
+  const str = val.asString();
+  return Value.String(str.toUpperCase());
+}
+
+/**
+ * Convert a string to lowercase.
+ *
+ * Non-alphabetic characters (numbers, symbols, spaces) remain unchanged.
+ * If the input is not a string, returns null.
+ *
+ * Examples:
+ * - lower("HELLO") \u2192 "hello"
+ * - lower("Hello World") \u2192 "hello world"
+ * - lower("123ABC") \u2192 "123abc"
+ * - lower("!@#") \u2192 "!@#"
+ * - lower(123) \u2192 null
+ * - lower(null) \u2192 null
+ *
+ * @param val - The value to convert to lowercase
+ * @returns The lowercase string, or null if input is not a string
+ */
+export function lowerString(val: Value): Value {
+  if (!val.isString()) return Value.Null();
+  const str = val.asString();
+  return Value.String(str.toLowerCase());
+}
+
+/**
+ * Remove leading and trailing whitespace from a string.
+ *
+ * Whitespace includes spaces, tabs, newlines, and other whitespace characters.
+ * If the input is not a string, returns null.
+ *
+ * Examples:
+ * - trim("  hello  ") \u2192 "hello"
+ * - trim("\\t\\nhello\\n\\t") \u2192 "hello"
+ * - trim("hello") \u2192 "hello" (no change)
+ * - trim("  hello world  ") \u2192 "hello world"
+ * - trim("") \u2192 "" (empty string)
+ * - trim("   ") \u2192 "" (only whitespace)
+ * - trim(123) \u2192 null
+ * - trim(null) \u2192 null
+ *
+ * @param val - The value to trim whitespace from
+ * @returns The trimmed string, or null if input is not a string
+ */
+export function trimString(val: Value): Value {
+  if (!val.isString()) return Value.Null();
+  const str = val.asString();
+  return Value.String(str.trim());
+}
+
+/**
+ * Extract a portion of a string.
+ *
+ * Returns a substring starting at the specified index and optionally
+ * ending at the specified index (or length).
+ *
+ * Parameters:
+ * - str: The input string
+ * - start: The starting index (0-based, inclusive)
+ * - endOrLength: Optional end index (exclusive) or length. If omitted,
+ *       extracts from start to the end of the string.
+ *
+ * Behavior:
+ * - If start is negative, it's treated as an offset from the end of the string
+ * - If start < 0, it's clamped to 0 (empty prefix)
+ * - If start >= str.length, returns empty string
+ * - If endOrLength is omitted or null, extracts to end of string
+ * - If endOrLength is negative, it's treated as an offset from the end
+ * - If endOrLength > str.length, it's clamped to str.length
+ * - If endOrLength <= start, returns empty string
+ *
+ * Examples:
+ * - substring("hello", 0, 2) \u2192 "he"
+ * - substring("hello", 1, 3) \u2192 "el"
+ * - substring("hello", 2) \u2192 "llo"
+ * - substring("hello", 0) \u2192 "hello"
+ * - substring("hello", 0, 5) \u2192 "hello"
+ * - substring("hello", 0, 10) \u2192 "hello" (clamped to end)
+ * - substring("hello", 3, 5) \u2192 "lo"
+ * - substring("hello", -3) \u2192 "llo" (from end)
+ * - substring("hello", 0, -2) \u2192 "hel" (from end)
+ * - substring("hello", 10) \u2192 "" (start beyond length)
+ * - substring("", 0, 5) \u2192 "" (empty string)
+ * - substring(123, 0, 2) \u2192 null (not a string)
+ * - substring(null, 0, 2) \u2192 null (not a string)
+ *
+ * @param strVal - The string value to extract from
+ * @param startVal - The starting index
+ * @param endOrLengthVal - Optional end index (exclusive) or length
+ * @returns The substring, or null if input is not a string
+ */
+export function substringString(strVal: Value, startVal: Value, endOrLengthVal: Value): Value {
+  if (!strVal.isString()) return Value.Null();
+  const str = strVal.asString();
+  const len = str.length;
+
+  if (len == 0) return Value.String('');
+
+  // Parse start index - use asFloat() to handle both Int and Float types
+  let start: i32 = 0;
+  if (startVal.isNumber()) {
+    start = <i32>startVal.asFloat();
+  }
+
+  // Handle negative start (offset from end)
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0; // Clamp to 0
+  }
+
+  // Handle start beyond length
+  if (start >= len) {
+    return Value.String('');
+  }
+
+  // Parse end index if provided
+  let hasEnd = !endOrLengthVal.isNull();
+  let end: i32 = len; // Default to end of string
+
+  if (hasEnd && endOrLengthVal.isNumber()) {
+    end = <i32>endOrLengthVal.asFloat();
+
+    // Handle negative end (offset from end)
+    if (end < 0) {
+      end = len + end;
+      if (end < 0) end = 0;
+    }
+
+    // Clamp end to string length
+    if (end > len) end = len;
+
+    // Ensure end >= start
+    if (end < start) end = start;
+  }
+
+  // Extract substring
+  return Value.String(str.substring(start, end));
+}
+
+/**
+ * Find the index of the first occurrence of a substring.
+ *
+ * Returns the index of the first occurrence of the search string,
+ * starting from the specified position. Returns -1 if not found.
+ *
+ * Parameters:
+ * - str: The string to search in
+ * - searchVal: The substring to search for
+ * - startVal: Optional starting position (default: 0)
+ *
+ * Behavior:
+ * - If the source string is not a string, returns null
+ * - If the search value is not a string, returns null
+ * - If start is negative or omitted, defaults to 0
+ * - If start > str.length, returns -1 (not found)
+ * - If search string is empty, returns the start position
+ * - Returns -1 if the substring is not found
+ *
+ * Examples:
+ * - indexOf("hello", "l") \u2192 2
+ * - indexOf("hello", "x") \u2192 -1
+ * - indexOf("hello", "l", 3) \u2192 3
+ * - indexOf("hello", "ll") \u2192 2
+ * - indexOf("hello", "lo", 0) \u2192 3
+ * - indexOf("hello", "") \u2192 0 (empty search string)
+ * - indexOf("hello", "o", 5) \u2192 -1 (start at end)
+ * - indexOf("hello", "o", 10) \u2192 -1 (start beyond length)
+ * - indexOf("", "x") \u2192 -1 (empty source)
+ * - indexOf("", "") \u2192 0 (both empty)
+ * - indexOf(123, "1") \u2192 null (not a string)
+ *
+ * @param strVal - The string value to search in
+ * @param searchVal - The substring value to search for
+ * @param startVal - Optional starting position
+ * @returns The index of the first occurrence, or -1 if not found, or null if inputs are not strings
+ */
+export function indexOfString(strVal: Value, searchVal: Value, startVal: Value): Value {
+  if (!strVal.isString() || !searchVal.isString()) return Value.Null();
+  const str = strVal.asString();
+  const search = searchVal.asString();
+
+  // Parse start index
+  let start: i32 = 0;
+  if (!startVal.isNull() && startVal.isNumber()) {
+    start = <i32>startVal.asFloat();
+  }
+
+  // Handle negative start
+  if (start < 0) {
+    start = 0;
+  }
+
+  // Special case: empty search string (matches JavaScript behavior)
+  // When searching for empty string, return the start position clamped to string length
+  if (search.length == 0) {
+    const len = <i32>str.length;
+    if (start >= len) {
+      return Value.Int(<i64>len);
+    }
+    return Value.Int(<i64>start);
+  }
+
+  // AssemblyScript's indexOf returns -1 for not found
+  const index = str.indexOf(search, start);
+  return Value.Int(<i64>index);
+}
+
+/**
+ * Check if a string starts with a given prefix.
+ *
+ * Returns true if the string begins with the specified prefix, false otherwise.
+ *
+ * Parameters:
+ * - str: The string to check
+ * - prefix: The prefix to look for
+ *
+ * Behavior:
+ * - If either input is not a string, returns null
+ * - If the prefix is an empty string, returns true
+ * - Case-sensitive comparison
+ *
+ * Examples:
+ * - startsWith("hello", "he") \u2192 true
+ * - startsWith("hello", "lo") \u2192 false
+ * - startsWith("hello", "hello") \u2192 true
+ * - startsWith("hello", "hello world") \u2192 false (prefix longer than string)
+ * - startsWith("", "") \u2192 true (empty strings)
+ * - startsWith("hello", "") \u2192 true (empty prefix)
+ * - startsWith("", "he") \u2192 false (prefix longer than empty string)
+ * - startsWith("Hello", "he") \u2192 false (case-sensitive)
+ * - startsWith(123, "1") \u2192 null (not a string)
+ * - startsWith(null, "he") \u2192 null (not a string)
+ *
+ * @param strVal - The string value to check
+ * @param prefixVal - The prefix value to look for
+ * @returns true if the string starts with the prefix, false otherwise, or null if inputs are not strings
+ */
+export function startsWithString(strVal: Value, prefixVal: Value): Value {
+  if (!strVal.isString() || !prefixVal.isString()) return Value.Null();
+  const str = strVal.asString();
+  const prefix = prefixVal.asString();
+
+  // AssemblyScript's startsWith returns a bool
+  const result = str.startsWith(prefix);
+  return Value.Bool(result);
+}
+
+/**
+ * Check if a string ends with a given suffix.
+ *
+ * Returns true if the string ends with the specified suffix, false otherwise.
+ *
+ * Parameters:
+ * - str: The string to check
+ * - suffix: The suffix to look for
+ *
+ * Behavior:
+ * - If either input is not a string, returns null
+ * - If the suffix is an empty string, returns true
+ * - Case-sensitive comparison
+ *
+ * Examples:
+ * - endsWith("hello", "lo") \u2192 true
+ * - endsWith("hello", "he") \u2192 false
+ * - endsWith("hello", "hello") \u2192 true
+ * - endsWith("hello", "hello world") \u2192 false (suffix longer than string)
+ * - endsWith("", "") \u2192 true (empty strings)
+ * - endsWith("hello", "") \u2192 true (empty suffix)
+ * - endsWith("", "lo") \u2192 false (suffix longer than empty string)
+ * - endsWith("Hello", "LO") \u2192 false (case-sensitive)
+ * - endsWith(123, "1") \u2192 null (not a string)
+ * - endsWith(null, "lo") \u2192 null (not a string)
+ *
+ * @param strVal - The string value to check
+ * @param suffixVal - The suffix value to look for
+ * @returns true if the string ends with the suffix, false otherwise, or null if inputs are not strings
+ */
+export function endsWithString(strVal: Value, suffixVal: Value): Value {
+  if (!strVal.isString() || !suffixVal.isString()) return Value.Null();
+  const str = strVal.asString();
+  const suffix = suffixVal.asString();
+
+  // AssemblyScript's endsWith returns a bool
+  const result = str.endsWith(suffix);
+  return Value.Bool(result);
+}
+
+/**
+ * Split a string into an array based on a delimiter.
+ *
+ * Returns an array of substrings by dividing the input string at each
+ * occurrence of the specified delimiter.
+ *
+ * Parameters:
+ * - str: The string to split
+ * - delimiter: The delimiter to split on
+ *
+ * Behavior:
+ * - If the input string is not a string, returns null
+ * - If the delimiter is not a string, returns null
+ * - If the delimiter is an empty string, returns an array of individual characters
+ * - If the string and delimiter are both empty, returns an array with one empty string
+ * - If the delimiter is not found, returns an array with the original string
+ *
+ * Examples:
+ * - split("a,b,c", ",") \u2192 ["a", "b", "c"]
+ * - split("hello", "") \u2192 ["h", "e", "l", "l", "o"]
+ * - split("a-b-c", "-") \u2192 ["a", "b", "c"]
+ * - split("word", "x") \u2192 ["word"]
+ * - split("", ",") \u2192 [""]
+ * - split("", "") \u2192 [""] (special case: empty string splits into array with one empty string)
+ * - split("a,,b", ",") \u2192 ["a", "", "b"] (preserves empty segments)
+ * - split(null, ",") \u2192 null
+ * - split("hello", null) \u2192 null
+ * - split("hello", 123) \u2192 null
+ *
+ * @param strVal - The string value to split
+ * @param delimiterVal - The delimiter value to split on
+ * @returns An array of strings, or null if inputs are invalid
+ */
+export function splitString(strVal: Value, delimiterVal: Value): Value {
+  if (!strVal.isString() || !delimiterVal.isString()) return Value.Null();
+  const str = strVal.asString();
+  const delimiter = delimiterVal.asString();
+
+  const parts = str.split(delimiter);
+
+  // Convert string array to Value array
+  const result = new Array<Value>(parts.length);
+  for (let i = 0; i < parts.length; i++) {
+    unchecked((result[i] = Value.String(unchecked(parts[i]))));
+  }
+
+  return Value.Array(result);
+}
+
+/**
+ * Join array elements into a string with a separator.
+ *
+ * Returns a string that concatenates all elements of the array,
+ * separated by the specified delimiter.
+ *
+ * Parameters:
+ * - arr: The array to join
+ * - delimiter: The delimiter to insert between elements
+ *
+ * Behavior:
+ * - If the input is not an array, returns null
+ * - If the delimiter is not a string, returns null
+ * - If the array is empty, returns an empty string
+ * - Each array element is converted to its string representation
+ * - The delimiter is placed between each adjacent element, not at the start or end
+ *
+ * Examples:
+ * - join(["a", "b", "c"], "-") \u2192 "a-b-c"
+ * - join(["hello", "world"], " ") \u2192 "hello world"
+ * - join(["a"], ",") \u2192 "a"
+ * - join([], ",") \u2192 ""
+ * - join([1, 2, 3], "-") \u2192 "1-2-3" (numbers converted to strings)
+ * - join([true, false], " ") \u2192 "true false" (booleans converted to strings)
+ * - join(["a", null, "b"], "-") \u2192 "a-null-b" (null converted to "null")
+ * - join(null, ",") \u2192 null
+ * - join(["a"], null) \u2192 null
+ * - join(["a"], 123) \u2192 null
+ *
+ * @param arrVal - The array value to join
+ * @param delimiterVal - The delimiter to insert between elements
+ * @returns The concatenated string, or null if inputs are invalid
+ */
+export function joinArray(arrVal: Value, delimiterVal: Value): Value {
+  if (!arrVal.isArray() || !delimiterVal.isString()) return Value.Null();
+  const arr = arrVal.asArray();
+  const delimiter = delimiterVal.asString();
+
+  // Handle empty array
+  if (arr.length == 0) {
+    return Value.String('');
+  }
+
+  // Build the result string
+  let result: string = '';
+  for (let i = 0; i < arr.length; i++) {
+    // Append delimiter if not first element
+    if (i > 0) {
+      result += delimiter;
+    }
+    // Convert value to string and append
+    result += valueToString(unchecked(arr[i]));
+  }
+
+  return Value.String(result);
+}
+
+/**
+ * Convert a string value to a number.
+ *
+ * Parses a string containing a numeric value and returns it as a float.
+ * Supports decimal numbers and negative numbers.
+ *
+ * Parameters:
+ * - val: The value to convert to a number (must be a string)
+ *
+ * Behavior:
+ * - If input is not a string, returns null
+ * - If string cannot be parsed as a number, returns NaN
+ * - Returns f64 (float) for all numeric values
+ *
+ * Examples:
+ * - number("123") \u2192 123.0
+ * - number("3.14") \u2192 3.14
+ * - number("-42") \u2192 -42.0
+ * - number("0.5") \u2192 0.5
+ * - number("not a number") \u2192 NaN
+ * - number(null) \u2192 null
+ * - number(123) \u2192 null (not a string)
+ *
+ * @param val - The value to convert to a number
+ * @returns The numeric value as a float, or null if input is not a string
+ */
+export function numberValue(val: Value): Value {
+  if (val.isString()) {
+    const str = val.asString();
+    // Parse the string using the same logic as parseIntValue
+    let result: i64 = 0;
+    let negative = false;
+    let i = 0;
+
+    // Handle leading whitespace
+    while (i < str.length && str.charCodeAt(i) == 32) {
+      i++;
+    }
+
+    // Handle negative sign
+    if (i < str.length && str.charCodeAt(i) == 45) {
+      // '-'
+      negative = true;
+      i++;
+    }
+
+    // Parse digits
+    let hasDigits = false;
+    while (i < str.length) {
+      const c = str.charCodeAt(i);
+      if (c >= 48 && c <= 57) {
+        // '0'-'9'
+        result = result * 10 + (c - 48);
+        hasDigits = true;
+        i++;
+      } else {
+        break;
+      }
+    }
+
+    if (!hasDigits) return Value.Null();
+
+    const finalResult = negative ? -result : result;
+    return Value.Float(<f64>finalResult);
+  } else if (val.isNumber()) {
+    return val;
+  } else if (val.isBool()) {
+    return val.asBool() ? Value.Float(1.0) : Value.Float(0.0);
+  }
+  return Value.Null();
+}
+
+/**
+ * Convert any value to a string.
+ *
+ * Converts the input value to its string representation.
+ *
+ * Parameters:
+ * - val: Any value to convert to string
+ *
+ * Behavior:
+ * - Boolean: "true" or "false"
+ * - Number: numeric string representation
+ * - String: returned as-is
+ * - Null: null (returns null, not the string "null")
+ * - Array/Object: "[object]"
+ *
+ * Examples:
+ * - string(42) \u2192 "42"
+ * - string(3.14) \u2192 "3.14"
+ * - string(true) \u2192 "true"
+ * - string(false) \u2192 "false"
+ * - string("hello") \u2192 "hello"
+ * - string(null) \u2192 null
+ *
+ * @param val - The value to convert to a string
+ * @returns The string representation, or null if input is null
+ */
+export function stringValue(val: Value): Value {
+  if (val.isNull()) {
+    return Value.Null();
+  }
+  if (val.isBool()) {
+    return Value.String(val.asBool() ? 'true' : 'false');
+  }
+  if (val.isNumber()) {
+    // Converting to string matches JavaScript String() coercion for consistency with JS engines.
+    // Integers print without decimals (3 not 3.0), floats use AS toString() formatting.
+    if (val.type == TYPE_INT) {
+      return Value.String(val.intVal.toString());
+    }
+    const f = val.asFloat();
+    // Check if it's a whole number by testing if remainder is 0
+    if (f % 1.0 == 0.0) {
+      return Value.String(i64(<i64>f).toString());
+    }
+    return Value.String(f.toString());
+  }
+  if (val.isString()) {
+    return val;
+  }
+  // Arrays and objects fall back to a placeholder
+  return Value.String('[object]');
+}
+
+/**
+ * Replace the first occurrence of a substring with another string.
+ *
+ * Returns a new string where the first occurrence of the search string
+ * is replaced by the replacement string.
+ *
+ * Parameters:
+ * - str: The string to modify
+ * - search: The substring to search for
+ * - replacement: The string to replace with
+ *
+ * Behavior:
+ * - If the source string is not a string, returns null
+ * - If the search value is not a string, returns null
+ * - If the replacement value is not a string, returns null
+ * - If the search string is empty, the replacement is inserted at the beginning
+ * - If the search string is not found, returns the original string unchanged
+ * - Only the first occurrence is replaced
+ *
+ * Examples:
+ * - replace("hello", "l", "L") \u2192 "heLlo"
+ * - replace("hello", "lo", "LO") \u2192 "heLLO"
+ * - replace("hello", "x", "X") \u2192 "hello" (not found, unchanged)
+ * - replace("hello hello", "l", "L") \u2192 "heLlo hello" (only first occurrence)
+ * - replace("hello", "", "X") \u2192 "Xhello" (empty search, insert at start)
+ * - replace("", "x", "X") \u2192 "" (empty source, no match)
+ * - replace(null, "l", "L") \u2192 null (not a string)
+ * - replace("hello", null, "L") \u2192 null (not a string)
+ * - replace("hello", "l", null) \u2192 null (not a string)
+ *
+ * @param strVal - The string value to modify
+ * @param searchVal - The substring value to search for
+ * @param replacementVal - The replacement string value
+ * @returns The modified string with first occurrence replaced, or null if inputs are invalid
+ */
+export function replaceString(strVal: Value, searchVal: Value, replacementVal: Value): Value {
+  if (!strVal.isString() || !searchVal.isString() || !replacementVal.isString())
+    return Value.Null();
+  const str = strVal.asString();
+  const search = searchVal.asString();
+  const replacement = replacementVal.asString();
+
+  // AssemblyScript's replace() replaces all occurrences by default
+  // We need to replace only the first occurrence, so we use indexOf and string concatenation
+  const index = str.indexOf(search);
+
+  // Search string not found - return original string
+  if (index < 0) {
+    return Value.String(str);
+  }
+
+  // Build result: prefix + replacement + suffix
+  const prefix = str.substring(0, index);
+  const suffix = str.substring(index + search.length);
+  return Value.String(prefix + replacement + suffix);
+}
+
+/**
+ * Replace all occurrences of a substring with another string.
+ *
+ * Returns a new string where all occurrences of the search string
+ * are replaced by the replacement string.
+ *
+ * Parameters:
+ * - str: The string to modify
+ * - search: The substring to search for
+ * - replacement: The string to replace with
+ *
+ * Behavior:
+ * - If the source string is not a string, returns null
+ * - If the search value is not a string, returns null
+ * - If the replacement value is not a string, returns null
+ * - If the search string is empty, the replacement is inserted between each character
+ * - If the search string is not found, returns the original string unchanged
+ * - All occurrences are replaced
+ *
+ * Examples:
+ * - replaceAll("hello", "l", "L") \u2192 "heLLo"
+ * - replaceAll("hello hello", "l", "L") \u2192 "heLLo heLLo"
+ * - replaceAll("hello", "lo", "LO") \u2192 "heLLO"
+ * - replaceAll("hello", "x", "X") \u2192 "hello" (not found, unchanged)
+ * - replaceAll("hello", "", "X") \u2192 "XhXeXlXlXoX" (empty search, insert between chars)
+ * - replaceAll("", "x", "X") \u2192 "" (empty source, no match)
+ * - replaceAll(null, "l", "L") \u2192 null (not a string)
+ * - replaceAll("hello", null, "L") \u2192 null (not a string)
+ * - replaceAll("hello", "l", null) \u2192 null (not a string)
+ *
+ * @param strVal - The string value to modify
+ * @param searchVal - The substring value to search for
+ * @param replacementVal - The replacement string value
+ * @returns The modified string with all occurrences replaced, or null if inputs are invalid
+ */
+export function replaceAllString(strVal: Value, searchVal: Value, replacementVal: Value): Value {
+  if (!strVal.isString() || !searchVal.isString() || !replacementVal.isString())
+    return Value.Null();
+  let str = strVal.asString();
+  const search = searchVal.asString();
+  const replacement = replacementVal.asString();
+
+  // Handle empty search string - insert replacement between each character
+  if (search.length == 0) {
+    let result = replacement;
+    for (let i = 0; i < str.length; i++) {
+      result += str.charAt(i) + replacement;
+    }
+    return Value.String(result);
+  }
+
+  // Use split and join for O(n) complexity instead of quadratic substring approach
+  const parts = str.split(search);
+  return Value.String(parts.join(replacement));
+}
+
+// === Value Type Conversion ===
+
+/**
+ * Convert a Value to its string representation.
+ *
+ * This follows JavaScript's String() conversion rules:
+ * - Number: converted using JS toString()
+ * - Boolean: "true" or "false"
+ * - String: returned as-is
+ * - Null: "null"
+ *
+ * @param val - The value to convert
+ * @returns The string representation
+ */
+function valueToString(val: Value): string {
+  if (val.isNull()) {
+    return 'null';
+  }
+  if (val.isBool()) {
+    return val.asBool() ? 'true' : 'false';
+  }
+  if (val.isNumber()) {
+    // Converting to string matches JavaScript String() coercion for consistency with JS engines.
+    // Integers print without decimals (3 not 3.0), floats use AS toString() formatting.
+    if (val.type == TYPE_INT) {
+      return val.intVal.toString();
+    }
+    const f = val.asFloat();
+    // Check if it's a whole number by testing if remainder is 0
+    if (f % 1.0 == 0.0) {
+      return i64(<i64>f).toString();
+    }
+    return f.toString();
+  }
+  if (val.isString()) {
+    return val.asString();
+  }
+  // Arrays and objects fall back to a placeholder
+  return '[object]';
+}
+
+// === Comparison Helpers ===
+
+export function valuesEqual(a: Value, b: Value): bool {
+  if (a.type != b.type) {
+    // Allow int/float comparison
+    if (a.isNumber() && b.isNumber()) {
+      return a.asFloat() == b.asFloat();
+    }
+    return false;
+  }
+  if (a.isBool()) return a.boolVal == b.boolVal;
+  if (a.type == TYPE_INT) return a.intVal == b.intVal;
+  if (a.type == TYPE_FLOAT) return a.floatVal == b.floatVal;
+  if (a.isString()) return a.asString() == b.asString();
+  if (a.isNull()) return true; // null == null
+  return false; // Arrays/objects: reference equality not supported
+}
+
+/**
+ * Compare two values for ordering.
+ *
+ * Returns:
+ * - Negative number if a < b
+ * - Zero if a == b
+ * - Positive number if a > b
+ *
+ * Comparison rules:
+ * - Strings: Lexicographic comparison using UTF-16 code units (case-sensitive)
+ * - Numbers: Numeric comparison (int and float are comparable)
+ * - Booleans: false < true
+ * - Null: Treated as less than all other values
+ * - Mixed types: Comparisons between incompatible types return 0 (not recommended)
+ *
+ * Examples:
+ * - compareValues(String("apple"), String("banana")) \u2192 negative
+ * - compareValues(String("zebra"), String("apple")) \u2192 positive
+ * - compareValues(String("abc"), String("abc")) \u2192 0
+ * - compareValues(Float(3.14), Float(2.71)) \u2192 positive
+ * - compareValues(Bool(false), Bool(true)) \u2192 negative
+ *
+ * @param a - The left operand to compare
+ * @param b - The right operand to compare
+ * @returns Comparison result (-1, 0, or 1)
+ */
+export function compareValues(a: Value, b: Value): i32 {
+  // Handle null - null is less than all other values
+  if (a.isNull()) return b.isNull() ? 0 : -1;
+  if (b.isNull()) return 1;
+
+  // Allow int/float comparison for numbers
+  if (a.isNumber() && b.isNumber()) {
+    const aNum = a.asFloat();
+    const bNum = b.asFloat();
+    if (aNum < bNum) return -1;
+    if (aNum > bNum) return 1;
+    return 0;
+  }
+
+  // String comparison - lexicographic, case-sensitive
+  if (a.isString() && b.isString()) {
+    const aStr = a.asString();
+    const bStr = b.asString();
+    if (aStr < bStr) return -1;
+    if (aStr > bStr) return 1;
+    return 0;
+  }
+
+  // Boolean comparison
+  if (a.isBool() && b.isBool()) {
+    const aBool = a.asBool();
+    const bBool = b.asBool();
+    if (!aBool && bBool) return -1;
+    if (aBool && !bBool) return 1;
+    return 0;
+  }
+
+  // Mixed types or unsupported types - treat as equal (but probably shouldn't happen)
+  return 0;
+}
+
+// === Arithmetic Operators ===
+
+/**
+ * Add two values, supporting both numeric addition and string concatenation.
+ *
+ * Type coercion rules:
+ * - If either operand is a string, both are converted to strings and concatenated
+ * - Otherwise, both operands are treated as numbers and added together
+ *
+ * Examples:
+ * - "hello" + " " + "world" \u2192 "hello world"
+ * - "count: " + 5 \u2192 "count: 5"
+ * - 1 + 2 \u2192 3
+ * - true + false \u2192 1 (true=1, false=0, numeric addition)
+ * - null + 5 \u2192 5 (null=0, numeric addition)
+ * - "prefix" + null \u2192 "prefixnull" (string concatenation)
+ *
+ * @param a - The left operand
+ * @param b - The right operand
+ * @returns The sum or concatenation result
+ */
+export function addValues(a: Value, b: Value): Value {
+  // String concatenation takes priority over numeric addition
+  // If either operand is a string, concatenate both as strings
+  if (a.isString() || b.isString()) {
+    const leftStr = a.isString() ? a.asString() : valueToString(a);
+    const rightStr = b.isString() ? b.asString() : valueToString(b);
+    return Value.String(leftStr + rightStr);
+  }
+
+  // Numeric addition
+  const aNum = a.isNumber() ? a.asFloat() : a.isBool() ? (a.asBool() ? 1.0 : 0.0) : 0.0;
+  const bNum = b.isNumber() ? b.asFloat() : b.isBool() ? (b.asBool() ? 1.0 : 0.0) : 0.0;
+  return Value.Float(aNum + bNum);
+}
+
+export function subtractValues(a: Value, b: Value): Value {
+  if (!a.isNumber() || !b.isNumber()) return Value.Null();
+  const aVal = a.asFloat();
+  const bVal = b.asFloat();
+  return Value.Float(aVal - bVal);
+}
+
+export function multiplyValues(a: Value, b: Value): Value {
+  if (!a.isNumber() || !b.isNumber()) return Value.Null();
+  const aVal = a.asFloat();
+  const bVal = b.asFloat();
+  return Value.Float(aVal * bVal);
+}
+
+export function divideValues(a: Value, b: Value): Value {
+  if (!a.isNumber() || !b.isNumber()) return Value.Null();
+  const aVal = a.asFloat();
+  const bVal = b.asFloat();
+  if (bVal == 0) return Value.Null(); // Division by zero
+  return Value.Float(aVal / bVal);
+}
+
+export function moduloValues(a: Value, b: Value): Value {
+  if (!a.isNumber() || !b.isNumber()) return Value.Null();
+  const aVal = a.asFloat();
+  const bVal = b.asFloat();
+  if (bVal == 0) return Value.Null(); // Division by zero
+  // Use fmod for floating point modulo
+  const result = aVal - Math.trunc(aVal / bVal) * bVal;
+  return Value.Float(result);
+}
+
+export function powerValues(a: Value, b: Value): Value {
+  if (!a.isNumber() || !b.isNumber()) return Value.Null();
+  const aVal = a.asFloat();
+  const bVal = b.asFloat();
+  const result = Math.pow(aVal, bVal);
+  return Value.Float(result);
+}
+
+export function negateValue(a: Value): Value {
+  if (!a.isNumber()) return Value.Null();
+  const n = a.asFloat();
+  return Value.Float(-n);
+}
+
+/**
+ * Get a property from an object Value.
+ *
+ * @param obj - The Value to get the property from (should be an object)
+ * @param property - The property name to get
+ * @returns The Value of the property, or Null if not found or obj is null/not an object
+ */
+export function getProperty(obj: Value, property: string): Value {
+  if (obj.isNull()) return Value.Null();
+  if (!obj.isObject()) return Value.Null();
+
+  const map = obj.asObject();
+  if (map.has(property)) {
+    return map.get(property);
+  }
+  return Value.Null();
+}
+
+/**
+ * Get an element from an array at the specified index.
+ *
+ * @param arr - The Value to get the element from (should be an array)
+ * @param idx - The index to get (must be a number Value)
+ * @returns The Value at the index, or Null if out of bounds or arr is null/not an array
+ */
+export function getIndex(arr: Value, idx: Value): Value {
+  if (arr.isNull()) return Value.Null();
+  if (idx.isNull()) return Value.Null();
+
+  // Handle object access with string keys (e.g., baseCosts["FastTrack"])
+  if (arr.isObject()) {
+    if (idx.isString()) {
+      const obj = arr.asObject();
+      const key = idx.asString();
+      if (obj.has(key)) {
+        return obj.get(key);
+      }
+      return Value.Null();
+    }
+    // If idx is a number, convert to string for object key lookup
+    // This handles cases like obj[0] where obj is {"0": value}
+    const keyStr = idx.asString();
+    const obj = arr.asObject();
+    if (obj.has(keyStr)) {
+      return obj.get(keyStr);
+    }
+    return Value.Null();
+  }
+
+  if (!arr.isArray()) return Value.Null();
+
+  const array = arr.asArray();
+  const index = idx.asFloat();
+
+  // Handle negative indices (from end of array)
+  let actualIndex = <i32>index;
+  if (actualIndex < 0) {
+    actualIndex = <i32>(array.length + actualIndex);
+  }
+
+  // Check bounds
+  if (actualIndex < 0 || actualIndex >= array.length) {
+    return Value.Null();
+  }
+
+  return array[actualIndex];
+}
+
+/**
+ * Create an interval object for range checking.
+ *
+ * @param start - Start value of the interval
+ * @param end - End value of the interval
+ * @param startInclusive - Whether the start is inclusive (true) or exclusive (false)
+ * @param endInclusive - Whether the end is inclusive (true) or exclusive (false)
+ * @returns An object representing the interval
+ */
+export function createInterval(
+  start: Value,
+  end: Value,
+  startInclusive: bool,
+  endInclusive: bool,
+): Value {
+  const intervalMap = new Map<string, Value>();
+  intervalMap.set('__isInterval', Value.Bool(true));
+  intervalMap.set('start', start);
+  intervalMap.set('end', end);
+  intervalMap.set('startInclusive', Value.Bool(startInclusive));
+  intervalMap.set('endInclusive', Value.Bool(endInclusive));
+  return Value.Object(intervalMap);
+}
+
+/**
+ * Check if a value is within an interval.
+ *
+ * @param needle - The value to check
+ * @param interval - The interval object created by createInterval
+ * @returns true if the value is within the interval, false otherwise
+ */
+function valueInInterval(needle: Value, interval: Value): bool {
+  if (!interval.isObject()) return false;
+
+  const intervalObj = interval.asObject();
+
+  // Check if this is actually an interval object
+  if (!intervalObj.has('__isInterval')) return false;
+
+  const start = intervalObj.get('start');
+  const end = intervalObj.get('end');
+  const startInclusive = intervalObj.get('startInclusive').asBool();
+  const endInclusive = intervalObj.get('endInclusive').asBool();
+
+  const cmpStart = compareValues(needle, start);
+  const cmpEnd = compareValues(needle, end);
+
+  // Check start boundary
+  let passesStart: bool;
+  if (startInclusive) {
+    passesStart = cmpStart >= 0;
+  } else {
+    passesStart = cmpStart > 0;
+  }
+
+  // Check end boundary
+  let passesEnd: bool;
+  if (endInclusive) {
+    passesEnd = cmpEnd <= 0;
+  } else {
+    passesEnd = cmpEnd < 0;
+  }
+
+  return passesStart && passesEnd;
+}
+
+/**
+ * Check if a value is in an array, a substring is in a string, or a value is in an interval.
+ * For arrays: checks if the exact value exists in the array
+ * For strings: checks if the needle string is a substring of the haystack
+ * For intervals: checks if the value is within the range
+ *
+ * @param needle - The Value or string to search for
+ * @param haystack - The Value to search in (should be an array, string, or interval)
+ * @returns true if found, false otherwise
+ */
+export function valueIn(needle: Value, haystack: Value): Value {
+  if (needle.isNull() || haystack.isNull()) return Value.Bool(false);
+
+  // Check if haystack is an interval
+  if (haystack.isObject()) {
+    const obj = haystack.asObject();
+    if (obj.has('__isInterval')) {
+      return Value.Bool(valueInInterval(needle, haystack));
+    }
+  }
+
+  // Check if haystack is an array
+  if (haystack.isArray()) {
+    const array = haystack.asArray();
+    for (let i = 0; i < array.length; i++) {
+      if (valuesEqual(needle, unchecked(array[i]))) {
+        return Value.Bool(true);
+      }
+    }
+    return Value.Bool(false);
+  }
+
+  // Check if haystack is a string
+  if (haystack.isString() && needle.isString()) {
+    const hayStr = haystack.asString();
+    const needStr = needle.asString();
+    if (hayStr.indexOf(needStr) >= 0) {
+      return Value.Bool(true);
+    }
+    return Value.Bool(false);
+  }
+
+  return Value.Bool(false);
+}
+`;
+var RUNTIME_TABLES = "// assembly/runtime/tables.ts (AssemblyScript)\nimport { Value } from './values';\nimport { Context } from './context';\nimport { valuesEqual } from './expressions';\n\n/**\n * Condition for decision table row evaluation.\n * Uses Value tagged union consistently.\n */\nexport class Condition {\n  field: string;\n  op: string;\n  value: Value;\n\n  constructor(field: string, op: string, value: Value) {\n    this.field = field;\n    this.op = op;\n    this.value = value;\n  }\n\n  evaluate(ctx: Context): bool {\n    const actual = ctx.get(this.field);\n    const expected = this.value;\n\n    // Handle null cases\n    if (actual.isNull()) {\n      if (this.op == '==' && expected.isNull()) return true;\n      if (this.op == '!=' && !expected.isNull()) return true;\n      return false;\n    }\n\n    // Numeric comparisons\n    if (actual.isNumber() && expected.isNumber()) {\n      const a = actual.asFloat();\n      const e = expected.asFloat();\n\n      if (this.op == '==') return a == e;\n      if (this.op == '!=') return a != e;\n      if (this.op == '<') return a < e;\n      if (this.op == '<=') return a <= e;\n      if (this.op == '>') return a > e;\n      if (this.op == '>=') return a >= e;\n    }\n\n    // String comparisons\n    if (actual.isString() && expected.isString()) {\n      const a = actual.asString();\n      const e = expected.asString();\n\n      if (this.op == '==') return a == e;\n      if (this.op == '!=') return a != e;\n      // Lexicographic comparison for strings\n      if (this.op == '<') return a < e;\n      if (this.op == '<=') return a <= e;\n      if (this.op == '>') return a > e;\n      if (this.op == '>=') return a >= e;\n    }\n\n    // Boolean equality\n    if (actual.isBool() && expected.isBool()) {\n      if (this.op == '==') return actual.boolVal == expected.boolVal;\n      if (this.op == '!=') return actual.boolVal != expected.boolVal;\n    }\n\n    // Generic equality via valuesEqual\n    if (this.op == '==') return valuesEqual(actual, expected);\n    if (this.op == '!=') return !valuesEqual(actual, expected);\n\n    return false;\n  }\n}\n\n/**\n * Check if a value is within an interval (range).\n * Supports open/closed boundaries: [a..b], (a..b), [a..b), (a..b]\n */\nexport function inInterval(\n  val: Value,\n  start: Value,\n  end: Value,\n  startInclusive: bool,\n  endInclusive: bool,\n): bool {\n  if (!val.isNumber() || !start.isNumber() || !end.isNumber()) {\n    return false;\n  }\n\n  const v = val.asFloat();\n  const s = start.asFloat();\n  const e = end.asFloat();\n\n  const aboveStart = startInclusive ? v >= s : v > s;\n  const belowEnd = endInclusive ? v <= e : v < e;\n\n  return aboveStart && belowEnd;\n}\n";
+var RUNTIME_MEMORY = "// assembly/runtime/memory.ts (AssemblyScript)\n// Memory layout and management utilities for WASM linear memory\n\nimport { writeString } from './strings';\n\n// ============================================================================\n// Memory Layout Constants\n// ============================================================================\n\n// Reserved space for null pointer trap (first 4 bytes)\n// Accessing address 0 should trap, catching null/nullish pointer bugs\nexport const NULL_POINTER_TRAP_SIZE: usize = 4;\n\n// Fixed memory region offsets\nexport const INPUT_BUFFER_START: usize = NULL_POINTER_TRAP_SIZE; // 0x0004\n\n// Schema-specific field layouts require different buffer sizes. Computing sizes at\n// compile time based on actual schema ensures optimal memory usage per decision.\nexport let INPUT_BUFFER_SIZE: usize = 0;\n\n// Variable-length input data starts after the fixed input buffer\nexport let INPUT_VAR_START: usize = 0;\n\n// Output buffer follows input variable data\nexport let OUTPUT_START: usize = 0;\n\n// Computed at compilation time based on input/output schema field sizes\nexport let OUTPUT_BUFFER_SIZE: usize = 0;\n\n// Variable-length output data starts after the fixed output buffer\nexport let OUTPUT_VAR_START: usize = 0;\n\n// Runtime heap for intermediate values (temporary arrays, string concat buffers, etc.)\nexport let HEAP_START: usize = 0;\n\n// ============================================================================\n// Header Constants\n// ============================================================================\n\n// Schema hash size in bytes\nexport const SCHEMA_HASH_SIZE: usize = 8;\n\n// String descriptor format: [offset (4 bytes)] [length (4 bytes)]\nexport const STRING_DESC_SIZE: usize = 8;\n\n// Array descriptor format: [offset (4 bytes)] [length (4 bytes)]\nexport const ARRAY_DESC_SIZE: usize = 8;\n\n// ============================================================================\n// Memory Allocation\n// ============================================================================\n\n// Decision evaluation is single-pass (no GC needed), and most allocations are temporary\n// (freed after result is marshaled). Linear bump allocator is fast and simple.\nlet heapPointer: usize = 0;\n\n/**\n * Initialize memory layout.\n *\n * This function must be called once at startup with the computed sizes\n * for the input and output buffers based on the schema.\n *\n * @param inputFixedSize - Size of fixed input fields in bytes\n * @param outputFixedSize - Size of fixed output fields in bytes\n */\nexport function initializeMemoryLayout(inputFixedSize: usize, outputFixedSize: usize): void {\n  INPUT_BUFFER_SIZE = inputFixedSize;\n  INPUT_VAR_START = INPUT_BUFFER_START + inputFixedSize;\n\n  OUTPUT_BUFFER_SIZE = outputFixedSize;\n  OUTPUT_START = INPUT_VAR_START; // Output follows input variable data\n  OUTPUT_VAR_START = OUTPUT_START + outputFixedSize;\n\n  HEAP_START = OUTPUT_VAR_START; // Heap follows output variable data\n  heapPointer = HEAP_START; // Reset heap pointer\n}\n\n/**\n * Get the current memory layout info.\n *\n * @returns Object with all memory region offsets and sizes\n */\nexport function getMemoryLayout(): MemoryLayout {\n  return new MemoryLayout(\n    NULL_POINTER_TRAP_SIZE,\n    INPUT_BUFFER_START,\n    INPUT_BUFFER_SIZE,\n    INPUT_VAR_START,\n    OUTPUT_START,\n    OUTPUT_BUFFER_SIZE,\n    OUTPUT_VAR_START,\n    HEAP_START,\n  );\n}\n\n/**\n * Memory layout information structure.\n */\nexport class MemoryLayout {\n  nullPointerTrapSize: usize;\n  inputBufferStart: usize;\n  inputBufferSize: usize;\n  inputVarStart: usize;\n  outputStart: usize;\n  outputBufferSize: usize;\n  outputVarStart: usize;\n  heapStart: usize;\n\n  constructor(\n    nullPointerTrapSize: usize,\n    inputBufferStart: usize,\n    inputBufferSize: usize,\n    inputVarStart: usize,\n    outputStart: usize,\n    outputBufferSize: usize,\n    outputVarStart: usize,\n    heapStart: usize,\n  ) {\n    this.nullPointerTrapSize = nullPointerTrapSize;\n    this.inputBufferStart = inputBufferStart;\n    this.inputBufferSize = inputBufferSize;\n    this.inputVarStart = inputVarStart;\n    this.outputStart = outputStart;\n    this.outputBufferSize = outputBufferSize;\n    this.outputVarStart = outputVarStart;\n    this.heapStart = heapStart;\n  }\n}\n\n// ============================================================================\n// Simple Linear Heap Allocator\n// ============================================================================\n\n/**\n * Allocate memory from the runtime heap.\n *\n * A simple linear allocator - memory is never freed during a single evaluation.\n * Suitable for short-lived operations like decision table evaluation.\n *\n * Memory is never freed during a single evaluation because:\n * (1) evaluations are short-lived (milliseconds),\n * (2) heap is reset between evaluations, and\n * (3) avoiding free list management simplifies allocator and improves performance.\n *\n * @param size - Number of bytes to allocate (must be > 0)\n * @returns Pointer to allocated memory\n * @throws Calls abort() on OUT_OF_MEMORY - this is a critical error that halts execution\n */\nexport function heapAlloc(size: usize): usize {\n  if (size == 0) return 0;\n\n  // Get current memory size in bytes (1 page = 64KB = 65536 bytes)\n  const memorySize: usize = (<usize>memory.size()) << 16;\n\n  // Align the heap pointer to 8-byte boundary\n  const alignedPtr = alignPtr(heapPointer, 8);\n\n  // Check for overflow when computing aligned pointer\n  // If alignedPtr wrapped around (became smaller than heapPointer), we've overflowed\n  if (alignedPtr < heapPointer) {\n    SetLastError(RuntimeErrorCode.OUT_OF_MEMORY);\n    return 0;\n  }\n\n  // Check for overflow when computing new heap pointer\n  // If newHeapPointer would wrap around, we've overflowed\n  const maxAllowedSize = memorySize - alignedPtr;\n  if (size > maxAllowedSize) {\n    SetLastError(RuntimeErrorCode.OUT_OF_MEMORY);\n    return 0;\n  }\n\n  const newHeapPointer = alignedPtr + size;\n\n  // Bounds check: ensure new heap pointer doesn't exceed memory\n  if (newHeapPointer > memorySize) {\n    SetLastError(RuntimeErrorCode.OUT_OF_MEMORY);\n    return 0;\n  }\n\n  // All checks passed, update heap pointer and return allocation\n  heapPointer = newHeapPointer;\n  return alignedPtr;\n}\n\n/**\n * Get the current heap pointer (next allocation will start here).\n *\n * @returns Current heap pointer address\n */\nexport function getHeapPointer(): usize {\n  return heapPointer;\n}\n\n/**\n * Reset the heap pointer to the start of the heap region.\n *\n * This allows reusing heap memory for multiple evaluations.\n */\nexport function resetHeap(): void {\n  heapPointer = HEAP_START;\n}\n\n/**\n * Save the current heap pointer state.\n *\n * @returns Current heap pointer address\n */\nexport function saveHeapPointer(): usize {\n  return heapPointer;\n}\n\n/**\n * Restore the heap pointer to a previously saved state.\n *\n * @param saved - Saved heap pointer address from saveHeapPointer()\n */\nexport function restoreHeapPointer(saved: usize): usize {\n  const old = heapPointer;\n  heapPointer = saved;\n  return old;\n}\n\n// ============================================================================\n// Pointer Utilities\n// ============================================================================\n\n/**\n * Align a pointer to the specified alignment boundary.\n *\n * @param ptr - Pointer to align\n * @param alignment - Alignment boundary (must be a power of 2)\n * @returns Aligned pointer\n */\nexport function alignPtr(ptr: usize, alignment: usize): usize {\n  return (ptr + alignment - 1) & ~(alignment - 1);\n}\n\n/**\n * Check if a pointer is null (0).\n *\n * @param ptr - Pointer to check\n * @returns true if pointer is 0, false otherwise\n */\nexport function isNullPtr(ptr: usize): bool {\n  return ptr == 0;\n}\n\n/**\n * Check if a pointer is valid (non-null and aligned).\n *\n * @param ptr - Pointer to check\n * @param alignment - Required alignment (default: 4 bytes)\n * @returns true if pointer is valid, false otherwise\n */\nexport function isValidPtr(ptr: usize, alignment: usize = 4): bool {\n  if (ptr == 0) return false;\n  return (ptr & (alignment - 1)) == 0;\n}\n\n// ============================================================================\n// Buffer Access Helpers\n// ============================================================================\n\n/**\n * Get the pointer to a schema hash field.\n *\n * @param basePtr - Base pointer of the buffer\n * @returns Pointer to the schema hash field\n */\nexport function getSchemaHashPtr(basePtr: usize): usize {\n  return basePtr;\n}\n\n/**\n * Read a schema hash from a buffer.\n *\n * @param basePtr - Base pointer of the buffer\n * @returns Schema hash as u64\n */\nexport function readSchemaHash(basePtr: usize): u64 {\n  return load<u64>(basePtr);\n}\n\n/**\n * Write a schema hash to a buffer.\n *\n * @param basePtr - Base pointer of the buffer\n * @param hash - Schema hash to write\n */\nexport function writeSchemaHash(basePtr: usize, hash: u64): void {\n  store<u64>(basePtr, hash);\n}\n\n/**\n * Get the pointer to a field in a fixed-size buffer.\n *\n * @param bufferPtr - Base pointer of the buffer\n * @param fieldOffset - Offset of the field from the buffer start\n * @returns Pointer to the field\n */\nexport function getFieldPtr(bufferPtr: usize, fieldOffset: usize): usize {\n  return bufferPtr + fieldOffset;\n}\n\n// ============================================================================\n// String Descriptor Helpers\n// ============================================================================\n\n/**\n * Get the offset and length components of a string descriptor.\n *\n * String descriptor format: [offset (4 bytes)] [length (4 bytes)]\n *\n * @param descPtr - Pointer to the string descriptor\n * @returns Object with offset and length\n */\nexport function readStringDesc(descPtr: usize): StringDesc {\n  return new StringDesc(load<u32>(descPtr), load<u32>(descPtr + 4));\n}\n\n/**\n * Write a string descriptor.\n *\n * @param descPtr - Pointer to the string descriptor\n * @param offset - Offset to the string data\n * @param length - Length of the string data\n */\nexport function writeStringDesc(descPtr: usize, offset: u32, length: u32): void {\n  store<u32>(descPtr, offset);\n  store<u32>(descPtr + 4, length);\n}\n\n/**\n * String descriptor structure.\n */\nexport class StringDesc {\n  offset: u32;\n  length: u32;\n\n  constructor(offset: u32, length: u32) {\n    this.offset = offset;\n    this.length = length;\n  }\n\n  isEmpty(): bool {\n    return this.length == 0;\n  }\n}\n\n// ============================================================================\n// Array Descriptor Helpers\n// ============================================================================\n\n/**\n * Get the offset and length components of an array descriptor.\n *\n * Array descriptor format: [offset (4 bytes)] [length (4 bytes)]\n *\n * @param descPtr - Pointer to the array descriptor\n * @returns Object with offset and length\n */\nexport function readArrayDesc(descPtr: usize): ArrayDesc {\n  return new ArrayDesc(load<u32>(descPtr), load<u32>(descPtr + 4));\n}\n\n/**\n * Write an array descriptor.\n *\n * @param descPtr - Pointer to the array descriptor\n * @param offset - Offset to the array data\n * @param length - Number of elements in the array\n */\nexport function writeArrayDesc(descPtr: usize, offset: u32, length: u32): void {\n  store<u32>(descPtr, offset);\n  store<u32>(descPtr + 4, length);\n}\n\n/**\n * Array descriptor structure.\n */\nexport class ArrayDesc {\n  offset: u32;\n  length: u32;\n\n  constructor(offset: u32, length: u32) {\n    this.offset = offset;\n    this.length = length;\n  }\n\n  isEmpty(): bool {\n    return this.length == 0;\n  }\n}\n\n// ============================================================================\n// Runtime Error Handling\n// ============================================================================\n\n// Error codes for runtime failures\nexport enum RuntimeErrorCode {\n  NONE = 0,\n  SCHEMA_MISMATCH = 1,\n  NULL_POINTER = 2,\n  INVALID_ACCESS = 3,\n  EVALUATION_ERROR = 4,\n  OUT_OF_MEMORY = 5,\n}\n\n// Last error that occurred during evaluation\nlet lastErrorCode: RuntimeErrorCode = RuntimeErrorCode.NONE;\n\n// Optional error message (allocated on heap for variable-length messages)\nlet errorMessagePtr: usize = 0;\n\n/**\n * Check if an error code represents a critical error that should abort execution.\n *\n * Critical errors are unrecoverable conditions where continuing execution would\n * likely lead to memory corruption, crashes, or incorrect results. These errors\n * call abort() to immediately halt the WASM module.\n *\n * Critical errors:\n * - OUT_OF_MEMORY: Memory allocation failed; continuing could corrupt state\n * - NULL_POINTER: Null pointer dereference; memory safety violation\n * - INVALID_ACCESS: Invalid memory access; memory safety violation\n *\n * Non-critical errors (set flag, caller must check hasError()):\n * - SCHEMA_MISMATCH: Input doesn't match schema; recoverable\n * - EVALUATION_ERROR: Logic error in decision evaluation; recoverable\n *\n * @param code - The error code to check\n * @returns true if the error is critical and should abort\n */\nexport function isCriticalError(code: RuntimeErrorCode): bool {\n  return (\n    code === RuntimeErrorCode.OUT_OF_MEMORY ||\n    code === RuntimeErrorCode.NULL_POINTER ||\n    code === RuntimeErrorCode.INVALID_ACCESS\n  );\n}\n\n/**\n * Get the last error code that occurred during evaluation.\n *\n * @returns The last error code\n */\nexport function getLastError(): RuntimeErrorCode {\n  return lastErrorCode;\n}\n\n/**\n * Set the last error code and optional message.\n *\n * For critical errors (OUT_OF_MEMORY, NULL_POINTER, INVALID_ACCESS), this function\n * calls abort() to immediately halt execution. Critical errors indicate unrecoverable\n * conditions where continuing would lead to memory corruption or undefined behavior.\n *\n * For non-critical errors (SCHEMA_MISMATCH, EVALUATION_ERROR), callers MUST check\n * hasError() after operations that can fail and handle the error appropriately.\n * Failure to check error state may result in incorrect evaluation results.\n *\n * @param code - The error code\n * @param message - Optional error message (allocated on heap)\n */\nexport function SetLastError(code: RuntimeErrorCode, message: usize = 0): void {\n  lastErrorCode = code;\n  errorMessagePtr = message;\n\n  // Critical errors abort immediately to prevent corrupted state propagation\n  if (isCriticalError(code)) {\n    abort();\n  }\n}\n\n/**\n * Clear the last error (reset to NONE).\n */\nexport function clearLastError(): void {\n  lastErrorCode = RuntimeErrorCode.NONE;\n  errorMessagePtr = 0;\n}\n\n/**\n * Set an error with a string message.\n *\n * This is a convenience function that combines SetLastError() with writeString().\n * The error message is allocated on the heap and will be freed by the next error.\n *\n * For critical errors (OUT_OF_MEMORY, NULL_POINTER, INVALID_ACCESS), this function\n * will call abort() after setting the error, immediately halting execution.\n *\n * For non-critical errors (SCHEMA_MISMATCH, EVALUATION_ERROR), callers MUST check\n * hasError() after operations that can fail.\n *\n * @param code - The error code\n * @param message - The error message string\n */\nexport function SetLastErrorWithMessage(code: RuntimeErrorCode, message: string): void {\n  const messagePtr = writeString(message);\n  SetLastError(code, messagePtr);\n}\n\n/**\n * Get the pointer to the error message.\n *\n * @returns Pointer to error message (0 if no message)\n */\nexport function getErrorMessagePtr(): usize {\n  return errorMessagePtr;\n}\n\n/**\n * Check if an error occurred.\n *\n * Callers MUST check this function after operations that can set non-critical errors\n * (SCHEMA_MISMATCH, EVALUATION_ERROR). Critical errors (OUT_OF_MEMORY, NULL_POINTER,\n * INVALID_ACCESS) abort immediately and never reach this check.\n *\n * Example usage:\n * ```assemblyscript\n * let result = someOperationThatCanFail();\n * if (hasError()) {\n *   // Handle error - return early, propagate error, etc.\n *   return Value.Null();\n * }\n * // Continue with valid result\n * ```\n *\n * @returns true if a non-critical error occurred, false otherwise\n */\nexport function hasError(): bool {\n  return lastErrorCode !== RuntimeErrorCode.NONE;\n}\n\n// ============================================================================\n// Memory Validation Helpers\n// ============================================================================\n\n/**\n * Check if a pointer is within the valid memory range.\n *\n * This is a basic check that can help catch out-of-bounds accesses.\n * Note: In production, you may want to disable these checks for performance.\n *\n * @param ptr - Pointer to check\n * @param size - Size of the region to check\n * @return true if pointer is within valid range, false otherwise\n */\nexport function isValidMemoryRange(ptr: usize, size: usize): bool {\n  if (ptr == 0) return false;\n\n  // Get current memory size (AssemblyScript runtime provides this)\n  const memorySize: usize = memory.size() << 16; // 1 page = 64KB\n\n  return ptr + size <= memorySize;\n}\n\n/**\n * Check if a pointer is within the input buffer region.\n *\n * @param ptr - Pointer to check\n * @return true if pointer is within input buffer, false otherwise\n */\nexport function isWithinInputBuffer(ptr: usize): bool {\n  return ptr >= INPUT_BUFFER_START && ptr < INPUT_VAR_START;\n}\n\n/**\n * Check if a pointer is within the input variable data region.\n *\n * @param ptr - Pointer to check\n * @return true if pointer is within input variable data, false otherwise\n */\nexport function isWithinInputVar(ptr: usize): bool {\n  return ptr >= INPUT_VAR_START && ptr < OUTPUT_START;\n}\n\n/**\n * Check if a pointer is within the output buffer region.\n *\n * @param ptr - Pointer to check\n * @return true if pointer is within output buffer, false otherwise\n */\nexport function isWithinOutputBuffer(ptr: usize): bool {\n  return ptr >= OUTPUT_START && ptr < OUTPUT_VAR_START;\n}\n\n/**\n * Check if a pointer is within the output variable data region.\n *\n * @param ptr - Pointer to check\n * @return true if pointer is within output variable data, false otherwise\n */\nexport function isWithinOutputVar(ptr: usize): bool {\n  return ptr >= OUTPUT_VAR_START && ptr < HEAP_START;\n}\n\n/**\n * Check if a pointer is within the heap region.\n *\n * @param ptr - Pointer to check\n * @return true if pointer is within heap, false otherwise\n */\nexport function isWithinHeap(ptr: usize): bool {\n  return ptr >= HEAP_START;\n}\n";
+var RUNTIME_STRINGS = "// assembly/runtime/strings.ts (AssemblyScript)\n// UTF-16 string handling for WASM linear memory\n\nimport { heapAlloc } from './memory';\n\n// ============================================================================\n// String Memory Format\n// ============================================================================\n\n/**\n * String memory layout: [length: u32][utf16 chars...]\n *\n * We use a length-prefixed format; this allows O(1) length checks and efficient substring\n * operations without scanning for null terminators. Also matches AssemblyScript's native\n * string representation. The first 4 bytes contain the length (number of UTF-16 code units).\n * Following that are the UTF-16 code units, each 2 bytes.\n */\n\n// ============================================================================\n// String Constants\n// ============================================================================\n\n/**\n * Size of the length field header in bytes.\n */\nexport const STRING_LENGTH_SIZE: usize = 4;\n\n/**\n * Size of each UTF-16 code unit in bytes.\n */\nexport const UTF16_CODE_UNIT_SIZE: usize = 2;\n\n/**\n * Minimum string length to use bulk memory operations.\n * For strings shorter than this, character-by-character writes are used\n * as the setup overhead dominates. For longer strings, bulk operations\n * provide significant performance benefits.\n */\nconst MIN_BULK_COPY_STRING_LENGTH: usize = 32;\n\n// ============================================================================\n// String Writing\n// ============================================================================\n\n/**\n * Write a string to memory and return its pointer.\n *\n * Memory is allocated from the runtime heap using heapAlloc().\n * The memory is aligned to 4 bytes for efficient access.\n *\n * @param s - The string to write to memory\n * @returns Pointer to the allocated string data, or 0 if allocation failed\n */\nexport function writeString(s: string): usize {\n  const len: usize = <usize>s.length;\n\n  // Calculate total size: length field (4 bytes) + UTF-16 characters (2 bytes each)\n  const totalSize = STRING_LENGTH_SIZE + len * UTF16_CODE_UNIT_SIZE;\n\n  // Four-byte alignment ensures proper alignment for u32 loads/stores, avoiding unaligned access\n  // penalties on some architectures. WASM requires aligned memory access for multi-byte types.\n  // Allocate memory from heap\n  const ptr = heapAlloc(totalSize);\n\n  // Return 0 if allocation failed\n  if (ptr == 0) {\n    return 0;\n  }\n\n  // Write length (number of UTF-16 code units)\n  store<u32>(ptr, len);\n\n  // Handle empty string case (len == 0)\n  if (len == 0) {\n    return ptr;\n  }\n\n  // For long strings, use bulk memory copy for better performance.\n  // AssemblyScript strings are internally UTF-16, matching our memory format.\n  if (len >= MIN_BULK_COPY_STRING_LENGTH) {\n    // Get pointer to the string's internal UTF-16 data\n    const srcPtr = changetype<usize>(s);\n    // Copy the UTF-16 data directly\n    memory.copy(ptr + STRING_LENGTH_SIZE, srcPtr, len * UTF16_CODE_UNIT_SIZE);\n  } else {\n    // For short strings, character-by-character writes avoid bulk operation overhead\n    for (let i: usize = 0; i < len; i++) {\n      const codeUnit: u16 = unchecked(<u16>s.charCodeAt(<i32>i));\n      store<u16>(ptr + STRING_LENGTH_SIZE + i * UTF16_CODE_UNIT_SIZE, codeUnit);\n    }\n  }\n\n  return ptr;\n}\n\n// ============================================================================\n// String Reading\n// ============================================================================\n\n/**\n * Read a string from memory.\n *\n * @param ptr - Pointer to the string data in memory\n * @returns The read string, or empty string if pointer is null\n */\nexport function readString(ptr: usize): string {\n  // Return empty string for null pointer\n  if (ptr == 0) {\n    return '';\n  }\n\n  // Read length (number of UTF-16 code units)\n  const len: usize = <usize>load<u32>(ptr);\n\n  // Handle empty string case\n  if (len == 0) {\n    return '';\n  }\n\n  // Use bulk memory read for O(n) performance instead of O(n\xB2) string concatenation.\n  // String.UTF16.decodeUnsafe reads UTF-16 data directly from memory in a single allocation,\n  // avoiding the repeated string allocations that occur with character-by-character concatenation.\n  return String.UTF16.decodeUnsafe(ptr + STRING_LENGTH_SIZE, len * UTF16_CODE_UNIT_SIZE);\n}\n\n// ============================================================================\n// String Utility Functions\n// ============================================================================\n\n/**\n * Calculate the size in bytes needed to store a string in memory.\n *\n * @param len - The length of the string (number of UTF-16 code units)\n * @returns The total size in bytes including the length header\n */\nexport function getStringSize(len: usize): usize {\n  return STRING_LENGTH_SIZE + len * UTF16_CODE_UNIT_SIZE;\n}\n\n/**\n * Calculate the length of a string from its pointer in memory.\n *\n * @param ptr - Pointer to the string data in memory\n * @returns The length of the string (number of UTF-16 code units), or 0 if null\n */\nexport function getStringLength(ptr: usize): usize {\n  if (ptr == 0) {\n    return 0;\n  }\n  return load<u32>(ptr);\n}\n\n/**\n * Check if a string pointer points to an empty string.\n *\n * @param ptr - Pointer to the string data in memory\n * @returns true if the string is empty or pointer is null, false otherwise\n */\nexport function isStringEmpty(ptr: usize): bool {\n  if (ptr == 0) {\n    return true;\n  }\n  return load<u32>(ptr) == 0;\n}\n\n/**\n * Compare two strings in memory.\n *\n * @param ptr1 - Pointer to the first string\n * @param ptr2 - Pointer to the second string\n * @returns true if the strings are equal, false otherwise\n */\nexport function stringsEqual(ptr1: usize, ptr2: usize): bool {\n  // If both are null, they're equal\n  if (ptr1 == 0 && ptr2 == 0) {\n    return true;\n  }\n\n  // If only one is null, they're not equal\n  if (ptr1 == 0 || ptr2 == 0) {\n    return false;\n  }\n\n  // Compare lengths\n  const len1 = load<u32>(ptr1);\n  const len2 = load<u32>(ptr2);\n\n  if (len1 != len2) {\n    return false;\n  }\n\n  // Compare each UTF-16 code unit\n  for (let i: usize = 0; i < <usize>len1; i++) {\n    const offset = STRING_LENGTH_SIZE + i * UTF16_CODE_UNIT_SIZE;\n    const char1 = load<u16>(ptr1 + offset);\n    const char2 = load<u16>(ptr2 + offset);\n    if (char1 != char2) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/**\n * Calculate a simple hash of a string in memory.\n *\n * This can be used for quick comparisons or deduplication.\n * Uses a simple polynomial rolling hash algorithm.\n *\n * @param ptr - Pointer to the string data in memory\n * @returns A hash value for the string (0 if null)\n */\nexport function hashString(ptr: usize): u32 {\n  if (ptr == 0) {\n    return 0;\n  }\n\n  const len: usize = <usize>load<u32>(ptr);\n  let hash: u32 = 5381;\n\n  for (let i: usize = 0; i < len; i++) {\n    const charCode = load<u16>(ptr + STRING_LENGTH_SIZE + i * UTF16_CODE_UNIT_SIZE);\n    hash = unchecked((hash << 5) + hash + unchecked(charCode)); // hash * 33 + charCode\n  }\n\n  return hash;\n}\n\n/**\n * Copy a string within memory.\n *\n * Creates a new copy of the string at a new location in the heap.\n *\n * @param srcPtr - Pointer to the source string\n * @returns Pointer to the newly allocated copy, or 0 if allocation failed\n */\nexport function copyString(srcPtr: usize): usize {\n  if (srcPtr == 0) {\n    return 0;\n  }\n\n  // Get the length of the source string\n  const len: usize = <usize>load<u32>(srcPtr);\n\n  // Calculate total size\n  const totalSize = STRING_LENGTH_SIZE + len * UTF16_CODE_UNIT_SIZE;\n\n  // Allocate new memory\n  const dstPtr = heapAlloc(totalSize);\n\n  if (dstPtr == 0) {\n    return 0;\n  }\n\n  // Copy the entire string data (length header + UTF-16 code units)\n  memory.copy(dstPtr, srcPtr, totalSize);\n\n  return dstPtr;\n}\n";
+var RUNTIME_ARRAYS = "// assembly/runtime/arrays.ts (AssemblyScript)\n// Array handling for WASM linear memory\n\nimport { heapAlloc } from './memory';\nimport { writeString, readString } from './strings';\nimport {\n  Value,\n  TYPE_NULL,\n  TYPE_BOOL,\n  TYPE_INT,\n  TYPE_FLOAT,\n  TYPE_STRING,\n  TYPE_ARRAY,\n  TYPE_OBJECT,\n} from './values';\n\n// ============================================================================\n// Array Constants\n// ============================================================================\n\n/**\n * Size of the length field header in bytes for arrays.\n */\nexport const ARRAY_LENGTH_SIZE: usize = 4;\n\n/**\n * Size of each F64 element in bytes.\n */\nexport const F64_ELEMENT_SIZE: usize = 8;\n\n/**\n * Size of each element pointer (usize) in bytes for generic arrays.\n */\nexport const ELEMENT_PTR_SIZE: usize = 4;\n\n/**\n * Size of the type tag field in bytes for serialized Values.\n */\nexport const VALUE_TYPE_SIZE: usize = 4;\n\n/**\n * Size of the bool field in bytes for serialized Values.\n */\nexport const VALUE_BOOL_SIZE: usize = 1;\n\n/**\n * Size of the int field in bytes for serialized Values.\n */\nexport const VALUE_INT_SIZE: usize = 8;\n\n/**\n * Size of the float field in bytes for serialized Values.\n */\nexport const VALUE_FLOAT_SIZE: usize = 8;\n\n/**\n * Size of the pointer field in bytes for serialized Values (string, array, object).\n */\nexport const VALUE_PTR_SIZE: usize = 4;\n\n// ============================================================================\n// F64 Array Handling\n// ============================================================================\n\n/**\n * Write a numeric array (Array<f64>) to memory.\n *\n * The array is stored in the format: [length: u32][f64 elements...]\n *\n * Memory is allocated from the runtime heap using heapAlloc().\n * The memory is aligned to 8 bytes for efficient access.\n *\n * @param arr - The array to write to memory\n * @returns Pointer to the allocated array data, or 0 if allocation failed\n */\nexport function writeF64Array(arr: Array<f64>): usize {\n  const len = <u32>arr.length;\n\n  // Calculate total size: length field (4 bytes) + f64 elements (8 bytes each)\n  const totalSize = ARRAY_LENGTH_SIZE + <usize>len * F64_ELEMENT_SIZE;\n\n  // Allocate memory from heap\n  const ptr = heapAlloc(totalSize);\n\n  // Return 0 if allocation failed\n  if (ptr == 0) {\n    return 0;\n  }\n\n  // Write length\n  store<u32>(ptr, len);\n\n  // Write each f64 element\n  for (let i: u32 = 0; i < len; i++) {\n    store<f64>(ptr + ARRAY_LENGTH_SIZE + <usize>i * F64_ELEMENT_SIZE, arr[i]);\n  }\n\n  return ptr;\n}\n\n/**\n * Read a numeric array (Array<f64>) from memory.\n *\n * The array must be stored in the format: [length: u32][f64 elements...]\n *\n * @param ptr - Pointer to the array data in memory\n * @returns The read array, or empty array if pointer is null\n */\nexport function readF64Array(ptr: usize): Array<f64> {\n  // Return empty array for null pointer\n  if (ptr == 0) {\n    return new Array<f64>();\n  }\n\n  // Read length\n  const len = load<u32>(ptr);\n\n  // Create array and populate it\n  const result = new Array<f64>(len);\n  for (let i: u32 = 0; i < len; i++) {\n    result[i] = load<f64>(ptr + ARRAY_LENGTH_SIZE + <usize>i * F64_ELEMENT_SIZE);\n  }\n\n  return result;\n}\n\n/**\n * Calculate the size in bytes needed to store an F64 array in memory.\n *\n * @param len - The length of the array\n * @returns The total size in bytes including the length header\n */\nexport function getF64ArraySize(len: usize): usize {\n  return ARRAY_LENGTH_SIZE + len * F64_ELEMENT_SIZE;\n}\n\n// ============================================================================\n// Value Serialization\n// ============================================================================\n\n/**\n * Write a Value to memory and return its pointer.\n *\n * For complex types (string/array/object), storing the actual data inline would make\n * Value structs variable-sized and unpredictable. Storing pointers provides fixed-size\n * Values (predictable offsets) while allowing arbitrary complex data on the heap.\n *\n * The Value is stored in the format: [type: u32][value_data...]\n *\n * For primitive types (bool, int, float), value_data is the actual value.\n * For complex types (string, array, object), value_data is a pointer to the data.\n *\n * Memory is allocated from the runtime heap using heapAlloc().\n *\n * @param v - The Value to write to memory\n * @returns Pointer to the allocated Value data, or 0 if allocation failed\n */\nexport function writeValue(v: Value): usize {\n  const type = v.type;\n\n  if (type == TYPE_NULL) {\n    // For null, just write the type tag\n    const ptr = heapAlloc(VALUE_TYPE_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    return ptr;\n  } else if (type == TYPE_BOOL) {\n    // Format: [type: u32][bool: u8]\n    const ptr = heapAlloc(VALUE_TYPE_SIZE + VALUE_BOOL_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    store<u8>(ptr + VALUE_TYPE_SIZE, v.boolVal ? 1 : 0);\n    return ptr;\n  } else if (type == TYPE_INT) {\n    // Format: [type: u32][int: i64]\n    const ptr = heapAlloc(VALUE_TYPE_SIZE + VALUE_INT_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    store<i64>(ptr + VALUE_TYPE_SIZE, v.intVal);\n    return ptr;\n  } else if (type == TYPE_FLOAT) {\n    // Format: [type: u32][float: f64]\n    const ptr = heapAlloc(VALUE_TYPE_SIZE + VALUE_FLOAT_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    store<f64>(ptr + VALUE_TYPE_SIZE, v.floatVal);\n    return ptr;\n  } else if (type == TYPE_STRING) {\n    // Format: [type: u32][stringPtr: u32]\n    const ptr = heapAlloc(VALUE_TYPE_SIZE + VALUE_PTR_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    const stringVal = v.stringVal != null ? v.stringVal! : '';\n    const stringPtr = writeString(stringVal);\n    store<u32>(ptr + VALUE_TYPE_SIZE, stringPtr);\n    return ptr;\n  } else if (type == TYPE_ARRAY) {\n    // Format: [type: u32][arrayPtr: u32]\n    const ptr = heapAlloc(VALUE_TYPE_SIZE + VALUE_PTR_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    const arrayVal = v.arrayVal != null ? v.arrayVal! : new Array<Value>();\n    const arrayPtr = writeValueArray(arrayVal);\n    store<u32>(ptr + VALUE_TYPE_SIZE, arrayPtr);\n    return ptr;\n  } else if (type == TYPE_OBJECT) {\n    // Format: [type: u32][objectPtr: u32]\n    const ptr = heapAlloc(VALUE_TYPE_SIZE + VALUE_PTR_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, type);\n    const objectVal = v.objectVal != null ? v.objectVal! : new Map<string, Value>();\n    const objectPtr = writeValueMap(objectVal);\n    store<u32>(ptr + VALUE_TYPE_SIZE, objectPtr);\n    return ptr;\n  }\n\n  return 0; // Unknown type\n}\n\n/**\n * Read a Value from memory.\n *\n * The Value must be stored in the format: [type: u32][value_data...]\n *\n * @param ptr - Pointer to the Value data in memory\n * @returns The read Value, or null if pointer is invalid\n */\nexport function readValue(ptr: usize): Value {\n  // Return null for null pointer\n  if (ptr == 0) {\n    return Value.Null();\n  }\n\n  // Read type\n  const type = load<u32>(ptr);\n\n  if (type == TYPE_NULL) {\n    return Value.Null();\n  } else if (type == TYPE_BOOL) {\n    const boolVal = load<u8>(ptr + VALUE_TYPE_SIZE) != 0;\n    return Value.Bool(boolVal);\n  } else if (type == TYPE_INT) {\n    const intVal = load<i64>(ptr + VALUE_TYPE_SIZE);\n    return Value.Int(intVal);\n  } else if (type == TYPE_FLOAT) {\n    const floatVal = load<f64>(ptr + VALUE_TYPE_SIZE);\n    return Value.Float(floatVal);\n  } else if (type == TYPE_STRING) {\n    const stringPtr = load<u32>(ptr + VALUE_TYPE_SIZE);\n    const stringVal = readString(stringPtr);\n    return Value.String(stringVal);\n  } else if (type == TYPE_ARRAY) {\n    const arrayPtr = load<u32>(ptr + VALUE_TYPE_SIZE);\n    const arrayVal = readValueArray(arrayPtr);\n    return Value.Array(arrayVal);\n  } else if (type == TYPE_OBJECT) {\n    const objectPtr = load<u32>(ptr + VALUE_TYPE_SIZE);\n    const objectVal = readValueMap(objectPtr);\n    return Value.Object(objectVal);\n  }\n\n  return Value.Null(); // Unknown type\n}\n\n// ============================================================================\n// Value Array Handling\n// ============================================================================\n\n// Format marker for flat numeric arrays (high bit set in length field)\nconst FLAT_ARRAY_MARKER: u32 = 0x80000000;\n\n/**\n * Detect if an array contains only floats/ints (homogeneous numeric array).\n *\n * @param arr - The array to check\n * @returns true if all elements are TYPE_FLOAT or TYPE_INT, false otherwise\n */\nfunction isHomogeneousNumericArray(arr: Array<Value>): bool {\n  const len = arr.length;\n  if (len == 0) return false;\n\n  for (let i = 0; i < len; i++) {\n    const type = arr[i].type;\n    if (type != TYPE_FLOAT && type != TYPE_INT) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Write a homogeneous numeric array in flat format.\n *\n * Format: [length | FLAT_ARRAY_MARKER: u32][f64 elements...]\n *\n * The high bit of the length field is set to indicate flat format.\n * This specialized format avoids individual Value allocations and type tags,\n * reducing memory overhead and fragmentation significantly.\n *\n * @param arr - The array to write (must be homogeneous numeric)\n * @returns Pointer to the allocated array data, or 0 if allocation failed\n */\nfunction writeHomogeneousNumericArray(arr: Array<Value>): usize {\n  const len = <u32>arr.length;\n\n  // Calculate total size: length with marker (4) + f64 elements (8 each)\n  const totalSize = ARRAY_LENGTH_SIZE + <usize>len * F64_ELEMENT_SIZE;\n\n  // Single allocation for entire array\n  const ptr = heapAlloc(totalSize);\n  if (ptr == 0) return 0;\n\n  // Write length with high bit set to indicate flat format\n  store<u32>(ptr, len | FLAT_ARRAY_MARKER);\n\n  // Write all numeric values as f64 directly (no Value wrapping)\n  for (let i: u32 = 0; i < len; i++) {\n    const val = arr[i];\n    const numVal = val.type == TYPE_FLOAT ? val.floatVal : <f64>val.intVal;\n    store<f64>(ptr + ARRAY_LENGTH_SIZE + <usize>i * F64_ELEMENT_SIZE, numVal);\n  }\n\n  return ptr;\n}\n\n/**\n * Read a homogeneous numeric array from flat format.\n *\n * Format: [length | FLAT_ARRAY_MARKER: u32][f64 elements...]\n *\n * @param ptr - Pointer to the array data in memory\n * @param len - The actual length (without the marker bit)\n * @returns The read array of Value objects\n */\nfunction readHomogeneousNumericArray(ptr: usize, len: u32): Array<Value> {\n  const result = new Array<Value>(len);\n\n  // Read all f64 values and wrap them as Value.Float\n  for (let i: u32 = 0; i < len; i++) {\n    const numVal = load<f64>(ptr + ARRAY_LENGTH_SIZE + <usize>i * F64_ELEMENT_SIZE);\n    result[i] = Value.Float(numVal);\n  }\n\n  return result;\n}\n\n/**\n * Write a Value array to memory.\n *\n * The array is stored in one of two formats:\n *\n * 1. Flat numeric format (for homogeneous numeric arrays):\n *    [length | FLAT_ARRAY_MARKER: u32][f64 elements...]\n *\n * 2. Generic format (for mixed-type arrays):\n *    [length: u32][Value pointers...]\n *\n * Homogeneous numeric arrays are detected and serialized using a flat format\n * that eliminates per-element allocations and type tags, significantly reducing\n * memory overhead (from ~16+ bytes per element to 8 bytes) and fragmentation.\n * The flat format is indicated by setting the high bit of the length field.\n *\n * Memory is allocated from the runtime heap using heapAlloc().\n *\n * @param arr - The array to write to memory\n * @returns Pointer to the allocated array data, or 0 if allocation failed\n */\nexport function writeValueArray(arr: Array<Value>): usize {\n  const len = <u32>arr.length;\n\n  // Empty array (generic format)\n  if (len == 0) {\n    const ptr = heapAlloc(ARRAY_LENGTH_SIZE);\n    if (ptr == 0) return 0;\n    store<u32>(ptr, 0);\n    return ptr;\n  }\n\n  // Optimization: detect homogeneous numeric arrays and use flat format\n  if (isHomogeneousNumericArray(arr)) {\n    return writeHomogeneousNumericArray(arr);\n  }\n\n  // Generic path: mixed-type array\n  // Format: [length: u32][Value pointers...]\n  const totalSize = ARRAY_LENGTH_SIZE + <usize>len * ELEMENT_PTR_SIZE;\n\n  const ptr = heapAlloc(totalSize);\n  if (ptr == 0) return 0;\n\n  store<u32>(ptr, len);\n\n  // Write each Value pointer\n  for (let i: u32 = 0; i < len; i++) {\n    const valuePtr = writeValue(arr[i]);\n    store<u32>(ptr + ARRAY_LENGTH_SIZE + <usize>i * ELEMENT_PTR_SIZE, valuePtr);\n  }\n\n  return ptr;\n}\n\n/**\n * Read a Value array from memory.\n *\n * Handles both flat numeric format and generic format:\n *\n * 1. Flat numeric format: [length | FLAT_ARRAY_MARKER: u32][f64 elements...]\n * 2. Generic format: [length: u32][Value pointers...]\n *\n * The format is detected by checking if the high bit of the length is set.\n *\n * @param ptr - Pointer to the array data in memory\n * @returns The read array, or empty array if pointer is null\n */\nexport function readValueArray(ptr: usize): Array<Value> {\n  // Return empty array for null pointer\n  if (ptr == 0) {\n    return new Array<Value>();\n  }\n\n  // Read length (with potential marker bit)\n  const lengthField = load<u32>(ptr);\n\n  // Check if this is a flat numeric array (high bit set)\n  if ((lengthField & FLAT_ARRAY_MARKER) != 0) {\n    // Flat numeric format - extract actual length\n    const len = lengthField & ~FLAT_ARRAY_MARKER;\n    return readHomogeneousNumericArray(ptr, len);\n  }\n\n  // Generic format - length is used as-is\n  const len = lengthField;\n\n  // Empty array\n  if (len == 0) {\n    return new Array<Value>();\n  }\n\n  // Read array of Value pointers\n  const result = new Array<Value>(len);\n  for (let i: u32 = 0; i < len; i++) {\n    const valuePtr = load<u32>(ptr + ARRAY_LENGTH_SIZE + <usize>i * ELEMENT_PTR_SIZE);\n    result[i] = readValue(valuePtr);\n  }\n\n  return result;\n}\n\n/**\n * Calculate the size in bytes needed to store a Value array in memory.\n *\n * Note: This calculates the size for the generic format.\n * For flat numeric arrays, the actual size may be different.\n *\n * @param len - The length of the array\n * @returns The total size in bytes including the length header (but not the individual Values)\n */\nexport function getValueArraySize(len: usize): usize {\n  return ARRAY_LENGTH_SIZE + len * ELEMENT_PTR_SIZE;\n}\n\n// ============================================================================\n// Value Map (Object) Handling\n// ============================================================================\n\n/**\n * Write a Value map to memory.\n *\n * The map is stored in the format: [length: u32][keyPtr1: u32][valuePtr1: u32][keyPtr2: u32][valuePtr2: u32]...\n *\n * Keys are always strings and written to memory separately using writeString().\n * Values are serialized using writeValue() separately.\n *\n * Memory is allocated from the runtime heap using heapAlloc().\n *\n * JavaScript object property order is insertion-ordered (ES2015+), so we must preserve\n * order when serializing to match JS semantics and ensure deterministic output.\n *\n * @param map - The map to write to memory\n * @returns Pointer to the allocated map data, or 0 if allocation failed\n */\nexport function writeValueMap(map: Map<string, Value>): usize {\n  const len = <u32>map.size;\n\n  // Calculate total size: length field (4 bytes) + key/value pairs (8 bytes each)\n  const totalSize = ARRAY_LENGTH_SIZE + <usize>len * 2 * ELEMENT_PTR_SIZE;\n\n  // Allocate memory from heap\n  const ptr = heapAlloc(totalSize);\n\n  // Return 0 if allocation failed\n  if (ptr == 0) {\n    return 0;\n  }\n\n  // Write length\n  store<u32>(ptr, len);\n\n  // Get keys and write each key/value pair\n  const keys = map.keys();\n  for (let i: u32 = 0; i < <u32>keys.length; i++) {\n    const key = keys[i];\n    const offset = ptr + ARRAY_LENGTH_SIZE + <usize>i * 2 * ELEMENT_PTR_SIZE;\n\n    // Write key pointer\n    const keyPtr = writeString(key);\n    store<u32>(offset, keyPtr);\n\n    // Write value pointer\n    const valuePtr = writeValue(map.get(key));\n    store<u32>(offset + ELEMENT_PTR_SIZE, valuePtr);\n  }\n\n  return ptr;\n}\n\n/**\n * Read a Value map from memory.\n *\n * The map must be stored in the format: [length: u32][keyPtr1: u32][valuePtr1: u32][keyPtr2: u32][valuePtr2: u32]...\n *\n * @param ptr - Pointer to the map data in memory\n * @returns The read map, or empty map if pointer is null\n */\nexport function readValueMap(ptr: usize): Map<string, Value> {\n  // Return empty map for null pointer\n  if (ptr == 0) {\n    return new Map<string, Value>();\n  }\n\n  // Read length\n  const len = load<u32>(ptr);\n\n  // Create map and populate it\n  const result = new Map<string, Value>();\n  for (let i: u32 = 0; i < len; i++) {\n    const keyPtr = load<u32>(ptr + ARRAY_LENGTH_SIZE + <usize>i * 2 * ELEMENT_PTR_SIZE);\n    const valuePtr = load<u32>(\n      ptr + ARRAY_LENGTH_SIZE + <usize>i * 2 * ELEMENT_PTR_SIZE + ELEMENT_PTR_SIZE,\n    );\n\n    const key = readString(keyPtr);\n    const value = readValue(valuePtr);\n\n    result.set(key, value);\n  }\n\n  return result;\n}\n\n// ============================================================================\n// Array Utility Functions\n// ============================================================================\n\n/**\n * Calculate the length of an array from its pointer in memory.\n *\n * @param ptr - Pointer to the array data in memory\n * @returns The length of the array, or 0 if null\n */\nexport function getArrayLength(ptr: usize): usize {\n  if (ptr == 0) {\n    return 0;\n  }\n  return load<u32>(ptr);\n}\n\n/**\n * Check if an array pointer points to an empty array.\n *\n * @param ptr - Pointer to the array data in memory\n * @returns true if the array is empty or pointer is null, false otherwise\n */\nexport function isArrayEmpty(ptr: usize): bool {\n  if (ptr == 0) {\n    return true;\n  }\n  return load<u32>(ptr) == 0;\n}\n";
 
 // src/compiler/cache.ts
 var packageVersion = "";
 function getPackageVersion() {
   if (packageVersion === "") {
     try {
-      const packagePath = join(dirname2(__dirname), "..", "package.json");
-      const pkg = JSON.parse(readFileSync2(packagePath, "utf-8"));
+      const packagePath = join(dirname(__dirname), "..", "package.json");
+      const pkg = JSON.parse(readFileSync(packagePath, "utf-8"));
       packageVersion = pkg.version || "unknown";
     } catch {
       packageVersion = "unknown";
@@ -8581,7 +10779,7 @@ function readCacheFromDisk(cacheKey) {
     return null;
   }
   try {
-    const content = readFileSync2(cachePath, "utf-8");
+    const content = readFileSync(cachePath, "utf-8");
     const entry = JSON.parse(content);
     if (entry.version !== getPackageVersion()) {
       unlinkSync(cachePath);
@@ -8795,8 +10993,8 @@ function createASCFileSystemCallbacks(virtualFS) {
       const key = baseDir ? `${baseDir}/${name}` : name;
       virtualFS.set(key, data2);
     },
-    listFiles(dirname3, baseDir) {
-      const prefix = baseDir ? `${baseDir}/${dirname3}` : dirname3;
+    listFiles(dirname2, baseDir) {
+      const prefix = baseDir ? `${baseDir}/${dirname2}` : dirname2;
       return [...virtualFS.keys()].filter((f) => f.startsWith(prefix));
     }
   };
@@ -10428,7 +12626,7 @@ function canonicalizeSchema(schema) {
 }
 
 // src/compiler/index.ts
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import path2 from "path";
 
 // src/compiler/ast-types.ts
@@ -12120,7 +14318,7 @@ function createFilesystemLoader(testDataRoot) {
     for (const basePath of possiblePaths) {
       try {
         const filePath = path2.join(basePath, key);
-        const content = readFileSync3(filePath, "utf-8");
+        const content = readFileSync2(filePath, "utf-8");
         return parseJDM(content);
       } catch (error) {
         if (isFileNotFoundError(error)) {