numbl 0.3.0 → 0.3.3

package/dist-lib/numbl-core/jit/e1/scalarFnKernel.d.ts

@@ -1,44 +0,0 @@
-/**
- * e1 (experimental) — whole-function scalar kernel emission.
- *
- * Complements [kernelEmit.ts](./kernelEmit.ts) (which handles tensor
- * fusible chains) by covering the other big win case: a user function
- * that is entirely scalar arithmetic — e.g. the inner loop of a
- * Horner-style series, a Runge-Kutta step on a handful of doubles,
- * benchmarks/scalar_bench.m's `run_bench(N, M)`.
- *
- * Under `--opt e1`, when a JIT-able function's signature and body are
- * purely scalar, we call `generateC()` (the same emitter the C-JIT
- * uses at `--opt 2`) and wrap its output with a thin inline JS
- * function that shells out to `$h.compileKernel(...)`. The C source
- * and koffi signature are inlined as JS string literals, so
- * `--dump-js` shows the complete picture.
- *
- * Scope for the prototype:
- *   - All params are scalar doubles / booleans (CParamDesc.kind === "scalar")
- *   - All outputs are scalar / boolean (COutputDesc.kind === "scalar" | "boolean")
- *   - No tic/toc, no Index reads (no errFlag), no disp(...) calls
- *
- * Anything outside that envelope returns `null` and the caller falls
- * back to the plain JS-JIT path, which still benefits from e1's
- * per-chain tensor kernels.
- */
-import type { FunctionDef } from "../../interpreter/types.js";
-import type { JitStmt, JitType } from "../jitTypes.js";
-import type { GeneratedFn } from "../jitLower.js";
-import type { Interpreter } from "../../interpreter/interpreter.js";
-export interface ScalarFnKernelResult {
-    /** The inline-compileKernel JS source. The JIT caller splices this
-     *  in place of the normal JS-JIT body. */
-    jsSource: string;
-    /** Content-addressed kernel name from generateC, for logging. */
-    kernelName: string;
-    /** Raw C source (also embedded in `jsSource` as a string literal).
-     *  Exposed for `--dump-c` / logging. */
-    cSource: string;
-}
-/**
- * Try to emit a whole-function scalar kernel for the given lowered IR.
- * Returns null when the function is not a pure-scalar candidate.
- */
-export declare function tryEmitScalarFnKernel(interp: Interpreter, fn: FunctionDef, body: JitStmt[], outputNames: string[], localVars: Set<string>, outputType: JitType | null, outputTypes: JitType[], argTypes: JitType[], nargout: number, generatedIRBodies: Map<string, GeneratedFn>): ScalarFnKernelResult | null;

package/dist-lib/numbl-core/jit/e2/assignKernel.d.ts

@@ -1,34 +0,0 @@
-/**
- * e2 — per-assign / chain kernel driver.
- *
- * Entry point `tryE2Assign` is called from `interpreterExec.ts` for
- * every `Assign` statement when `interp.experimental === "e2"`.
- *
- * Multi-LHS chain detection: scans consecutive suppressed Assigns
- * regardless of LHS name. For each chain LHS, uses scope-body liveness
- * (via `interp._currentScopeBody`) to decide whether the LHS escapes
- * (materializes as an `out_<name>` buffer) or is purely chain-local
- * (kept as a per-element stack-local). Reads of a chain LHS before
- * its first assign in the chain become `in_<name>` parameters.
- *
- * On success:
- *   - Single chain assign: handled like a one-stmt chain.
- *   - Multi-stmt chain: one C kernel runs all assigns, only escape
- *     LHSs materialize back to env. `interp._e2ChainAdvance` is set
- *     so the surrounding loop skips the consumed sibling stmts.
- *
- * Compilation failures are hard errors (RuntimeError). Classification
- * bails (non-classifiable RHS, mismatched lengths, etc.) silently fall
- * through to the regular interpreter path.
- */
-import type { Stmt } from "../../parser/types.js";
-import type { Interpreter } from "../../interpreter/interpreter.js";
-/**
- * Try to compile a chain (1+ stmts) starting at `stmt`. Returns true
- * on success — `interp._e2ChainAdvance` is set to the count of EXTRA
- * sibling stmts the kernel consumed (0 for a single-stmt chain).
- * Returns false to fall back to the regular interpreter path.
- */
-export declare function tryE2Assign(interp: Interpreter, stmt: Stmt & {
-    type: "Assign";
-}): boolean;

