@danielsimonjr/mathts-tensor 0.2.18 → 0.2.20

package/dist/operations/roll.d.ts

@@ -0,0 +1,44 @@
+/**
+ * roll — cyclic shift along given axes.
+ *
+ * Each element is moved `shifts[k]` positions forward along `axes[k]`
+ * (wrapping around at the axis boundaries). Negative shifts move backward.
+ *
+ * When `axes` is omitted, `shifts` must be a single number and the tensor is
+ * treated as a flattened 1-D array that is shifted by that amount, then
+ * reshaped back to the original shape — exactly matching NumPy `np.roll(t, n)`.
+ *
+ * Implementation: for each output flat index, the corresponding input flat
+ * index is computed by decoding the multi-index, un-shifting each specified
+ * axis (with modulo wrap), then re-encoding to a flat input index.
+ *
+ * Axis-label semantics: cyclic shifting does not change the semantic identity
+ * of any axis (it is the same axis with reordered elements), so all axis
+ * labels from the input are preserved unchanged in the output.
+ */
+import { Tensor } from '../Tensor.js';
+/**
+ * Cyclically shift a tensor along given axes.
+ *
+ * @param t      - Input tensor of any rank.
+ * @param shifts - Number of positions to shift. A single number when `axes` is
+ *                 omitted (flat shift); an array of the same length as `axes`
+ *                 when `axes` is provided.
+ * @param axes   - Axes to shift along. Supports negative indexing. When
+ *                 omitted, the tensor is treated as flattened and `shifts` must
+ *                 be a single number.
+ * @returns A new `Tensor` with the same shape as `t`, with axis labels
+ *          preserved from `t`.
+ *
+ * @throws {Error} If `axes` is provided and `shifts` array length !== `axes`
+ *                 length, or if any axis value is out of range.
+ *
+ * @example
+ * // Shift a rank-1 tensor [1,2,3,4,5] by 2: → [4,5,1,2,3]
+ * const r = roll(t, 2, [0]);
+ *
+ * // Flat shift (no axes):
+ * const flat = roll(matrix, 3);
+ */
+export declare function roll(t: Tensor, shifts: number | readonly number[], axes?: readonly number[]): Tensor;
+//# sourceMappingURL=roll.d.ts.map

package/dist/operations/roll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roll.d.ts","sourceRoot":"","sources":["../../src/operations/roll.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAClB,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,EAClC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,CAkFR"}

package/dist/operations/scatter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * scatter — inverse of gather. Writes `updates` into a copy of `t` at the
+ * given `indices` along `axis` (NumPy `np.put_along_axis` / JAX `scatter`).
+ *
+ * For each position `i` in `indices`, the corresponding "slice" of `updates`
+ * along `axis` is written into the matching "slice" of the output at position
+ * `indices[i]`. All positions of `t` not referenced by `indices` are copied
+ * unchanged.
+ *
+ * Duplicate-index semantics: **last-wins** — when the same index appears more
+ * than once in `indices`, the last occurrence overwrites earlier ones. This
+ * mirrors NumPy's default scatter behaviour. Document-level note: if
+ * deterministic accumulation (e.g. `add`) is needed, use `ScatterOpts.reduce`.
+ *
+ * Axis-label semantics: the output has exactly the same shape as `t`
+ * (scatter never changes the size of any axis), so all axis labels from `t`
+ * are preserved unchanged.
+ */
+import { Tensor } from '../Tensor.js';
+export interface ScatterOpts {
+    /**
+     * How to combine `updates` with existing values at the target positions.
+     * - `'overwrite'` (default) — last-wins; target is replaced.
+     * - `'add'`                 — target is incremented by the update value.
+     */
+    reduce?: 'overwrite' | 'add';
+}
+/**
+ * Scatter `updates` into a copy of `t` at `indices` along `axis`.
+ *
+ * @param t       - Destination tensor (not mutated). Any rank.
+ * @param axis    - The axis along which to scatter. Supports negative indexing.
+ * @param indices - Target positions along `axis`. Must all be in
+ *                  `[0, t.shape[axis])`. Duplicates are allowed (last-wins
+ *                  by default, or add-accumulate when `opts.reduce === 'add'`).
+ * @param updates - Source tensor. Must have the same rank as `t` with
+ *                  `updates.shape[axis] === indices.length` and all other
+ *                  dimensions equal to `t.shape`.
+ * @param opts    - Optional scatter options.
+ * @returns A new `Tensor` with the same shape as `t`, with axis labels
+ *          preserved from `t`.
+ *
+ * @throws {Error}      If `axis` is out of range, `updates` rank mismatches,
+ *                      or `updates` shape is incompatible.
+ * @throws {RangeError} If any index in `indices` is outside `[0, shape[axis])`.
+ *
+ * @example
+ * // Round-trip with gather: scatter zeros back to a masked copy
+ * const zeros = new Tensor([3, 4], new Float64Array(12));
+ * const result = scatter(zeros, 0, [0, 2], gather(t, 0, [0, 2]));
+ * // result[0, :] === t[0, :], result[1, :] === 0, result[2, :] === t[2, :]
+ */
+export declare function scatter(t: Tensor, axis: number, indices: readonly number[], updates: Tensor, opts?: ScatterOpts): Tensor;
+//# sourceMappingURL=scatter.d.ts.map

