numpy-ts 1.2.0 → 1.3.0

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

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = cos(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).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

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

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = cosh(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).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

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

@@ -0,0 +1,17 @@
+/**
+ * Relaxed SIMD feature detection.
+ *
+ * Probes for relaxed SIMD support using WebAssembly.validate() with a
+ * minimal module containing f32x4.relaxed_madd. Sync, cached, zero cost
+ * after first call.
+ */
+/** Returns true if the runtime supports WASM relaxed SIMD. Cached after first call. */
+export declare function supportsRelaxedSimd(): boolean;
+/**
+ * Returns true if relaxed SIMD kernels should be used, respecting config override.
+ * - 'auto' (default): detect via probe
+ * - true: force relaxed (will fail instantiation on unsupported runtimes)
+ * - false: force baseline
+ */
+export declare function useRelaxedKernels(): boolean;
+//# sourceMappingURL=detect.d.ts.map

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

@@ -4,6 +4,10 @@
  * Binary: out[i] = a[i] / b[i]
  * Scalar: out[i] = a[i] / scalar
  * Returns null if WASM can't handle this case.
+ * Integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 export declare function wasmDiv(a: ArrayStorage, b: ArrayStorage): ArrayStorage | null;

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

@@ -0,0 +1,13 @@
+/**
+ * WASM-accelerated fused divmod (scalar divisor).
+ *
+ * Computes floor quotient and floor remainder in a single pass.
+ * Returns [quotient, remainder] or null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * Fused divmod with scalar divisor.
+ * Returns [quotient, remainder] or null if WASM can't handle.
+ */
+export declare function wasmDivmodScalar(a: ArrayStorage, scalar: number): [ArrayStorage, ArrayStorage] | null;
+//# sourceMappingURL=divmod.d.ts.map

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

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = exp(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).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

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

@@ -3,8 +3,10 @@
  *
  * Unary: out[i] = exp2(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).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

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

@@ -31,22 +31,22 @@ export declare function wasmIrfft(a: ArrayStorage, nOut: number): ArrayStorage |
  * WASM-accelerated 2D complex FFT or IFFT.
  * Input: contiguous complex128 2D array (rows × cols).
  */
-export declare function wasmFft2(data: Float64Array, rows: number, cols: number, inverse: boolean): Float64Array | null;
+export declare function wasmFft2(data: Float64Array | Float32Array, rows: number, cols: number, inverse: boolean): Float64Array | Float32Array | null;
 /**
  * WASM-accelerated batch 1D complex FFT or IFFT.
  * Processes `batch` contiguous rows of `n` complex elements each.
  */
-export declare function wasmFftBatch(data: Float64Array, n: number, batch: number, inverse: boolean): Float64Array | null;
+export declare function wasmFftBatch(data: Float64Array | Float32Array, n: number, batch: number, inverse: boolean): Float64Array | Float32Array | null;
 /**
  * WASM-accelerated batch real→complex rfft.
  * Input: real f64 data with `batch` rows of `n` elements.
  */
-export declare function wasmRfftBatch(srcData: Float64Array, n: number, batch: number, inStride: number, outStride: number): Float64Array | null;
+export declare function wasmRfftBatch(srcData: Float64Array | Float32Array, n: number, batch: number, inStride: number, outStride: number): Float64Array | Float32Array | null;
 /**
  * WASM-accelerated batch complex→real irfft.
  * Input: complex128 data with `batch` rows of `nHalf` complex elements.
  */
-export declare function wasmIrfftBatch(srcData: Float64Array, nHalf: number, nOut: number, batch: number, inStride: number, outStride: number): Float64Array | null;
+export declare function wasmIrfftBatch(srcData: Float64Array | Float32Array, nHalf: number, nOut: number, batch: number, inStride: number, outStride: number): Float64Array | Float32Array | null;
 /**
  * WASM-accelerated 2D real→complex rfft2.
  * Input: real f64 (rows × cols). Output: complex128 (rows × halfCols).
@@ -56,7 +56,7 @@ export declare function wasmRfft2(inputData: Float64Array | TypedArray, rows: nu
  * WASM-accelerated 2D inverse real FFT (irfft2).
  * Input: complex128 (rows × colsHalf). Output: real f64 (rows × outCols).
  */
