numbl 0.3.0 → 0.3.3

package/dist-lib/numbl-core/jit/c/emit/scalar.d.ts

@@ -1,23 +0,0 @@
-import { type JitExpr } from "../../jitTypes.js";
-import { type EmitCtx } from "../context.js";
-/** Emit a value-expression. For scalars, returns a C `double` expression.
- *  For tensors, returns the data-variable name (the caller knows to also
- *  access the corresponding _len variable).
- *
- *  Complex-typed expressions are *not* valid here — they produce a pair
- *  of doubles and must go through `emitComplex`. Reaching this function
- *  with a complex expression indicates a missed routing at the caller. */
-export declare function emitExpr(expr: JitExpr, ctx: EmitCtx): string;
-export declare function emitBinary(expr: JitExpr & {
-    tag: "Binary";
-}, ctx: EmitCtx): string;
-export declare function emitUnary(expr: JitExpr & {
-    tag: "Unary";
-}, ctx: EmitCtx): string;
-export declare function emitIndex(expr: JitExpr & {
-    tag: "Index";
-}, ctx: EmitCtx): string;
-export declare function emitCall(expr: JitExpr & {
-    tag: "Call";
-}, ctx: EmitCtx): string;
-export declare function emitTruthiness(expr: JitExpr, ctx: EmitCtx): string;

package/dist-lib/numbl-core/jit/c/emit/stmt.d.ts

@@ -1,25 +0,0 @@
-/**
- * Statement-level emission — the top-level dispatch for every JitStmt.
- *
- * Exports:
- *   - `emitStmts(lines, stmts, indent, ctx)` — public entry point; the
- *     outer function body is fed through this. Runs the fusion pass
- *     when `ctx.fuse` is set, otherwise emits one statement at a time.
- *   - `emitStmt` — per-statement dispatch used internally (also used
- *     inside If / For / While bodies via `emitStmts`).
- *   - `withPendingStmts` — scoped helper for nested expressions that
- *     need to hoist declarations above the calling statement.
- *
- * This module is thin on purpose: it routes to the specialized emitters
- * in [./scalar.ts](./scalar.ts), [./complexScalar.ts](./complexScalar.ts),
- * [./tensor.ts](./tensor.ts), [./assign.ts](./assign.ts),
- * [./userCall.ts](./userCall.ts), and [./fused.ts](./fused.ts).
- */
-import { type JitStmt } from "../../jitTypes.js";
-import { type EmitCtx } from "../context.js";
-/** Evaluate `fn` with `ctx.pendingStmts` set to `{lines, indent}` so any
- *  UserCall / RangeSliceRead nested inside can hoist its decl+call into
- *  `lines` ahead of the calling statement. Restores the prior value on
- *  exit (safe even if nested save/restore frames stack). */
-export declare function withPendingStmts<T>(ctx: EmitCtx, lines: string[], indent: string, fn: () => T): T;
-export declare function emitStmts(lines: string[], stmts: JitStmt[], indent: string, ctx: EmitCtx): void;

package/dist-lib/numbl-core/jit/c/emit/tensor.d.ts

