numpy-ts 0.5.0 → 0.7.0

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @module numpy-ts
  */
-export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, dot, trace, transpose, inner, outer, tensordot, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, broadcast_to, broadcast_arrays, take, put, choose, array_equal, } from './core/ndarray';
+export { NDArray, zeros, ones, array, arange, linspace, logspace, geomspace, eye, empty, full, identity, asarray, copy, zeros_like, ones_like, empty_like, full_like, asanyarray, ascontiguousarray, asfortranarray, diag, diagflat, frombuffer, fromfile, fromfunction, fromiter, fromstring, meshgrid, tri, tril, triu, vander, sqrt, power, absolute, negative, sign, mod, floor_divide, positive, reciprocal, cbrt, fabs, divmod, square, remainder, heaviside, dot, trace, diagonal, kron, transpose, inner, outer, tensordot, einsum, sin, cos, tan, arcsin, arccos, arctan, arctan2, hypot, degrees, radians, deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, swapaxes, moveaxis, concatenate, stack, vstack, hstack, dstack, split, array_split, vsplit, hsplit, tile, repeat, ravel, reshape, squeeze, expand_dims, flip, fliplr, flipud, rot90, roll, rollaxis, atleast_1d, atleast_2d, atleast_3d, dsplit, column_stack, row_stack, resize, append, delete_ as delete, insert, pad, broadcast_to, broadcast_arrays, broadcast_shapes, take, put, choose, array_equal, array_equiv, take_along_axis, put_along_axis, putmask, compress, select, place, diag_indices, diag_indices_from, tril_indices, tril_indices_from, triu_indices, triu_indices_from, mask_indices, indices, ix_, ravel_multi_index, unravel_index, cumsum, cumprod, ptp, median, percentile, quantile, average, nansum, nanprod, nanmean, nanvar, nanstd, nanmin, nanmax, nanargmin, nanargmax, nancumsum, nancumprod, nanmedian, bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert, left_shift, right_shift, packbits, unpackbits, } from './core/ndarray';
 export { parseNpy, serializeNpy, parseNpyHeader, parseNpyData, UnsupportedDTypeError, InvalidNpyError, SUPPORTED_DTYPES, DTYPE_TO_DESCR, type NpyHeader, type NpyMetadata, type NpyVersion, parseNpz, parseNpzSync, loadNpz, loadNpzSync, serializeNpz, serializeNpzSync, type NpzParseOptions, type NpzParseResult, type NpzSerializeOptions, } from './io';
 export declare const __version__: string;
 //# sourceMappingURL=index.d.ts.map

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

@@ -5,6 +5,7 @@
  * @module ops/advanced
  */
 import { ArrayStorage } from '../core/storage';
