numpy-ts 1.0.0 → 1.2.0

package/dist/types/common/wasm/reduce_argmax.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction argmax.
+ *
+ * Reduction: result = argmax(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction argmax (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceArgmax(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_argmax.d.ts.map

package/dist/types/common/wasm/reduce_argmin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction argmin.
+ *
+ * Reduction: result = argmin(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction argmin (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceArgmin(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_argmin.d.ts.map

package/dist/types/common/wasm/reduce_count_nz.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction count_nz.
+ *
+ * Reduction: result = count_nonzero(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (non-zero check is sign-agnostic).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction count_nz (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceCountNz(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_count_nz.d.ts.map

package/dist/types/common/wasm/reduce_max.d.ts

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated reduction max.
+ *
+ * Reduction: result = max(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction max (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceMax(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided max along an axis.
+ * Output dtype matches input dtype. Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceMaxStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_max.d.ts.map

package/dist/types/common/wasm/reduce_mean.d.ts

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated reduction mean.
+ *
+ * Reduction: result = mean(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels (for correct floatFromInt).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction mean (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceMean(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided mean along an axis.
+ * Output is always float64. Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceMeanStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_mean.d.ts.map

package/dist/types/common/wasm/reduce_min.d.ts

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated reduction min.
+ *
+ * Reduction: result = min(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction min (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceMin(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided min along an axis.
+ * Output dtype matches input dtype. Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceMinStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_min.d.ts.map

package/dist/types/common/wasm/reduce_nanmax.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction nanmax.
+ *
+ * Reduction: result = nanmax(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Only float64 and float32.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction nanmax (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceNanmax(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_nanmax.d.ts.map

package/dist/types/common/wasm/reduce_nanmin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction nanmin.
+ *
+ * Reduction: result = nanmin(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Only float64 and float32.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction nanmin (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceNanmin(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_nanmin.d.ts.map

package/dist/types/common/wasm/reduce_nansum.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction nansum.
+ *
+ * Reduction: result = nansum(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Only float64 and float32 — TS routes int/uint to regular sum.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction nansum (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceNansum(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_nansum.d.ts.map

package/dist/types/common/wasm/reduce_prod.d.ts

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated reduction product.
+ *
+ * Reduction: result = product(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (wrapping multiplication gives same bits).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction product (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceProd(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided prod along an axis.
+ * Output dtype may be promoted (narrow ints → i64/u64).
+ * Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceProdStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_prod.d.ts.map

package/dist/types/common/wasm/reduce_quantile.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated quantile computation.
+ *
+ * Sorts a copy of the data in WASM, then interpolates.
+ * All dtypes are converted to f64 before passing to WASM.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated quantile (no axis, full array).
+ * Converts all data to f64, sorts in WASM, interpolates.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmReduceQuantile(a: ArrayStorage, q: number): number | null;
+//# sourceMappingURL=reduce_quantile.d.ts.map

package/dist/types/common/wasm/reduce_std.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction std.
+ *
+ * Reduction: result = std(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction std (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceStd(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_std.d.ts.map

package/dist/types/common/wasm/reduce_sum.d.ts

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated reduction sum.
+ *
+ * Reduction: result = sum(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * uint types route to signed kernels (wrapping addition gives same bits).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction sum (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceSum(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided sum along an axis.
+ * Output is always f64 (the JS caller converts to the correct output dtype).
+ * Returns f64 ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceSumStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+//# sourceMappingURL=reduce_sum.d.ts.map

package/dist/types/common/wasm/reduce_var.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated reduction var.
+ *
+ * Reduction: result = var(a[0..N])
+ * Returns null if WASM can't handle this case.
+ * Unsigned types use SEPARATE kernels.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated reduction var (no axis, full array).
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmReduceVar(a: ArrayStorage): number | null;
+//# sourceMappingURL=reduce_var.d.ts.map

package/dist/types/common/wasm/repeat.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated flat repeat.
+ *
+ * repeat: Each element a[i] is written `reps` times to output.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated flat repeat with uniform repeat count.
+ * Only handles flattened repeat (no axis) with a single repeat count (not array).
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmRepeat(a: ArrayStorage, reps: number): ArrayStorage | null;
+//# sourceMappingURL=repeat.d.ts.map

package/dist/types/common/wasm/right_shift.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated element-wise right shift.
+ *
+ * Binary: out[i] = a[i] >> b[i]  (same-shape contiguous arrays)
+ * Scalar: out[i] = a[i] >> scalar
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmRightShift(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+export declare function wasmRightShiftScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=right_shift.d.ts.map

package/dist/types/common/wasm/rng.d.ts

@@ -0,0 +1,65 @@
+/**
+ * WASM RNG wrapper — NumPy-compatible random number generation.
+ *
+ * Unlike other WASM wrappers, this is always used (no JS fallback).
+ * State persists in WASM globals across calls.
+ */
+export declare function initMT19937(seed: number): void;
+export declare function mt19937Uint32(): number;
+export declare function mt19937Float64(): number;
+export declare function getMT19937State(): {
+    mt: Uint32Array;
+    mti: number;
+};
+export declare function setMT19937State(mt: Uint32Array, mti: number): void;
+export declare function initPCG64FromSeed(seed: number): void;
+export declare function pcg64Float64(): number;
+export declare function pcg64BoundedUint64(off: number, rng: number): bigint;
+export declare function pcg64SaveState(): BigUint64Array;
+export declare function pcg64RestoreState(state: BigUint64Array): void;
+export declare const standardNormalPCG: () => number;
+export declare const standardExponentialPCG: () => number;
+export declare const legacyGauss: () => number;
+export declare const legacyStandardExponential: () => number;
+export declare const legacyGaussReset: () => void;
+export declare const wasmLegacyStandardGamma: (shape: number) => number;
+export declare const fillUniformF64MT: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillUniformF64PCG: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillStandardNormalPCG: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillStandardExponentialPCG: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillLegacyGauss: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillLegacyStandardExponential: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillStandardCauchy: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillPermutation: (n: number) => Float64Array<ArrayBuffer>;
+export declare const fillPermutationPCG: (n: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillLegacyStandardGamma: (n: number, shape: number) => Float64Array<ArrayBuffer>;
+export declare const fillLegacyChisquare: (n: number, df: number) => Float64Array<ArrayBuffer>;
+export declare const fillPareto: (n: number, a: number) => Float64Array<ArrayBuffer>;
+export declare const fillPower: (n: number, a: number) => Float64Array<ArrayBuffer>;
+export declare const fillWeibull: (n: number, a: number) => Float64Array<ArrayBuffer>;
+export declare const fillLogistic: (n: number, loc: number, scale: number) => Float64Array<ArrayBuffer>;
+export declare const fillGumbel: (n: number, loc: number, scale: number) => Float64Array<ArrayBuffer>;
+export declare const fillLaplace: (n: number, loc: number, scale: number) => Float64Array<ArrayBuffer>;
+export declare const fillRayleigh: (n: number, scale: number) => Float64Array<ArrayBuffer>;
+export declare const fillTriangular: (n: number, left: number, mode: number, right: number) => Float64Array<ArrayBuffer>;
+export declare const fillLognormal: (n: number, mean: number, sigma: number) => Float64Array<ArrayBuffer>;
+export declare const fillWald: (n: number, mean: number, scale: number) => Float64Array<ArrayBuffer>;
+export declare const fillStandardT: (n: number, df: number) => Float64Array<ArrayBuffer>;
+export declare const fillBeta: (n: number, a: number, b: number) => Float64Array<ArrayBuffer>;
+export declare const fillF: (n: number, dfnum: number, dfden: number) => Float64Array<ArrayBuffer>;
+export declare const fillNoncentralChisquare: (n: number, df: number, nonc: number) => Float64Array<ArrayBuffer>;
+export declare const fillNoncentralF: (n: number, dfnum: number, dfden: number, nonc: number) => Float64Array<ArrayBuffer>;
+export declare const fillVonmises: (n: number, mu: number, kappa: number) => Float64Array<ArrayBuffer>;
+export declare const fillGeometric: (n: number, p: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillPoisson: (n: number, lam: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillBinomial: (n: number, trials: number, p: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillNegativeBinomial: (n: number, nn2: number, p: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillHypergeometric: (n: number, ngood: number, nbad: number, nsample: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillLogseries: (n: number, p: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillZipf: (n: number, a: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillRkInterval: (n: number, max: number) => Uint32Array<ArrayBuffer>;
+export declare const fillRandintI64: (n: number, max: number, low: number) => BigInt64Array<ArrayBuffer>;
+export declare const fillRandintU8: (n: number, rng: number, off: number) => Uint8Array<ArrayBuffer>;
+export declare const fillRandintU16: (n: number, rng: number, off: number) => Uint16Array<ArrayBuffer>;
+export declare const fillBoundedUint64PCG: (n: number, off: number, rng: number) => BigInt64Array<ArrayBuffer>;
+//# sourceMappingURL=rng.d.ts.map

package/dist/types/common/wasm/roll.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated flat array roll (circular shift).
+ *
+ * roll: out[i] = a[(i - shift + N) % N]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated flat roll (no axis).
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmRoll(a: ArrayStorage, shift: number): ArrayStorage | null;
+//# sourceMappingURL=roll.d.ts.map

package/dist/types/common/wasm/rot90.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 2D 90-degree rotation (k=1, CCW).
+ *
+ * rot90: dst[r,c] = src[c, cols-1-r]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 2D rot90 (k=1, CCW).
+ * Only handles 2D C-contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmRot90(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=rot90.d.ts.map

package/dist/types/common/wasm/runtime.d.ts

@@ -0,0 +1,55 @@
+/**
+ * WASM Runtime — shared memory management for all WASM kernels.
+ *
+ * All kernel modules share a single WebAssembly.Memory instance.
+ * Uses a bump allocator that resets on every kernel call (no fragmentation).
+ * Memory grows monotonically (high-water-mark pattern).
+ */
+import type { TypedArray } from '../dtype';
+/**
+ * Get the shared WebAssembly.Memory instance.
+ * All WASM kernel modules import this same memory.
+ * Starts with 17 pages (~1.1MB) — enough for debug (ReleaseSmall/Safe) WASM builds
+ * which have larger binaries and declare higher minimum memory.
+ */
+export declare function getSharedMemory(): WebAssembly.Memory;
+/**
+ * Ensure the shared memory has at least `bytes` of usable space
+ * (above heapBase). Grows if necessary.
+ */
+export declare function ensureMemory(bytes: number): void;
+/**
+ * Reset the bump allocator. Call before each kernel invocation.
+ * Also increments wasmCallCount so callers can detect WASM execution.
+ */
+export declare function resetAllocator(base?: number): void;
+/**
+ * Set the heap base offset. Called once when the first WASM instance
+ * is initialized (reads __heap_base from the WASM exports).
+ */
+export declare function setHeapBase(base: number): void;
+/**
+ * Bump-allocate `bytes` from WASM memory. Returns the byte offset.
+ * Always 8-byte aligned for TypedArray compatibility.
+ */
+export declare function alloc(bytes: number): number;
+/**
+ * Copy a JS TypedArray into WASM memory. Returns the byte offset.
+ */
+export declare function copyIn(src: TypedArray): number;
+/**
+ * Copy data from WASM memory into a new JS TypedArray.
+ */
+export declare function copyOut<T extends TypedArray>(ptr: number, length: number, Ctor: new (buffer: ArrayBuffer, byteOffset: number, length: number) => T): T;
+/**
+ * Convert Float16Array data to Float32Array for WASM kernel input.
+ * WASM kernels operate on f32 for float16 data (no native f16 SIMD).
+ * Returns the original data unchanged if not float16.
+ */
+export declare function f16ToF32Input(data: TypedArray, dtype: string): TypedArray;
+/**
+ * Convert Float32Array WASM output back to Float16Array.
+ * Call after copyOut when the operation's dtype is float16.
+ */
+export declare function f32ToF16Output(data: TypedArray, dtype: string): TypedArray;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/types/common/wasm/searchsorted.d.ts

@@ -0,0 +1,12 @@
+/**
+ * WASM-accelerated searchsorted (binary search for insertion indices).
+ *
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated searchsorted.
+ * Returns ArrayStorage of int32 insertion indices or null if WASM can't handle it.
+ */
+export declare function wasmSearchsorted(sorted: ArrayStorage, values: ArrayStorage, side: 'left' | 'right'): ArrayStorage | null;
+//# sourceMappingURL=searchsorted.d.ts.map

package/dist/types/common/wasm/sign.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated element-wise sign.
+ *
+ * Unary: out[i] = sign(a[i])  (returns -1, 0, or 1)
+ * Returns null if WASM can't handle this case.
+ * Not defined for complex types.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise sign.
+ * Returns null if WASM can't handle (complex types, non-contiguous, too small).
+ */
+export declare function wasmSign(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sign.d.ts.map

package/dist/types/common/wasm/sinh.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise hyperbolic sine.
+ *
+ * Unary: out[i] = sinh(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise hyperbolic sine.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmSinh(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sinh.d.ts.map

package/dist/types/common/wasm/sort.d.ts

@@ -0,0 +1,20 @@
+/**
+ * WASM-accelerated in-place array sorting.
+ *
+ * Sorts a contiguous 1D buffer in-place using heap sort.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import type { DType, TypedArray } from '../dtype';
+/**
+ * WASM-accelerated sort of contiguous slices in a typed array buffer.
+ * Uses a single batched WASM call for all slices (eliminates per-slice JS→WASM overhead).
+ * Returns true if WASM handled it.
+ */
+export declare function wasmSortSlices(resultData: TypedArray, sliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, dtype: DType): boolean;
+/**
+ * WASM-accelerated sort of a contiguous 1D buffer.
+ * Returns sorted ArrayStorage or null if WASM can't handle it.
+ */
+export declare function wasmSort(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sort.d.ts.map

package/dist/types/common/wasm/sqrt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise square root.
+ *
+ * Unary: out[i] = sqrt(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types output same type; integer types use native WASM kernels
+ * that convert to f64 internally (no JS conversion loop needed).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise square root.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmSqrt(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sqrt.d.ts.map

package/dist/types/common/wasm/square.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated element-wise square.
+ *
+ * Unary: out[i] = a[i] * a[i]
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise square.
+ * Returns null if WASM can't handle (non-contiguous, too small).
+ */
+export declare function wasmSquare(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=square.d.ts.map

package/dist/types/common/wasm/sub.d.ts

@@ -0,0 +1,19 @@
+/**
+ * WASM-accelerated element-wise subtraction.
+ *
+ * Binary: out[i] = a[i] - b[i]  (same-shape contiguous arrays)
+ * Scalar: out[i] = a[i] - scalar
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise subtract of two same-shape contiguous arrays.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmSub(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+/**
+ * WASM-accelerated element-wise subtract scalar.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmSubScalar(a: ArrayStorage, scalar: number): ArrayStorage | null;
+//# sourceMappingURL=sub.d.ts.map

package/dist/types/common/wasm/svd.d.ts

@@ -0,0 +1,18 @@
+/**
+ * WASM-accelerated Singular Value Decomposition.
+ *
+ * Computes A[m×n] = U[m×m] · diag(S) · Vt[n×n] via Jacobi eigendecomposition of A^T·A.
+ * Only supports float64 (matches JS behavior of converting all inputs to float64).
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated full SVD for 2D float64 matrices.
+ * Returns { u: ArrayStorage, s: ArrayStorage, vt: ArrayStorage } or null.
+ */
+export declare function wasmSvd(a: ArrayStorage): {
+    u: ArrayStorage;
+    s: ArrayStorage;
+    vt: ArrayStorage;
+} | null;
+//# sourceMappingURL=svd.d.ts.map

package/dist/types/common/wasm/tan.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise tangent.
+ *
+ * Unary: out[i] = tan(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise tangent.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmTan(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=tan.d.ts.map

package/dist/types/common/wasm/tanh.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated element-wise hyperbolic tangent.
+ *
+ * Unary: out[i] = tanh(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types are converted to float64
+ * in JS and run through the f64 SIMD kernel (matches NumPy's promotion).
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise hyperbolic tangent.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmTanh(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=tanh.d.ts.map

package/dist/types/common/wasm/tile.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated 2D tile.
+ *
+ * Tiles a [rows x cols] matrix by [rep_rows x rep_cols].
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated 2D tile.
+ * Only handles 2D C-contiguous arrays with 2-element reps.
+ * Returns null if WASM can't handle.
+ */
+export declare function wasmTile2D(a: ArrayStorage, repRows: number, repCols: number): ArrayStorage | null;
+//# sourceMappingURL=tile.d.ts.map

package/dist/types/common/wasm/vdot.d.ts

@@ -0,0 +1,16 @@
+/**
+ * WASM-accelerated conjugate dot product (vdot) for complex types.
+ *
+ * Computes sum_k conj(a[k]) * b[k] for flattened 1D complex arrays.
+ * For real/integer types, vdot = dot — use wasmDot1D instead.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+import { Complex } from '../complex';
+/**
+ * WASM-accelerated conjugate dot product for complex types.
+ * Both a and b must be 1D, contiguous, same-length, complex dtype.
+ * Returns Complex or null.
+ */
+export declare function wasmVdotComplex(a: ArrayStorage, b: ArrayStorage): Complex | null;
+//# sourceMappingURL=vdot.d.ts.map

package/dist/types/common/wasm/vecdot.d.ts

@@ -0,0 +1,15 @@
+/**
+ * WASM-accelerated batched vector dot product (vecdot).
+ *
+ * Computes out[i] = sum_k a[i,k] * b[i,k] for contiguous 2D arrays
+ * where the last axis is contracted. Both a and b must have the same shape.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated vecdot for 2D arrays with contraction along the last axis.
+ * a and b must be 2D with matching shapes, both C-contiguous.
+ * Returns ArrayStorage with shape [B] (batch dimension), or null.
+ */
+export declare function wasmVecdot(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=vecdot.d.ts.map