@@ -1,127 +0,0 @@
-import { type JitExpr } from "../../jitTypes.js";
-import { type EmitCtx } from "../context.js";
-import { type ComplexTensorResult } from "./helpers.js";
-/** Size a scratch tensor buffer to `lenExpr` doubles, freeing any stale
- *  buffer from a prior loop iteration first. A plain `if (!sData) malloc`
- *  would overflow the buffer if a later iteration demanded more bytes. */
-export declare function emitScratchBufAlloc(lines: string[], indent: string, sData: string, sLen: string, lenExpr: string): void;
-/** Complex scratch alloc: re + im buffers, both sized to `lenExpr`. The
- *  complex kernels in numbl_ops write both buffers unconditionally, so
- *  both must be valid pointers (len > 0).
- *
- *  Same length-match fast-path as emitScratchBufAlloc: both buffers are
- *  kept in lockstep, so a single size check guards both. */
-export declare function emitScratchBufAllocComplex(lines: string[], indent: string, sData: string, sDataIm: string, sLen: string, lenExpr: string): void;
-/** Derive (d0, d1) C expressions for a dynamic tensor output whose
- *  shape is inherited from an elemwise operand. Uses the operand's
- *  static shape when known; else — when `ctx` is provided — falls
- *  back to the nearest tensor Var's runtime `_d0`/`_d1` locals
- *  (accurate even for partial-shape specializations). Final fallback
- *  recovers the missing dim from lenExpr and the other dim (e.g. row
- *  `[1, -1]` → `[1, len]`), or `[len, 1]` (column convention) when
- *  nothing is known. */
-export declare function shapeExprsFor(shapeSrc: JitExpr | undefined, lenExpr: string, ctx?: EmitCtx): [string, string];
-/** Find a tensor-length expression from a tensor expr tree (for pre-
- *  allocating scratch buffers). Returns a C expression for the length. */
-export declare function findTensorLenExpr(expr: JitExpr, ctx: EmitCtx): string;
-/** Ensure `destName`'s buffer is sized to exactly `lenExpr` doubles
- *  before an elemwise op writes into it. For locals and dynamic
- *  outputs, always free+malloc — loop iterations can produce different
- *  sizes, so a first-time-only malloc would overflow the buffer in
- *  later iterations. For fixed-size outputs (caller-aliased buffer),
- *  just records the length; freeing would corrupt the caller.
- *
- *  When the destination is a dynamic output, also writes its _d0/_d1
- *  shape locals. Pass the tensor operand whose shape the result
- *  inherits (elemwise preserves operand shape); we use its static
- *  jitType.shape when available, else fall back to `[lenExpr, 1]`. */
-export declare function emitEnsureTensorBuf(lines: string[], indent: string, destName: string, lenExpr: string, ctx: EmitCtx, shapeSrc?: JitExpr): void;
-/** Emit an elemwise tensor-assign with aliasing safety and a
- *  steady-state fast path.
- *
- *  Problem: the RHS of `dst = <elemwise-expr>` may read from `dst` itself
- *  (e.g. `r = r .* y + 3.0`). If we resized the dst buffer first and
- *  then the kernel read the old dst data, it would dangle. Pre-c54add0
- *  the kernel wrote inline into dst, which was only safe when no resize
- *  was needed — resizing freed the operand buffer before the kernel
- *  read it. c54add0 defused this via an unconditional scratch-transfer
- *  (eval into scratch, then free+malloc dst, then memcpy) but that
- *  added a full-tensor memcpy to every elemwise assign in hot loops.
- *
- *  This helper splits at runtime: if dst is already the right size,
- *  emit the kernel directly into dst (no memcpy, no scratch). Else
- *  evaluate into a scratch, then realloc dst and memcpy. Both paths
- *  are aliasing-safe: the fast path doesn't free dst at all; the slow
- *  path reads operands before dst is freed.
- *
- *  Fixed-size outputs (caller-owned buffer) skip the guard — their
- *  buffer is never freed, so the inline path is always safe.
- *
- *  `emitKernel` emits the tensor kernel writing `targetLen` doubles
- *  into `targetData`. It is invoked exactly once; both paths share
- *  a single emission. Sub-expressions may use scratch buffers freely. */
-export declare function emitElemwiseTensorAssign(lines: string[], indent: string, destName: string, lenExpr: string, shapeSrc: JitExpr | undefined, ctx: EmitCtx, emitKernel: (lines: string[], indent: string, targetData: string, targetLen: string) => void): void;
-/** Complex-tensor sibling of `emitElemwiseTensorAssign`. Same runtime
- *  size-match scheme, but manages paired (re, im) buffers. The kernel
- *  callback receives both `targetData` and `targetDataIm` so it can
- *  write the paired output in one shot.
- *
- *  When the kernel's operand aliases the target (e.g. `z = -z`, `z =
- *  conj(z)`), the callback MUST be element-wise safe — kernels like
- *  `numbl_complex_scalar_binary_elemwise` already are, but a memcpy
- *  from operand→target against a same-buffer alias is UB. Use an
- *  element-wise loop there. */
-export declare function emitComplexElemwiseTensorAssign(lines: string[], indent: string, destName: string, lenExpr: string, shapeSrc: JitExpr | undefined, ctx: EmitCtx, emitKernel: (lines: string[], indent: string, targetData: string, targetDataIm: string, targetLen: string) => void): void;
-/** Complex-tensor version of emitEnsureTensorBuf. Reallocates both re
- *  and im buffers in lockstep, so kernel writes into the paired
- *  destination don't mismatch in size. Fixed outputs keep their
- *  caller-aliased re buffer and (for complex) the caller-aliased im
- *  buffer — we only record the length. */
-export declare function emitEnsureComplexTensorBuf(lines: string[], indent: string, destName: string, lenExpr: string, ctx: EmitCtx, shapeSrc?: JitExpr): void;
-/** Emit a tensor expression as statements, returning the data/len vars. */
-export declare function emitTensorExprToStmts(lines: string[], indent: string, expr: JitExpr, ctx: EmitCtx): {
-    data: string;
-    len: string;
-};
-/** For tensor binary/unary, we need multi-statement emission. This helper
- *  emits the operation as statements into `lines` and returns the result
- *  data pointer variable name. Callers that route the result into a
- *  named dst (vs. a scratch) must use the scratch-transfer pattern —
- *  let this helper write the full expression into a fresh scratch via
- *  `emitTensorExprToStmts`, then `emitEnsureTensorBuf` + memcpy into
- *  the dst. That ordering avoids clobbering an operand that aliases
- *  the dst (e.g. `r = r .* y + 3.0`). */
-export declare function emitTensorBinaryStmts(lines: string[], indent: string, expr: JitExpr & {
-    tag: "Binary";
-}, ctx: EmitCtx, destDataVar: string, destLenVar: string): void;
-/** Emit a tensor expression in complex (paired-buffer) form, producing
- *  scratch locals for sub-expressions. Handles:
- *   - Var on a complex tensor: returns the name's `_data`/`_data_im`/`_len`.
- *   - Var on a real tensor: widens via `dataIm = NULL`.
- *   - Binary on a complex-typed tensor expr (the result is complex).
- *   - Unary Plus/Minus on a complex-typed tensor expr.
- *   - conj / real / imag on a complex tensor — real/imag are actually
- *     handled via the real tensor path (result is real), but conj stays
- *     complex and is lowered here.
- */
-export declare function emitComplexTensorExprToStmts(lines: string[], indent: string, expr: JitExpr, ctx: EmitCtx): ComplexTensorResult;
-/** Emit a complex tensor binary op into caller-provided dest buffers
- *  (both re and im). Handles all combos of real-tensor/complex-tensor/
- *  real-scalar/complex-scalar operands. Operand widening is kernel-side
- *  (NULL imag pointer or imag=0.0). */
-export declare function emitComplexTensorBinaryStmts(lines: string[], indent: string, expr: JitExpr & {
-    tag: "Binary";
-}, ctx: EmitCtx, destDataVar: string, destDataImVar: string, destLenVar: string): void;
-/** Emit `dstData = src(a:b) copy` pattern into caller-provided dst data /
- *  len vars. */
-export declare function emitRangeSliceReadToBuf(lines: string[], indent: string, expr: JitExpr & {
-    tag: "RangeSliceRead";
-}, ctx: EmitCtx, destData: string, destLen: string): void;
-/** Emit a `src(a:b)` RangeSliceRead into a fresh scratch buffer,
- *  returning the {data, len} pair for the result. */
-export declare function emitRangeSliceReadToStmts(lines: string[], indent: string, expr: JitExpr & {
-    tag: "RangeSliceRead";
-}, ctx: EmitCtx): {
-    data: string;
-    len: string;
-};