+import { broadcastShapes } from '../core/broadcasting';
 /**
  * Broadcast an array to a given shape
  * Returns a read-only view on the original array
@@ -15,6 +16,11 @@ export declare function broadcast_to(storage: ArrayStorage, targetShape: number[
  * Returns views on the original arrays
  */
 export declare function broadcast_arrays(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Compute the broadcast shape for multiple shapes
+ * Re-export from core/broadcasting for convenience
+ */
+export { broadcastShapes as broadcast_shapes };
 /**
  * Take elements from an array along an axis
  */
@@ -31,4 +37,72 @@ export declare function choose(indexStorage: ArrayStorage, choices: ArrayStorage
  * Check if two arrays are element-wise equal
  */
 export declare function array_equal(a: ArrayStorage, b: ArrayStorage, equal_nan?: boolean): boolean;
+/**
+ * Take values along an axis using 1D index array
+ */
+export declare function take_along_axis(storage: ArrayStorage, indices: ArrayStorage, axis: number): ArrayStorage;
+/**
+ * Put values into array along an axis using 1D index array
+ */
+export declare function put_along_axis(storage: ArrayStorage, indices: ArrayStorage, values: ArrayStorage, axis: number): void;
+/**
+ * Change elements of array based on conditional mask
+ */
+export declare function putmask(storage: ArrayStorage, mask: ArrayStorage, values: ArrayStorage | number | bigint): void;
+/**
+ * Return selected slices along given axis based on condition
+ */
+export declare function compress(condition: ArrayStorage, storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return array drawn from elements in choicelist, depending on conditions
+ */
+export declare function select(condlist: ArrayStorage[], choicelist: ArrayStorage[], defaultValue?: number | bigint): ArrayStorage;
+/**
+ * Change elements of array based on conditional and input values
+ */
+export declare function place(storage: ArrayStorage, mask: ArrayStorage, vals: ArrayStorage): void;
+/**
+ * Return indices to access main diagonal of array
+ */
+export declare function diag_indices(n: number, ndim?: number): ArrayStorage[];
+/**
+ * Return indices to access main diagonal of array from given array
+ */
+export declare function diag_indices_from(storage: ArrayStorage): ArrayStorage[];
+/**
+ * Return indices for lower-triangle of an (n, m) array
+ */
+export declare function tril_indices(n: number, k?: number, m?: number): ArrayStorage[];
+/**
+ * Return indices for lower-triangle of given array
+ */
+export declare function tril_indices_from(storage: ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return indices for upper-triangle of an (n, m) array
+ */
+export declare function triu_indices(n: number, k?: number, m?: number): ArrayStorage[];
+/**
+ * Return indices for upper-triangle of given array
+ */
+export declare function triu_indices_from(storage: ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return indices to access elements using mask function
+ */
+export declare function mask_indices(n: number, mask_func: (n: number, k: number) => ArrayStorage, k?: number): ArrayStorage[];
+/**
+ * Return array representing indices of a grid
+ */
+export declare function indices(dimensions: number[], dtype?: 'int32' | 'int64' | 'float64'): ArrayStorage;
+/**
+ * Construct open mesh from multiple sequences
+ */
+export declare function ix_(...args: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert multi-dimensional index arrays to flat index array
+ */
+export declare function ravel_multi_index(multi_index: ArrayStorage[], dims: number[], mode?: 'raise' | 'wrap' | 'clip'): ArrayStorage;
+/**
+ * Convert flat index array to tuple of coordinate arrays
+ */
+export declare function unravel_index(indices: ArrayStorage | number, shape: number[], order?: 'C' | 'F'): ArrayStorage[];
 //# sourceMappingURL=advanced.d.ts.map

package/dist/types/ops/arithmetic.d.ts

@@ -105,4 +105,58 @@ export declare function positive(a: ArrayStorage): ArrayStorage;
  * @returns Result storage with reciprocal values
  */
 export declare function reciprocal(a: ArrayStorage): ArrayStorage;
+/**
+ * Cube root of each element
+ * NumPy behavior: Promotes integer types to float64
+ *
+ * @param a - Input array storage
+ * @returns Result storage with cube root values
+ */
+export declare function cbrt(a: ArrayStorage): ArrayStorage;
+/**
+ * Absolute value of each element, returning float
+ * NumPy behavior: fabs always returns floating point
+ *
+ * @param a - Input array storage
+ * @returns Result storage with absolute values as float
+ */
+export declare function fabs(a: ArrayStorage): ArrayStorage;
+/**
+ * Returns both quotient and remainder (floor divide and modulo)
+ * NumPy behavior: divmod(a, b) = (floor_divide(a, b), mod(a, b))
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Tuple of [quotient, remainder] storages
+ */
+export declare function divmod(a: ArrayStorage, b: ArrayStorage | number): [ArrayStorage, ArrayStorage];
+/**
+ * Element-wise square of each element
+ * NumPy behavior: x**2
+ *
+ * @param a - Input array storage
+ * @returns Result storage with squared values
+ */
+export declare function square(a: ArrayStorage): ArrayStorage;
+/**
+ * Remainder of division (same as mod)
+ * NumPy behavior: Same as mod, alias for compatibility
+ *
+ * @param a - Dividend array storage
+ * @param b - Divisor (array storage or scalar)
+ * @returns Result storage with remainder values
+ */
+export declare function remainder(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Heaviside step function
+ * NumPy behavior:
+ *   heaviside(x1, x2) = 0 if x1 < 0
+ *                     = x2 if x1 == 0
+ *                     = 1 if x1 > 0
+ *
+ * @param x1 - Input array storage
+ * @param x2 - Value to use when x1 == 0 (array storage or scalar)
+ * @returns Result storage with heaviside values
+ */
+export declare function heaviside(x1: ArrayStorage, x2: ArrayStorage | number): ArrayStorage;
 //# sourceMappingURL=arithmetic.d.ts.map

package/dist/types/ops/bitwise.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Bitwise operations
+ *
+ * Pure functions for element-wise bitwise operations:
+ * bitwise_and, bitwise_or, bitwise_xor, bitwise_not, invert,
+ * left_shift, right_shift, packbits, unpackbits
+ *
+ * These operations only work on integer types.
+ */
+import { ArrayStorage } from '../core/storage';
+/**
+ * Bitwise AND of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_and(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise OR of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_or(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise XOR of two arrays or array and scalar
+ *
+ * @param a - First array storage (must be integer type)
+ * @param b - Second array storage or scalar (must be integer type)
+ * @returns Result storage
+ */
+export declare function bitwise_xor(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Bitwise NOT (invert) of each element
+ *
+ * @param a - Input array storage (must be integer type)
+ * @returns Result storage with bitwise NOT values
+ */
+export declare function bitwise_not(a: ArrayStorage): ArrayStorage;
+/**
+ * Invert (bitwise NOT) - alias for bitwise_not
+ *
+ * @param a - Input array storage (must be integer type)
+ * @returns Result storage with inverted values
+ */
+export declare function invert(a: ArrayStorage): ArrayStorage;
+/**
+ * Left shift of array elements
+ *
+ * @param a - Input array storage (must be integer type)
+ * @param b - Shift amount (array storage or scalar)
+ * @returns Result storage with left-shifted values
+ */
+export declare function left_shift(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Right shift of array elements
+ *
+ * @param a - Input array storage (must be integer type)
+ * @param b - Shift amount (array storage or scalar)
+ * @returns Result storage with right-shifted values
+ */
+export declare function right_shift(a: ArrayStorage, b: ArrayStorage | number): ArrayStorage;
+/**
+ * Pack binary values into uint8 array
+ *
+ * Packs the elements of a binary-valued array into bits in a uint8 array.
+ * The result has the same shape as the input, except for the specified axis
+ * which is divided by 8 (rounded up).
+ *
+ * @param a - Input array (values are interpreted as binary: 0 or non-zero)
+ * @param axis - The dimension over which bit-packing is done (default: -1, meaning the last axis)
+ * @param bitorder - The order of bits within each packed byte. 'big' means the most significant bit is first. (default: 'big')
+ * @returns Packed uint8 array
+ */
+export declare function packbits(a: ArrayStorage, axis?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+/**
+ * Unpack uint8 array into binary values
+ *
+ * Unpacks elements of a uint8 array into a binary-valued output array.
+ * Each element of the input array is unpacked into 8 binary values.
+ *
+ * @param a - Input uint8 array
+ * @param axis - The dimension over which bit-unpacking is done (default: -1, meaning the last axis)
+ * @param count - The number of elements to unpack along axis, or -1 for all (default: -1)
+ * @param bitorder - The order of bits within each packed byte. 'big' means the most significant bit is first. (default: 'big')
+ * @returns Unpacked uint8 array of 0s and 1s
+ */
+export declare function unpackbits(a: ArrayStorage, axis?: number, count?: number, bitorder?: 'big' | 'little'): ArrayStorage;
+//# sourceMappingURL=bitwise.d.ts.map

package/dist/types/ops/comparison.d.ts

@@ -40,4 +40,16 @@ export declare function isclose(a: ArrayStorage, b: ArrayStorage | number, rtol?
  * Returns true if all elements satisfy isclose condition
  */
 export declare function allclose(a: ArrayStorage, b: ArrayStorage | number, rtol?: number, atol?: number): boolean;
+/**
+ * Returns True if two arrays are element-wise equal within a tolerance.
+ * Unlike array_equal, this function broadcasts the arrays before comparison.
+ *
+ * NumPy behavior: Broadcasts arrays before comparing, returns True if shapes
+ * are broadcast-compatible and all elements are equal.
+ *
+ * @param a1 - First input array
+ * @param a2 - Second input array
+ * @returns True if arrays are equivalent (after broadcasting), False otherwise
+ */
+export declare function arrayEquiv(a1: ArrayStorage, a2: ArrayStorage): boolean;
 //# sourceMappingURL=comparison.d.ts.map

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

@@ -92,4 +92,55 @@ export declare function outer(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
  * @returns Tensor dot product
  */
 export declare function tensordot(a: ArrayStorage, b: ArrayStorage, axes: number | [number[], number[]]): ArrayStorage | number | bigint;
+/**
+ * Extract a diagonal or construct a diagonal array.
+ *
+ * NumPy behavior:
+ * - For 2D arrays: extract the k-th diagonal
+ * - For ND arrays (N >= 2): extract diagonal from the axes specified
+ * - Returns a view when possible, copy otherwise
+ *
+ * @param a - Input array (must be at least 2D)
+ * @param offset - Offset of the diagonal from the main diagonal (default: 0)
+ *                 - offset > 0: diagonal above main diagonal
+ *                 - offset < 0: diagonal below main diagonal
+ * @param axis1 - First axis for ND arrays (default: 0)
+ * @param axis2 - Second axis for ND arrays (default: 1)
+ * @returns Array containing the diagonal elements
+ */
+export declare function diagonal(a: ArrayStorage, offset?: number, axis1?: number, axis2?: number): ArrayStorage;
+/**
+ * Einstein summation convention
+ *
+ * Performs tensor contractions and reductions using Einstein summation notation.
+ *
+ * Examples:
+ * - 'ij,jk->ik': matrix multiplication
+ * - 'i,i->': dot product (inner product)
+ * - 'ij->ji': transpose
+ * - 'ii->': trace
+ * - 'ij->j': sum over first axis
+ * - 'ijk,ikl->ijl': batched matrix multiplication
+ *
+ * @param subscripts - Einstein summation subscripts (e.g., 'ij,jk->ik')
+ * @param operands - Input arrays
+ * @returns Result of the Einstein summation
+ */
+export declare function einsum(subscripts: string, ...operands: ArrayStorage[]): ArrayStorage | number | bigint;
+/**
+ * Kronecker product of two arrays.
+ *
+ * Computes the Kronecker product, a composite array made of blocks of the
+ * second array scaled by the elements of the first.
+ *
+ * NumPy behavior:
+ * - If both inputs are vectors (1D), output is also a vector
+ * - If both inputs are 2D matrices, output shape is (m1*m2, n1*n2)
+ * - General case: broadcasts shapes then computes block product
+ *
+ * @param a - First input array
+ * @param b - Second input array
+ * @returns Kronecker product of a and b
+ */
+export declare function kron(a: ArrayStorage, b: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=linalg.d.ts.map

package/dist/types/ops/reduction.d.ts

@@ -58,4 +58,80 @@ export declare function all(storage: ArrayStorage, axis?: number, keepdims?: boo
  * Test whether any array elements along a given axis evaluate to True
  */
 export declare function any(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | boolean;
+/**
+ * Return cumulative sum of elements along a given axis
+ */
+export declare function cumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return cumulative product of elements along a given axis
+ */
+export declare function cumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Peak to peak (maximum - minimum) value along a given axis
+ */
+export declare function ptp(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the median along the specified axis
+ */
+export declare function median(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th percentile of data along specified axis
+ */
+export declare function percentile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the q-th quantile of data along specified axis
+ */
+export declare function quantile(storage: ArrayStorage, q: number, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute the weighted average along the specified axis
+ */
+export declare function average(storage: ArrayStorage, axis?: number, weights?: ArrayStorage, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return sum of elements, treating NaNs as zero
+ */
+export declare function nansum(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return product of elements, treating NaNs as one
+ */
+export declare function nanprod(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute mean ignoring NaN values
+ */
+export declare function nanmean(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute variance ignoring NaN values
+ */
+export declare function nanvar(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Compute standard deviation ignoring NaN values
+ */
+export declare function nanstd(storage: ArrayStorage, axis?: number, ddof?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return minimum ignoring NaN values
+ */
+export declare function nanmin(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return maximum ignoring NaN values
+ */
+export declare function nanmax(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
+/**
+ * Return indices of minimum value, ignoring NaNs
+ */
+export declare function nanargmin(storage: ArrayStorage, axis?: number): ArrayStorage | number;
+/**
+ * Return indices of maximum value, ignoring NaNs
+ */
+export declare function nanargmax(storage: ArrayStorage, axis?: number): ArrayStorage | number;
+/**
+ * Return cumulative sum, treating NaNs as zero
+ */
+export declare function nancumsum(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Return cumulative product, treating NaNs as one
+ */
+export declare function nancumprod(storage: ArrayStorage, axis?: number): ArrayStorage;
+/**
+ * Compute median ignoring NaN values
+ */
+export declare function nanmedian(storage: ArrayStorage, axis?: number, keepdims?: boolean): ArrayStorage | number;
 //# sourceMappingURL=reduction.d.ts.map

package/dist/types/ops/shape.d.ts

@@ -97,4 +97,48 @@ export declare function tile(storage: ArrayStorage, reps: number | number[]): Ar
  * Repeat elements of an array
  */
 export declare function repeat(storage: ArrayStorage, repeats: number | number[], axis?: number): ArrayStorage;
+/**
+ * Reverse the order of elements in an array along given axis
+ */
+export declare function flip(storage: ArrayStorage, axis?: number | number[]): ArrayStorage;
+/**
+ * Rotate array by 90 degrees in the plane specified by axes
+ */
+export declare function rot90(storage: ArrayStorage, k?: number, axes?: [number, number]): ArrayStorage;
+/**
+ * Roll array elements along a given axis
+ */
+export declare function roll(storage: ArrayStorage, shift: number | number[], axis?: number | number[]): ArrayStorage;
+/**
+ * Roll the specified axis backwards until it lies in a given position
+ */
+export declare function rollaxis(storage: ArrayStorage, axis: number, start?: number): ArrayStorage;
+/**
+ * Split array along third axis (depth)
+ */
+export declare function dsplit(storage: ArrayStorage, indicesOrSections: number | number[]): ArrayStorage[];
+/**
+ * Stack 1-D arrays as columns into a 2-D array
+ */
+export declare function columnStack(storages: ArrayStorage[]): ArrayStorage;
+/**
+ * Stack arrays in sequence vertically (row_stack is an alias for vstack)
+ */
+export declare const rowStack: typeof vstack;
+/**
+ * Resize array to new shape (returns new array, may repeat or truncate)
+ */
+export declare function resize(storage: ArrayStorage, newShape: number[]): ArrayStorage;
+/**
+ * Convert arrays to at least 1D
+ */
+export declare function atleast1d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert arrays to at least 2D
+ */
+export declare function atleast2d(storages: ArrayStorage[]): ArrayStorage[];
+/**
+ * Convert arrays to at least 3D
+ */
+export declare function atleast3d(storages: ArrayStorage[]): ArrayStorage[];
 //# sourceMappingURL=shape.d.ts.map

package/dist/types/ops/trig.d.ts

@@ -91,4 +91,20 @@ export declare function degrees(a: ArrayStorage): ArrayStorage;
  * @returns Angles in radians
  */
 export declare function radians(a: ArrayStorage): ArrayStorage;
+/**
+ * Convert angles from degrees to radians (alias for radians).
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in degrees)
+ * @returns Angles in radians
+ */
+export declare function deg2rad(a: ArrayStorage): ArrayStorage;
+/**
+ * Convert angles from radians to degrees (alias for degrees).
+ * NumPy behavior: Always promotes to float64 for integer types
+ *
+ * @param a - Input array storage (angles in radians)
+ * @returns Angles in degrees
+ */
+export declare function rad2deg(a: ArrayStorage): ArrayStorage;
 //# sourceMappingURL=trig.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numpy-ts",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Complete NumPy implementation for TypeScript and JavaScript (under construction)",
   "main": "dist/numpy-ts.node.cjs",
   "browser": "dist/numpy-ts.browser.js",
@@ -54,8 +54,10 @@
     "test:ci": "npm run lint && npm run typecheck && npm test && npm run test:bundles",
     "test:summary": "vitest run --reporter=tap | grep -E 'not ok|# tests'",
     "test:watch": "vitest watch",
-    "test:coverage": "vitest run tests/unit --coverage",
-    "test:coverage:view": "vitest run tests/unit --coverage; open coverage/index.html",
+    "test:coverage": "vitest run --project=unit --coverage",
+    "test:coverage:view": "vitest run --project=unit --coverage && open coverage/index.html",
+    "test:coverage:validation": "vitest run --project=validation-quick --coverage",
+    "test:coverage:validation:view": "vitest run --project=validation-quick --coverage && open coverage/index.html",
     "test:coverage:all": "vitest run --coverage",
     "lint": "eslint src tests --ext .ts",
     "lint:fix": "eslint src tests --ext .ts --fix",
@@ -111,7 +113,6 @@
     "lint-staged": "^16.2.6",
     "playwright": "^1.56.1",
     "prettier": "^3.1.1",
-    "ts-node": "^10.9.2",
     "tsx": "^4.20.6",
     "typescript": "^5.3.3",
     "vitest": "^4.0.3"