package/dist-lib/numbl-core/jit/e2/astToJitExpr.d.ts

@@ -1,25 +0,0 @@
-/**
- * e2 — minimal AST `Expr` → `JitExpr` lowerer.
- *
- * Only handles the whitelist that `classify.ts` accepts: Number, Ident,
- * whitelisted Binary/Unary, whitelisted FuncCall. Types are read from
- * the live runtime environment (the caller passes in a per-name
- * `JitType` lookup), so there's no cross-branch unification.
- *
- * The classifier already replaced opaque subtrees with synthetic Ident
- * nodes whose `name` is also in `envTypes`, so this lowerer doesn't need
- * to know about opacity — every Ident it sees has a known runtime type.
- */
-import type { Expr } from "../../parser/types.js";
-import type { JitExpr, JitType } from "../jitTypes.js";
-export declare class E2LowerError extends Error {
-}
-export interface LowerOptions {
-    /** When a `FuncCall{name, args}` has `name` in `envTypes` as a tensor,
-     *  treat it as tensor indexing and lower to an `Index` node instead
-     *  of looking up a builtin. Used by the e2 whole-loop kernel — the
-     *  chain emitters don't set this (their classifier has already
-     *  marked tensor-access FuncCalls as opaque). */
-    resolveFuncCallAsTensorIndex?: boolean;
-}
-export declare function lowerAstToJitExpr(expr: Expr, envTypes: ReadonlyMap<string, JitType>, options?: LowerOptions): JitExpr;

package/dist-lib/numbl-core/jit/e2/cache.d.ts

@@ -1,80 +0,0 @@
-/**
- * e2 — per-AST-node compiled-kernel cache.
- *
- * Each AST `Expr` (the RHS of an `Assign` we've seen at least once) maps
- * to a per-signature cache: the same expression visited with a different
- * runtime type signature produces a different specialization. The
- * signature includes input names, scalar-vs-tensor, complex-or-not, and
- * the LHS name (since the kernel hard-codes which output to write).
- *
- * The Map is keyed by the AST node identity, not by source text — two
- * identical-looking `r = r .* y` statements at different file:line
- * positions get separate cache entries, so a recompile from a
- * different call-site doesn't poison earlier ones.
- *
- * The cache holds either an `E2CacheEntry` or the `E2_BAILED` sentinel
- * indicating that classification or compilation failed for this
- * signature; the sentinel prevents re-attempting the same hopeless
- * lowering on every invocation.
- */
-import type { Stmt, BinaryOperation } from "../../parser/types.js";
-export type CompiledKernelFn = (...args: unknown[]) => unknown;
-export declare const E2_BAILED: unique symbol;
-export interface E2ReductionInfo {
-    /** Reduction op name (sum / prod / max / min / mean / any / all). */
-    reduceName: string;
-    /** Accumulator variable name in env. */
-    accName: string;
-    /** When true, the source pattern was `acc = acc OP reduce(...)`;
-     *  the driver applies the same OP to combine the kernel's scalar
-     *  output with the existing env value of `acc`. When false, the
-     *  source pattern was `acc = reduce(...)` and the kernel output is
-     *  written directly. */
-    hasAccumulate: boolean;
-    /** Only meaningful when `hasAccumulate` is true. */
-    accOp?: BinaryOperation;
-}
-/** Complex-path partitioning info. Present iff the kernel was compiled
- *  via the paired-buffer complex emitter. The driver uses these lists
- *  to marshal complex tensors (two pointers per tensor), complex
- *  scalars (two doubles per scalar), and to allocate complex output
- *  buffers (data + imag Float64Arrays). */
-export interface E2ComplexInfo {
-    complexTensorNames: string[];
-    realTensorNames: string[];
-    complexInputLhsNames: string[];
-    realInputLhsNames: string[];
-    complexScalarNames: string[];
-    realScalarNames: string[];
-    complexEscapeLhsNames: string[];
-    realEscapeLhsNames: string[];
-}
-export interface E2CacheEntry {
-    fn: CompiledKernelFn;
-    /** Env tensor input names (combined — for diagnostics). When
-     *  `complex` is defined, the complex marshaling code uses
-     *  `complex.complexTensorNames` and `complex.realTensorNames`
-     *  instead of this. */
-    tensorNames: string[];
-    /** Chain LHS names that need `in_<name>` (between tensors and scalars). */
-    inputLhsNames: string[];
-    /** Ordered scalar input names. */
-    scalarNames: string[];
-    /** Chain LHS names that materialize via `out_<name>` (escape names). */
-    escapeLhsNames: string[];
-    /** Number of chain assigns this entry encodes (0 for a standalone
-     *  reduction kernel, 1 for a single-assign chain kernel, >=2 for
-     *  multi-stmt chains). */
-    chainLength: number;
-    /** Set when the kernel produces a trailing scalar reduction output.
-     *  The driver allocates a `Float64Array(1)` for `out_acc`, calls the
-     *  kernel, then combines the result with `env[accName]` per the
-     *  `accOp` and `hasAccumulate` fields. Complex chains never set this
-     *  — the complex emitter rejects trailing reductions. */
-    reduction?: E2ReductionInfo;
-    /** Paired-buffer complex path info. When set, the marshaling code
-     *  takes the complex branch. */
-    complex?: E2ComplexInfo;
-}
-export declare function chainCacheGet(firstStmt: Stmt, sig: string): E2CacheEntry | typeof E2_BAILED | undefined;
-export declare function chainCacheSet(firstStmt: Stmt, sig: string, entry: E2CacheEntry | typeof E2_BAILED): void;

