@elaraai/east 0.0.1-beta.9 → 1.0.0

package/dist/src/fuzz.js

@@ -4,18 +4,37 @@
  *
  * @remarks
  */
-import { NullType, BooleanType, IntegerType, FloatType, StringType, DateTimeType, BlobType, ArrayType, SetType, DictType, StructType, VariantType, OptionType, } from "./types.js";
+import { NullType, BooleanType, IntegerType, FloatType, StringType, DateTimeType, BlobType, ArrayType, SetType, DictType, StructType, VariantType, OptionType, RecursiveType, FunctionType, RefType, VectorType, MatrixType, } from "./types.js";
+import { matrix } from "./containers/matrix.js";
 import { isVariant, variant } from "./containers/variant.js";
 import { printType } from "./types.js";
 import { printFor } from "./serialization/east.js";
 import { toEastTypeValue } from "./type_of_type.js";
 import { ref } from "./containers/ref.js";
-// TODO generate RefType
-// TODO generate RecursiveType
+/**
+ * Generates a random primitive East type.
+ */
+function randomPrimitiveType() {
+    const r = Math.random() * 7;
+    if (r < 1)
+        return NullType;
+    if (r < 2)
+        return BooleanType;
+    if (r < 3)
+        return IntegerType;
+    if (r < 4)
+        return FloatType;
+    if (r < 5)
+        return StringType;
+    if (r < 6)
+        return DateTimeType;
+    return BlobType;
+}
 /**
  * Generates a random East type for fuzz testing.
  *
  * @param depth - Current nesting depth (used internally to limit recursion)
+ * @param options - Configuration options
  * @returns A randomly generated {@link EastType}
  *
  * @remarks
@@ -25,34 +44,28 @@ import { ref } from "./containers/ref.js";
  * - Sets and Dicts use {@link StringType} keys (immutability constraint)
  * - Structs have 0-4 random fields
  * - Variants have 1-3 random cases, with 30% chance of {@link OptionType}
+ * - Recursive types include linked lists, trees, and option-wrapped patterns
+ * - Function types have 0-3 arguments with random input/output types
  */
