@elaraai/east 0.0.1-beta.8 → 1.0.0

package/dist/src/serialization/east.js

@@ -3,6 +3,7 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 import { printIdentifier, TypeWiden, isTypeEqual, NeverType, NullType, BooleanType, IntegerType, FloatType, StringType, DateTimeType, BlobType, ArrayType, SetType, DictType, StructType, VariantType } from "../types.js";
+import { matrix } from "../containers/matrix.js";
 import { compareFor } from "../comparison.js";
 import { SortedMap } from "../containers/sortedmap.js";
 import { SortedSet } from "../containers/sortedset.js";
@@ -139,7 +140,7 @@ export function decodeEastFor(type) {
         }
     };
 }
-export function printFor(type, typeCtx = []) {
+export function printFor(type, typeCtx = new Map()) {
     // Convert EastType to EastTypeValue if necessary
     if (!isVariant(type)) {
         type = toEastTypeValue(type);
@@ -199,9 +200,7 @@ export function printFor(type, typeCtx = []) {
             ctx.currentPath.pop();
             return `&${str}`;
         };
-        typeCtx.push(ret);
         value_printer = printFor(type.value, typeCtx);
-        typeCtx.pop();
         return ret;
     }
     else if (type.type === "Array") {
@@ -224,9 +223,7 @@ export function printFor(type, typeCtx = []) {
             }
             return `[${parts.join(", ")}]`;
         };
-        typeCtx.push(ret);
         value_printer = printFor(type.value, typeCtx);
-        typeCtx.pop();
         return ret;
     }
     else if (type.type === "Set") {
@@ -276,9 +273,7 @@ export function printFor(type, typeCtx = []) {
             }
             return `{${parts.join(",")}}`;
         };
-        typeCtx.push(ret);
         value_printer = printFor(type.value.value, typeCtx);
-        typeCtx.pop();
         return ret;
     }
     else if (type.type === "Struct") {
@@ -295,11 +290,9 @@ export function printFor(type, typeCtx = []) {
             }
             return `(${parts.join(", ")})`;
         };
-        typeCtx.push(ret);
         for (const { name: k, type: t } of type.value) {
             field_printers.push([k, printFor(t, typeCtx)]);
         }