-export declare function wasmIrfft2(inputData: Float64Array, rows: number, colsHalf: number, outCols: number): Float64Array | null;
+export declare function wasmIrfft2(inputData: Float64Array | Float32Array, rows: number, colsHalf: number, outCols: number): Float64Array | Float32Array | null;
 /**
  * WASM-accelerated 3D inverse real FFT (irfftn for 3D).
  * Input: complex128 (d0 × d1 × d2Half). Output: real f64 (d0 × d1 × d2Out).

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

@@ -2,6 +2,7 @@
  * WASM-accelerated element-wise frexp (decompose into mantissa + exponent).
  *
  * Returns [mantissa, exponent] where x = mantissa * 2^exponent.
+ * Mantissa preserves input dtype (f64→f64, f32→f32, f16→f16).
  * Returns null if WASM can't handle this case.
  */
 import { ArrayStorage } from '../storage';

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

@@ -6,6 +6,10 @@ import { ArrayStorage } from '../storage';
  * WASM-accelerated extract (conditional gather).
  * condition must be flattened int32, data must be contiguous.
  * Returns ArrayStorage or null.
+ *
+ * Note: extract output size is unknown until kernel runs, so we use
+ * wasmMalloc for worst-case, then trim. For the actual result we need
+ * to know the count, so we read from the persistent region.
  */
 export declare function wasmExtract(condition: ArrayStorage, storage: ArrayStorage): ArrayStorage | null;
 /**

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

@@ -3,6 +3,7 @@
  *
  * Scalar: out[i] = gcd(a[i], scalar)
  * Binary: out[i] = gcd(a[i], b[i])
+ * Preserves the promoted integer dtype (NumPy behavior).
  * Returns null if WASM can't handle this case.
  */
 import { ArrayStorage } from '../storage';

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

@@ -4,8 +4,10 @@
  * Binary: out[i] = hypot(a[i], b[i])  (same-shape contiguous arrays)
  * Scalar: out[i] = hypot(a[i], scalar)
  * Returns null if WASM can't handle this case.
- * Float types use native kernels; int64/uint64 use native i64 kernels
- * that convert to f64 in WASM (avoiding JS BigInt→Number overhead).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

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

@@ -1,9 +1,10 @@
 /**
  * WASM-accelerated np.indices() for 2D and 3D grids.
+ * Supports int32, int64, and float64 output dtypes.
  */
 import { ArrayStorage } from '../storage';
 /**
- * WASM-accelerated indices for 2D/3D grids with int32 dtype.
+ * WASM-accelerated indices for 2D/3D grids.
  * Returns null if WASM can't handle this case.
  */
 export declare function wasmIndices(dimensions: number[], dtype: string): ArrayStorage | null;

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