-export function randomType(depth = 0) {
+export function randomType(depth = 0, options = {}) {
+    const { includeRecursive = true, includeFunctions = true } = options;
     // Limit nesting to avoid stack overflow and keep tests fast
     const maxDepth = 3;
     // Higher chance of primitives at deeper levels
     const primitiveWeight = depth >= maxDepth ? 0.9 : 0.5;
     if (Math.random() < primitiveWeight) {
-        // Primitive type
-        const r = Math.random() * 7;
-        if (r < 1)
-            return NullType;
-        if (r < 2)
-            return BooleanType;
-        if (r < 3)
-            return IntegerType;
-        if (r < 4)
-            return FloatType;
-        if (r < 5)
-            return StringType;
-        if (r < 6)
-            return DateTimeType;
-        return BlobType;
-    }
-    // Complex type
-    const r = Math.random() * 5;
+        return randomPrimitiveType();
+    }
+    // Complex type - weights adjusted based on options
+    let totalWeight = 7; // Array, Set, Dict, Struct, Variant, Vector, Matrix
+    if (includeRecursive && depth === 0)
+        totalWeight += 1; // Recursive only at top level
+    if (includeFunctions)
+        totalWeight += 1;
+    const r = Math.random() * totalWeight;
     if (r < 1) {
         // Array
-        return ArrayType(randomType(depth + 1));
+        return ArrayType(randomType(depth + 1, { includeRecursive: false, includeFunctions: false }));
     }
     else if (r < 2) {
         // Set (keys must be immutable)
@@ -60,39 +73,167 @@ export function randomType(depth = 0) {
     }
     else if (r < 3) {
         // Dict (keys must be immutable)
-        return DictType(StringType, randomType(depth + 1));
+        return DictType(StringType, randomType(depth + 1, { includeRecursive: false, includeFunctions: false }));
     }
     else if (r < 4) {
         // Struct with 0-4 fields
         const fieldCount = Math.floor(Math.random() * 5);
         const fields = {};
         for (let i = 0; i < fieldCount; i++) {
-            fields[`field${i}`] = randomType(depth + 1);
+            fields[`field${i}`] = randomType(depth + 1, { includeRecursive: false, includeFunctions: false });
         }
         return StructType(fields);
     }
-    else {
+    else if (r < 5) {
         // Variant
         if (Math.random() < 0.3) {
             // Option type (common variant pattern)
-            return OptionType(randomType(depth + 1));
+            return OptionType(randomType(depth + 1, { includeRecursive: false, includeFunctions: false }));
         }
         else {
             // Custom variant with 1-3 cases
             const caseCount = 1 + Math.floor(Math.random() * 3);
             const cases = {};
             for (let i = 0; i < caseCount; i++) {
-                cases[`case${i}`] = randomType(depth + 1);
+                cases[`case${i}`] = randomType(depth + 1, { includeRecursive: false, includeFunctions: false });
             }
             return VariantType(cases);
         }
     }
+    else if (r < 6) {
+        // Vector with random numeric element type
+        const elemTypes = [FloatType, IntegerType, BooleanType];
+        return VectorType(elemTypes[Math.floor(Math.random() * elemTypes.length)]);
+    }
+    else if (r < 7) {
+        // Matrix with random numeric element type
+        const elemTypes = [FloatType, IntegerType, BooleanType];
+        return MatrixType(elemTypes[Math.floor(Math.random() * elemTypes.length)]);
+    }
+    else if (r < 8 && includeRecursive && depth === 0) {
+        // Recursive type - only at top level to avoid nested recursion complexity
+        return randomRecursiveType();
+    }
+    else {
+        // Function type
+        return randomFunctionType();
+    }
 }
-export function randomValueFor(type) {
-    // Convert EastTypeValue to EastType if needed
-    if (!isVariant(type)) {
-        type = toEastTypeValue(type);
+/**
+ * Generates a random recursive type pattern.
+ *
+ * @returns A randomly generated {@link RecursiveType}
+ *
+ * @remarks
+ * Generates common recursive patterns:
+ * - Linked list: `rec t. <nil: Null, cons: (head: T, tail: t)>`
+ * - Tree: `rec t. (value: T, children: Array<t>)`
+ * - Option chain: `rec t. (value: T, next: Option<t>)`
+ * - Binary tree: `rec t. <leaf: T, node: (left: t, right: t)>`
+ * - Nested variant: `rec t. <a: T, b: (inner: t)>`
+ */
+export function randomRecursiveType() {
+    const innerType = randomPrimitiveType();
+    const pattern = Math.floor(Math.random() * 5);
+    switch (pattern) {
+        case 0:
+            // Linked list: rec t. <nil: Null, cons: (head: T, tail: t)>
+            return RecursiveType((self) => VariantType({
+                nil: NullType,
+                cons: StructType({ head: innerType, tail: self }),
+            }));
+        case 1:
+            // Tree with children array: rec t. (value: T, children: Array<t>)
+            return RecursiveType((self) => StructType({
+                value: innerType,
+                children: ArrayType(self),
+            }));
+        case 2:
+            // Option chain: rec t. (value: T, next: Option<t>)
+            return RecursiveType((self) => StructType({
+                value: innerType,
+                next: OptionType(self),
+            }));
+        case 3:
+            // Binary tree: rec t. <leaf: T, node: (left: t, right: t)>
+            return RecursiveType((self) => VariantType({
+                leaf: innerType,
+                node: StructType({ left: self, right: self }),
+            }));
+        case 4:
+        default:
+            // Nested variant with ref: rec t. <done: T, more: Ref<t>>
+            return RecursiveType((self) => VariantType({
+                done: innerType,
+                more: RefType(self),
+            }));
     }
+}
+/**
+ * Generates a random function type.
+ *
+ * @returns A randomly generated {@link FunctionType}
+ *
+ * @remarks
+ * Functions have 0-3 arguments with random primitive or simple types.
+ * Output types are also kept simple to avoid excessive nesting.
+ */
+export function randomFunctionType() {
+    const argCount = Math.floor(Math.random() * 4);
+    const args = [];
+    for (let i = 0; i < argCount; i++) {
+        // Use simple types for arguments to keep things manageable
+        const argType = Math.random() < 0.7
+            ? randomPrimitiveType()
+            : ArrayType(randomPrimitiveType());
+        args.push(argType);
+    }
+    // Output type - also keep simple
+    const outputType = Math.random() < 0.7
+        ? randomPrimitiveType()
+        : StructType({
+            result: randomPrimitiveType(),
+            status: BooleanType,
+        });
+    return FunctionType(args, outputType);
+}
+/**
+ * Check if a type contains any `.Recursive n` back-references.
+ * A type without recursive refs is "terminal" - it won't cause infinite recursion.
+ * @internal
+ */
+function containsRecursive(type) {
+    switch (type.type) {
+        case "Recursive":
+            return true;
+        case "Ref":
+        case "Array":
+            return containsRecursive(type.value);
+        case "Set":
+            return containsRecursive(type.value);
+        case "Dict":
+            return containsRecursive(type.value.key) || containsRecursive(type.value.value);
+        case "Struct":
+            return type.value.some(f => containsRecursive(f.type));
+        case "Variant":
+            return type.value.some(c => containsRecursive(c.type));
+        case "Vector":
+        case "Matrix":
+        default:
+            // Primitives, vectors, matrices, functions don't contain recursive refs
+            return false;
+    }
+}
+/**
+ * Internal helper that generates random values with explicit depth passing.
+ * Returns a function that takes depth and produces a value.
+ *
+ * This design passes depth explicitly through all generators, avoiding the bug
+ * where shared mutable depth state was incorrectly restored after generating
+ * sibling fields in structs.
+ * @internal
+ */
+function buildValueGenerator(type, ctx) {
     if (type.type === "Never") {
         throw new Error("Cannot generate values for Never type");
     }
@@ -100,13 +241,13 @@ export function randomValueFor(type) {
         return () => null;
     }
     else if (type.type === "Boolean") {
-        return (() => Math.random() < 0.5);
+        return () => Math.random() < 0.5;
     }
     else if (type.type === "Integer") {
-        return (() => BigInt(Math.floor(Math.random() * 200) - 100));
+        return () => BigInt(Math.floor(Math.random() * 200) - 100);
     }
     else if (type.type === "Float") {
-        return (() => {
+        return () => {
             const r = Math.random();
             if (r < 0.05)
                 return NaN;
@@ -119,98 +260,287 @@ export function randomValueFor(type) {
             if (r < 0.25)
                 return -0.0;
             return Math.random() * 200 - 100;
-        });
+        };
     }
     else if (type.type === "String") {
-        return (() => {
+        return () => {
             const length = Math.floor(Math.random() * 20);
             if (length === 0)
                 return "";
             return Math.random().toString(36).substring(2, 2 + length);
-        });
+        };
     }
     else if (type.type === "DateTime") {
-        return (() => {
+        return () => {
             const year2025 = new Date("2025-01-01T00:00:00.000Z").valueOf();
             const oneYear = 1000 * 60 * 60 * 24 * 365;
             return new Date(year2025 + Math.floor(Math.random() * oneYear));
-        });
+        };
     }
     else if (type.type === "Blob") {
-        return (() => {
-            const length = Math.floor(Math.random() * 100); // Keep small for speed
+        return () => {
+            const length = Math.floor(Math.random() * 100);
             const arr = new Uint8Array(length);
             for (let i = 0; i < length; i++) {
                 arr[i] = Math.floor(Math.random() * 256);
             }
             return arr;
-        });
+        };
     }
     else if (type.type === "Ref") {
-        const valueFn = randomValueFor(type.value);
-        return (() => ref(valueFn()));
+        // Create function shell, push, recurse, pop - like apply.ts pattern
+        let valueGen;
+        const ret = (depth) => ref(valueGen(depth));
+        valueGen = buildValueGenerator(type.value, ctx);
+        return ret;
     }
     else if (type.type === "Array") {
-        const itemFn = randomValueFor(type.value);
-        return (() => {
-            const length = Math.floor(Math.random() * 5);
-            return Array.from({ length }, itemFn);
-        });
+        let itemGen;
+        const ret = (depth) => {
+            const maxLen = depth >= ctx.maxDepth ? 0 : Math.max(1, 5 - depth);
+            const length = Math.floor(Math.random() * (maxLen + 1));
+            return Array.from({ length }, () => itemGen(depth));
+        };
+        itemGen = buildValueGenerator(type.value, ctx);
+        return ret;
     }
     else if (type.type === "Set") {
-        const itemFn = randomValueFor(type.value);
-        return (() => {
-            const length = Math.floor(Math.random() * 5);
+        let itemGen;
+        const ret = (depth) => {
+            const maxLen = depth >= ctx.maxDepth ? 0 : 5;
+            const length = Math.floor(Math.random() * (maxLen + 1));
             const set = new Set();
             for (let i = 0; i < length; i++) {
-                set.add(itemFn());
+                set.add(itemGen(depth));
             }
             return set;
-        });
+        };
+        itemGen = buildValueGenerator(type.value, ctx);
+        return ret;
     }
     else if (type.type === "Dict") {
-        const keyFn = randomValueFor(type.value.key);
-        const valueFn = randomValueFor(type.value.value);
-        return (() => {
-            const length = Math.floor(Math.random() * 5);
+        let keyGen;
+        let valueGen;
+        const ret = (depth) => {
+            const maxLen = depth >= ctx.maxDepth ? 0 : 5;
+            const length = Math.floor(Math.random() * (maxLen + 1));
             const dict = new Map();
             for (let i = 0; i < length; i++) {
-                dict.set(keyFn(), valueFn());
+                dict.set(keyGen(depth), valueGen(depth));
             }
             return dict;
-        });
+        };
+        keyGen = buildValueGenerator(type.value.key, ctx);
+        valueGen = buildValueGenerator(type.value.value, ctx);
+        return ret;
     }
     else if (type.type === "Struct") {
-        const fieldFns = Object.fromEntries(type.value.map(({ name, type: fieldType }) => [name, randomValueFor(fieldType)]));
-        return (() => {
+        let fieldGens;
+        const ret = (depth) => {
             const obj = {};
-            for (const [key, fn] of Object.entries(fieldFns)) {
-                obj[key] = fn();
+            for (const { name, gen } of fieldGens) {
+                obj[name] = gen(depth);
             }
             return obj;
-        });
+        };
+        fieldGens = type.value.map(({ name, type: fieldType }) => ({
+            name,
+            gen: buildValueGenerator(fieldType, ctx),
+        }));
+        return ret;
     }
     else if (type.type === "Variant") {
-        const caseKeys = type.value.map(({ name }) => name);
-        const caseFns = Object.fromEntries(type.value.map(({ name, type: caseType }) => [name, randomValueFor(caseType)]));
-        return (() => {
-            const caseKey = caseKeys[Math.floor(Math.random() * caseKeys.length)];
-            return variant(caseKey, caseFns[caseKey]());
-        });
+        let caseInfos;
+        const ret = (depth) => {
+            const terminalCases = caseInfos.filter((c) => c.isTerminal);
+            const nonTerminalCases = caseInfos.filter((c) => !c.isTerminal);
+            let chosen;
+            if (depth >= ctx.maxDepth && terminalCases.length > 0) {
+                chosen = terminalCases[Math.floor(Math.random() * terminalCases.length)];
+            }
+            else if (terminalCases.length > 0 && nonTerminalCases.length > 0) {
+                const terminalProb = Math.min(0.3 + depth * 0.2, 0.9);
+                if (Math.random() < terminalProb) {
+                    chosen = terminalCases[Math.floor(Math.random() * terminalCases.length)];
+                }
+                else {
+                    chosen = nonTerminalCases[Math.floor(Math.random() * nonTerminalCases.length)];
+                }
+            }
+            else {
+                chosen = caseInfos[Math.floor(Math.random() * caseInfos.length)];
+            }
+            return variant(chosen.name, chosen.gen(depth));
+        };
+        caseInfos = type.value.map(({ name, type: caseType }) => ({
+            name,
+            gen: buildValueGenerator(caseType, ctx),
+            isTerminal: !containsRecursive(caseType),
+        }));
+        return ret;
+    }
+    else if (type.type === "Recursive" && type.value.type === "wrapper") {
+        // Recursive wrapper: register by id, build inner
+        let inner;
+        const ret = (...args) => inner(...args);
+        ctx.generators.set(type.value.value.id, ret);
+        inner = buildValueGenerator(type.value.value.inner, ctx);
+        return ret;
     }
     else if (type.type === "Recursive") {
-        throw new Error("Cannot generate values for Recursive type");
+        // Look up the generator by type id
+        const id = type.value.value;
+        const generator = ctx.generators.get(id);
+        if (!generator) {
+            throw new Error(`Recursive generator not found for id ${id}`);
+        }
+        // Return a generator that calls the captured recursive generator with depth+1
+        return (depth) => generator(depth + 1);
     }
     else if (type.type === "Function") {
-        throw new Error("Cannot generate values for Function type");
+        let outputGen;
+        const ret = (depth) => {
+            return (..._args) => outputGen(depth);
+        };
+        outputGen = buildValueGenerator(type.value.output, ctx);
+        return ret;
     }
     else if (type.type === "AsyncFunction") {
-        throw new Error("Cannot generate values for AsyncFunction type");
+        let outputGen;
+        const ret = (depth) => {
+            return (..._args) => Promise.resolve(outputGen(depth));
+        };
+        outputGen = buildValueGenerator(type.value.output, ctx);
+        return ret;
+    }
+    else if (type.type === "Vector") {
+        const elemType = type.value;
+        return () => {
+            const length = Math.floor(Math.random() * 10);
+            if (elemType.type === "Float") {
+                const arr = new Float64Array(length);
+                for (let i = 0; i < length; i++) {
+                    const r = Math.random();
+                    if (r < 0.05)
+                        arr[i] = NaN;
+                    else if (r < 0.10)
+                        arr[i] = Infinity;
+                    else if (r < 0.15)
+                        arr[i] = -Infinity;
+                    else
+                        arr[i] = Math.random() * 200 - 100;
+                }
+                return arr;
+            }
+            else if (elemType.type === "Integer") {
+                const arr = new BigInt64Array(length);
+                for (let i = 0; i < length; i++)
+                    arr[i] = BigInt(Math.floor(Math.random() * 200) - 100);
+                return arr;
+            }
+            else {
+                const arr = new Uint8ClampedArray(length);
+                for (let i = 0; i < length; i++)
+                    arr[i] = Math.random() < 0.5 ? 1 : 0;
+                return arr;
+            }
+        };
+    }
+    else if (type.type === "Matrix") {
+        const elemType = type.value;
+        return () => {
+            const rows = Math.floor(Math.random() * 5);
+            const cols = rows === 0 ? 0 : Math.floor(Math.random() * 5);
+            const totalLen = rows * cols;
+            if (elemType.type === "Float") {
+                const data = new Float64Array(totalLen);
+                for (let i = 0; i < totalLen; i++) {
+                    const r = Math.random();
+                    if (r < 0.05)
+                        data[i] = NaN;
+                    else if (r < 0.10)
+                        data[i] = Infinity;
+                    else if (r < 0.15)
+                        data[i] = -Infinity;
+                    else
+                        data[i] = Math.random() * 200 - 100;
+                }
+                return matrix(data, rows, cols);
+            }
+            else if (elemType.type === "Integer") {
+                const data = new BigInt64Array(totalLen);
+                for (let i = 0; i < totalLen; i++)
+                    data[i] = BigInt(Math.floor(Math.random() * 200) - 100);
+                return matrix(data, rows, cols);
+            }
+            else {
+                const data = new Uint8ClampedArray(totalLen);
+                for (let i = 0; i < totalLen; i++)
+                    data[i] = Math.random() < 0.5 ? 1 : 0;
+                return matrix(data, rows, cols);
+            }
+        };
     }
     else {
         throw new Error(`Unhandled type: ${printType(type)}`);
     }
 }
+/**
+ * Internal helper to handle RecursiveType before conversion.
+ * Sets up the context stack and builds the value generator.
+ *
+ * The key insight: we create the generator function first, register it in the
+ * context stack, then build the inner generator. This allows the inner generator
+ * to find the outer generator via de Bruijn index lookup when it hits a
+ * `.Recursive n` back-reference.
+ * @internal
+ */
+function randomValueForRecursive(innerNode, ctx) {
+    // The inner generator - will be set after building
+    let innerGen = null;
+    // Create the self-referential generator
+    // This will be called when we hit a .Recursive n back-reference
+    const selfGenerator = (depth) => {
+        if (!innerGen) {
+            throw new Error("Internal error: recursive generator not initialized");
+        }
+        // Hard limit to prevent stack overflow
+        if (depth > ctx.maxDepth + 5) {
+            throw new Error("Fuzz value generation exceeded max recursion depth");
+        }
+        return innerGen(depth);
+    };
+    // Push BEFORE building the inner generator so .Recursive can find it
+    // Convert inner node to EastTypeValue with recursive context
+    // Pass empty stack - the type structure will build up the stack naturally
+    // as it recurses. When self-references (RecursiveType pointing back) are hit,
+    // they'll find the struct in the stack and return .Recursive indices.
+    const innerTypeValue = toEastTypeValue(innerNode, [], true);
+    // Build the inner generator
+    innerGen = buildValueGenerator(innerTypeValue, ctx);
+    // Pop after building (generator is now self-contained via closure)
+    // Return a function that starts generation at depth 0
+    return () => selfGenerator(0);
+}
+export function randomValueFor(type) {
+    const ctx = {
+        generators: new Map(),
+        maxDepth: 5, // Limit recursion depth to avoid huge values
+    };
+    // Check if this is an EastType (not yet converted)
+    if (!isVariant(type)) {
+        // Handle RecursiveType specially before conversion
+        if (type.type === "Recursive") {
+            return randomValueForRecursive(type.node, ctx);
+        }
+        // Convert other EastTypes to EastTypeValue
+        const typeValue = toEastTypeValue(type);
+        const gen = buildValueGenerator(typeValue, ctx);
+        return () => gen(0);
+    }
+    const gen = buildValueGenerator(type, ctx);
+    return () => gen(0);
+}
 /**
  * Runs a fuzz test over a generic function parameterized by a type.
  *
@@ -247,7 +577,9 @@ export function randomValueFor(type) {
  * );
  * ```
  */
-export async function fuzzerTest(fn, n_types = 100, n_samples = 10) {
+export async function fuzzerTest(fn, n_types = 100, n_samples = 10, options = {}) {
+    // Default: include recursive types but NOT functions (can't generate values for functions)
+    const { includeRecursive = true, includeFunctions = false } = options;
     let n_type_success = 0;
     let n_type_fail = 0;
     const type_cache = new Set();
@@ -258,7 +590,7 @@ export async function fuzzerTest(fn, n_types = 100, n_samples = 10) {
         let type;
         let attempts = 0;
         while (true) {
-            type = randomType();
+            type = randomType(0, { includeRecursive, includeFunctions });
             const typeStr = printType(type);
             if (!type_cache.has(typeStr)) {
                 type_cache.add(typeStr);