-        typeCtx.pop();
         return ret;
     }
     else if (type.type === "Variant") {
@@ -311,7 +304,6 @@ export function printFor(type, typeCtx = []) {
             ctx.currentPath.pop();
             return result;
         };
-        typeCtx.push(ret);
         for (const { name: k, type: t } of type.value) {
             if (t.type === "Null") {
                 const prefix = `.${printIdentifier(k)}`;
@@ -323,7 +315,6 @@ export function printFor(type, typeCtx = []) {
                 case_printers[k] = (value, ctx) => prefix + print_data(value, ctx);
             }
         }
-        typeCtx.pop();
         return ret;
     }
     else if (type.type === "Function") {
@@ -334,8 +325,42 @@ export function printFor(type, typeCtx = []) {
         // This is just a convenience printer - async functions cannot be serialized/deserialized
         return (_, _ctx) => `async (${type.value.inputs.map((x) => printTypeValue(x)).join(", ")}) => ${printTypeValue(type.value.output)}`;
     }
+    else if (type.type === "Vector") {
+        const elementPrinter = printFor(type.value, typeCtx);
+        const isBoolean = type.value.type === "Boolean";
+        return (v, _ctx) => {
+            const parts = [];
+            for (let i = 0; i < v.length; i++) {
+                parts.push(elementPrinter(isBoolean ? v[i] !== 0 : v[i]));
+            }
+            return `vec[${parts.join(", ")}]`;
+        };
+    }
+    else if (type.type === "Matrix") {
+        const elementPrinter = printFor(type.value, typeCtx);
+        const isBoolean = type.value.type === "Boolean";
+        return (v, _ctx) => {
+            const { data, rows, cols } = v;
+            const rowParts = [];
+            for (let r = 0; r < rows; r++) {
+                const elemParts = [];
+                for (let c = 0; c < cols; c++) {
+                    elemParts.push(elementPrinter(isBoolean ? data[r * cols + c] !== 0 : data[r * cols + c]));
+                }
+                rowParts.push(`[${elemParts.join(", ")}]`);
+            }
+            return `mat[${rowParts.join(", ")}]`;
+        };
+    }
+    else if (type.type === "Recursive" && type.value.type === "wrapper") {
+        let inner;
+        const ret = (...args) => inner(...args);
+        typeCtx.set(type.value.value.id, ret);
+        inner = printFor(type.value.value.inner, typeCtx);
+        return ret;
+    }
     else if (type.type === "Recursive") {
-        const ret = typeCtx[typeCtx.length - Number(type.value)];
+        const ret = typeCtx.get(type.value.value);
         if (ret === undefined) {
             throw new Error(`Internal error: Recursive type context not found`);
         }
@@ -406,7 +431,7 @@ const consumeWhitespace = (input, pos) => {
     }
     return pos;
 };
-const createParser = (type, frozen, typeCtx = []) => {
+const createParser = (type, frozen, typeCtx = new Map()) => {
     switch (type.type) {
         case "Null":
             return parseNull;
@@ -438,10 +463,21 @@ const createParser = (type, frozen, typeCtx = []) => {
             throw new Error(`Cannot parse .Function`);
         case "AsyncFunction":
             throw new Error(`Cannot parse .AsyncFunction`);
+        case "Vector":
+            return createVectorParser(type.value, frozen);
+        case "Matrix":
+            return createMatrixParser(type.value, frozen);
         case "Never":
             return (_input, pos, _ctx) => { throw new ParseError(`Attempted to parse value of type .Never`, pos); };
         case "Recursive":
-            const ret = typeCtx[typeCtx.length - Number(type.value)];
+            if (type.value.type === "wrapper") {
+                let inner;
+                const wrapRet = (...args) => inner(...args);
+                typeCtx.set(type.value.value.id, wrapRet);
+                inner = createParser(type.value.value.inner, frozen, typeCtx);
+                return wrapRet;
+            }
+            const ret = typeCtx.get(type.value.value);
             if (ret === undefined) {
                 throw new Error(`Internal error: Recursive type context not found`);
             }
@@ -456,7 +492,7 @@ const parseInteger = (input, pos, _ctx) => {
         throw new ParseError("expected integer, got end of input", pos);
     }
     let start = pos;
-    if (input[pos] === '-') {
+    if (input[pos] === '-' || input[pos] === '+') {
         pos++;
     }
     let hasDigits = false;
@@ -471,7 +507,8 @@ const parseInteger = (input, pos, _ctx) => {
     const intStr = input.slice(start, pos);
     let value;
     try {
-        value = BigInt(intStr);
+        // BigInt() rejects a leading '+', so strip it before constructing.
+        value = BigInt(intStr[0] === '+' ? intStr.slice(1) : intStr);
     }
     catch {
         // BigInt() throws if the string is invalid (shouldn't happen given our parsing logic)
@@ -793,9 +830,7 @@ const createRefParser = (value_type, frozen, typeCtx) => {
         r.value = value;
         return { value: r, position };
     };
-    typeCtx.push(ret);
     valueParser = createParser(value_type, frozen, typeCtx);
-    typeCtx.pop();
     return ret;
 };
 const createArrayParser = (value_type, frozen, typeCtx) => {
@@ -862,9 +897,7 @@ const createArrayParser = (value_type, frozen, typeCtx) => {
             elementIndex++;
         }
     };
-    typeCtx.push(ret);
     valueParser = createParser(value_type, frozen, typeCtx);
-    typeCtx.pop();
     return ret;
 };
 const createSetParser = (key_type, frozen, typeCtx) => {
@@ -1027,9 +1060,7 @@ const createDictParser = (key_type, value_type, frozen, typeCtx) => {
             entryIndex++;
         }
     };
-    typeCtx.push(ret);
     valueParser = createParser(value_type, frozen, typeCtx);
-    typeCtx.pop();
     return ret;
 };
 const parseQuotedIdentifier = (input, pos, _ctx) => {
@@ -1199,11 +1230,9 @@ const createStructParser = (fields, frozen, typeCtx) => {
         }
         return { value: result, position: pos + 1 };
     };
-    typeCtx.push(ret);
     for (const field of fields) {
         fieldParsers.push(createParser(field.type, frozen, typeCtx));
     }
-    typeCtx.pop();
     return ret;
 };
 const createVariantParser = (cases, frozen, typeCtx) => {
@@ -1256,7 +1285,6 @@ const createVariantParser = (cases, frozen, typeCtx) => {
                 ctx.currentPath.pop();
         }
     };
-    typeCtx.push(ret);
     for (const { name, type: caseType } of cases) {
         if (caseType.type === 'Null') {
             // Special case for null type - the "null" is actually optional
@@ -1279,9 +1307,133 @@ const createVariantParser = (cases, frozen, typeCtx) => {
             caseParsers[name] = createParser(caseType, frozen, typeCtx);
         }
     }
-    typeCtx.pop();
     return ret;
 };
+const createVectorParser = (element_type, frozen) => {
+    const elementParser = createParser(element_type, frozen);
+    return (input, pos, _ctx) => {
+        pos = consumeWhitespace(input, pos);
+        if (!input.startsWith('vec[', pos)) {
+            throw new ParseError("expected 'vec[' to start vector", pos);
+        }
+        pos = consumeWhitespace(input, pos + 4);
+        const values = [];
+        // Handle empty vector
+        if (input[pos] === ']') {
+            return { value: _createTypedArray(element_type, values, frozen), position: pos + 1 };
+        }
+        let elementIndex = 0;
+        while (true) {
+            try {
+                const { value: elementValue, position: elementPos } = elementParser(input, pos);
+                values.push(elementValue);
+                pos = consumeWhitespace(input, elementPos);
+            }
+            catch (e) {
+                if (e instanceof ParseError) {
+                    const newPath = `[${elementIndex}]` + (e.path ? e.path : '');
+                    throw new ParseError(e.message, e.position, newPath);
+                }
+                throw e;
+            }
+            if (input[pos] === ']') {
+                return { value: _createTypedArray(element_type, values, frozen), position: pos + 1 };
+            }
+            if (input[pos] !== ',') {
+                throw new ParseError("expected ',' or ']' after vector element", pos);
+            }
+            pos = consumeWhitespace(input, pos + 1);
+            elementIndex++;
+        }
+    };
+};
+const createMatrixParser = (element_type, frozen) => {
+    const elementParser = createParser(element_type, frozen);
+    return (input, pos, _ctx) => {
+        pos = consumeWhitespace(input, pos);
+        if (!input.startsWith('mat[', pos)) {
+            throw new ParseError("expected 'mat[' to start matrix", pos);
+        }
+        pos = consumeWhitespace(input, pos + 4);
+        const rows = [];
+        // Handle empty matrix
+        if (input[pos] === ']') {
+            return { value: matrix(_createTypedArray(element_type, [], frozen), 0, 0), position: pos + 1 };
+        }
+        while (true) {
+            // Parse a row: [elem, elem, ...]
+            pos = consumeWhitespace(input, pos);
+            if (input[pos] !== '[') {
+                throw new ParseError("expected '[' to start matrix row", pos);
+            }
+            pos = consumeWhitespace(input, pos + 1);
+            const row = [];
+            // Handle empty row
+            if (input[pos] !== ']') {
+                let colIndex = 0;
+                while (true) {
+                    try {
+                        const { value: elementValue, position: elementPos } = elementParser(input, pos);
+                        row.push(elementValue);
+                        pos = consumeWhitespace(input, elementPos);
+                    }
+                    catch (e) {
+                        if (e instanceof ParseError) {
+                            const newPath = `[${rows.length}][${colIndex}]` + (e.path ? e.path : '');
+                            throw new ParseError(e.message, e.position, newPath);
+                        }
+                        throw e;
+                    }
+                    if (input[pos] === ']') {
+                        break;
+                    }
+                    if (input[pos] !== ',') {
+                        throw new ParseError("expected ',' or ']' after matrix element", pos);
+                    }
+                    pos = consumeWhitespace(input, pos + 1);
+                    colIndex++;
+                }
+            }
+            pos = consumeWhitespace(input, pos + 1); // consume ']'
+            rows.push(row);
+            if (input[pos] === ']') {
+                // Validate all rows have the same number of columns
+                const numCols = rows.length > 0 ? rows[0].length : 0;
+                for (let i = 1; i < rows.length; i++) {
+                    if (rows[i].length !== numCols) {
+                        throw new ParseError(`matrix row ${i} has ${rows[i].length} columns, expected ${numCols}`, pos);
+                    }
+                }
+                const flat = rows.flat();
+                const numRows = rows.length;
+                return { value: matrix(_createTypedArray(element_type, flat, frozen), numRows, numCols), position: pos + 1 };
+            }
+            if (input[pos] !== ',') {
+                throw new ParseError("expected ',' or ']' after matrix row", pos);
+            }
+            pos = consumeWhitespace(input, pos + 1);
+        }
+    };
+};
+function _createTypedArray(element_type, values, frozen) {
+    let result;
+    if (element_type.type === "Float") {
+        result = new Float64Array(values);
+    }
+    else if (element_type.type === "Integer") {
+        result = new BigInt64Array(values);
+    }
+    else if (element_type.type === "Boolean") {
+        result = new Uint8ClampedArray(values.map(v => v ? 1 : 0));
+    }
+    else {
+        throw new Error(`Unsupported vector/matrix element type: ${element_type.type}`);
+    }
+    if (frozen) {
+        Object.freeze(result);
+    }
+    return result;
+}
 /**
  * Parse an East value and infer its type from the syntax.
  *