numbl 0.3.0 → 0.4.0

package/dist-lib/numbl-core/jit/jitTypes.d.ts

@@ -1,394 +0,0 @@
-/**
- * JIT type system and IR node definitions.
- */
-import type { BinaryOperation, UnaryOperation } from "../parser/types.js";
-export type SignCategory = "positive" | "nonneg" | "nonpositive" | "negative";
-export type JitType = {
-    kind: "number";
-    exact?: number;
-    sign?: SignCategory;
-    isInteger?: boolean;
-} | {
-    kind: "boolean";
-    value?: boolean;
-} | {
-    kind: "complex_or_number";
-    pureImaginary?: boolean;
-} | {
-    kind: "tensor";
-    isComplex: boolean;
-    shape?: number[];
-    ndim?: number;
-    isLogical?: boolean;
-    nonneg?: boolean;
-} | {
-    kind: "string";
-    value?: string;
-} | {
-    kind: "char";
-    value?: string;
-} | {
-    kind: "struct";
-    fields?: Record<string, JitType>;
-} | {
-    /**
-     * A 1-D homogeneous array of structs (matlab struct array form
-     * `T.nodes(i)`). `elemFields` records the per-element field types
-     * unified across all elements. `length` is optional and carries
-     * the statically-known element count when available.
-     */
-    kind: "struct_array";
-    elemFields?: Record<string, JitType>;
-    length?: number;
-} | {
-    kind: "class_instance";
-    className: string;
-    isHandleClass?: boolean;
-    fields?: Record<string, JitType>;
-} | {
-    kind: "sparse_matrix";
-    isComplex: boolean;
-    m?: number;
-    n?: number;
-} | {
-    kind: "cell";
-    shape?: number[];
-} | {
-    kind: "dictionary";
-} | {
-    kind: "function_handle";
-} | {
-    kind: "unknown";
-};
-export declare function signFromNumber(v: number): SignCategory | undefined;
-export declare function isNonneg(t: JitType): boolean;
-export declare function flipSign(s?: SignCategory): SignCategory | undefined;
-export declare function unifySign(a?: SignCategory, b?: SignCategory): SignCategory | undefined;
-export declare function jitTypeKey(t: JitType): string;
-export declare function computeJitCacheKey(nargout: number, argTypes: JitType[]): string;
-/** Compute a unique JS function name for a JIT'd specialization. */
-export declare function computeJitFnName(identity: string, funcName: string): string;
-/** Widen/unify two types at control-flow join points. */
-export declare function unifyJitTypes(a: JitType, b: JitType): JitType;
-export declare function isScalarType(t: JitType): boolean;
-export declare function isNumericScalarType(t: JitType): boolean;
-export declare function isTensorType(t: JitType): boolean;
-export declare function isComplexType(t: JitType): boolean;
-/** True when the type guarantees an integer value at runtime (safe for |0). */
-export declare function isKnownInteger(t: JitType): boolean;
-/** Types that support arithmetic binary operations in the JIT. */
-export declare function isArithmeticType(t: JitType): boolean;
-export declare function shapeAfterReduction(shape: number[], dim?: number): {
-    scalar: true;
-} | {
-    scalar: false;
-    shape: number[];
-};
-export type JitExpr = {
-    tag: "NumberLiteral";
-    value: number;
-    jitType: JitType;
-} | {
-    tag: "ImagLiteral";
-    jitType: JitType;
-} | {
-    tag: "Var";
-    name: string;
-    jitType: JitType;
-} | {
-    tag: "Binary";
-    op: BinaryOperation;
-    left: JitExpr;
-    right: JitExpr;
-    jitType: JitType;
-} | {
-    tag: "Unary";
-    op: UnaryOperation;
-    operand: JitExpr;
-    jitType: JitType;
-} | {
-    tag: "StringLiteral";
-    value: string;
-    isChar: boolean;
-    jitType: JitType;
-} | {
-    tag: "Call";
-    name: string;
-    args: JitExpr[];
-    jitType: JitType;
-} | {
-    tag: "UserCall";
-    jitName: string;
-    name: string;
-    args: JitExpr[];
-    jitType: JitType;
-} | {
-    tag: "Index";
-    base: JitExpr;
-    indices: JitExpr[];
-    jitType: JitType;
-} | {
-    /**
-     * Range slice read on a real tensor: `src(a:b)` producing a fresh
-     * column-vector tensor of length `b - a + 1`. Stage 21 — unblocks
-     * chunkie's chunk_nearparam Newton loop which splits a Legendre
-     * expansion vector via `r0 = all0(1:dim)`.
-     *
-     * Codegen emits `$h.subarrayCopy1r(srcData, srcLen, start, end)`
-     * using the hoisted data/length aliases. Per-iter allocation is
-     * unavoidable without a range-alias extension to stage 5; small
-     * slices are cheap in V8 young-gen.
-     */
-    tag: "RangeSliceRead";
-    baseName: string;
-    start: JitExpr;
-    /** `null` when the range endpoint is the `end` keyword — codegen
-     *  substitutes the hoisted `.data.length` alias. */
-    end: JitExpr | null;
-    /** True when the source is a statically-known row vector
-     *  (shape `[1, n]`); the slice then preserves row orientation.
-     *  Otherwise the slice is a column vector (MATLAB semantics). */
-    isRow: boolean;
-    jitType: JitType;
-} | {
-    tag: "TensorLiteral";
-    rows: JitExpr[][];
-    nRows: number;
-    nCols: number;
-    jitType: JitType;
-} | {
-    /**
-     * Vertical concat growth: `[base; value]` where `base` is a real
-     * column-vector (or empty) tensor and `value` is a numeric scalar.
-     * Lowered from the chunkie grow-a-list pattern `it = [it; i]`.
-     * Codegens to `$h.vconcatGrow1r(base, value)` which allocates a
-     * fresh `(k+1, 1)` tensor and copies.
-     */
-    tag: "VConcatGrow";
-    base: JitExpr;
-    value: JitExpr;
-    jitType: JitType;
-} | {
-    /**
-     * Scalar read of a struct field: `s.f` where `s` has a struct type
-     * with a statically-known scalar field `f`. Lowered from `Member`
-     * exprs with an `Ident` base. The codegen hoists each unique
-     * `(baseName, fieldName)` pair to a local alias at function entry
-     * so per-iter reads are bare local loads (no `Map.get` per use).
-     * Mirrors the chunkie `opts.rho`, `chnkr.k`, `chnkr.nch` pattern.
-     */
-    tag: "MemberRead";
-    baseName: string;
-    fieldName: string;
-    jitType: JitType;
-} | {
-    /**
-     * Chained struct array member read: `T.nodes(i).leaf` where
-     * `T.nodes` is a struct array whose elements all share a field
-     * `leaf`. Lowered from the parser shape
-     * `Member(MethodCall(Ident(T), "nodes", [i]), "leaf")`.
-     *
-     * Codegen hoists `var $T_nodes_elements = T.fields.get("nodes").elements`
-     * at function entry (one alias per unique (structVarName,
-     * structArrayFieldName) pair) and emits
-     * `$T_nodes_elements[Math.round(i) - 1].fields.get("leaf")` per use.
-     *
-     * `leafFieldJitType` records the result type: either a scalar
-     * numeric type (number/boolean/complex_or_number) or a real tensor.
-     * Tensor-valued leaves work because the existing per-Assign hoist
-     * refresh picks up the newly-read tensor when the result flows
-     * into `chld = T.nodes(i).chld` and the callers then use
-     * `chld(k)` through the hoisted alias path.
-     */
-    tag: "StructArrayMemberRead";
-    structVarName: string;
-    structArrayFieldName: string;
-    indexExpr: JitExpr;
-    leafFieldName: string;
-    jitType: JitType;
-} | {
-    /**
-     * Indirect call through a function handle variable: `f(a, b)` where
-     * `f` has JitType `function_handle`. The codegen emits
-     * `$h.callFuncHandle($rt, f, arg1, arg2, ...)` which invokes the
-     * handle via its `jsFn` closure (or falls back to `rt.dispatch`).
-     * The `returnType` is determined at lowering time by probing the
-     * function handle's runtime value.
-     */
-    tag: "FuncHandleCall";
-    name: string;
-    args: JitExpr[];
-    jitType: JitType;
-} | {
-    /**
-     * User function call that bailed recursive lowering (stage 24 —
-     * soft-bail). Instead of bailing the containing loop, emit a
-     * runtime dispatch through the interpreter. Return type is
-     * determined at JIT compile time by probing (actually calling
-     * the function once with representative args). The helper
-     * `callUserFunc` verifies the actual return type on every call
-     * and throws `JitFuncHandleBailError` on mismatch so the loop
-     * runner can invalidate the cache entry and fall back to
-     * interpretation.
-     *
-     * Use case: `oneintp(...)` / `lege.exev(...)` in chunkie's adap
-     * inner loop — the callee body has tensor arithmetic the JIT
-     * can't inline, but the outer loop (scalar stack + col-slice
-     * writes + scalar compares) is a perfect JIT fit.
-     */
-    tag: "UserDispatchCall";
-    name: string;
-    args: JitExpr[];
-    jitType: JitType;
-};
-export type JitStmt = {
-    tag: "Assign";
-    name: string;
-    expr: JitExpr;
-} | {
-    tag: "AssignIndex";
-    /** Name of the tensor variable being written to (must be an Ident-based lvalue). */
-    baseName: string;
-    /** Scalar index expressions (1..3). */
-    indices: JitExpr[];
-    /** RHS scalar value to store. */
-    value: JitExpr;
-    /** Type of the base tensor (for codegen to choose the right helper). */
-    baseType: JitType;
-} | {
-    /**
-     * Range-slice write of the form `dst(a:b) = src(c:d)` or
-     * `dst(a:b) = src` (whole-tensor source). Both `dst` and `src` must
-     * be real tensors, and the LHS must use exactly one (linear) range
-     * index. Used by the loop JIT for the chunkie grow-and-copy pattern.
-     *
-     * When `srcStart` and `srcEnd` are both `null`, the source is used
-     * in its entirety — codegen substitutes `1` and `srcLen` (the
-     * source's hoisted length alias). This is stage 9's whole-tensor
-     * RHS form: `isp(1:nn) = itemp` where `itemp` is a plain Var.
-     */
-    tag: "AssignIndexRange";
-    baseName: string;
-    baseType: JitType;
-    dstStart: JitExpr;
-    dstEnd: JitExpr;
-    srcBaseName: string;
-    srcType: JitType;
-    srcStart: JitExpr | null;
-    srcEnd: JitExpr | null;
-} | {
-    /**
-     * Multi-dim column slice write `dst(:, j) = src` where both `dst`
-     * and `src` are real tensors. LHS must be `Index(Ident(dst),
-     * [Colon, scalar_j])` with `dst` having statically 2-D shape.
-     * RHS must be a plain Ident referencing a real-tensor var whose
-     * total element count matches `dst.shape[0]` at runtime.
-     *
-     * Used by the loop JIT for chunkie's adapgausskerneval column
-     * stack write: `vals(:, jj+1) = v2`. Also covers
-     * chunkerinterior's `rss(:, jj) = rval(:, k)` after a slice
-     * alias binds the RHS.
-     */
-    tag: "AssignIndexCol";
-    baseName: string;
-    baseType: JitType;
-    colIndex: JitExpr;
-    srcBaseName: string;
-    srcType: JitType;
-} | {
-    /**
-     * Page-slice write `dst(:, :, k) = rhs` where `dst` is a 3-D tensor
-     * and `rhs` is a 2-D tensor. Real-base + complex-rhs upgrades the
-     * base to complex in place.  Drives chunkie helm2d.green's
-     * `grad(:,:,k) = ...` / `hess(:,:,k) = ...` assignments.
-     */
-    tag: "AssignIndexPage3d";
-    baseName: string;
-    /** Base tensor type AFTER the write (may be complex even if the
-     *  initializer was real — the lowerer promotes in ctx.env). */
-    baseType: JitType;
-    /** Page index (1-based). */
-    pageIndex: JitExpr;
-    /** 2-D tensor RHS. */
-    value: JitExpr;
-} | {
-    /**
-     * Struct field assign lvalue `s.f = v`. When `needsPromote` is
-     * true, the base is (re)initialized as a fresh empty struct
-     * before the field is set — mirrors MATLAB's
-     * `s = []; s.f = v` idiom that promotes the empty matrix to a
-     * struct on first field write. `valueType` is the JIT type of
-     * `value` so stage 12 can hoist subsequent reads through a
-     * typed alias.
-     */
-    tag: "AssignMember";
-    baseName: string;
-    fieldName: string;
-    value: JitExpr;
-    needsPromote: boolean;
-} | {
-    tag: "If";
-    cond: JitExpr;
-    thenBody: JitStmt[];
-    elseifBlocks: {
-        cond: JitExpr;
-        body: JitStmt[];
-    }[];
-    elseBody: JitStmt[] | null;
-} | {
-    tag: "For";
-    varName: string;
-    start: JitExpr;
-    step: JitExpr | null;
-    end: JitExpr;
-    body: JitStmt[];
-} | {
-    tag: "While";
-    cond: JitExpr;
-    body: JitStmt[];
-} | {
-    tag: "Break";
-} | {
-    tag: "Continue";
-} | {
-    tag: "Return";
-} | {
-    tag: "ExprStmt";
-    expr: JitExpr;
-} | {
-    tag: "MultiAssign";
-    names: (string | null)[];
-    callName: string;
-    args: JitExpr[];
-    outputTypes: JitType[];
-} | {
-    /**
-     * Call a synthetic specialization (installed as a forwarder on $h)
-     * and write back multiple outputs into outer-scope vars. Only
-     * produced by the hybrid-loop pass in hybrid.ts, which
-     * replaces a For/While JitStmt with this call form when the
-     * extracted loop specialization compiled to native C.
-     *
-     * Semantics (0 / 1 / N outputs):
-     *   nargout==0 → emit `$h.callUser(...)` as a stmt (no writeback)
-     *   nargout==1 → emit `out = $h.callUser(...)`
-     *   nargout>=2 → emit `var $r = $h.callUser(...); out0=$r[0]; ...`
-     */
-    tag: "UserCallWriteback";
-    outputs: string[];
-    jitName: string;
-    name: string;
-    args: JitExpr[];
-    outputTypes: JitType[];
-} | {
-    tag: "SetLoc";
-    line: number;
-} | {
-    /** C-JIT assertion: if this JitStmt survives to JS codegen at --opt 2,
-     *  emit a runtime throw. The C-JIT codegen elides it. */
-    tag: "AssertCJit";
-};
-export interface JitCacheEntry {
-    fn: (...args: unknown[]) => unknown;
-    source: string;
-}

