numpy-ts 1.1.0 → 1.3.0

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

@@ -0,0 +1,75 @@
+/**
+ * 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.
+ */
+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;
+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 { 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>;
+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/runtime.d.ts

@@ -1,44 +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;
+/**
+ * Copy a JS TypedArray into the scratch region. Returns byte offset.
+ */
+export declare function scratchCopyIn(src: TypedArray): number;
+/**
+ * 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 resolveInputPtr(data: TypedArray, isWasmBacked: boolean, wasmPtr: number, offset: number, elementCount: number, bpe: number): number;
+/**
+ * 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 resolveTypedArrayPtr(data: TypedArray): number;
 /**
- * Bump-allocate `bytes` from WASM memory. Returns the byte offset.
- * Always 8-byte aligned for TypedArray compatibility.
+ * 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 alloc(bytes: number): number;
+export declare function f16InputToScratchF32(a: {
+    data: TypedArray;
+    isWasmBacked: boolean;
+    wasmPtr: number;
+    offset: number;
+}, size: number): number;
 /**
- * Copy a JS TypedArray into WASM memory. Returns the byte offset.
+ * 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 copyIn(src: TypedArray): number;
+export declare function f32OutputToF16Region(outRegion: WasmRegion, size: number): WasmRegion | null;
 /**
- * Copy data from WASM memory into a new JS TypedArray.
+ * 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 copyOut<T extends TypedArray>(ptr: number, length: number, Ctor: new (buffer: ArrayBuffer, byteOffset: number, length: number) => T): T;
+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

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

@@ -3,8 +3,10 @@
  *
  * 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).
+ * 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/sort.d.ts

@@ -5,11 +5,14 @@
  * 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 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.
+ *
+ * Note: wasmSortSlices operates on pre-existing JS buffers (resultData), so it uses
+ * scratch copy-in and copy-out rather than wasmMalloc. The caller owns the buffer.
  */
 export declare function wasmSortSlices(resultData: TypedArray, sliceOffsets: Int32Array | number[], axisSize: number, outerSize: number, dtype: DType): boolean;
 /**

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

@@ -3,8 +3,10 @@
  *
  * 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).
+ * Float types output same type; 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/svd.d.ts

@@ -15,4 +15,10 @@ export declare function wasmSvd(a: ArrayStorage): {
     s: ArrayStorage;
     vt: ArrayStorage;
 } | null;
+/**
+ * WASM-accelerated singular values only (no U, V) via Golub-Kahan.
+ * Much faster than full SVD for svdvals/cond/matrix_rank.
+ * Returns ArrayStorage with singular values, or null.
+ */
+export declare function wasmSvdValues(a: ArrayStorage): ArrayStorage | null;
 //# sourceMappingURL=svd.d.ts.map

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

@@ -3,8 +3,10 @@
  *
  * 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).
+ * 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/tanh.d.ts

@@ -3,8 +3,10 @@
  *
  * 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).
+ * 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/unravel_index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * WASM-accelerated unravel_index: convert flat indices to multi-dimensional indices.
+ * Uses native i32/i64 kernels for integer inputs (no JS conversion overhead),
+ * with f64 kernel as fallback. All kernels output f64 directly.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated unravel_index for flat indices with C-order strides.
+ * Returns ndim ArrayStorage arrays (float64), or null if WASM can't handle this case.
+ */
+export declare function wasmUnravelIndex(indices: ArrayStorage, shape: number[]): ArrayStorage[] | null;
+//# sourceMappingURL=unravel_index.d.ts.map

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

@@ -0,0 +1,11 @@
+/**
+ * WASM-accelerated L2 vector norm: sqrt(sum(x[i]^2)).
+ * Returns null if WASM can't handle.
+ */
+import { ArrayStorage } from '../storage';
+/**
+ * WASM-accelerated L2 norm (Euclidean norm).
+ * Returns sqrt(sum(x^2)) as a number, or null if WASM can't handle.
+ */
+export declare function wasmVectorNorm2(a: ArrayStorage): number | null;
+//# sourceMappingURL=vector_norm.d.ts.map

package/dist/types/core/advanced.d.ts