package/dist-lib/numbl-core/jit/c/emit/userCall.d.ts

@@ -1,58 +0,0 @@
-/**
- * UserCall emission — scalar returns in value position, and tensor
- * returns from an Assign RHS.
- *
- * A UserCall lowers to a static C function (`jit_<jitName>`) generated
- * alongside the outer function by [../assemble.ts](../assemble.ts).
- * This module marshals arg slots per the callee's ABI and emits the
- * call itself.
- *
- * Exports:
- *   - `emitUserCall` — scalar-return UserCall in value position (Assign
- *     RHS / nested expr). Stashes the result into a fresh `__ucN_out`
- *     local and returns the name as the expression text.
- *   - `emitUserCallArgSlots` — helper used by `emitUserCall` *and* the
- *     tensor-return variant in [./assign.ts](./assign.ts) to convert
- *     one arg into its ABI-slot expression list.
- *   - `emitUserCallTensorAssign` — tensor-return UserCall, only allowed
- *     as the top RHS of an Assign. Uses the dynamic-output ABI: the
- *     callee mallocs + transfers ownership via `double **` out-params.
- */
-import type { JitExpr } from "../../jitTypes.js";
-import type { TensorMeta } from "../classify.js";
-import { type EmitCtx } from "../context.js";
-/** Emit the C expressions for one arg's ABI slots, consulting the
- *  callee's paramDesc so the slot order matches the callee's signature.
- *  Scalars contribute one slot; tensors contribute data + len + optional
- *  d0 / d1. For the shape slots the caller falls back to
- *  `(int64_t)tensorLen(arg)` / `1` when its own arg-var wasn't classified
- *  with matching shape plumbing. */
-export declare function emitUserCallArgSlots(a: JitExpr, paramDesc: {
-    kind: "scalar" | "complexScalar" | "tensor";
-    slots: {
-        kind: string;
-    }[];
-}, ctx: EmitCtx): string[];
-/** Scalar-return UserCall. Tensor args are marshaled via the callee's
- *  paramDescs (data + len + optional d0/d1 slots). The callee is emitted
- *  as `static void jit_<jitName>(...)` in the same .c file by
- *  `generateC`, with a trailing `__err_flag` pointer. We stash the
- *  return value in a fresh local and return its name as the expression
- *  text. Must be invoked from statement context so the decl + call can
- *  be inserted before the surrounding expression.
- *
- *  Tensor-return UserCall is handled upstream by emitTensorAssign (only
- *  allowed as an Assign RHS), not here. */
-export declare function emitUserCall(expr: JitExpr & {
-    tag: "UserCall";
-}, ctx: EmitCtx): string;
-/** Emit `dest = foo(...)` where foo returns a tensor via the dynamic-
- *  output ABI. Feasibility has already verified the callee's output[0]
- *  is a fresh-alloc dynamic output, so the callee fills
- *  `buf_out / out_len / d0_out / d1_out` and transfers ownership. The
- *  caller frees the old dest buffer (if any), takes the new buffer, and
- *  lets the epilogue free() it at end-of-scope alongside the other
- *  local tensors. */
-export declare function emitUserCallTensorAssign(lines: string[], indent: string, destName: string, destMeta: TensorMeta, expr: JitExpr & {
-    tag: "UserCall";
-}, ctx: EmitCtx): void;