package/dist-lib/numbl-core/jit/js/jitCodegen.d.ts

@@ -1,7 +0,0 @@
-/**
- * JIT IR -> JavaScript code generation.
- *
- * IR walkers for hoist-pass data collection are in jitCodegenHoist.ts.
- */
-import { type JitStmt } from "../jitTypes.js";
-export declare function generateJS(body: JitStmt[], params: string[], outputs: string[], nargout: number, localVars: Set<string>, fileName?: string, experimental?: string, par?: boolean): string;

package/dist-lib/numbl-core/jit/js/jitCodegenHoist.d.ts

@@ -1,70 +0,0 @@
-/**
- * IR walkers for the JIT codegen hoist pass.
- *
- * These pure functions walk the JIT IR to collect information needed
- * for hoisting tensor aliases, struct field reads, and struct array
- * element reads to the top of the generated function.
- */
-import type { JitStmt } from "../jitTypes.js";
-/**
- * Hoisted aliases for a tensor variable read/written in the loop body.
- * Maps the original variable name to local JS identifiers for its
- * .data, .data.length, .shape[0], and .shape[1].
- */
-export interface HoistedAlias {
-    data: string;
-    len: string;
-    d0: string;
-    d1: string;
-    maxDim: number;
-    isWriteTarget: boolean;
-    isParam: boolean;
-}
-export declare function structFieldKey(baseName: string, fieldName: string): string;
-export declare function structArrayElementsKey(structVarName: string, structArrayFieldName: string): string;
-export interface TensorUsage {
-    maxReadDim: number;
-    maxWriteDim: number;
-    isReal: boolean;
-}
-/**
- * Walk the JIT IR collecting, for every variable that appears as the base
- * of an Index read, AssignIndex write, or AssignIndexRange write, the
- * maximum indexing arity and whether all uses are on a real tensor.
- */
-export declare function collectTensorUsage(body: JitStmt[]): Map<string, TensorUsage>;
-/**
- * Walk the JIT IR collecting every base name that is the target of an
- * `AssignMember` stmt (stage 22 struct field write). Used by the
- * codegen to emit a one-time `$h.structUnshare_h(s)` at function entry
- * for any such name that is also a function parameter — this preserves
- * MATLAB value semantics when structs are passed by value and the
- * callee mutates a field.
- */
-export declare function collectStructMemberWrites(body: JitStmt[]): Set<string>;
-/**
- * Walk the JIT IR collecting every name that is the target of any
- * plain `Assign` stmt. Used by the stage-12 struct-field-read hoist to
- * decide whether a struct-typed param is safe to hoist: if the body
- * ever reassigns the name (e.g. `s = [];` promoted to struct, or `s =
- * struct()` inside the loop), the pre-loop hoisted field aliases would
- * be stale and must be disabled.
- */
-export declare function collectPlainAssignTargets(body: JitStmt[]): Set<string>;
-/**
- * Walk the JIT IR collecting all unique (baseName, fieldName) pairs
- * referenced by MemberRead nodes. The codegen hoists each pair as a
- * local alias at function entry.
- */
-export declare function collectStructFieldReads(body: JitStmt[]): Map<string, {
-    baseName: string;
-    fieldName: string;
-}>;
-/**
- * Walk the JIT IR collecting all unique (structVarName, structArrayFieldName)
- * pairs referenced by StructArrayMemberRead nodes.
- */
-export declare function collectStructArrayElementReads(body: JitStmt[]): Map<string, {
-    structVarName: string;
-    structArrayFieldName: string;
-}>;