package/dist-lib/numbl-core/jit/e2/chainKernelEmit.d.ts

@@ -1,55 +0,0 @@
-/**
- * e2 — multi-LHS fused chain C kernel emission.
- *
- * Given a sequence of `JitExpr` RHSs each writing to a (possibly
- * distinct) chain LHS, produces one C function that runs every assign
- * in a single per-element loop. Each chain LHS becomes a stack-local
- * `double <name>` declared once at the top of the loop body. Within
- * the body, references to a chain-LHS name resolve to the stack-local
- * once the corresponding assign has run; before that point they
- * resolve to `in_<name>[i]` (so the kernel signature includes
- * `in_<lhsName>` for any chain LHS that's read before being written).
- *
- * After the per-iter assigns, every "escape" LHS (one that's actually
- * referenced by the rest of the function body) gets written to its
- * `out_<name>[i]` pointer. Chain-locals (only used inside the chain)
- * are dropped at the end of the iteration with no buffer materialized.
- *
- *     void e2c_<hash>(int64_t n,
- *                     const double *in_<input1>, ...,
- *                     [const double *in_<lhs_needing_input>, ...,]
- *                     double s_<scalar1>, ...,
- *                     double *out_<escape_lhs1>, ...)
- *     {
- *         #pragma omp simd
- *         for (int64_t i = 0; i < n; i++) {
- *             double <chain_lhs1>, <chain_lhs2>, ...;
- *             <chain_lhs1> = <stmt0_rhs_C>;
- *             <chain_lhs2> = <stmt1_rhs_C>;
- *             ...
- *             out_<escape_lhs1>[i] = <escape_lhs1>;
- *             out_<escape_lhs2>[i] = <escape_lhs2>;
- *         }
- *     }
- */
-import { type ChainAssignSpec, type KernelInputs } from "./emitShared.js";
-export type { ChainAssignSpec } from "./emitShared.js";
-export interface E2ChainEmitResult {
-    kernelName: string;
-    cSource: string;
-    koffiSig: string;
-    hash: string;
-    /** Tensor input names in signature order — does NOT include any
-     *  in_<lhs> entries. */
-    inputTensors: string[];
-    /** Chain LHS names that appear as `in_<name>` in the signature, in
-     *  order. */
-    inputLhsNames: string[];
-    /** Scalar input names in signature order. */
-    inputScalars: string[];
-    /** Chain LHS names that appear as `out_<name>` in the signature,
-     *  in order. */
-    escapeLhsNames: string[];
-    chainLength: number;
-}
-export declare function emitE2ChainKernel(assigns: ChainAssignSpec[], inputs: KernelInputs, par?: boolean): E2ChainEmitResult;