package/dist-lib/numbl-core/jit/c/epilogue.d.ts

@@ -1,26 +0,0 @@
-/**
- * Function epilogue emission.
- *
- * The epilogue is the set of statements appended after the body of a
- * generated function: output-slot writes (scalar out-pointers, tensor
- * dynamic-output transfers), scratch buffer frees, and local / unshared
- * tensor frees. Called once per function by `generateC` in
- * [assemble.ts](./assemble.ts).
- *
- * The prelude is in [prelude.ts](./prelude.ts); both read from the same
- * shared state (`ClassificationResult` + `EmitCtx`).
- */
-import type { ClassificationResult } from "./classify.js";
-import type { COutputDesc } from "./abi.js";
-import { type EmitCtx } from "./context.js";
-export interface EpilogueInput {
-    cls: ClassificationResult;
-    ctx: EmitCtx;
-    outputDescs: COutputDesc[];
-    /** Pure-input tensor params that were malloc'd in the prelude's
-     *  unshare path — must be freed here. */
-    unshareTensorParams: Set<string>;
-    /** Indent string to prepend to each emitted line. */
-    indent: string;
-}
-export declare function buildEpilogue(input: EpilogueInput): string[];

package/dist-lib/numbl-core/jit/c/feasibility.d.ts

@@ -1,44 +0,0 @@
-/**
- * Feasibility prepass for the C-JIT path.
- *
- * Given the lowered JIT IR for a function and the argument types, decide
- * whether the C codegen can handle it. On any construct that isn't in
- * the whitelist, return `{ok: false, reason}` so the caller falls
- * through to the JS-JIT path.
- *
- * The whitelist intentionally mirrors what [assemble.ts](./assemble.ts)
- * can emit, which in turn mirrors what JS-JIT does. Widen all three
- * together.
- *
- * Covered today: scalar arithmetic and control flow (numbers, booleans,
- * complex-scalar pairs); real tensor params / locals / outputs with
- * Index / AssignIndex (1-3D), RangeSliceRead, AssignIndexRange,
- * AssignIndexCol, TensorLiteral, VConcatGrow, zeros/ones (1-2D); real
- * tensor binary + unary + reductions via the jitCapabilities opcodes;
- * complex tensor binary + unary (minus, conj, real, imag, abs) and
- * flat reductions (sum, prod, any, all); UserCall (scalar args/return
- * and real / complex tensor args/return when the callee passes its own
- * feasibility check).
- */
-import type { JitStmt, JitType } from "../jitTypes.js";
-import type { GeneratedFn } from "../jitLower.js";
-export type FeasibilityResult = {
-    ok: true;
-} | {
-    ok: false;
-    reason: string;
-    line?: number;
-};
-/**
- * Check if the lowered function can be handled by the C-JIT.
- *
- * `outputTypes` holds the types of every output variable in order;
- * `outputType` is kept for backwards-compatibility and equals
- * `outputTypes[0]` when present.
- *
- * Multi-output mirrors the JS-JIT's `return [out0, out1, ...]` shape:
- * the generated C builds a `napi_value` array of length `nargout`,
- * each entry boxed according to its type (scalar doubles, booleans, or
- * tensors).
- */
-export declare function checkCFeasibility(body: JitStmt[], paramNames: string[], argTypes: JitType[], outputType: JitType | null, outputTypes: JitType[], nargout: number, generatedIRBodies?: Map<string, GeneratedFn>): FeasibilityResult;