package/dist-lib/numbl-core/jit/js/jitHelpers.d.ts

@@ -1,34 +0,0 @@
-/**
- * JIT runtime helpers assembly point.
- *
- * This module assembles the $h helpers object from focused sub-modules:
- * - jitHelpersComplex.ts — complex number arithmetic
- * - jitHelpersIndex.ts  — tensor indexing (generic, fast-path, hoisted)
- * - jitHelpersTensor.ts — tensor binary/unary ops, concat, COW
- *
- * The $h object is passed to every JIT-compiled function. V8 inline
- * caches require a stable hidden class, so buildPerRuntimeJitHelpers()
- * creates a fresh snapshot via a single spread expression.
- */
-export { re, im, mkc, cAdd, cSub, cMul, cDiv, cNeg, cConj, cAngle, cTruthy, } from "./jitHelpersComplex.js";
-export { bce, idx1, idx2, idxN, idx1r, idx2r, idx3r, idx1r_h, idx2r_h, idx3r_h, set1r_h, set2r_h, set3r_h, setRange1r_h, setCol2r_h, subarrayCopy1r, subarrayCopy1rRow, } from "./jitHelpersIndex.js";
-export { makeTensor, tensorBinaryOp, tensorCompareOp, tensorUnary, tensorNeg, vconcatGrow1r, unshare, shareTensor, asTensor, tDouble, tSum, tAdd, tSub, tMul, tDiv, tPow, tEq, tNeq, tLt, tLe, tGt, tGe, } from "./jitHelpersTensor.js";
-export { JitBailToInterpreter } from "./jitHelpersIndex.js";
-/**
- * Thrown when a function handle called from JIT code returns a type
- * different from what the JIT expected (determined by probing at compile
- * time). The loop runner catches this and falls back to interpretation.
- */
-export declare class JitFuncHandleBailError extends Error {
-    readonly fnName: string;
-    readonly expectedType: string;
-    readonly actualType: string;
-    constructor(fnName: string, expectedType: string, actualType: string);
-}
-export declare const jitHelpers: Record<string, unknown>;
-import type { IBuiltin } from "../../interpreter/builtins/index.js";
-/**
- * Build a per-runtime jitHelpers snapshot. Uses a single spread expression
- * for a fresh V8 hidden class (critical for inline-cache performance).
- */
-export declare function buildPerRuntimeJitHelpers(jsUserFunctions: ReadonlyMap<string, IBuiltin>): Record<string, any>;