package/dist-lib/numbl-core/jit/e2/classify.d.ts

@@ -1,119 +0,0 @@
-/**
- * e2 (experimental) — per-assign expression classifier.
- *
- * Walks an AST `Expr` and decides whether it can be compiled into a
- * single per-element C kernel. The classifier never evaluates anything
- * — it only inspects the AST shape and the names referenced.
- *
- * Whitelist:
- *   - Number, Ident
- *   - Binary with arithmetic / comparison ops
- *   - Unary Plus, Minus, Not
- *   - FuncCall to a whitelisted scalar math builtin
- *
- * Anything outside the whitelist is recorded as an "opaque root": the
- * driver is expected to evaluate that subtree via the interpreter and
- * bind the result to a fresh synthetic name, then re-classify with that
- * name in scope.
- *
- * The classifier returns a list of opaque-root subtrees and the
- * "rewritten" expression that uses synthetic names where the opaque
- * roots used to be. The driver is responsible for runtime type checks
- * and for actually evaluating the opaque subtrees.
- */
-import type { Expr } from "../../parser/types.js";
-import { BinaryOperation } from "../../parser/types.js";
-export { BinaryOperation } from "../../parser/types.js";
-/** Scalar math builtins that map cleanly to C99. Mirrors the JS-JIT
- *  Math.* table plus pow / hypot / atan2 / etc. */
-export declare const E2_BUILTIN_WHITELIST: ReadonlySet<string>;
-/** One opaque subtree the driver must evaluate before invoking the
- *  kernel. The classifier replaces it in `emittableExpr` with an Ident
- *  named `syntheticName`. */
-export interface OpaqueRoot {
-    syntheticName: string;
-    expr: Expr;
-}
-export interface ClassifyResult {
-    /** AST with opaque subtrees replaced by Ident(syntheticName) nodes. */
-    emittableExpr: Expr;
-    /** Subtrees the driver must evaluate via the interpreter. */
-    opaqueRoots: OpaqueRoot[];
-    /** Identifiers referenced in `emittableExpr` that originated from the
-     *  user's environment (i.e. NOT synthetic opaque-root bindings). The
-     *  driver looks these up in the env to determine input types. */
-    envIdents: Set<string>;
-}
-/** Classify an expression. Always succeeds — the worst case is the
- *  whole expression becomes a single opaque root, which the driver
- *  will reject. */
-export declare function classifyExpr(expr: Expr): ClassifyResult;
-/** Heuristic gate: an expression is "worth" JIT'ing only when it does
- *  some work — a bare Ident or Number is not. The driver also gates
- *  on tensor size at runtime; this is just a structural pre-filter to
- *  skip the cost of lowering trivial expressions. */
-export declare function isWorthCompiling(emittableExpr: Expr): boolean;
-/** A single classification entry for one assign in a chain. The chain
- *  emitter consumes one of these per assign in order. */
-export interface ChainAssignClassification {
-    /** The original AST stmt (kept so the cache can key on it). */
-    stmt: import("../../parser/types.js").Stmt & {
-        type: "Assign";
-    };
-    /** The classifier's rewritten RHS — opaque subtrees replaced by
-     *  Ident(syntheticName). */
-    emittableExpr: Expr;
-    /** Opaque subtrees this assign contributed (driver evaluates these
-     *  before the kernel call). */
-    opaqueRoots: OpaqueRoot[];
-    /** Identifiers referenced by this assign's emittableExpr. Includes
-     *  synthetic opaque-root names. */
-    envIdents: Set<string>;
-    /** True if the assign reads its own LHS (e.g. `r = r + x`). For the
-     *  first stmt of a chain this means the kernel needs `in_<lhs>` as
-     *  an input pointer; for later stmts it just means a chain-local
-     *  read. */
-    selfReadsLhs: boolean;
-}
-export interface ChainClassification {
-    /** Chain assigns, in source order. May have multiple distinct LHSs. */
-    assigns: ChainAssignClassification[];
-}
-/** Detect a chain of consecutive suppressed classifiable Assigns
- *  starting at `stmts[startIdx]`. Each LHS may be a different name;
- *  the driver decides — using full-scope liveness — whether each LHS
- *  becomes a chain-local or a materialized output buffer.
- *
- *  The chain ends at the first non-Assign, the first unsuppressed
- *  Assign, or the first Assign whose RHS classification is not worth
- *  compiling.
- *
- *  Returns null if the very first stmt isn't a chainable Assign. */
-export declare function classifyAssignChain(stmts: import("../../parser/types.js").Stmt[], startIdx: number): ChainClassification | null;
-/** Reduction op names whose semantics the e2 reduction emitter knows. */
-export declare const E2_REDUCTION_OPS: ReadonlySet<string>;
-export interface TrailingReductionMatch {
-    /** The original Assign stmt — pinned for cache identity. */
-    stmt: import("../../parser/types.js").Stmt & {
-        type: "Assign";
-    };
-    /** LHS = accumulator name. */
-    accName: string;
-    /** Reduction op name. */
-    reduceName: string;
-    /** AST expression argument to the reduction call. The driver decides
-     *  whether to treat it as a Var-targeting-chain-local (for trailing-
-     *  after-chain) or as a standalone elemwise expression. */
-    targetExpr: Expr;
-    /** True for `acc = acc OP reduce(...)`; false for `acc = reduce(...)`. */
-    hasAccumulate: boolean;
-    /** The accumulate op (only meaningful when `hasAccumulate` is true). */
-    accOp?: BinaryOperation;
-}
-/** Match an Assign of the form:
- *    acc = reduce(arg)
- *    acc = acc OP reduce(arg)
- *    acc = reduce(arg) OP acc        (commutative ops only)
- *  where `reduce` is a single-argument call to a known reduction op.
- *  Returns the matched details or null. */
-export declare function matchTrailingReduction(stmt: import("../../parser/types.js").Stmt): TrailingReductionMatch | null;

