@elaraai/east 1.0.65 → 1.0.67

package/dist/src/compile.js

@@ -1363,6 +1363,40 @@ function allocateTypedArray(elementType, length) {
         return new Uint8ClampedArray(length);
     throw new Error(`Unsupported vector element type: ${elementType.type}`);
 }
+/** Wraps to East's 64-bit Integer semantics */
+function wrapI64(x) {
+    return BigInt.asIntN(64, x);
+}
+/** Throws unless the vector/matrix element type parameter is Float or Integer */
+function requireNumericElem(builtin, T, loc_id, source_map) {
+    if (T.type !== "Float" && T.type !== "Integer") {
+        throw new EastError(`${builtin} requires Float or Integer elements`, { location: (source_map?.resolve(loc_id) ?? []) });
+    }
+    return T.type;
+}
+/** Throws the shared length-mismatch error for elementwise vector operands */
+function requireSameLength(a, b, loc_id, source_map) {
+    if (a.length !== b.length) {
+        throw new EastError(`Vector length mismatch (${a.length} vs ${b.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
+    }
+}
+/** Throws the shared dimension-mismatch error for elementwise matrix operands */
+function requireSameDims(a, b, loc_id, source_map) {
+    if (a.rows !== b.rows || a.cols !== b.cols) {
+        throw new EastError(`Matrix dimension mismatch (${a.rows}x${a.cols} vs ${b.rows}x${b.cols})`, { location: (source_map?.resolve(loc_id) ?? []) });
+    }
+}
+/** Validates the sparse-accumulator invariant: parallel lengths and strictly ascending indices */
+function requireSparse(ix, v, loc_id, source_map) {
+    if (ix.length !== v.length) {
+        throw new EastError(`Sparse index and value lengths differ (${ix.length} vs ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
+    }
+    for (let i = 1; i < ix.length; i++) {
+        if (ix[i] <= ix[i - 1]) {
+            throw new EastError(`Sparse index vector must be strictly ascending`, { location: (source_map?.resolve(loc_id) ?? []) });
+        }
+    }
+}
 /** Creates the appropriate TypedArray for a given element type */
 function createTypedArray(elementType, values) {
     if (elementType.type === "Float") {
@@ -3510,6 +3544,483 @@ const builtin_evaluators = {
         }
         return acc;
     },
+    // Vector elementwise arithmetic + reductions. Reductions fold in index
+    // order, left to right — part of the cross-runtime contract, since a
+    // reassociated float sum gives a different last bit.
+    VectorScale: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorScale", T, loc_id, source_map);
+        return (v, alpha) => {
+            if (elem === "Float") {
+                const result = new Float64Array(v.length);
+                for (let i = 0; i < v.length; i++)
+                    result[i] = v[i] * alpha;
+                return result;
+            }
+            const result = new BigInt64Array(v.length);
+            for (let i = 0; i < v.length; i++)
+                result[i] = wrapI64(v[i] * alpha);
+            return result;
+        };
+    },
+    VectorSum: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorSum", T, loc_id, source_map);
+        return (v) => {
+            if (elem === "Float") {
+                let acc = 0;
+                for (let i = 0; i < v.length; i++)
+                    acc += v[i];
+                return acc;
+            }
+            let acc = 0n;
+            for (let i = 0; i < v.length; i++)
+                acc = wrapI64(acc + v[i]);
+            return acc;
+        };
+    },
+    VectorAddScaled: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorAddScaled", T, loc_id, source_map);
+        return (a, b, alpha) => {
+            requireSameLength(a, b, loc_id, source_map);
+            if (elem === "Float") {
+                const result = new Float64Array(a.length);
+                for (let i = 0; i < a.length; i++)
+                    result[i] = a[i] + alpha * b[i];
+                return result;
+            }
+            const result = new BigInt64Array(a.length);
+            for (let i = 0; i < a.length; i++)
+                result[i] = wrapI64(a[i] + wrapI64(alpha * b[i]));
+            return result;
+        };
+    },
+    VectorMul: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorMul", T, loc_id, source_map);
+        return (a, b) => {
+            requireSameLength(a, b, loc_id, source_map);
+            if (elem === "Float") {
+                const result = new Float64Array(a.length);
+                for (let i = 0; i < a.length; i++)
+                    result[i] = a[i] * b[i];
+                return result;
+            }
+            const result = new BigInt64Array(a.length);
+            for (let i = 0; i < a.length; i++)
+                result[i] = wrapI64(a[i] * b[i]);
+            return result;
+        };
+    },
+    VectorAddScalar: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorAddScalar", T, loc_id, source_map);
+        return (v, c) => {
+            if (elem === "Float") {
+                const result = new Float64Array(v.length);
+                for (let i = 0; i < v.length; i++)
+                    result[i] = v[i] + c;
+                return result;
+            }
+            const result = new BigInt64Array(v.length);
+            for (let i = 0; i < v.length; i++)
+                result[i] = wrapI64(v[i] + c);
+            return result;
+        };
+    },
+    VectorDot: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorDot", T, loc_id, source_map);
+        return (a, b) => {
+            requireSameLength(a, b, loc_id, source_map);
+            if (elem === "Float") {
+                let acc = 0;
+                for (let i = 0; i < a.length; i++)
+                    acc += a[i] * b[i];
+                return acc;
+            }
+            let acc = 0n;
+            for (let i = 0; i < a.length; i++)
+                acc = wrapI64(acc + wrapI64(a[i] * b[i]));
+            return acc;
+        };
+    },
+    VectorMax: (loc_id, source_map, _platformDef, T) => {
+        requireNumericElem("VectorMax", T, loc_id, source_map);
+        const less = lessFor(T);
+        return (v) => {
+            if (v.length === 0) {
+                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            let best = v[0];
+            for (let i = 1; i < v.length; i++) {
+                if (less(best, v[i]))
+                    best = v[i];
+            }
+            return best;
+        };
+    },
+    VectorMin: (loc_id, source_map, _platformDef, T) => {
+        requireNumericElem("VectorMin", T, loc_id, source_map);
+        const less = lessFor(T);
+        return (v) => {
+            if (v.length === 0) {
+                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            let best = v[0];
+            for (let i = 1; i < v.length; i++) {
+                if (less(v[i], best))
+                    best = v[i];
+            }
+            return best;
+        };
+    },
+    VectorArgMax: (loc_id, source_map, _platformDef, T) => {
+        requireNumericElem("VectorArgMax", T, loc_id, source_map);
+        const less = lessFor(T);
+        return (v) => {
+            if (v.length === 0) {
+                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            let bestIdx = 0;
+            for (let i = 1; i < v.length; i++) {
+                if (less(v[bestIdx], v[i]))
+                    bestIdx = i;
+            }
+            return BigInt(bestIdx);
+        };
+    },
+    VectorArgMin: (loc_id, source_map, _platformDef, T) => {
+        requireNumericElem("VectorArgMin", T, loc_id, source_map);
+        const less = lessFor(T);
+        return (v) => {
+            if (v.length === 0) {
+                throw new EastError("Cannot reduce empty Vector", { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            let bestIdx = 0;
+            for (let i = 1; i < v.length; i++) {
+                if (less(v[i], v[bestIdx]))
+                    bestIdx = i;
+            }
+            return BigInt(bestIdx);
+        };
+    },
+    VectorMean: (loc_id, source_map, _platformDef, T) => {
+        requireNumericElem("VectorMean", T, loc_id, source_map);
+        return (v) => {
+            let acc = 0;
+            for (let i = 0; i < v.length; i++)
+                acc += Number(v[i]);
+            return acc / v.length;
+        };
+    },
+    VectorCumSum: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorCumSum", T, loc_id, source_map);
+        return (v) => {
+            if (elem === "Float") {
+                const result = new Float64Array(v.length);
+                let acc = 0;
+                for (let i = 0; i < v.length; i++) {
+                    acc += v[i];
+                    result[i] = acc;
+                }
+                return result;
+            }
+            const result = new BigInt64Array(v.length);
+            let acc = 0n;
+            for (let i = 0; i < v.length; i++) {
+                acc = wrapI64(acc + v[i]);
+                result[i] = acc;
+            }
+            return result;
+        };
+    },
+    VectorAbs: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorAbs", T, loc_id, source_map);
+        return (v) => {
+            if (elem === "Float") {
+                const result = new Float64Array(v.length);
+                for (let i = 0; i < v.length; i++) {
+                    const x = v[i];
+                    result[i] = x < 0 ? -x : x;
+                }
+                return result;
+            }
+            const result = new BigInt64Array(v.length);
+            for (let i = 0; i < v.length; i++) {
+                const x = v[i];
+                result[i] = wrapI64(x < 0n ? -x : x);
+            }
+            return result;
+        };
+    },
+    VectorClamp: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorClamp", T, loc_id, source_map);
+        const less = lessFor(T);
+        return (v, lo, hi) => {
+            const result = elem === "Float" ? new Float64Array(v.length) : new BigInt64Array(v.length);
+            for (let i = 0; i < v.length; i++) {
+                const x = v[i];
+                result[i] = less(x, lo) ? lo : less(hi, x) ? hi : x;
+            }
+            return result;
+        };
+    },
+    // Vector gather/scatter and sorted search
+    VectorGather: (loc_id, source_map, _platformDef, T) => (v, idx) => {
+        const result = allocateTypedArray(T, idx.length);
+        for (let j = 0; j < idx.length; j++) {
+            const i = Number(idx[j]);
+            if (i < 0 || i >= v.length) {
+                throw new EastError(`Vector index ${idx[j]} out of bounds (length ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            result[j] = v[i];
+        }
+        return result;
+    },
+    VectorScatterAdd: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("VectorScatterAdd", T, loc_id, source_map);
+        return (dst, idx, src) => {
+            requireSameLength(idx, src, loc_id, source_map);
+            const result = dst.slice();
+            for (let j = 0; j < idx.length; j++) {
+                const i = Number(idx[j]);
+                if (i < 0 || i >= dst.length) {
+                    throw new EastError(`Vector index ${idx[j]} out of bounds (length ${dst.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
+                }
+                if (elem === "Float") {
+                    result[i] = (result[i]) + src[j];
+                }
+                else {
+                    result[i] = wrapI64((result[i]) + src[j]);
+                }
+            }
+            return result;
+        };
+    },
+    VectorSearchSorted: (loc_id, source_map, _platformDef, T) => {
+        const less = lessFor(T);
+        const readElem = T.type === "Boolean"
+            ? (v, i) => v[i] !== 0
+            : (v, i) => v[i];
+        return (haystack, needles) => {
+            const result = new BigInt64Array(needles.length);
+            for (let j = 0; j < needles.length; j++) {
+                const needle = readElem(needles, j);
+                let lo = 0;
+                let hi = haystack.length;
+                while (lo < hi) {
+                    const mid = (lo + hi) >>> 1;
+                    if (less(readElem(haystack, mid), needle)) {
+                        lo = mid + 1;
+                    }
+                    else {
+                        hi = mid;
+                    }
+                }
+                result[j] = BigInt(lo);
+            }
+            return result;
+        };
+    },
+    // Vector masks and selection (comparisons use East's total order)
+    VectorEq: (loc_id, source_map, _platformDef, T) => {
+        const equal = equalFor(T);
+        const readElem = T.type === "Boolean"
+            ? (v, i) => v[i] !== 0
+            : (v, i) => v[i];
+        return (a, b) => {
+            requireSameLength(a, b, loc_id, source_map);
+            const result = new Uint8ClampedArray(a.length);
+            for (let i = 0; i < a.length; i++)
+                result[i] = equal(readElem(a, i), readElem(b, i)) ? 1 : 0;
+            return result;
+        };
+    },
+    VectorLt: (loc_id, source_map, _platformDef, T) => {
+        const less = lessFor(T);
+        const readElem = T.type === "Boolean"
+            ? (v, i) => v[i] !== 0
+            : (v, i) => v[i];
+        return (a, b) => {
+            requireSameLength(a, b, loc_id, source_map);
+            const result = new Uint8ClampedArray(a.length);
+            for (let i = 0; i < a.length; i++)
+                result[i] = less(readElem(a, i), readElem(b, i)) ? 1 : 0;
+            return result;
+        };
+    },
+    VectorGt: (loc_id, source_map, _platformDef, T) => {
+        const greater = greaterFor(T);
+        const readElem = T.type === "Boolean"
+            ? (v, i) => v[i] !== 0
+            : (v, i) => v[i];
+        return (a, b) => {
+            requireSameLength(a, b, loc_id, source_map);
+            const result = new Uint8ClampedArray(a.length);
+            for (let i = 0; i < a.length; i++)
+                result[i] = greater(readElem(a, i), readElem(b, i)) ? 1 : 0;
+            return result;
+        };
+    },
+    VectorSelect: (loc_id, source_map, _platformDef, T) => (mask, a, b) => {
+        requireSameLength(mask, a, loc_id, source_map);
+        requireSameLength(a, b, loc_id, source_map);
+        const result = allocateTypedArray(T, mask.length);
+        for (let i = 0; i < mask.length; i++)
+            result[i] = (mask[i] !== 0 ? a[i] : b[i]);
+        return result;
+    },
+    VectorCompress: (loc_id, source_map, _platformDef, T) => (mask, v) => {
+        requireSameLength(mask, v, loc_id, source_map);
+        let count = 0;
+        for (let i = 0; i < mask.length; i++) {
+            if (mask[i] !== 0)
+                count++;
+        }
+        const result = allocateTypedArray(T, count);
+        let j = 0;
+        for (let i = 0; i < mask.length; i++) {
+            if (mask[i] !== 0)
+                result[j++] = v[i];
+        }
+        return result;
+    },
+    VectorCountTrue: (_loc_id, _source_map, _platformDef) => (mask) => {
+        let count = 0n;
+        for (let i = 0; i < mask.length; i++) {
+            if (mask[i] !== 0)
+                count += 1n;
+        }
+        return count;
+    },
+    // Sparse accumulators: parallel (ix, v) with strictly ascending ix.
+    // Entries absent from a side are structurally absent, not explicit zeros:
+    // an A-only entry passes through unscaled, a B-only entry contributes
+    // alpha*vB even when alpha is NaN or infinite.
+    SparseAxpy: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("SparseAxpy", T, loc_id, source_map);
+        return (ixA, vA, ixB, vB, alpha) => {
+            requireSparse(ixA, vA, loc_id, source_map);
+            requireSparse(ixB, vB, loc_id, source_map);
+            let count = 0;
+            let i = 0;
+            let j = 0;
+            while (i < ixA.length && j < ixB.length) {
+                const a = ixA[i];
+                const b = ixB[j];
+                if (a < b)
+                    i++;
+                else if (b < a)
+                    j++;
+                else {
+                    i++;
+                    j++;
+                }
+                count++;
+            }
+            count += (ixA.length - i) + (ixB.length - j);
+            const outIx = new BigInt64Array(count);
+            const outV = elem === "Float" ? new Float64Array(count) : new BigInt64Array(count);
+            i = 0;
+            j = 0;
+            let k = 0;
+            while (i < ixA.length && j < ixB.length) {
+                const a = ixA[i];
+                const b = ixB[j];
+                if (a < b) {
+                    outIx[k] = a;
+                    outV[k] = vA[i];
+                    i++;
+                }
+                else if (b < a) {
+                    outIx[k] = b;
+                    outV[k] = elem === "Float" ? alpha * vB[j] : wrapI64(alpha * vB[j]);
+                    j++;
+                }
+                else {
+                    outIx[k] = a;
+                    outV[k] = elem === "Float"
+                        ? vA[i] + alpha * vB[j]
+                        : wrapI64(vA[i] + wrapI64(alpha * vB[j]));
+                    i++;
+                    j++;
+                }
+                k++;
+            }
+            for (; i < ixA.length; i++, k++) {
+                outIx[k] = ixA[i];
+                outV[k] = vA[i];
+            }
+            for (; j < ixB.length; j++, k++) {
+                outIx[k] = ixB[j];
+                outV[k] = elem === "Float" ? alpha * vB[j] : wrapI64(alpha * vB[j]);
+            }
+            return { ix: outIx, v: outV };
+        };
+    },
+    SparseFromPairs: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("SparseFromPairs", T, loc_id, source_map);
+        return (ix, v) => {
+            if (ix.length !== v.length) {
+                throw new EastError(`Sparse index and value lengths differ (${ix.length} vs ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            // Stable: order by (index, original position) so equal indices
+            // accumulate in input order and the float result is deterministic.
+            const order = new Array(ix.length);
+            for (let i = 0; i < ix.length; i++)
+                order[i] = i;
+            order.sort((p, q) => {
+                const a = ix[p];
+                const b = ix[q];
+                if (a < b)
+                    return -1;
+                if (a > b)
+                    return 1;
+                return p - q;
+            });
+            let count = 0;
+            for (let i = 0; i < order.length; i++) {
+                if (i === 0 || ix[order[i]] !== ix[order[i - 1]])
+                    count++;
+            }
+            const outIx = new BigInt64Array(count);
+            const outV = elem === "Float" ? new Float64Array(count) : new BigInt64Array(count);
+            let k = -1;
+            for (let i = 0; i < order.length; i++) {
+                const p = order[i];
+                if (i === 0 || ix[p] !== outIx[k]) {
+                    k++;
+                    outIx[k] = ix[p];
+                    outV[k] = v[p];
+                }
+                else {
+                    outV[k] = elem === "Float"
+                        ? (outV[k]) + v[p]
+                        : wrapI64((outV[k]) + v[p]);
+                }
+            }
+            return { ix: outIx, v: outV };
+        };
+    },
+    SparseFilterGt: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("SparseFilterGt", T, loc_id, source_map);
+        const greater = greaterFor(T);
+        return (ix, v, threshold) => {
+            requireSparse(ix, v, loc_id, source_map);
+            let count = 0;
+            for (let i = 0; i < v.length; i++) {
+                if (greater(v[i], threshold))
+                    count++;
+            }
+            const outIx = new BigInt64Array(count);
+            const outV = elem === "Float" ? new Float64Array(count) : new BigInt64Array(count);
+            let k = 0;
+            for (let i = 0; i < v.length; i++) {
+                if (greater(v[i], threshold)) {
+                    outIx[k] = ix[i];
+                    outV[k] = v[i];
+                    k++;
+                }
+            }
+            return { ix: outIx, v: outV };
+        };
+    },
     // Matrix builtins
     MatrixRows: (_loc_id, _source_map, _platformDef, _T) => (m) => BigInt(m.rows),
     MatrixCols: (_loc_id, _source_map, _platformDef, _T) => (m) => BigInt(m.cols),
@@ -3677,6 +4188,137 @@ const builtin_evaluators = {
             data.set(arr[r], r * cols);
         return matrix(data, arr.length, cols);
     },
+    // Matrix elementwise arithmetic + reductions. Sums accumulate in ascending
+    // index order (row-major for whole-matrix walks, ascending row for column
+    // sums, ascending column within each row for row sums and vec-mul) — the
+    // same left-to-right contract as the Vector reductions.
+    MatrixScale: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("MatrixScale", T, loc_id, source_map);
+        return (m, alpha) => {
+            const src = m.data;
+            if (elem === "Float") {
+                const data = new Float64Array(src.length);
+                for (let i = 0; i < src.length; i++)
+                    data[i] = src[i] * alpha;
+                return matrix(data, m.rows, m.cols);
+            }
+            const data = new BigInt64Array(src.length);
+            for (let i = 0; i < src.length; i++)
+                data[i] = wrapI64(src[i] * alpha);
+            return matrix(data, m.rows, m.cols);
+        };
+    },
+    MatrixAddScaled: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("MatrixAddScaled", T, loc_id, source_map);
+        return (a, b, alpha) => {
+            requireSameDims(a, b, loc_id, source_map);
+            const ad = a.data;
+            const bd = b.data;
+            if (elem === "Float") {
+                const data = new Float64Array(ad.length);
+                for (let i = 0; i < ad.length; i++)
+                    data[i] = ad[i] + alpha * bd[i];
+                return matrix(data, a.rows, a.cols);
+            }
+            const data = new BigInt64Array(ad.length);
+            for (let i = 0; i < ad.length; i++)
+                data[i] = wrapI64(ad[i] + wrapI64(alpha * bd[i]));
+            return matrix(data, a.rows, a.cols);
+        };
+    },
+    MatrixMulElementwise: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("MatrixMulElementwise", T, loc_id, source_map);
+        return (a, b) => {
+            requireSameDims(a, b, loc_id, source_map);
+            const ad = a.data;
+            const bd = b.data;
+            if (elem === "Float") {
+                const data = new Float64Array(ad.length);
+                for (let i = 0; i < ad.length; i++)
+                    data[i] = ad[i] * bd[i];
+                return matrix(data, a.rows, a.cols);
+            }
+            const data = new BigInt64Array(ad.length);
+            for (let i = 0; i < ad.length; i++)
+                data[i] = wrapI64(ad[i] * bd[i]);
+            return matrix(data, a.rows, a.cols);
+        };
+    },
+    MatrixRowSums: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("MatrixRowSums", T, loc_id, source_map);
+        return (m) => {
+            const src = m.data;
+            if (elem === "Float") {
+                const result = new Float64Array(m.rows);
+                for (let r = 0; r < m.rows; r++) {
+                    let acc = 0;
+                    for (let c = 0; c < m.cols; c++)
+                        acc += src[r * m.cols + c];
+                    result[r] = acc;
+                }
+                return result;
+            }
+            const result = new BigInt64Array(m.rows);
+            for (let r = 0; r < m.rows; r++) {
+                let acc = 0n;
+                for (let c = 0; c < m.cols; c++)
+                    acc = wrapI64(acc + src[r * m.cols + c]);
+                result[r] = acc;
+            }
+            return result;
+        };
+    },
+    MatrixColSums: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("MatrixColSums", T, loc_id, source_map);
+        return (m) => {
+            const src = m.data;
+            if (elem === "Float") {
+                const result = new Float64Array(m.cols);
+                for (let c = 0; c < m.cols; c++) {
+                    let acc = 0;
+                    for (let r = 0; r < m.rows; r++)
+                        acc += src[r * m.cols + c];
+                    result[c] = acc;
+                }
+                return result;
+            }
+            const result = new BigInt64Array(m.cols);
+            for (let c = 0; c < m.cols; c++) {
+                let acc = 0n;
+                for (let r = 0; r < m.rows; r++)
+                    acc = wrapI64(acc + src[r * m.cols + c]);
+                result[c] = acc;
+            }
+            return result;
+        };
+    },
+    MatrixVecMul: (loc_id, source_map, _platformDef, T) => {
+        const elem = requireNumericElem("MatrixVecMul", T, loc_id, source_map);
+        return (m, v) => {
+            if (v.length !== m.cols) {
+                throw new EastError(`MatrixVecMul dimension mismatch (${m.rows}x${m.cols} vs length ${v.length})`, { location: (source_map?.resolve(loc_id) ?? []) });
+            }
+            const src = m.data;
+            if (elem === "Float") {
+                const result = new Float64Array(m.rows);
+                for (let r = 0; r < m.rows; r++) {
+                    let acc = 0;
+                    for (let c = 0; c < m.cols; c++)
+                        acc += src[r * m.cols + c] * v[c];
+                    result[r] = acc;
+                }
+                return result;
+            }
+            const result = new BigInt64Array(m.rows);
+            for (let r = 0; r < m.rows; r++) {
+                let acc = 0n;
+                for (let c = 0; c < m.cols; c++)
+                    acc = wrapI64(acc + wrapI64(src[r * m.cols + c] * v[c]));
+                result[r] = acc;
+            }
+            return result;
+        };
+    },
 };
 /** @internal */
 export function applyTypeParameters(t, params) {