package/dist-lib/numbl-core/jit/js/jitHelpersComplex.d.ts

@@ -1,21 +0,0 @@
-/**
- * Complex number arithmetic helpers for JIT-compiled code.
- * These are pure functions used by the $h helpers object.
- */
-import type { RuntimeComplexNumber } from "../../runtime/types.js";
-export declare function re(v: unknown): number;
-export declare function im(v: unknown): number;
-export declare function mkc(r: number, i: number): number | RuntimeComplexNumber;
-export declare function cAdd(a: unknown, b: unknown): number | RuntimeComplexNumber;
-export declare function cSub(a: unknown, b: unknown): number | RuntimeComplexNumber;
-export declare function cMul(a: unknown, b: unknown): number | RuntimeComplexNumber;
-/**
- * Complex division using Smith's method to avoid overflow/underflow.
- * Handles division by zero consistently with MATLAB (produces Inf, not NaN).
- */
-export declare function cDiv(a: unknown, b: unknown): number | RuntimeComplexNumber;
-export declare function cNeg(a: unknown): number | RuntimeComplexNumber;
-export declare function cConj(a: unknown): number | RuntimeComplexNumber;
-export declare function cAngle(a: unknown): number;
-/** Complex truthiness: nonzero if either real or imag part is nonzero. */
-export declare function cTruthy(v: unknown): boolean;