@@ -0,0 +1,7 @@
+/**
+ * WASM-accelerated isfinite: out[i] = 1 if a[i] is finite, else 0.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmIsfinite(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=isfinite.d.ts.map

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

@@ -0,0 +1,7 @@
+/**
+ * WASM-accelerated isnan: out[i] = 1 if a[i] is NaN, else 0.
+ * Returns null if WASM can't handle this case.
+ */
+import { ArrayStorage } from '../storage';
+export declare function wasmIsnan(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=isnan.d.ts.map

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

@@ -1,6 +1,8 @@
 /**
  * WASM-accelerated lexsort (indirect stable sort on multiple keys).
  *
+ * Output is float64 indices for JS ergonomics (no BigInt).
+ * WASM sorts u32 internally and converts to f64 before returning.
  * All keys must be the same dtype and contiguous.
  * Returns null if WASM can't handle this case.
  */
@@ -8,7 +10,7 @@ import { ArrayStorage } from '../storage';
 /**
  * WASM-accelerated lexsort.
  * All keys must be the same dtype and 1D contiguous.
- * Returns ArrayStorage of int32 indices or null if WASM can't handle it.
+ * Returns ArrayStorage of float64 indices or null if WASM can't handle it.
  */
 export declare function wasmLexsort(keys: ArrayStorage[]): ArrayStorage | null;
 //# sourceMappingURL=lexsort.d.ts.map

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

@@ -4,8 +4,10 @@
  * Binary: out[i] = log(exp(a[i]) + exp(b[i]))  (same-shape contiguous arrays)
  * Scalar: out[i] = log(exp(a[i]) + exp(scalar))
  * Returns null if WASM can't handle this case.
- * Float types use native kernels; int64/uint64 use native i64 kernels
- * that convert to f64 in WASM (avoiding JS BigInt→Number overhead).
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
  */
 import { ArrayStorage } from '../storage';
 /**

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

@@ -0,0 +1,27 @@
+/**
+ * WASM-accelerated LU decomposition with partial pivoting.
+ *
+ * Provides lu_factor, lu_solve, and lu_inv for f64 and f32 square matrices.
+ */
+import { ArrayStorage } from '../storage';
+import type { DType } from '../dtype';
+/**
+ * WASM LU factorization. Returns { lu, piv, sign } or null.
+ * lu: n×n f64 ArrayStorage with L (below diag) and U (on+above diag).
+ * piv: Int32Array of pivot indices.
+ * sign: +1 or -1 (permutation sign for determinant).
+ */
+export declare function wasmLuFactor(a: ArrayStorage): {
+    lu: ArrayStorage;
+    piv: Int32Array;
+    sign: number;
+} | null;
+/**
+ * WASM LU inverse. Takes pre-computed LU + piv, returns n×n inverse.
+ */
+export declare function wasmLuInv(lu: ArrayStorage, piv: Int32Array, dtype: DType): ArrayStorage | null;
+/**
+ * WASM LU solve. Solves LU @ x = b for a single RHS vector.
+ */
+export declare function wasmLuSolve(lu: ArrayStorage, piv: Int32Array, b: ArrayStorage, dtype: DType): ArrayStorage | null;
+//# sourceMappingURL=lu.d.ts.map

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

@@ -6,10 +6,12 @@
  * Returns null if WASM can't handle this case.
  */
 import { ArrayStorage } from '../storage';
-import type { DType, TypedArray } from '../dtype';
+import { type DType, TypedArray } from '../dtype';
 /**
  * WASM-accelerated partition of contiguous slices.
  * Uses batch kernel when slices are packed contiguously.
+ *
+ * Note: operates on pre-existing JS buffers, uses scratch.
  */
 export declare function wasmPartitionSlices(resultData: TypedArray, sliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, kth: number, dtype: DType): boolean;
 /**

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

@@ -11,4 +11,9 @@ import { ArrayStorage } from '../storage';
  * Returns null if WASM can't handle (complex types, non-contiguous, too small).
  */
 export declare function wasmReduceArgmax(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided argmax along an axis.
+ * Output dtype is always int32 (indices). Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceArgmaxStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
 //# sourceMappingURL=reduce_argmax.d.ts.map

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

@@ -11,4 +11,9 @@ import { ArrayStorage } from '../storage';
  * Returns null if WASM can't handle (complex types, non-contiguous, too small).
  */
 export declare function wasmReduceArgmin(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated strided argmin along an axis.
+ * Output dtype is always int32 (indices). Returns output ArrayStorage, or null if WASM can't handle.
+ */
+export declare function wasmReduceArgminStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
 //# sourceMappingURL=reduce_argmin.d.ts.map

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

@@ -17,4 +17,8 @@ export declare function wasmReduceProd(a: ArrayStorage): number | null;
  * Returns output ArrayStorage, or null if WASM can't handle.
  */
 export declare function wasmReduceProdStrided(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
+/**
+ * WASM-accelerated strided product for complex types.
+ */
+export declare function wasmReduceProdStridedComplex(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

@@ -1,15 +1,23 @@
 /**
  * WASM-accelerated quantile computation.
  *
- * Sorts a copy of the data in WASM, then interpolates.
- * All dtypes are converted to f64 before passing to WASM.
+ * Sorts a copy of the data in-place using native-dtype sort kernels (same as
+ * wasmSort), then interpolates. No f64 conversion — operates on the original
+ * dtype for both sort and readback.
+ *
  * 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.
+ * Sorts a scratch copy in the native dtype, then interpolates.
  * Returns null if WASM can't handle (complex, non-contiguous, too small).
  */
 export declare function wasmReduceQuantile(a: ArrayStorage, q: number): number | null;
+/**
+ * WASM-accelerated strided quantile along an axis.
+ * For shape [outer, axisSize, inner], sorts each column and interpolates.
+ * Output is [outer * inner] f64, or null if WASM can't handle.
+ */
+export declare function wasmReduceQuantileStrided(storage: ArrayStorage, outer: number, axisSize: number, inner: number, q: number): ArrayStorage | null;
 //# sourceMappingURL=reduce_quantile.d.ts.map

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

@@ -11,10 +11,20 @@ import { ArrayStorage } from '../storage';
  * Returns null if WASM can't handle (complex types, non-contiguous, too small).
  */
 export declare function wasmReduceSum(a: ArrayStorage): number | null;
+/**
+ * WASM-accelerated global sum for complex types.
+ * Returns [re, im] tuple or null.
+ */
+export declare function wasmReduceSumComplex(a: ArrayStorage): [number, 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;
+/**
+ * WASM-accelerated strided sum for complex types.
+ * Returns ArrayStorage of complex output, or null.
+ */
+export declare function wasmReduceSumStridedComplex(a: ArrayStorage, outerSize: number, axisSize: number, innerSize: number): ArrayStorage | null;
 //# sourceMappingURL=reduce_sum.d.ts.map

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

@@ -4,6 +4,15 @@
  * Unlike other WASM wrappers, this is always used (no JS fallback).
  * State persists in WASM globals across calls.
  */
+import { fill_uniform_f64_mt, fill_uniform_f64_pcg, fill_standard_normal_pcg, fill_standard_exponential_pcg, fill_legacy_gauss, fill_legacy_standard_exponential, fill_rk_interval, fill_legacy_standard_gamma, fill_legacy_chisquare, fill_pareto, fill_power, fill_weibull, fill_logistic, fill_gumbel, fill_laplace, fill_rayleigh, fill_triangular, fill_standard_cauchy, fill_lognormal, fill_wald, fill_standard_t, fill_beta, fill_f, fill_noncentral_chisquare, fill_noncentral_f, fill_geometric, fill_poisson, fill_binomial, fill_negative_binomial, fill_hypergeometric, fill_logseries, fill_zipf, fill_vonmises, fill_randint_i64, fill_randint_u8, fill_randint_u16, fill_permutation, fill_permutation_pcg, fill_bounded_uint64_pcg } from './bins/rng.wasm';
+/**
+ * Fill directly into a WASM pointer — zero-copy path for callers that already
+ * have a persistent WASM allocation (e.g., ArrayStorage.empty()).
+ * @param ptr - byte offset into WASM memory to write to
+ * @param n - number of elements
+ * @param fn - the raw WASM fill kernel
+ */
+export declare function directFill(ptr: number, n: number, fn: (outPtr: number, n: number) => void): void;
 export declare function initMT19937(seed: number): void;
 export declare function mt19937Uint32(): number;
 export declare function mt19937Float64(): number;
@@ -23,6 +32,7 @@ export declare const legacyGauss: () => number;
 export declare const legacyStandardExponential: () => number;
 export declare const legacyGaussReset: () => void;
 export declare const wasmLegacyStandardGamma: (shape: number) => number;
+export { fill_uniform_f64_mt as rawFillUniformF64MT, fill_uniform_f64_pcg as rawFillUniformF64PCG, fill_standard_normal_pcg as rawFillStandardNormalPCG, fill_standard_exponential_pcg as rawFillStandardExponentialPCG, fill_legacy_gauss as rawFillLegacyGauss, fill_legacy_standard_exponential as rawFillLegacyStandardExponential, fill_standard_cauchy as rawFillStandardCauchy, fill_permutation as rawFillPermutation, fill_permutation_pcg as rawFillPermutationPCG, fill_legacy_standard_gamma as rawFillLegacyStandardGamma, fill_legacy_chisquare as rawFillLegacyChisquare, fill_pareto as rawFillPareto, fill_power as rawFillPower, fill_weibull as rawFillWeibull, fill_logistic as rawFillLogistic, fill_gumbel as rawFillGumbel, fill_laplace as rawFillLaplace, fill_rayleigh as rawFillRayleigh, fill_triangular as rawFillTriangular, fill_lognormal as rawFillLognormal, fill_wald as rawFillWald, fill_standard_t as rawFillStandardT, fill_beta as rawFillBeta, fill_f as rawFillF, fill_noncentral_chisquare as rawFillNoncentralChisquare, fill_noncentral_f as rawFillNoncentralF, fill_vonmises as rawFillVonmises, fill_geometric as rawFillGeometric, fill_poisson as rawFillPoisson, fill_binomial as rawFillBinomial, fill_negative_binomial as rawFillNegativeBinomial, fill_hypergeometric as rawFillHypergeometric, fill_logseries as rawFillLogseries, fill_zipf as rawFillZipf, fill_rk_interval as rawFillRkInterval, fill_randint_i64 as rawFillRandintI64, fill_randint_u8 as rawFillRandintU8, fill_randint_u16 as rawFillRandintU16, fill_bounded_uint64_pcg as rawFillBoundedUint64PCG, };
 export declare const fillUniformF64MT: (n: number) => Float64Array<ArrayBuffer>;
 export declare const fillUniformF64PCG: (n: number) => Float64Array<ArrayBuffer>;
 export declare const fillStandardNormalPCG: (n: number) => Float64Array<ArrayBuffer>;

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

@@ -1,55 +1,138 @@
 /**
- * WASM Runtime — shared memory management for all WASM kernels.
+ * WASM Runtime — zero-copy 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).
+ * All array data lives in a single fixed-size WebAssembly.Memory instance.
+ * A persistent free-list allocator (alloc.zig) manages long-lived ArrayStorage
+ * data. A scratch bump allocator handles temporary copy-ins for JS-fallback
+ * arrays during kernel calls.
+ *
+ * Memory layout:
+ *   [WASM statics][--- persistent heap (free-list) ---][--- scratch (bump) ---]
+ *   0          heapBase                            scratchBase          maxBytes
+ *
+ * Because initial === maximum pages, memory.buffer is never detached by grow().
+ * All TypedArray views into it remain valid for the program lifetime.
  */
 import type { TypedArray } from '../dtype';
+import { type ConfigureWasmOptions } from './config';
 /**
  * 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.
+ * Allocated once with initial === maximum pages so the buffer never detaches.
  */
 export declare function getSharedMemory(): WebAssembly.Memory;
 /**
- * Ensure the shared memory has at least `bytes` of usable space
- * (above heapBase). Grows if necessary.
+ * Set the heap base offset. Called by each WASM module on first init
+ * (reads __heap_base from exports). The highest value wins.
  */
-export declare function ensureMemory(bytes: number): void;
+export declare function setHeapBase(base: number): void;
 /**
- * Reset the bump allocator. Call before each kernel invocation.
- * Also increments wasmCallCount so callers can detect WASM execution.
+ * Configure WASM memory settings. Must be called before any array operations
+ * (i.e. before the WASM memory is initialized on first use).
+ *
+ * @example
+ * ```ts
+ * import { configureWasm } from 'numpy-ts';
+ * configureWasm({ maxMemory: 512 * 1024 * 1024 }); // 512 MiB
+ * ```
  */
-export declare function resetAllocator(base?: number): void;
+export declare function configureWasm(options: ConfigureWasmOptions): void;
+export declare class WasmRegion {
+    readonly ptr: number;
+    readonly byteLength: number;
+    private _refCount;
+    constructor(ptr: number, byteLength: number);
+    retain(): void;
+    release(): void;
+    get refCount(): number;
+}
 /**
- * Set the heap base offset. Called once when the first WASM instance
- * is initialized (reads __heap_base from the WASM exports).
+ * Register an object (typically ArrayStorage) so that when it is garbage
+ * collected, the associated WasmRegion's refcount is decremented.
+ * The instance itself is used as the unregister token, allowing
+ * eager cleanup via unregisterCleanup() to prevent double-free.
  */
-export declare function setHeapBase(base: number): void;
+export declare function registerForCleanup(instance: object, region: WasmRegion): void;
+/**
+ * Unregister an object from the FinalizationRegistry.
+ * Must be called when eagerly releasing WASM memory to prevent
+ * the GC callback from double-freeing the region.
+ */
+export declare function unregisterCleanup(instance: object): void;
+/**
+ * Allocate `bytes` from the persistent WASM heap.
+ * Returns a WasmRegion, or null if out of memory (caller should fall back to JS).
+ */
+export declare function wasmMalloc(bytes: number): WasmRegion | null;
+/**
+ * Total free bytes in the persistent heap.
+ */
+export declare function wasmFreeBytes(): number;
+/**
+ * Reset the scratch bump allocator. Call before each kernel invocation
+ * that may need to copy JS-fallback inputs into WASM memory.
+ * Also frees any temp heap allocations from the previous kernel call.
+ */
+export declare function resetScratchAllocator(): void;
+/**
+ * Bump-allocate `bytes` from the scratch region. Returns byte offset.
+ * Always 8-byte aligned. Falls back to heap if scratch space is exhausted.
+ */
+export declare function scratchAlloc(bytes: number): number;
 /**
- * Bump-allocate `bytes` from WASM memory. Returns the byte offset.
- * Always 8-byte aligned for TypedArray compatibility.
+ * Copy a JS TypedArray into the scratch region. Returns byte offset.
  */
-export declare function alloc(bytes: number): number;
+export declare function scratchCopyIn(src: TypedArray): number;
 /**
- * Copy a JS TypedArray into WASM memory. Returns the byte offset.
+ * Resolve an ArrayStorage input to a WASM pointer for kernel use.
+ * If the storage is WASM-backed, returns its direct pointer (zero-copy).
+ * If JS-backed, copies data into the scratch region.
+ *
+ * @param data - The TypedArray from storage.data
+ * @param isWasmBacked - Whether the storage is backed by WASM memory
+ * @param wasmPtr - The WASM pointer (only valid if isWasmBacked)
+ * @param offset - Element offset into the data
+ * @param elementCount - Number of elements to resolve
+ * @param bpe - Bytes per element
  */
-export declare function copyIn(src: TypedArray): number;
+export declare function resolveInputPtr(data: TypedArray, isWasmBacked: boolean, wasmPtr: number, offset: number, elementCount: number, bpe: number): number;
 /**
- * Copy data from WASM memory into a new JS TypedArray.
+ * Resolve a TypedArray to a WASM pointer. If the array is already a view
+ * into WASM memory, returns its byte offset directly (zero-copy).
+ * Otherwise copies to scratch. Useful when you have a TypedArray but
+ * don't know if it's WASM-backed (e.g. from getContiguousData).
  */
-export declare function copyOut<T extends TypedArray>(ptr: number, length: number, Ctor: new (buffer: ArrayBuffer, byteOffset: number, length: number) => T): T;
+export declare function resolveTypedArrayPtr(data: TypedArray): number;
 /**
- * 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.
+ * Convert f16 input to f32 in the scratch region using .set() — no JS allocation.
+ * Creates Float32Array view on WASM scratch memory and uses .set(f16Data) which
+ * converts f16→f32 in-place. 1.2x–3x faster than f16ToF32Input + scratchCopyIn.
+ *
+ * @param a - The ArrayStorage with f16 data
+ * @param size - Number of elements
+ * @returns WASM byte offset of the f32 scratch data
+ */
+export declare function f16InputToScratchF32(a: {
+    data: TypedArray;
+    isWasmBacked: boolean;
+    wasmPtr: number;
+    offset: number;
+}, size: number): number;
+/**
+ * Convert f32 kernel output to f16 in a new WASM region using .set() — no JS round-trip.
+ * Allocates a persistent f16 WasmRegion, creates Float16Array + Float32Array views
+ * on WASM memory, and uses .set() to convert in-place.
+ * Replaces: copyOut + f32ToF16Output + fromData (saves 2 copies).
+ *
+ * @param outRegion - The WasmRegion containing f32 output from the kernel
+ * @param size - Number of elements
+ * @returns New WasmRegion with f16 data, or null on OOM. Caller must release outRegion.
  */
-export declare function f16ToF32Input(data: TypedArray, dtype: string): TypedArray;
+export declare function f32OutputToF16Region(outRegion: WasmRegion, size: number): WasmRegion | null;
 /**
- * Convert Float32Array WASM output back to Float16Array.
- * Call after copyOut when the operation's dtype is float16.
+ * Convert f32 WASM output to f16 in-place within the same region.
+ * Safe because f16[i] at byte 2i never reaches unread f32[j>i] at byte 4j.
+ * Avoids extra wasmMalloc + release overhead of f32OutputToF16Region.
+ * The region retains its original (f32-sized) allocation; the extra bytes are unused.
  */
-export declare function f32ToF16Output(data: TypedArray, dtype: string): TypedArray;
+export declare function f32ToF16InPlace(outRegion: WasmRegion, size: number): void;
 //# sourceMappingURL=runtime.d.ts.map

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

@@ -1,12 +1,14 @@
 /**
  * WASM-accelerated searchsorted (binary search for insertion indices).
  *
+ * Output is float64 indices for JS ergonomics (no BigInt).
+ * WASM searches u32 internally and converts to f64 before returning.
  * 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.
+ * Returns ArrayStorage of float64 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/signbit.d.ts

@@ -0,0 +1,14 @@
+/**
+ * WASM-accelerated element-wise signbit with SIMD.
+ *
+ * Unary: out[i] = 1 if a[i] has negative sign bit, 0 otherwise
+ * Returns a boolean (uint8) array.
+ * For unsigned types, signbit is always 0 — returns zeros directly.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise signbit.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmSignbit(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=signbit.d.ts.map

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

@@ -0,0 +1,17 @@
+/**
+ * WASM-accelerated element-wise sine.
+ *
+ * Unary: out[i] = sin(a[i])
+ * Returns null if WASM can't handle this case.
+ * Float types use native kernels; integer types use type-appropriate output:
+ *   i8/u8 → f32 (then downcast to f16 if available)
+ *   i16/u16 → f32
+ *   i32/u32/i64/u64 → f64
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated element-wise sine.
+ * Returns null if WASM can't handle (complex, non-contiguous, too small).
+ */
+export declare function wasmSin(a: ArrayStorage): ArrayStorage | null;
+//# sourceMappingURL=sin.d.ts.map