package/dist-lib/numbl-core/jit/c/prelude.d.ts

@@ -1,37 +0,0 @@
-/**
- * Function prelude emission.
- *
- * The prelude is the set of C declarations at the top of a generated
- * function, written before any statement from the body: shadowed param
- * locals (for param-output seeding + unshare-at-entry), local tensor
- * declarations, complex-scalar imag companions, and scratch buffer
- * slots.
- *
- * Exported as `buildPrelude` — called once per function by `generateC`
- * in [assemble.ts](./assemble.ts).
- *
- * The epilogue (tensor frees, out-pointer writes) is in
- * [epilogue.ts](./epilogue.ts); both read from the same shared state
- * (`ClassificationResult` + `EmitCtx`) populated upstream.
- */
-import type { JitType } from "../jitTypes.js";
-import type { ClassificationResult } from "./classify.js";
-import { type EmitCtx } from "./context.js";
-export interface PreludeInput {
-    cls: ClassificationResult;
-    ctx: EmitCtx;
-    params: string[];
-    argTypes: JitType[];
-    /** Names with `kind === "paramOutput"` (output name reuses a param name). */
-    paramOutputTensors: Set<string>;
-    /** Pure-input tensor params that need an unshare-at-entry malloc+memcpy
-     *  (the body writes to them, and we must not mutate the caller's buffer). */
-    unshareTensorParams: Set<string>;
-    /** Locals to declare — outer-scope `localVars` minus params, sorted. */
-    allLocals: string[];
-    /** Names carrying `complex_or_number` scalar values (paired re+im locals). */
-    complexScalarVars: Set<string>;
-    /** Indent string to prepend to each emitted line. */
-    indent: string;
-}
-export declare function buildPrelude(input: PreludeInput): string[];

package/dist-lib/numbl-core/jit/c/visit.d.ts