package/dist-lib/numbl-core/jit/js/jitHelpersIndex.d.ts

@@ -1,33 +0,0 @@
-/**
- * Tensor indexing helpers for JIT-compiled code.
- *
- * Three tiers of helpers, from most general to most specialized:
- * 1. Generic (idx1, idx2, idxN) — handle any base type, real or complex
- * 2. Real-tensor fast path (idx1r, idx2r, idx3r) — skip type/imag checks
- * 3. Hoisted-base (idx*r_h, set*r_h) — take pre-extracted data/len/shape
- *
- * All helpers use 1-based MATLAB indexing and include per-dimension bounds
- * checks to ensure consistency with the interpreter.
- */
-import { type FloatXArrayType, type RuntimeTensor } from "../../runtime/types.js";
-export declare class JitBailToInterpreter extends Error {
-    readonly reason: string;
-    constructor(reason: string);
-}
-export declare function bce(): never;
-export declare function idx1(base: unknown, i: number): unknown;
-export declare function idx2(base: unknown, ri: number, ci: number): unknown;
-export declare function idxN(base: unknown, indices: number[]): unknown;
-export declare function idx1r(base: RuntimeTensor, i: number): number;
-export declare function idx2r(base: RuntimeTensor, ri: number, ci: number): number;
-export declare function idx3r(base: RuntimeTensor, i1: number, i2: number, i3: number): number;
-export declare function idx1r_h(data: FloatXArrayType, len: number, i: number): number;
-export declare function idx2r_h(data: FloatXArrayType, len: number, rows: number, ri: number, ci: number): number;
-export declare function idx3r_h(data: FloatXArrayType, len: number, d0: number, d1: number, i1: number, i2: number, i3: number): number;
-export declare function set1r_h(data: FloatXArrayType, len: number, i: number, v: number): void;
-export declare function set2r_h(data: FloatXArrayType, len: number, rows: number, ri: number, ci: number, v: number): void;
-export declare function set3r_h(data: FloatXArrayType, len: number, d0: number, d1: number, i1: number, i2: number, i3: number, v: number): void;
-export declare function setRange1r_h(dstData: FloatXArrayType, dstLen: number, dstStart: number, dstEnd: number, srcData: FloatXArrayType, srcLen: number, srcStart: number, srcEnd: number): void;
-export declare function subarrayCopy1r(srcData: FloatXArrayType, srcLen: number, start: number, end: number): RuntimeTensor;
-export declare function subarrayCopy1rRow(srcData: FloatXArrayType, srcLen: number, start: number, end: number): RuntimeTensor;
-export declare function setCol2r_h(dstData: FloatXArrayType, dstRows: number, dstLen: number, col: number, srcData: FloatXArrayType, srcLen: number): void;