package/dist-lib/numbl-core/jit/e2/compileFn.d.ts

@@ -1,16 +0,0 @@
-/**
- * e2 — browser-safe indirection for the C compile driver.
- *
- * The driver in `c/compile.ts` is Node-only (it shells out to `cc` and
- * loads via koffi). The browser bundle includes the e2 modules but
- * NOT this driver — `setE2CompileFn` from `e2/install.ts` (Node only)
- * swaps in the real implementation. In the browser, the stub throws.
- */
-export type E2CompileFn = (cSource: string, koffiSig: string, kernelName: string, log?: (msg: string) => void) => ((...args: unknown[]) => unknown) | null;
-export declare function setE2CompileFn(fn: E2CompileFn): void;
-export declare function getE2CompileFn(): E2CompileFn;
-/** Minimum element count of the largest tensor input before we'll
- *  consider compiling an e2 kernel. Below this, koffi overhead dwarfs
- *  the work and falling through to the interpreter is faster.
- *  Overridable via `NUMBL_E2_MIN_ELEMS`. */
-export declare function e2MinElems(): number;

package/dist-lib/numbl-core/jit/e2/complexChainKernelEmit.d.ts

@@ -1,79 +0,0 @@
-/**
- * e2 — complex multi-LHS fused chain C kernel emission (paired-buffer).
- *
- * Sister to [chainKernelEmit.ts](./chainKernelEmit.ts) for chains that
- * produce at least one complex tensor. Mirrors the codegen shape of
- * [e1/complexKernelEmit.ts](../e1/complexKernelEmit.ts) and uses the
- * same fusion envelope (+ - * .* unary +/- conj real imag, real/complex
- * widening, ImagLiteral). Anything outside that subset (`./`,
- * `abs(complex)`, transcendentals on complex) is rejected at the e2
- * lowerer level, which causes the driver to bail to the interpreter
- * per-op complex path — matching e1's fusion fallthrough behavior.
- *
- *     void e2cc_<hash>(int64_t n,
- *                      const double *in_<cta>_re, const double *in_<cta>_im,
- *                      const double *in_<rtb>,
- *                      [in_<lhs_input>_re/_im or in_<lhs_input> ...,]
- *                      double s_<csc>_re, double s_<csc>_im,
- *                      double s_<rsc>,
- *                      [out_<lhs>_re, out_<lhs>_im or out_<lhs> ...])
- *     {
- *         #pragma omp simd
- *         for (int64_t i = 0; i < n; i++) {
- *             double <clhs1>_re, <clhs1>_im, ..., <rlhs1>, ...;
- *             <clhs1>_re = ...; <clhs1>_im = ...;
- *             <rlhs1> = ...;
- *             out_<clhs>_re[i] = <clhs>_re; out_<clhs>_im[i] = <clhs>_im;
- *             out_<rlhs>[i] = <rlhs>;
- *         }
- *     }
- *
- * Complex chains deliberately stick to `#pragma omp simd` regardless of
- * `--par`: per-element bodies are ~6 flops spread across paired re/im
- * buffers (memory-bandwidth-bound), and thread-spawn overhead dominates
- * the compute win at realistic N. Matches e1's stance.
- */
-import type { ChainAssignSpec } from "./emitShared.js";
-export interface E2ComplexKernelInputs {
-    /** Env tensor names, split by complex-ness. */
-    complexTensorNames: string[];
-    realTensorNames: string[];
-    /** Env scalar names, split by complex-ness. */
-    complexScalarNames: string[];
-    realScalarNames: string[];
-    /** Chain LHS names that need `in_<name>` because they're read before
-     *  being written. Split by complex-ness of the LHS. */
-    complexInputLhsNames: string[];
-    realInputLhsNames: string[];
-    /** Chain LHS names that escape the chain. Split by complex-ness. */
-    complexEscapeLhsNames: string[];
-    realEscapeLhsNames: string[];
-}
-export interface E2ComplexChainEmitResult {
-    kernelName: string;
-    cSource: string;
-    koffiSig: string;
-    hash: string;
-    /** In signature order: complex tensors, real tensors. */
-    complexInputTensors: string[];
-    realInputTensors: string[];
-    /** In signature order: complex input LHSs, real input LHSs. */
-    complexInputLhsNames: string[];
-    realInputLhsNames: string[];
-    /** In signature order: complex scalars, real scalars. */
-    complexInputScalars: string[];
-    realInputScalars: string[];
-    /** In signature order: complex escape LHSs, real escape LHSs. */
-    complexEscapeLhsNames: string[];
-    realEscapeLhsNames: string[];
-    chainLength: number;
-}
-/** Per-assign LHS info — complex-ness of the RHS determines whether
- *  this stmt emits a paired (re/im) local or a single real local. */
-export interface ComplexChainAssignSpec extends ChainAssignSpec {
-    /** True when THIS stmt's RHS is complex. Chain-LHS type can differ
-     *  per reassignment; we track per-stmt so a `a = real; a = complex;`
-     *  sequence sees `a` as complex only after the second assign. */
-    rhsIsComplex: boolean;
-}
-export declare function emitE2ComplexChainKernel(assigns: ComplexChainAssignSpec[], inputs: E2ComplexKernelInputs): E2ComplexChainEmitResult;