@@ -1,63 +0,0 @@
-/**
- * Lightweight IR traversal helpers shared across the C-JIT subsystem.
- *
- * Several places in `jit/c/` need to walk a lowered IR body observing
- * (but not transforming) expressions and statements: the feasibility
- * fall-through paths, tensor-classification, hybrid-loop live-in/out
- * analysis, and the shape-propagation / callee-discovery / complex-
- * scalar scans in [assemble.ts](./assemble.ts). Each used to
- * reimplement the same switch-on-tag descent.
- *
- * This module centralizes the descent. Three primitives, composable:
- *
- *   - `walkExprNodes(expr, visit)` — post-order walk of every sub-node
- *     of `expr` (including `expr` itself). Every leaf calls `visit`
- *     once; nothing is skipped. Adding a new JitExpr tag means editing
- *     this one function.
- *
- *   - `walkStmts(body, visit)` — pre-order walk of every statement in
- *     `body`, recursing into If/For/While nested bodies. Does NOT
- *     traverse expressions inside the stmt — callers that need that
- *     compose with `walkStmtExprs` + `walkExprNodes`.
- *
- *   - `walkStmtExprs(stmt, visit)` — call `visit` on each top-level
- *     expression attached to `stmt` (the `expr` in an Assign, the
- *     `cond` in an If, the `start`/`end`/`step` in a For, etc.). Does
- *     NOT recurse into nested expression sub-nodes (use `walkExprNodes`
- *     for that) and does NOT walk into nested stmt bodies.
- *
- * The dispatchers in `feasibility.ts`, `emit/stmt.ts`, and
- * `emit/fused.ts` keep their native switches — they produce structured
- * results (feasibility verdicts, emitted C lines), so a callback-based
- * observer doesn't fit their shape.
- */
-import type { JitExpr, JitStmt } from "../jitTypes.js";
-/**
- * Walk every sub-node of `expr` in post-order (children first, then
- * `expr` itself), calling `visit` on each. Leaves (NumberLiteral,
- * ImagLiteral, Var, StringLiteral, MemberRead) are still visited once.
- *
- * Adding a new JitExpr tag: add a case here. Observer callers (which
- * is all of them) don't need to know about tag-specific sub-node
- * fields — this is the one place those are encoded.
- */
-export declare function walkExprNodes(expr: JitExpr, visit: (e: JitExpr) => void): void;
-/**
- * Walk every statement in `body`, recursing into nested If / For /
- * While bodies. Pre-order: `visit` is called on each stmt before
- * descending. Does NOT traverse expressions inside the stmt.
- */
-export declare function walkStmts(body: JitStmt[], visit: (s: JitStmt) => void): void;
-/**
- * Call `visit` on every top-level expression attached to `stmt` — the
- * RHS of an Assign, the indices + value of an AssignIndex, the start /
- * end / step of a For, the cond of an If / While, and so on. Does
- * NOT recurse into expression sub-nodes (compose with `walkExprNodes`)
- * and does NOT descend into nested stmt bodies (compose with
- * `walkStmts`).
- *
- * For If, the `cond` of the primary branch AND each elseif is visited;
- * the bodies themselves are stmt-trees, not exprs, and are reached via
- * `walkStmts` recursion.
- */
-export declare function walkStmtExprs(stmt: JitStmt, visit: (e: JitExpr) => void): void;

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

@@ -1,46 +0,0 @@
-/**
- * e1 (experimental) — complex-tensor standalone C-kernel emission.
- *
- * Sister module to `kernelEmit.ts` (which handles real-tensor chains).
- * Given a FusibleChain that produces at least one complex tensor, emit
- * a paired-buffer C kernel of the form
- *
- *   void k_<hash>(int64_t n,
- *                 const double *in_<a>_re, const double *in_<a>_im,  // complex tensor
- *                 const double *in_<b>,                              // real tensor (widened)
- *                 double s_<c>_re, double s_<c>_im,                  // complex scalar
- *                 double s_<d>,                                      // real scalar
- *                 double *out_<y>_re, double *out_<y>_im)            // complex output
- *   {
- *       #pragma omp simd
- *       for (int64_t i = 0; i < n; i++) {
- *           double __f_y_re = ...;
- *           double __f_y_im = ...;
- *           out_<y>_re[i] = __f_y_re;
- *           out_<y>_im[i] = __f_y_im;
- *       }
- *   }
- *
- * Supports the same fusion envelope as emitComplexPerElem in
- * `c/emit/fused.ts`:
- *   - Binary: + - * .*
- *   - Unary: + -
- *   - Call: conj, real, imag
- *   - Operand widening: real tensor / real scalar read with im = 0
- *   - ImagLiteral: (0.0, 1.0) pair
- *
- * Complex chains do NOT carry a trailing reduction — `fusion.ts` drops
- * the absorption for complex chains because the inline scalar
- * accumulator can't hold a complex value. Kernels emitted here have no
- * reduction output.
- */
-import type { FusibleChain } from "../fusion.js";
-import type { KernelEmitResult } from "./kernelEmit.js";
-/**
- * Emit a complex-tensor fused chain as a standalone C kernel.
- *
- * Returns null when the chain contains an expression the per-element
- * walker doesn't support (abs, complex divide, transcendental on
- * complex, etc.) — the caller falls back to the JS-JIT per-op path.
- */
-export declare function emitComplexChainKernel(chain: FusibleChain, allTensorVars: ReadonlySet<string>, complexTensorNames: ReadonlySet<string>, complexScalarVars: ReadonlySet<string>, outputTensorNames: ReadonlySet<string>): KernelEmitResult | null;

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

