numbl 0.2.0 → 0.3.3

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

@@ -1,14 +0,0 @@
-/**
- * Public entry point to the emit/ subpackage.
- *
- * Outside callers (the outer-function orchestrator in
- * [../assemble.ts](../assemble.ts)) see only:
- *   - `emitStmts` — walk a statement list and push C source lines.
- *   - `shapeExprsFor` — derive (d0, d1) C expressions for a dynamic
- *     tensor output (used inside this package too, but also by the
- *     outer orchestrator for param-output shape plumbing).
- *
- * Everything else is private to the emit/ subpackage.
- */
-export { emitStmts } from "./stmt.js";
-export { shapeExprsFor } from "./tensor.js";

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/hybrid.d.ts

@@ -1,42 +0,0 @@
-/**
- * Hybrid JS/C-JIT compilation: when the outer body falls back to JS-JIT,
- * still try C-JIT at narrower scopes and splice the native handles in.
- * Two shapes:
- *
- *   - `compileHybridCallees`: walks `generatedIRBodies` (one entry per
- *     user-function specialization reached by the outer) and tries
- *     C-JIT on each standalone. Successes get installed on
- *     `rt.jitHelpers[$cjit_<jitName>]` and their cached JS source is
- *     rewritten to `var <jitName> = $h.$cjit_<jitName>;` so the outer
- *     JS transparently calls native code at the callee boundary.
- *
- *   - `compileHybridLoops`: walks the outer's top-level JitStmt body,
- *     finds `For`/`While` stmts whose body is C-feasible, extracts each
- *     as a synthetic specialization (live-in vars → params, live-out
- *     vars → outputs), compiles it to native, and replaces the loop
- *     stmt in the outer's IR with a `UserCallWriteback` that invokes
- *     the handle and writes back outputs into the outer's locals.
- *
- * Preconditions at call time:
- *   - `interp.optimization >= 2`
- *   - `interp.rt.jitHelpers` is populated (i.e. past executeCode init)
- *   - the shared `generatedFns` / `generatedIRBodies` maps come from the
- *     outer specialization's `LoweringResult`
- *
- * Calling convention matches: `$h.callUser($rt, name, fn, ...args)`
- * invokes `fn(...args)`, and the args are the JIT's emitted JS forms —
- * raw JS numbers for scalars, RuntimeTensor for tensors, etc. — same
- * shape the C-JIT wrapper expects since it was compiled with matching
- * `argTypes`.
- */
-import type { Interpreter } from "../../interpreter/interpreter.js";
-import type { GeneratedFn } from "../jitLower.js";
-import type { JitStmt } from "../jitTypes.js";
-import type { TypeEnv } from "../jitLowerTypes.js";
-export declare function compileHybridCallees(interp: Interpreter, generatedIRBodies: Map<string, GeneratedFn>, generatedFns: Map<string, string>): void;
-/**
- * Extract top-level For/While loops from the outer's IR and try to
- * compile each to native. On success the loop is replaced in-place by a
- * `UserCallWriteback` stmt.
- */
-export declare function compileHybridLoops(interp: Interpreter, outerBody: JitStmt[], outerEndEnv: TypeEnv, outerOutputNames: string[], generatedIRBodies: Map<string, GeneratedFn>, generatedFns: Map<string, string>): void;

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

@@ -1,15 +0,0 @@
-/**
- * Installs the C-JIT backend (koffi path). Side-effect import only.
- *
- * Must be imported exactly once from a Node-only entry point (currently
- * src/cli.ts). The browser bundle never reaches this file, so the
- * Node-only dependencies stay out of the web build.
- *
- * The JS wrapper handles:
- *   - Extracting .data (Float64Array) and .data.length from RuntimeTensor args
- *   - Pre-allocating output buffers (Float64Array for tensor outputs,
- *     Float64Array(1) for scalar out-pointers)
- *   - Buffer reuse for tensor outputs (same logic as jitHelpersTensor.ts)
- *   - Wrapping results back into RuntimeTensor objects
- */
-export {};

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

@@ -1,26 +0,0 @@
-/**
- * Thrown under `--check-c-jit-parity` when the C-JIT declines to compile
- * a function/loop whose IR the JS-JIT would have accepted. The message
- * names the construct (from the feasibility checker) and the call site,
- * giving us an actionable punch list of features to implement in the
- * C-JIT so parity with JS-JIT holds.
- */
-export declare class CJitParityError extends Error {
-    readonly reason: string;
-    readonly kind: "infeasible" | "env";
-    constructor(message: string, reason: string, kind: "infeasible" | "env");
-}
-/**
- * Build a one-line parity-error message with the offending construct,
- * the call site (function/loop name + file:line), and the arg-type
- * signature that triggered the specialization.
- */
-export declare function formatCJitParityMessage(opts: {
-    kind: "infeasible" | "env";
-    reason: string;
-    reasonLine?: number;
-    siteLabel: string;
-    file: string;
-    callSiteLine: number;
-    argsDesc: string;
-}): string;

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/registry.d.ts

@@ -1,51 +0,0 @@
-/**
- * Registrable hook for the C-JIT backend.
- *
- * The C-JIT's implementation pulls in Node-only modules (`child_process`,
- * `fs`, `path`, ...) that would pollute the browser bundle if imported
- * statically from [jit/index.ts](./index.ts). This module defines a
- * thin interface + a module-level slot; the real backend is installed
- * from the CLI entry point via [install.ts](./install.ts),
- * which is only pulled into the Node-targeted build.
- *
- * When no backend is registered (e.g. browser, or someone running the
- * library API directly) `getCJitBackend()` returns null and
- * `tryJitCall` silently falls through to JS-JIT.
- */
-import type { Interpreter } from "../../interpreter/interpreter.js";
-import type { FunctionDef } from "../../interpreter/types.js";
-import type { JitStmt, JitType } from "../jitTypes.js";
-import type { GeneratedFn } from "../jitLower.js";
-/**
- * Outcome of a C-JIT compile attempt.
- *
- * - `ok: true`: compilation succeeded; `fn` is callable.
- * - `ok: false, kind: "infeasible"`: the lowered IR contains a construct
- *   the C-JIT doesn't handle (JS-JIT probably would). Carries a `reason`
- *   and optional `line` from the feasibility checker; `--check-c-jit-parity`
- *   treats this as a hard error.
- * - `ok: false, kind: "env"`: the environment couldn't support C-JIT
- *   (no C compiler, compile/link failed, header missing, etc.). Also a
- *   hard error under `--check-c-jit-parity` because the user explicitly
- *   asked for C-JIT.
- */
-export type CJitCompileResult = {
-    ok: true;
-    fn: (...args: unknown[]) => unknown;
-} | {
-    ok: false;
-    kind: "infeasible" | "env";
-    reason: string;
-    line?: number;
-};
-export interface CJitBackend {
-    /**
-     * Attempt to emit + compile + load a C specialization for the given
-     * lowered IR. Returns a structured result: callers distinguish
-     * `infeasible` (parity gap with JS-JIT) from `env` (missing compiler)
-     * when `--check-c-jit-parity` is on.
-     */
-    tryCompile(interp: Interpreter, fn: FunctionDef, body: JitStmt[], outputNames: string[], localVars: Set<string>, outputType: JitType | null, outputTypes: JitType[], argTypes: JitType[], nargout: number, generatedIRBodies: Map<string, GeneratedFn>): CJitCompileResult;
-}
-export declare function registerCJitBackend(b: CJitBackend): void;
-export declare function getCJitBackend(): CJitBackend | null;

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/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>): KernelEmitResult | null;

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;