package/dist/operations/scatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scatter.d.ts","sourceRoot":"","sources":["../../src/operations/scatter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,MAAM,CAAC,EAAE,WAAW,GAAG,KAAK,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,WAAW,GACjB,MAAM,CAsFR"}

package/dist/operations/slice.d.ts

@@ -0,0 +1,43 @@
+/**
+ * slice — extract a sub-tensor by per-axis [start, stop, step] ranges.
+ *
+ * Mirrors NumPy / JAX basic slicing semantics:
+ *   - Negative indices wrap around: -1 refers to the last element.
+ *   - `null` range for an axis means "take the entire axis".
+ *   - `step` must be >= 1 (reverse-step slicing is deferred).
+ *   - Output shape for axis i: Math.ceil((stop - start) / step).
+ *
+ * Axis-label semantics: labels from the input axes are preserved in the
+ * output. A slice is still the same logical axis — just smaller — so the
+ * label name and tags are carried forward (dimension is updated to match the
+ * new axis size; the id is re-minted since the Index type is immutable and
+ * dimension is part of the index identity).
+ */
+import { Tensor } from '../Tensor.js';
+export interface SliceRange {
+    /** Default 0. Supports negative indexing: -1 means shape[axis]-1. */
+    start?: number;
+    /** Default = shape[axis]. Supports negative indexing. */
+    stop?: number;
+    /** Default 1. Must be >= 1 (no reverse step). */
+    step?: number;
+}
+/**
+ * Extract a sub-tensor by per-axis `SliceRange` triples.
+ *
+ * @param t      - Input tensor of any rank.
+ * @param ranges - Array of length `t.shape.length`. Each element is either a
+ *                 `SliceRange` or `null` (which means "take the entire axis").
+ *                 Must have the same length as `t.shape`.
+ * @returns A new `Tensor` whose shape[i] = ceil((stop_i - start_i) / step_i),
+ *          carrying preserved axis labels (same name/tags, updated dim).
+ *
+ * @throws {RangeError} If `step` is not a positive integer.
+ * @throws {Error}      If `ranges.length !== t.shape.length`.
+ *
+ * @example
+ * // Extract rows 1–3 (exclusive), all columns from a 5×4 tensor:
+ * const sub = slice(t, [{ start: 1, stop: 3 }, null]);
+ */
+export declare function slice(t: Tensor, ranges: (SliceRange | null)[]): Tensor;
+//# sourceMappingURL=slice.d.ts.map

package/dist/operations/slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../src/operations/slice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,UAAU,GAAG,IAAI,CAAC,EAAE,GAAG,MAAM,CA0EtE"}

package/dist/operations/solve.d.ts

@@ -0,0 +1,54 @@
+/**
+ * tensorSolve — named-index linear solver for rank-N tensors.
+ *
+ * Reshapes tensor A into a square matrix and tensor b into a column vector (or
+ * multi-column RHS matrix), solves A·x = b via LU decomposition with partial
+ * pivoting, and reshapes the solution back.
+ *
+ * Axis matching:
+ *   - When A has `axisLabels` and `b` has `axisLabels`, the "row" axes of A
+ *     are matched to axes of `b` by Index identity (ignoring prime level).
+ *   - Otherwise `rowAxesA` / `rowAxesB` (integer indices) must be provided,
+ *     or the first axes of each tensor are used by default.
+ *
+ * Constraints:
+ *   - The reshaped A must be square (numRows_A × numRows_A).
+ *   - A must be non-singular (LU decomposition throws if pivot is zero).
+ *   - For multi-RHS, the RHS col dimension must match A's row dimension.
+ *
+ * Result shape:
+ *   - `x` has shape [...colDimsA, ...colDimsB] where colDimsA are the axes
+ *     of A not used as row axes and colDimsB are the axes of b not used as
+ *     row (contracting) axes.
+ *   - When A is square as a whole tensor (rank 2), the result has the same
+ *     shape as b.
+ *
+ * Axis labels: propagated from A's col axes and b's col axes.
+ */
+import { Tensor } from '../Tensor.js';
+import { Index } from '../named-index.js';
+export interface TensorSolveOpts {
+    /**
+     * Axis indices (integers) or Index objects of A that form the "contracting"
+     * (row) side of the square matrix. Default: first `ceil(rank/2)` axes.
+     */
+    rowAxesA?: ReadonlyArray<number | Index>;
+    /**
+     * Axis indices (integers) or Index objects of b that form the "contracting"
+     * (row) side matched to A's row dimension. Default: first axis of b.
+     */
+    rowAxesB?: ReadonlyArray<number | Index>;
+}
+export interface TensorSolveResult {
+    /** Solution tensor x satisfying A·x ≈ b. */
+    x: Tensor;
+}
+/**
+ * Solve A·x = b for x using LU decomposition.
+ *
+ * @param A    - Coefficient tensor (rank ≥ 2 when reshaped to square).
+ * @param b    - Right-hand side tensor.
+ * @param opts - Optional axis-selection overrides.
+ */
+export declare function tensorSolve(A: Tensor, b: Tensor, opts?: TensorSolveOpts): TensorSolveResult;
+//# sourceMappingURL=solve.d.ts.map