@@ -1,10 +0,0 @@
-/**
- * Shared content-hash helper for the e1 codegen.
- *
- * 64-bit FNV-1a over UTF-8 code units, returned as 16 hex chars.
- * Deterministic, fully self-contained, and browser-safe (no Node
- * `crypto` dependency). Cryptographic strength isn't needed — the
- * hash is a content-addressed suffix for kernel names and
- * `$h.$kernels[...]` cache keys.
- */
-export declare function fnv1a64Hex(s: string): string;

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

@@ -1,13 +0,0 @@
-/**
- * Node-only install shim for the e1 (experimental) kernel pipeline.
- *
- * Side-effect import from `cli.ts`. Replaces the `compileKernel` stub on
- * the module-level `jitHelpers` object with a real implementation that
- * shells out to `cc` via `compile.ts` and loads the result through koffi.
- *
- * Registration is idempotent — re-importing this module in tests won't
- * re-install. The kernel cache on `jitHelpers.$kernels` is shared across
- * all specializations in the process so the same fused chain used from
- * two different JIT'd functions compiles only once.
- */
-export {};

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

@@ -1,54 +0,0 @@
-/**
- * e1 (experimental) — standalone C-kernel emission for fusible tensor
- * chains used by the JS-JIT.
- *
- * Given a `FusibleChain` the normal JS fused codegen would emit, this
- * module produces an equivalent standalone C function of the form
- *
- *   void k_<hash>(int64_t n,
- *                 const double *in_<x>, ...,
- *                 double s_<scalar>, ...,
- *                 double *out_<y>, ...)
- *   {
- *       #pragma omp simd
- *       for (int64_t i = 0; i < n; i++) {
- *           double f_tmp1 = <expr>;
- *           ...
- *           out_<y>[i] = <final>;
- *       }
- *   }
- *
- * It returns the full C source, a koffi signature string, a content-
- * addressed hash, and the ordered list of JS expressions the generated
- * code should pass as arguments — everything the JS codegen needs to
- * emit a `$h.compileKernel(source, sig); kernel(n, x_data, y_data)`
- * dispatch.
- *
- * The prototype deliberately handles only the common real-tensor chain
- * shape: no reductions, no complex tensors, no dynamic-shape outputs.
- * Any chain that falls outside that envelope causes `emitChainKernel`
- * to return `null`, which signals the caller to fall back to the plain
- * inline JS fused loop.
- */
-import type { FusibleChain } from "../fusion.js";
-/**
- * A fused chain compiled to a standalone C kernel.  The caller (the JS
- * codegen) combines this with a runtime size threshold to emit
- *
- *     if (n >= THRESHOLD) $h.<kernelName>(n, x_data, y_data)
- *     else <plain JS fused loop>
- */
-export interface KernelEmitResult {
-    /** Hash-derived C function name, e.g. `nk_3a7f81b2`. */
-    kernelName: string;
-    /** Full C source: `#include` + function definition. */
-    cSource: string;
-    /** koffi function signature, e.g. `"void nk_3a7f81b2(int64_t, ...)"`. */
-    koffiSig: string;
-    /** Content hash over the final C source (stable id for caching). */
-    hash: string;
-    /** Ordered list of JS expressions to pass as call arguments. The
-     *  caller emits something like `$h.<kernelName>(${jsCallArgs.join(",")})`. */
-    jsCallArgs: string[];
-}
-export declare function emitChainKernel(chain: FusibleChain, allTensorVars: ReadonlySet<string>, outputTensorNames: ReadonlySet<string>, par: boolean): KernelEmitResult | null;

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