package/dist-lib/numbl-core/jit/e2/emitShared.d.ts

@@ -1,71 +0,0 @@
-/**
- * e2 — shared kernel-emission helpers used by both the chain emitter
- * and the reduction emitter. The two emitters build the same kernel
- * shape up to a few trailing differences (reduction init / combine /
- * out_acc output), so everything that's identical lives here.
- */
-import type { JitExpr } from "../jitTypes.js";
-import { type FusedTarget } from "../fusedScalarEmit.js";
-import type { ScalarOpTarget } from "../scalarEmit.js";
-/**
- * C helper included in every e2 kernel prologue.
- *
- * `-ffast-math` implies `-ffinite-math-only`, which lets the compiler
- * assume no NaN/Inf values and constant-fold `x != x` to 0 and `x == x`
- * to 1. The NaN-detection idiom `mask = x ~= x` would silently return all
- * zeros. `numbl_is_nan_fp` inspects the IEEE-754 bit pattern directly —
- * the optimizer cannot look through `memcpy` to apply finite-math
- * assumptions, so this survives the flag.
- */
-export declare const E2_C_PROLOGUE: string;
-/**
- * e2-specific scalar op target.
- *
- * Identical to `C_SCALAR_TARGET` except `binEq` / `binNe`: when both
- * operand strings are the same C expression (i.e. the source was `x == x`
- * or `x ~= x`), the standard `==` / `!=` forms are constant-folded to
- * 1 / 0 by `-ffinite-math-only`. Replace them with the bit-pattern NaN
- * helper so the self-comparison gives the correct IEEE 754 result.
- */
-export declare const E2_C_SCALAR_TARGET: ScalarOpTarget;
-export interface ChainAssignSpec {
-    lhsName: string;
-    rhs: JitExpr;
-}
-export interface KernelInputs {
-    /** Regular env input tensor names (NOT chain LHSs). */
-    tensorNames: string[];
-    /** Scalar env input names. */
-    scalarNames: string[];
-    /** Chain LHS names that need `in_<name>` because they're read before
-     *  being written. */
-    inputLhsNames: string[];
-    /** Chain LHS names that escape the chain (materialized via
-     *  `out_<name>`). Does NOT include a reduce-target name — that one
-     *  is always chain-local by construction. */
-    escapeLhsNames: string[];
-}
-export declare const cInputPtr: (name: string) => string;
-export declare const cOutputPtr: (name: string) => string;
-export declare const cScalarParam: (name: string) => string;
-/** FusedTarget for the per-element body. Resolves Var reads to either
- *  the chain-local stack name (once the corresponding assign has run)
- *  or `in_<name>[i]` (before that point), mangles scalar param names,
- *  and dispatches whitelisted builtins through their `jitEmitC`. */
-export declare function makeFusedTarget(locallyAssigned: ReadonlySet<string>): FusedTarget;
-/** Unique chain LHS names in source order — for the leading
- *  `double <a>, <b>;` declaration. */
-export declare function uniqueLhsOrdered(chain: ChainAssignSpec[]): string[];
-/** All tensor-typed names visible to emitFusedScalarExpr: regular env
- *  tensors, `in_<lhs>` tensors, and chain LHSs. */
-export declare function allTensorVarsFor(inputs: KernelInputs, chain: ChainAssignSpec[]): Set<string>;
-/** Emit one `<lhs> = <rhsC>;` line per chain assign, growing
- *  `locallyAssigned` as we go so later stmts resolve earlier LHSs to
- *  the stack-local. */
-export declare function emitChainAssignLines(chain: ChainAssignSpec[], allTensorVars: ReadonlySet<string>, ft: FusedTarget, locallyAssigned: Set<string>): string[];
-/** Kernel param list (tensor → inputLhs → scalar → escapeLhs). Callers
- *  append any trailing params (e.g. `double *out_acc`). */
-export declare function buildParamList(inputs: KernelInputs): string[];
-/** koffi type list in the same order as `buildParamList`. Callers
- *  append any trailing entries. */
-export declare function buildKoffiParts(inputs: KernelInputs): string[];