package/dist/operations/solve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve.d.ts","sourceRoot":"","sources":["../../src/operations/solve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAI1C,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,iBAAiB;IAChC,4CAA4C;IAC5C,CAAC,EAAE,MAAM,CAAC;CACX;AAoED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,iBAAiB,CA8J3F"}

package/dist/operations/stack.d.ts

@@ -0,0 +1,50 @@
+/**
+ * stack — stack same-shape tensors along a new axis (NumPy `stack`).
+ *
+ * All input tensors must have identical shapes. A new axis is inserted at
+ * position `axis` in the output, making the output rank = input rank + 1.
+ * `stack([a, b], 0)` is equivalent to NumPy's `np.stack([a, b], axis=0)`.
+ *
+ * Axis-label semantics:
+ *   - The new axis gets `undefined` label by default (it has no correspondence
+ *     to any input axis).
+ *   - Pass `opts.newAxisLabel` (an `Index`) to label the new axis explicitly.
+ *   - The remaining axes inherit labels from `tensors[0]`. If labels disagree
+ *     across inputs for a given axis, `tensors[0]`'s label is used silently
+ *     (no error, no warning — document this choice here).
+ *   - If `tensors[0]` has no `axisLabels`, the output also carries none.
+ */
+import { Tensor } from '../Tensor.js';
+import { Index } from '../named-index.js';
+export interface StackOpts {
+    /**
+     * Optional label for the newly created axis. If omitted, the new axis
+     * carries no label (`axisLabels[axis] === undefined` in the output, or more
+     * precisely: the output `axisLabels` array contains `undefined` at that
+     * position — encoded as `null` in the array but TypeScript sees it as the
+     * slot being absent when axisLabels is stripped to only defined entries).
+     *
+     * In practice: if `tensors[0].axisLabels` is defined, an `Index` for the
+     * new axis is created either from this option or as a placeholder.
+     */
+    newAxisLabel?: Index;
+}
+/**
+ * Stack same-shape tensors along a new axis.
+ *
+ * @param tensors - Array of tensors, all with the same shape. Must be non-empty.
+ * @param axis    - Position of the new axis in the output. Supports negative
+ *                  indexing relative to the output rank. E.g. `axis=0` inserts
+ *                  a new leading axis; `axis=-1` appends a new trailing axis.
+ * @param opts    - Optional `newAxisLabel` for the inserted axis.
+ * @returns A tensor of rank `inputRank + 1` with `shape[axis] === tensors.length`.
+ *
+ * @throws {Error} If `tensors` is empty, or if any tensor's shape differs from
+ *                 `tensors[0]`.
+ *
+ * @example
+ * // Stack two row-vectors [a, b, c] and [d, e, f] → 2×3 matrix:
+ * const matrix = stack([v1, v2], 0);
+ */
+export declare function stack(tensors: Tensor[], axis: number, opts?: StackOpts): Tensor;
+//# sourceMappingURL=stack.d.ts.map

package/dist/operations/stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stack.d.ts","sourceRoot":"","sources":["../../src/operations/stack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAE1C,MAAM,WAAW,SAAS;IACxB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,KAAK,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAuF/E"}

package/dist/operations/svd.d.ts