@@ -1,66 +0,0 @@
-/**
- * e1 — C kernel for multi-reduction scalar assigns.
- *
- * A MATLAB line like
- *
- *   red_acc = red_acc + (sum(x) + mean(x) + max(x) + min(x));
- *
- * has four reductions over the same vector. The default JS-JIT path
- * emits four `$h.tSum` / `$h.ib_*` helper calls, each of which scans
- * the whole vector. This module emits a single-pass C kernel that
- * computes every requested reduction in one loop and writes results
- * into caller-allocated scalar slots.
- *
- * Specialised per op-set: a group of `{sum, max, min}` compiles to a
- * different kernel than `{sum, mean, max, min}`. Source-addressed by
- * FNV-1a hash so the JS `$h.$kernels[...]` cache dedupes repeated call
- * sites.
- *
- * NaN handling: `-ffast-math` is on for the compile (matches the other
- * e1 kernels), so naive `isnan` is folded to `false`. The kernel uses
- * an inline bit-pattern NaN check to drive MATLAB's omit-NaN semantics
- * for `max`/`min` and records an `any_non_nan` flag the JS side uses
- * to map an all-NaN input to NaN.
- */
-/** Reductions we can fuse into one pass. `any` / `all` are excluded
- *  because their short-circuit `break` would prematurely stop the
- *  other accumulators. */
-export type MultiReduceOp = "sum" | "prod" | "max" | "min" | "mean";
-export interface MultiReductionKernelInfo {
-    /** Hash-derived C function name, e.g. `mr_3a7f81b2...`. */
-    kernelName: string;
-    /** Full C source string. */
-    cSource: string;
-    /** koffi function signature. */
-    koffiSig: string;
-    /** Content hash. */
-    hash: string;
-    /**
-     * Output slot layout. Each reduction in the kernel writes to its own
-     * Float64 slot, in the order of this array. `any_non_nan` (a 0/1 flag
-     * stored as double) is at the end when `hasMinOrMax` is true.
-     * The JS caller allocates a `Float64Array(slotCount)` and reads slots
-     * by index after the call.
-     */
-    slotNames: string[];
-    /** True when the kernel emits an `any_non_nan` slot at index
-     *  `slotNames.length - 1`. */
-    hasAnyNonNan: boolean;
-}
-/**
- * Build a multi-reduction kernel for the given op set. `ops` should be
- * a deduplicated list of reductions to compute (e.g. ["sum", "max"]).
- * The returned `slotNames` preserves insertion order for indexing; if
- * the op set contains `max`/`min`, an extra `any_non_nan` slot is
- * appended (the JS side uses it to override the sentinel max/min with
- * NaN when every input element was NaN).
- *
- * When `par` is true, the per-element loop is emitted as
- * `#pragma omp parallel for simd reduction(...)` with one reduction
- * clause per accumulator and an `if(n >= T)` gate that falls back to
- * serial below the threshold. Requires the caller to link with
- * `-fopenmp`; e1's `install.ts` already does this when libgomp is
- * available. When `par` is false, the loop is emitted as plain
- * `#pragma omp simd` (SIMD-only, single-threaded).
- */
-export declare function emitMultiReductionKernel(ops: readonly MultiReduceOp[], par?: boolean): MultiReductionKernelInfo;

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

@@ -1,13 +0,0 @@
-/**
- * Runtime-overridable OpenMP availability flag for the e1 codegen path.
- *
- * `scalarFnKernel.ts` is transitively reachable from the JS-JIT module
- * graph that Vite bundles for the web REPL, but `c/compile.ts` is
- * Node-only (child_process, fs, ...). Importing `cJitOpenmpAvailable`
- * directly from `compile.ts` would drag all of that into the browser
- * bundle. Instead we default to `false` here and let Node-only
- * `e1/install.ts` override the getter at install time — the same
- * pattern used for the `compileKernel` stub in `jitHelpers.ts`.
- */
-export declare function setOpenmpAvailableGetter(fn: () => boolean): void;
-export declare function isOpenmpAvailable(): boolean;