@@ -31,7 +31,7 @@ export declare function select(condlist: NDArrayCore[], choicelist: NDArrayCore[
 export declare function place(a: NDArrayCore, mask: NDArrayCore, vals: NDArrayCore): void;
 export declare function putmask(a: NDArrayCore, mask: NDArrayCore, values: NDArrayCore): void;
 export declare function copyto(dst: NDArrayCore, src: NDArrayCore | number | bigint): void;
-export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): NDArrayCore;
+export declare function indices(dimensions: number[], dtype?: string): NDArrayCore;
 export declare function ix_(...args: NDArrayCore[]): NDArrayCore[];
 export declare function ravel_multi_index(multi_index: NDArrayCore[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): NDArrayCore;
 export declare function unravel_index(indices: NDArrayCore | number, shape: number[]): NDArrayCore[];
@@ -42,7 +42,7 @@ export declare function tril_indices(n: number, k?: number, m?: number): NDArray
 export declare function tril_indices_from(a: NDArrayCore, k?: number): NDArrayCore[];
 export declare function triu_indices(n: number, k?: number, m?: number): NDArrayCore[];
 export declare function triu_indices_from(a: NDArrayCore, k?: number): NDArrayCore[];
-export declare function mask_indices(n: number, mask_func: (n: number, k: number) => NDArrayCore, k?: number): NDArrayCore[];
+export declare function mask_indices(n: number, mask_func: (m: NDArrayCore, k: number) => NDArrayCore, k?: number): NDArrayCore[];
 export declare function array_equal(a: NDArrayCore, b: NDArrayCore, equal_nan?: boolean): boolean;
 export declare function array_equiv(a: NDArrayCore, b: NDArrayCore): boolean;
 export declare function apply_along_axis(func1d: (arr: NDArrayCore) => NDArrayCore | number, axis: number, arr: NDArrayCore): NDArrayCore;
@@ -51,4 +51,12 @@ export declare function may_share_memory(a: NDArrayCore, b: NDArrayCore): boolea
 export declare function shares_memory(a: NDArrayCore, b: NDArrayCore): boolean;
 export declare const geterr: typeof advancedOps.geterr;
 export declare const seterr: typeof advancedOps.seterr;
+export type NDIndex = number | string | number[] | NDArrayCore;
+/**
+ * Vectorized multi-dimensional indexing (dask.vindex semantics).
+ *
+ * Integer-array subspace dimensions come first in the output, followed by
+ * slice dimensions in their original order.
+ */
+export declare function vindex(a: NDArrayCore, ...indices: (number | string | number[] | NDArrayCore)[]): NDArrayCore;
 //# sourceMappingURL=advanced.d.ts.map

package/dist/types/core/creation.d.ts

@@ -19,7 +19,7 @@ export declare function zeros(shape: number[], dtype?: DType): NDArrayCore;
  */
 export declare function ones(shape: number[], dtype?: DType): NDArrayCore;
 /**
- * Create an uninitialized array (zeros in JS)
+ * Create an uninitialized array
  */
 export declare function empty(shape: number[], dtype?: DType): NDArrayCore;
 /**

package/dist/types/core/index.d.ts

@@ -19,12 +19,13 @@ export { sum, mean, prod, max, amax, min, amin, ptp, argmin, argmax, variance, v
 export { logical_and, logical_or, logical_not, logical_xor, isfinite, isinf, isnan, isnat, isneginf, isposinf, iscomplex, iscomplexobj, isreal, isrealobj, real_if_close, isfortran, isscalar, iterable, isdtype, promote_types, copysign, signbit, nextafter, spacing, greater, greater_equal, less, less_equal, equal, not_equal, isclose, allclose, } from './logic';
 export { sort, argsort, lexsort, partition, argpartition, sort_complex, nonzero, argwhere, flatnonzero, where, searchsorted, extract, count_nonzero, } from './sorting';
 export { bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, bitwise_count, bitwise_invert, bitwise_left_shift, bitwise_right_shift, } from './bitwise';
-export { around, round_, round, ceil, fix, floor, rint, trunc } from './rounding';
+export { around, round, ceil, fix, floor, rint, trunc } from './rounding';
 export { unique, in1d, intersect1d, isin, setdiff1d, setxor1d, union1d, trim_zeros, unique_all, unique_counts, unique_inverse, unique_values, } from './sets';
 export { bincount, digitize, histogram, histogram2d, histogramdd, correlate, convolve, cov, corrcoef, histogram_bin_edges, trapezoid, } from './statistics';
 export { diff, ediff1d, gradient } from './gradient';
 export { real, imag, conj, conjugate, angle } from './complex';
-export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, take_along_axis, put_along_axis, choose, compress, select, place, putmask, copyto, indices, ix_, ravel_multi_index, unravel_index, diag_indices, diag_indices_from, fill_diagonal, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, array_equal, array_equiv, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, geterr, seterr, iindex, bindex, } from './advanced';
+export { broadcast_to, broadcast_arrays, broadcast_shapes, take, put, take_along_axis, put_along_axis, choose, compress, select, place, putmask, copyto, indices, ix_, ravel_multi_index, unravel_index, diag_indices, diag_indices_from, fill_diagonal, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, array_equal, array_equiv, apply_along_axis, apply_over_axes, may_share_memory, shares_memory, geterr, seterr, iindex, bindex, vindex, } from './advanced';
+export type { NDIndex } from './advanced';
 export { set_printoptions, get_printoptions, printoptions, format_float_positional, format_float_scientific, base_repr, binary_repr, array2string, array_repr, array_str, } from './formatting';
 export { ndim, shape, size, item, tolist, tobytes, byteswap, view, tofile, fill } from './utility';
 export { append, delete_, delete_ as delete, insert, pad } from './shape-extra';
@@ -37,4 +38,97 @@ export { parseNpz, parseNpzSync, loadNpz, loadNpzSync, type NpzParseOptions, typ
 export { serializeNpz, serializeNpzSync, type NpzArraysInput, type NpzSerializeOptions, } from '../io/npz/serializer';
 export { parseTxt, genfromtxt, fromregex, type ParseTxtOptions } from '../io/txt/parser';
 export { serializeTxt, type SerializeTxtOptions } from '../io/txt/serializer';
+import * as randomOps from '../common/ops/random';
+import { ArrayStorage } from '../common/storage';
+import { NDArrayCore as NDArrayCoreClass } from '../common/ndarray-core';
+import { DType } from '../common/dtype';
+export declare const random: {
+    seed: typeof randomOps.seed;
+    get_state: typeof randomOps.get_state;
+    set_state: typeof randomOps.set_state;
+    get_bit_generator: typeof randomOps.get_bit_generator;
+    set_bit_generator: typeof randomOps.set_bit_generator;
+    default_rng: (seedValue?: number) => {
+        random: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        choice: (a: number | (ArrayStorage | NDArrayCoreClass), size?: number | number[], replace?: boolean, p?: (ArrayStorage | NDArrayCoreClass) | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        permutation: (x: number | (ArrayStorage | NDArrayCoreClass)) => ArrayStorage | NDArrayCoreClass;
+        shuffle: (x: ArrayStorage | NDArrayCoreClass) => void;
+        exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+        binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    };
+    Generator: typeof randomOps.Generator;
+    random: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    rand: (...shape: number[]) => number | ArrayStorage | NDArrayCoreClass;
+    randn: (...shape: number[]) => number | ArrayStorage | NDArrayCoreClass;
+    randint: (low: number, high?: number | null, size?: number | number[], dtype?: DType) => number | ArrayStorage | NDArrayCoreClass;
+    random_sample: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    ranf: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    sample: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    random_integers: (low: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    bytes: typeof randomOps.bytes;
+    uniform: (low?: number, high?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    normal: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_normal: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    exponential: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_exponential: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    gamma: (shape: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_gamma: (shape: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    beta: (a: number, b: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    chisquare: (df: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    noncentral_chisquare: (df: number, nonc: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    f: (dfnum: number, dfden: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    noncentral_f: (dfnum: number, dfden: number, nonc: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_cauchy: (size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    standard_t: (df: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    laplace: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    logistic: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    lognormal: (mean?: number, sigma?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    gumbel: (loc?: number, scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    pareto: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    power: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    rayleigh: (scale?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    triangular: (left: number, mode: number, right: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    wald: (mean: number, scale: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    weibull: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    poisson: (lam?: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    geometric: (p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    hypergeometric: (ngood: number, nbad: number, nsample: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    logseries: (p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    negative_binomial: (n: number, p: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    zipf: (a: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    multinomial: (n: number, pvals: number[] | ArrayStorage, size?: number | number[]) => ArrayStorage | NDArrayCoreClass;
+    multivariate_normal: (mean: number[] | ArrayStorage, cov: number[][] | ArrayStorage, size?: number | number[], check_valid?: "warn" | "raise" | "ignore", tol?: number) => ArrayStorage | NDArrayCoreClass;
+    dirichlet: (alpha: number[] | ArrayStorage, size?: number | number[]) => ArrayStorage | NDArrayCoreClass;
+    vonmises: (mu: number, kappa: number, size?: number | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    choice: (a: number | ArrayStorage, size?: number | number[], replace?: boolean, p?: ArrayStorage | number[]) => number | ArrayStorage | NDArrayCoreClass;
+    permutation: (x: number | ArrayStorage) => ArrayStorage | NDArrayCoreClass;
+    shuffle: (x: NDArrayCoreClass | ArrayStorage) => void;
+};
+type ArrayInput = NDArrayCoreClass | ArrayStorage;
+export declare const fft: {
+    fft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ifft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    fft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ifft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    fftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ifftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    rfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    irfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    rfft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    irfft2: (a: ArrayInput, s?: [number, number], axes?: [number, number], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    rfftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    irfftn: (a: ArrayInput, s?: number[], axes?: number[], norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    hfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    ihfft: (a: ArrayInput, n?: number, axis?: number, norm?: "backward" | "ortho" | "forward") => NDArrayCoreClass;
+    fftfreq: (n: number, d?: number) => NDArrayCoreClass;
+    rfftfreq: (n: number, d?: number) => NDArrayCoreClass;
+    fftshift: (a: ArrayInput, axes?: number | number[]) => NDArrayCoreClass;
+    ifftshift: (a: ArrayInput, axes?: number | number[]) => NDArrayCoreClass;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/types/core/linalg.d.ts

@@ -48,7 +48,7 @@ export declare const linalg: {
     /** Dot product */
     dot: (a: NDArrayCore, b: NDArrayCore) => NDArrayCore | number | bigint | Complex;
     /** Matrix determinant (supports batched ND input) */
-    det: (a: NDArrayCore) => number | NDArrayCore;
+    det: (a: NDArrayCore) => number | Complex | NDArrayCore;
     /** Matrix inverse */
     inv: (a: NDArrayCore) => NDArrayCore;
     /** Solve linear system Ax = b */

package/dist/types/core/rounding.d.ts

@@ -7,8 +7,6 @@
 import { NDArrayCore } from './types';
 /** Round to given decimals */
 export declare function around(a: NDArrayCore, decimals?: number): NDArrayCore;
-/** Alias for around */
-export declare const round_: typeof around;
 /** Round (same as around) */
 export declare function round(a: NDArrayCore, decimals?: number): NDArrayCore;
 /** Ceiling */

package/dist/types/core/sets.d.ts

@@ -12,7 +12,10 @@ export declare function unique(ar: NDArrayCore, returnIndex?: boolean, returnInv
     inverse?: NDArrayCore;
     counts?: NDArrayCore;
 };
-/** Test if elements in ar1 are in ar2 (deprecated, use isin) */
+/**
+ * Test if elements in ar1 are in ar2.
+ * @deprecated Use {@link isin} instead. `in1d` follows NumPy's deprecation and will be removed in a future release.
+ */
 export declare function in1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;
 /** Find intersection of two arrays */
 export declare function intersect1d(ar1: NDArrayCore, ar2: NDArrayCore): NDArrayCore;

package/dist/types/core/statistics.d.ts

@@ -4,6 +4,7 @@
  * This module provides statistical operations that can be
  * imported independently for optimal tree-shaking.
  */
+import { Complex } from '../common/complex';
 import { NDArrayCore } from './types';
 type BinStrategyString = 'auto' | 'fd' | 'doane' | 'scott' | 'stone' | 'rice' | 'sturges' | 'sqrt';
 /** Count occurrences of values */
@@ -27,6 +28,6 @@ export declare function corrcoef(x: NDArrayCore, y?: NDArrayCore, rowvar?: boole
 /** Compute histogram bin edges */
 export declare function histogram_bin_edges(a: NDArrayCore, bins?: number | BinStrategyString, range?: [number, number], weights?: NDArrayCore): NDArrayCore;
 /** Integrate using trapezoidal rule */
-export declare function trapezoid(y: NDArrayCore, x?: NDArrayCore, dx?: number, axis?: number): NDArrayCore | number;
+export declare function trapezoid(y: NDArrayCore, x?: NDArrayCore, dx?: number, axis?: number): NDArrayCore | number | Complex;
 export {};
 //# sourceMappingURL=statistics.d.ts.map