package/dist-lib/numbl-core/jit/js/jitHelpersTensor.d.ts

@@ -1,34 +0,0 @@
-/**
- * Tensor operation helpers for JIT-compiled code.
- * Handles element-wise binary/unary ops, comparison ops, concat, and
- * tensor coercion for struct-array field access.
- */
-import { type FloatXArrayType, type RuntimeTensor } from "../../runtime/types.js";
-import type { RuntimeComplexNumber } from "../../runtime/types.js";
-export declare function makeTensor(data: FloatXArrayType, imag: FloatXArrayType | undefined, shape: number[]): RuntimeTensor;
-/** Bump rc on a tensor (no-op for non-tensor values). Used for var-to-var
- *  JIT assignments so the aliased tensor is no longer eligible for
- *  in-place buffer reuse. */
-export declare function shareTensor(v: unknown): unknown;
-type ScalarVal = number | RuntimeComplexNumber;
-export declare function tensorBinaryOp(a: unknown, b: unknown, realOp: (x: number, y: number) => number, complexOp: (a: ScalarVal, b: ScalarVal) => ScalarVal): RuntimeTensor | ScalarVal;
-export declare function tensorCompareOp(a: unknown, b: unknown, cmp: (x: number, y: number) => boolean): RuntimeTensor;
-export declare function tensorUnary(dest: unknown, a: RuntimeTensor, fn: (x: number) => number): RuntimeTensor;
-export declare function tensorNeg(dest: unknown, a: RuntimeTensor): RuntimeTensor;
-export declare function tDouble(v: unknown): unknown;
-export declare function tSum(v: unknown): unknown;
-export declare function vconcatGrow1r(base: unknown, v: number): RuntimeTensor;
-export declare function unshare(t: unknown): RuntimeTensor;
-export declare function asTensor(v: unknown): RuntimeTensor;
-export declare const tAdd: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tSub: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tMul: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tDiv: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tPow: (_dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tEq: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tNeq: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tLt: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tLe: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tGt: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tGe: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export {};

package/dist-lib/numbl-core/jit/js/jsFusedCodegen.d.ts

@@ -1,17 +0,0 @@
-/**
- * Fused per-element loop emission for the JS-JIT.
- *
- * Given a FusibleChain (from fusion.ts), emits a single block-scoped
- * JavaScript `for` loop that evaluates all the chain's tensor assigns
- * as inline scalar expressions per element — no $h.tAdd / $h.tMul
- * helper calls, no intermediate tensor allocations.
- *
- * Tensor var references become either:
- *   - `__<name>_data[__i]`  for input params / pre-existing tensors
- *   - `__f_<name>`           for chain-produced intermediates (scalar local)
- *
- * The optional trailing reduction is absorbed as an inline accumulator
- * inside the same loop.
- */
-import type { FusibleChain } from "../fusion.js";
-export declare function emitJsFusedChain(lines: string[], indent: string, chain: FusibleChain, allTensorVars: ReadonlySet<string>, paramTensors: ReadonlySet<string>, outputTensorNames: ReadonlySet<string>, _localTensorNames: ReadonlySet<string>, complexTensorNames: ReadonlySet<string>, complexScalarVars: ReadonlySet<string>, mangle: (n: string) => string, experimental?: string, par?: boolean): void;