package/dist-lib/numbl-core/jit/e2/install.d.ts

@@ -1,11 +0,0 @@
-/**
- * e2 — Node-only install hook.
- *
- * Sets the module-level `e2CompileFn` to the real `compileAndLoad`
- * driver from `c/compile.ts`. The browser bundle never imports this
- * file, so `e2CompileFn` stays at the throwing stub and any attempt
- * to use `--opt e2` from the web fails with a clear message.
- *
- * Idempotent: re-importing in tests doesn't re-install.
- */
-export {};

package/dist-lib/numbl-core/jit/e2/liveness.d.ts

@@ -1,29 +0,0 @@
-/**
- * e2 — AST liveness helpers.
- *
- * Used by the chain classifier to decide whether a chain LHS is
- * actually used outside the chain's own stmts. If not, it can be
- * compiled as a per-element stack-local instead of being materialized
- * as a tensor output buffer.
- *
- * The "scope" passed in is the innermost enclosing function body or
- * top-level script body — chosen so that for-bodies, if-bodies, etc.
- * are scanned recursively (MATLAB has flat function-level scoping for
- * locals, so a name introduced inside a for-loop is visible to other
- * stmts in the same function body).
- *
- * The walk excludes the chain's own stmts (and the trailing-reduction
- * stmt if any) from the scan, applying the exclusion at every nesting
- * level — so a chain inside a for-body whose LHS is read by another
- * stmt in the same function body counts as referenced, but the chain
- * stmts themselves don't trigger a false positive.
- */
-import type { Stmt } from "../../parser/types.js";
-/**
- * True iff `name` appears anywhere in `scopeBody` outside the stmts
- * listed in `excludeStmts`. The exclusion is by reference identity
- * and is applied at every nesting level — pass the chain stmts (and
- * the trailing-reduction stmt if any) so they don't trigger false
- * positives.
- */
-export declare function isNameReferencedOutsideStmts(scopeBody: readonly Stmt[], excludeStmts: ReadonlySet<Stmt>, name: string): boolean;