@@ -0,0 +1,56 @@
+/**
+ * tensorSvd — truncated SVD for rank-N tensors.
+ *
+ * Partitions the axes of `t` into "row" axes (joining with U) and "col" axes
+ * (the remaining axes, joining with V), permutes + reshapes `t` into a 2-D
+ * matrix, calls the existing DenseMatrix SVD primitive, optionally truncates
+ * the singular-value spectrum, and reshapes U / S / V back into Tensors.
+ *
+ * Phase-2 note: `rowAxes` is positional-integer-only. The named-Index overload
+ * (accepting `ReadonlyArray<Index>`) is reserved for the Phase-1-enabled
+ * follow-up once `Index` is part of the Tensor surface.
+ *
+ * The `joiningIndexName` option is accepted for forward-compatibility with the
+ * labelled-tensor extension but is unused in Phase 2 — the output Tensors carry
+ * no `axisLabels`.
+ */
+import { Tensor } from '../Tensor.js';
+export interface TensorSvdOpts {
+    /** If set, keep at most `maxdim` singular values. */
+    maxdim?: number;
+    /**
+     * If set, drop singular values whose absolute value is strictly less than
+     * `cutoff`. Default is 0 (no cutoff). The test is `s >= cutoff`.
+     */
+    cutoff?: number;
+    /**
+     * Accepted for forward-compatibility with the labelled-tensor extension
+     * (Phase-2-extension follow-up). Currently unused — output Tensors carry
+     * no `axisLabels` in Phase 2.
+     */
+    joiningIndexName?: string;
+}
+export interface TensorSvdResult {
+    /** U factor reshaped to [...rowDims, k]. */
+    U: Tensor;
+    /** Singular values as a rank-1 Tensor of shape [k]. */
+    S: Tensor;
+    /** V factor reshaped to [k, ...colDims]. */
+    V: Tensor;
+    /** Number of singular values retained after truncation. */
+    truncatedDim: number;
+    /** Sum of squares of the dropped singular values (Frobenius-norm squared of the discarded part). */
+    truncationError: number;
+}
+/**
+ * Truncated tensor SVD using the pure-JS DenseMatrix SVD primitive (synchronous).
+ */
+export declare function tensorSvd(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorSvdOpts): TensorSvdResult;
+/**
+ * Truncated tensor SVD routed through the AssemblyScript WASM SVD kernel
+ * (`svdWasm`) — the same result as {@link tensorSvd} but accelerated for large
+ * matricisations. Async because WASM instantiation is async; falls back to JS
+ * inside `svdWasm` when no binary is available.
+ */
+export declare function tensorSvdWasm(t: Tensor, rowAxes: ReadonlyArray<number>, opts?: TensorSvdOpts): Promise<TensorSvdResult>;
+//# sourceMappingURL=svd.d.ts.map

package/dist/operations/svd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svd.d.ts","sourceRoot":"","sources":["../../src/operations/svd.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAItC,MAAM,WAAW,aAAa;IAC5B,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,4CAA4C;IAC5C,CAAC,EAAE,MAAM,CAAC;IACV,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;IACV,4CAA4C;IAC5C,CAAC,EAAE,MAAM,CAAC;IACV,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAC;IACrB,oGAAoG;IACpG,eAAe,EAAE,MAAM,CAAC;CACzB;AAkID;;GAEG;AACH,wBAAgB,SAAS,CACvB,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,IAAI,CAAC,EAAE,aAAa,GACnB,eAAe,CAGjB;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,CAAC,EAAE,MAAM,EACT,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,IAAI,CAAC,EAAE,aAAa,GACnB,OAAO,CAAC,eAAe,CAAC,CAG1B"}

package/package.json

@@ -1,57 +1,57 @@
-{
-  "name": "@danielsimonjr/mathts-tensor",
-  "version": "0.2.18",
-  "description": "Rank-N dense Tensor type for MathTS with Float64Array-backed storage",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
-  },
-  "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.13.0",
-    "@danielsimonjr/mathts-matrix": "^0.7.0"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/danielsimonjr/mathts",
-    "directory": "tensor"
-  },
-  "keywords": [
-    "math",
-    "tensor",
-    "linear-algebra",
-    "typescript"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-tensor",
+  "version": "0.2.20",
+  "description": "Rank-N dense Tensor type for MathTS with Float64Array-backed storage",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean && tsc -p tsconfig.dts.json",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "bun test --isolate --timeout 30000",
+    "test:watch": "vitest",
+    "test:coverage": "bun test --isolate --timeout 30000 --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint src --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup src/index.ts --format esm --dts --clean --minify --treeshake"
+  },
+  "dependencies": {
+    "@danielsimonjr/mathts-core": "^0.15.0",
+    "@danielsimonjr/mathts-matrix": "^0.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "tsup": "^8.0.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danielsimonjr/MathTS.git",
+    "directory": "tensor"
+  },
+  "keywords": [
+    "math",
+    "tensor",
+    "linear-algebra",
+    "typescript"
+  ]
+}