package/dist-lib/numbl-core/jit/e2/loopKernel.d.ts

@@ -1,49 +0,0 @@
-/**
- * e2 whole-loop C JIT.
- *
- * For a `for varName = lo:hi <body> end` where the body fits a supported
- * shape, emit a single C function that runs all n iterations and call it
- * once, instead of walking the AST on every iteration.
- *
- * Without this path, `--opt e2` pays ~70–100 ns per iter on a trivial
- * `s = s + i` just for AST dispatch; a compiled C loop runs it in <1 ns.
- *
- * Current supported body shapes (all may mix in one loop):
- *   - scalar assign           `s = s + sin(i) * cos(i) + sqrt(i*0.01)`
- *   - scalar indexed read     `s = s + x(i)`                   (real tensor x)
- *   - scalar indexed write    `y(i) = sin(i*0.01)`             (preallocated y)
- *   - tensor local (elemwise) `c = a.*b + i*0.001`             (per-element
- *                                                               expression is
- *                                                               inlined into any
- *                                                               consuming sum();
- *                                                               last-iter value
- *                                                               is also written
- *                                                               back to the env
- *                                                               for MATLAB
- *                                                               post-loop
- *                                                               visibility)
- *   - reductions              `s = s + sum(c)`                 (c is a
- *                                                               tensor_local —
- *                                                               chained
- *                                                               tensor_locals
- *                                                               fuse through)
- *
- * Not supported (falls through to the interpreter / other JIT paths):
- *   - non-`lo:hi` loop shapes (stepped ranges, `for i = v`)
- *   - complex or logical tensor inputs
- *   - matrix-matrix / matrix-vector multiplication
- *   - bsxfun / broadcast across shapes
- *   - function-handle calls, user-function calls
- *   - control flow inside the body (if / while / return)
- *   - multi-dimensional tensor access
- */
-import type { Stmt } from "../../parser/types.js";
-import type { Interpreter } from "../../interpreter/interpreter.js";
-/**
- * Attempt to compile and execute a for-loop as one C kernel under
- * `--opt e2`. Returns true on success, false to fall back to the regular
- * interpreter path (the caller will run the loop normally).
- */
-export declare function tryE2Loop(interp: Interpreter, stmt: Stmt & {
-    type: "For";
-}): boolean;