numbl 0.3.3 → 0.4.0

package/dist-lib/numbl-core/executors/cJit/fuseAnalyze.d.ts

@@ -1,39 +0,0 @@
-/**
- * c-jit-fuse — structural feasibility analysis on a single AST `Assign`.
- *
- * Walks the AST directly (not the JS-JIT IR — that pipeline is sized
- * for whole-function lowering). Determines whether the RHS expression
- * tree can be compiled to a single-pass element-wise C kernel, and
- * extracts the tensor / scalar input identifiers in a stable order.
- *
- * Returns `null` when the stmt isn't a fusable shape — caller (the
- * lowering pipeline) then leaves the stmt for the interpreter.
- *
- * Today's scope: real-only, plain-Ident LHS, same-shape tensor
- * leaves. Broadcasting, complex tensors, and in-place mutation are
- * not handled yet.
- */
-import { type Expr, type Stmt } from "../../parser/types.js";
-import type { Environment } from "../../interpreter/types.js";
-/** Per-leaf classification: tensor, scalar (number), or literal. */
-export type LeafKind = "tensor" | "scalar";
-export interface FuseClassification {
-    /** Output variable name (LHS of the Assign). */
-    readonly outputName: string;
-    /** Tensor inputs in the order they should appear as C parameters. */
-    readonly tensorInputs: readonly string[];
-    /** Scalar inputs in the order they should appear as C parameters. */
-    readonly scalarInputs: readonly string[];
-    /** The RHS expression, kept as AST for codegen to walk. */
-    readonly rhs: Expr;
-    /** Stable cache key projected from the AST shape and per-leaf
-     *  classification. Drops sizes — those are runtime-only and live
-     *  in `propose()`. */
-    readonly cacheKey: string;
-    /** Per-name kind, used by codegen to map identifiers to either
-     *  `tN[i]` (tensor) or `sN` (scalar). */
-    readonly kindOf: ReadonlyMap<string, LeafKind>;
-}
-/** Determine whether `stmt` is a fusable Assign and, if so, return
- *  its classification. Returns null on any structural mismatch. */
-export declare function analyzeFuse(stmt: Stmt, env: Environment): FuseClassification | null;

package/dist-lib/numbl-core/executors/cJit/fuseCodegen.d.ts

@@ -1,16 +0,0 @@
-/**
- * c-jit-fuse codegen — single-pass element-wise C kernel.
- *
- * Emits one C function whose body is a single `for (long i = 0; i < n; i++)`
- * loop with `out[i] = <fused expression>;`. The fused expression is
- * the AST RHS, with each `Ident` mapped to either `tN[i]` (tensor)
- * or `sN` (scalar) via `emitElemwiseExpr`'s leaf callback.
- *
- * ABI:
- *   void <fnName>(double *out, long n,
- *                 const double *t0, const double *t1, ...,
- *                 double s0, double s1, ...);
- */
-import type { FuseClassification } from "./fuseAnalyze.js";
-/** Emit a complete C source file for a fuse classification. */
-export declare function generateFuseCSource(fnName: string, cls: FuseClassification): string;

package/dist-lib/numbl-core/executors/cJit/fuseExecutor.d.ts

@@ -1,28 +0,0 @@
-/**
- * c-jit-fuse — element-wise tensor op fusion.
- *
- *   - `propose()` filters on `lowered.kind === "fuse"`. Reads each
- *     tensor input's `numel` from env and verifies they all match;
- *     declines below a per-call threshold so small tensors stay on
- *     the interpreter path.
- *
- *   - `compile()` emits a single-pass C kernel, builds the koffi
- *     declaration, calls `compileAndLoad`. Surfaces the source via
- *     `interp.onCJitCompile` for `--dump-c`.
- *
- *   - `run()` gathers tensor data + scalar values, allocates an
- *     output `Float64Array(numel)`, invokes the kernel, wraps the
- *     output as a real `RuntimeTensor` whose shape mirrors the first
- *     tensor input's, and writes back.
- */
-import type { Executor } from "../types.js";
-import type { FuseLoweredStmt } from "../lowering.js";
-import { type CompiledC } from "./compile.js";
-interface CFuseCompiled {
-    readonly compiled: CompiledC;
-    readonly tensorInputs: readonly string[];
-    readonly scalarInputs: readonly string[];
-    readonly source: string;
-}
-export declare const cJitFuseExecutor: Executor<FuseLoweredStmt, CFuseCompiled | null>;
-export {};

package/dist-lib/numbl-core/executors/cJit/loopExecutor.d.ts

@@ -1,32 +0,0 @@
-/**
- * c-jit-loop — C codegen executor for scalar for/while loops.
- *
- *   - `propose()` filters on `lowered.kind === "loop"`, requires a
- *     wired `nativeBridge`, applies the C feasibility whitelist, and
- *     rejects loops containing IO + bail-risk.
- *
- *   - `compile()` generates C source from the lowered IR, caches the
- *     compiled `.so` under `~/.cache/numbl/c-jit/<sha>.so`, and loads
- *     via koffi.
- *
- *   - `run()` reads loop inputs from the interpreter env, marshals
- *     complex values to (re, im) pairs, invokes the compiled C
- *     function with an output Float64Array, and writes the outputs
- *     back to env.
- */
-import type { Executor } from "../types.js";
-import type { LoopLowered } from "../jsJit/jitLoop.js";
-import { type VarEncoding } from "./codegen.js";
-import { type CompiledC } from "./compile.js";
-interface CLoopCompiled {
-    readonly compiled: CompiledC;
-    readonly inputs: readonly string[];
-    readonly outputs: readonly string[];
-    readonly inputEncodings: readonly VarEncoding[];
-    readonly outputEncodings: readonly VarEncoding[];
-    /** Total `double` slots in `out` — sum of per-output slot counts. */
-    readonly outputSlots: number;
-    readonly source: string;
-}
-export declare const cJitLoopExecutor: Executor<LoopLowered, CLoopCompiled | null>;
-export {};

package/dist-lib/numbl-core/executors/cJit/register.d.ts

@@ -1,10 +0,0 @@
-/**
- * Node-only entry that wires the C-JIT executors into the shared
- * `plugins.ts` registrar slot. Importing this module for its side
- * effect (from `cli.ts`) is what makes `--opt e3` work in the CLI.
- *
- * The browser worker bundle deliberately does not import this file,
- * keeping `compile.ts` (and its `node:fs`/`node:os`/`node:child_process`
- * imports) out of the web build's module graph.
- */
-export {};

package/dist-lib/numbl-core/executors/cJit/whitelist.d.ts

@@ -1,15 +0,0 @@
-/**
- * c-jit-loop feasibility whitelist.
- *
- * Walks a `LoopLowered` IR body and returns true iff every node is
- * something the C codegen can emit. Nodes outside the whitelist
- * (tensor ops, struct field access, etc.) cause `propose()` to
- * decline so the dispatcher falls through to the interpreter.
- *
- * Today's scope: scalar-only loops, real or complex (pair-of-doubles
- * encoding). Math builtins on complex args are NOT supported except
- * `real`, `imag`, and `conj`.
- */
-import type { JitStmt, JitType } from "../../jitTypes.js";
-export declare function isCScalarType(t: JitType): boolean;
-export declare function isCJitFeasible(body: readonly JitStmt[]): boolean;

package/dist-lib/numbl-core/executors/jsJit/callExecutor.d.ts

@@ -1,25 +0,0 @@
-/**
- * js-jit-call — JS codegen executor for the call shape.
- *
- * Lowering is the dispatcher's job. The call executor receives the
- * lowered IR (with pre-computed feasibility flags) as the first arg
- * to propose, decides whether to commit, and produces a compiled JS
- * artifact on commit.
- *
- *   - `propose()` filters on `lowered.kind === "call"`, applies
- *     IO+bail-risk feasibility check. Returns null to decline.
- *
- *   - `compile()` calls `generateCallJS` against the lowered IR.
- *     Cached by the registry under the classification's cacheKey.
- *
- *   - `run()` calls `runCallCompiled`. JitBailToInterpreter →
- *     transient bail.
- */
-import type { Executor } from "../types.js";
-import { type CallLowered, type CallCompiled } from "./jitCall.js";
-interface JsJitCallData {
-    readonly lowered: CallLowered;
-    readonly args: readonly unknown[];
-}
-export declare const jsJitCallExecutor: Executor<JsJitCallData, CallCompiled | null>;
-export {};

package/dist-lib/numbl-core/executors/jsJit/codegen/jitCodegen.d.ts

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

package/dist-lib/numbl-core/executors/jsJit/codegen/jitCodegenHoist.d.ts

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

package/dist-lib/numbl-core/executors/jsJit/codegen/jsMultiReduction.d.ts

@@ -1,67 +0,0 @@
-/**
- * JS-side multi-reduction block emission.
- *
- * Detection + dispatch for scalar Assigns of the form
- *
- *   acc = <expr tree with >=2 reductions over a single tensor Var>
- *
- * On match, the JS codegen emits a block that runs a single-pass
- * inline JS reduction loop, stashes each reduction result in a local,
- * and then emits the Assign's RHS with each reduction Call substituted
- * by the local that holds its value. The RHS-substitution contract
- * lives in `jitCodegen._multiReductionSubst`, which this module
- * installs and clears around the `emitExpr` call the caller provides.
- *
- * Limited to:
- *   - sum / prod / max / min / mean (short-circuit any/all excluded)
- *   - a single tensor Var argument to every reduction
- *   - all reductions read the same tensor name
- *   - the tensor is real-typed
- *   - at least two reductions in the RHS
- *
- * NaN semantics for max/min are matched to MATLAB omit-NaN behaviour:
- * IEEE unordered compare already skips NaN, and an `any_non_nan` flag
- * drives the all-NaN → NaN fallback.
- */
-import type { JitExpr, JitStmt } from "../../../jitTypes.js";
-type MultiReduceOp = "sum" | "prod" | "max" | "min" | "mean";
-export interface MultiReductionMatch {
-    /** The scalar Assign being emitted (target + original RHS). */
-    stmt: JitStmt & {
-        tag: "Assign";
-    };
-    /** The tensor variable name all reductions read. */
-    tensorName: string;
-    /** Distinct ops that actually appear, in first-occurrence order. Used
-     *  to size the kernel's output buffer and decide which accumulators
-     *  to declare on the JS fallback path. */
-    ops: MultiReduceOp[];
-    /** Every reduction Call node found in the RHS, paired with its op.
-     *  The JS emitter builds a substitution map from each Call to the
-     *  local that holds its result. */
-    sites: {
-        call: JitExpr & {
-            tag: "Call";
-        };
-        op: MultiReduceOp;
-    }[];
-}
-/** Try to match the multi-reduction pattern on a single statement. */
-export declare function tryMatchMultiReduction(stmt: JitStmt): MultiReductionMatch | null;
-/**
- * Emit the multi-reduction block. Writes into `lines`.
- *
- * The block:
- *   1. Aliases `<tensorName>.data` to a local and reads its length.
- *   2. Emits a single-pass JS loop that updates each accumulator.
- *   3. Post-loop: `mean = sum / n`, and a NaN fixup for max/min when
- *      every input element was NaN.
- *   4. Installs `_multiReductionSubst` pointing each reduction Call at
- *      its local, emits the Assign's RHS via the caller-provided
- *      `emitExpr`, and writes the final `<target> = <rhs>;`.
- */
-export declare function emitMultiReductionBlock(lines: string[], indent: string, match: MultiReductionMatch, mangleName: (n: string) => string, emitExprWithSubst: (expr: JitExpr, subst: Map<JitExpr, string>) => string): void;
-/** Reset per-function counter so generated names stay stable between
- *  compiles of the same IR. Called from `generateJS`. */
-export declare function resetMultiReductionState(): void;
-export {};

package/dist-lib/numbl-core/executors/jsJit/helpers/jitHelpers.d.ts

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

package/dist-lib/numbl-core/executors/jsJit/helpers/jitHelpersComplex.d.ts

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

package/dist-lib/numbl-core/executors/jsJit/helpers/jitHelpersIndex.d.ts

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

package/dist-lib/numbl-core/executors/jsJit/helpers/jitHelpersTensor.d.ts

@@ -1,34 +0,0 @@
-/**
- * Tensor operation helpers for JIT-compiled code.
- * Handles element-wise binary/unary ops, comparison ops, concat, and
- * tensor coercion for struct-array field access.
- */
-import { RuntimeTensor } from "../../../runtime/types.js";
-import type { RuntimeComplexNumber } from "../../../runtime/types.js";
-export declare function makeTensor(data: Float64Array, imag: Float64Array | undefined, shape: number[]): RuntimeTensor;
-type ScalarVal = number | RuntimeComplexNumber;
-export declare function tensorBinaryOp(a: unknown, b: unknown, realOp: (x: number, y: number) => number, complexOp: (a: ScalarVal, b: ScalarVal) => ScalarVal): RuntimeTensor | ScalarVal;
-export declare function tensorCompareOp(a: unknown, b: unknown, cmp: (x: number, y: number) => boolean): RuntimeTensor;
-export declare function tensorUnary(dest: unknown, a: RuntimeTensor, fn: (x: number) => number): RuntimeTensor;
-export declare function tensorNeg(dest: unknown, a: RuntimeTensor): RuntimeTensor;
-export declare function tDouble(v: unknown): unknown;
-export declare function tSum(v: unknown): unknown;
-export declare function vconcatGrow1r(base: unknown, v: number): RuntimeTensor;
-/** Unconditionally allocate a fresh wrapper + buffer for `t`. The caller
- *  can mutate the result without affecting any other alias of the input.
- *  Used by the JIT path on entry to a write-target hoisted alias; the
- *  runtime indexed-store path uses the sweep instead. */
-export declare function unshare(t: unknown): RuntimeTensor;
-export declare function asTensor(v: unknown): RuntimeTensor;
-export declare const tAdd: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tSub: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tMul: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tDiv: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tPow: (_dest: unknown, a: unknown, b: unknown) => RuntimeTensor | ScalarVal;
-export declare const tEq: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tNeq: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tLt: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tLe: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tGt: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export declare const tGe: (dest: unknown, a: unknown, b: unknown) => RuntimeTensor;
-export {};

package/dist-lib/numbl-core/executors/jsJit/jitCall.d.ts

@@ -1,59 +0,0 @@
-/**
- * User-function call — phased pipeline.
- *
- *   1. `classifyCall`  — cheap classification + cacheKey synthesis.
- *      Type-infer args, prune `exact` for numeric scalars, type
- *      widening using fn._lastJitArgTypes. Returns null on
- *      type-unknown args or `~` placeholder params.
- *
- *   2. `lowerCall`     — IR lowering.
- *
- *   3. `generateCallJS` — JS codegen + `new Function`.
- *
- *   4. `runCallCompiled` — push call frame + cleanup scope, invoke
- *      compiled fn, pop frame. Translates JitBailToInterpreter into
- *      a transient bail.
- */
-import type { Interpreter } from "../../interpreter/interpreter.js";
-import type { FunctionDef } from "../../interpreter/types.js";
-import { type JitType } from "../../jitTypes.js";
-import { type LoweringResult } from "./lower/jitLower.js";
-/** Cheap pre-lowering data. */
-export interface CallClassification {
-    readonly fn: FunctionDef;
-    readonly nargout: number;
-    readonly argTypes: readonly JitType[];
-    readonly cacheKey: string;
-    /**
-     * Effective JS parameter names for this specialization. Mirrors
-     * `fn.params` for non-varargin functions. For varargin functions,
-     * the trailing `varargin` is replaced with one synthetic name per
-     * variadic arg (`$va_0`, `$va_1`, …) so each variadic arg becomes
-     * a regular JS function parameter. argTypes is one-to-one with
-     * effectiveParams.
-     */
-    readonly effectiveParams: readonly string[];
-    /** Number of variadic args (0 when fn has no varargin). */
-    readonly nVarargin: number;
-}
-/** Lowered IR plus the classification it came from. */
-export interface CallLowered {
-    readonly classification: CallClassification;
-    readonly result: LoweringResult;
-}
-/** A compiled JS artifact ready to run. */
-export interface CallCompiled {
-    readonly fn: (...args: unknown[]) => unknown;
-    readonly source: string;
-}
-export declare function classifyCall(fn: FunctionDef, args: unknown[], nargout: number, prevArgTypes: readonly JitType[] | undefined): CallClassification | null;
-export declare function lowerCall(interp: Interpreter, classification: CallClassification): CallLowered | null;
-export declare function generateCallJS(interp: Interpreter, lowered: CallLowered): CallCompiled | null;
-export type CallRunOutcome = {
-    ok: true;
-    result: unknown;
-} | {
-    ok: false;
-    transient: boolean;
-};
-export declare function runCallCompiled(interp: Interpreter, fn: FunctionDef, compiled: CallCompiled, args: unknown[]): CallRunOutcome;

package/dist-lib/numbl-core/executors/jsJit/jitLoop.d.ts

@@ -1,53 +0,0 @@
-/**
- * For/while loop body — phased pipeline.
- *
- *   1. `classifyLoop`   — analyze loop, gather typed env inputs,
- *      live-out filter on outputs (using post-siblings), type
- *      widening, cacheKey synthesis.
- *
- *   2. `lowerLoop`      — wrap as a synthetic `FunctionDef` and
- *      lower via `lowerSyntheticFn`.
- *
- *   3. `generateLoopJS` — `generateSyntheticFnJS` + diagnostics.
- *
- *   4. `runLoopCompiled` — `runSyntheticFnAgainstEnv`.
- *
- * Shared with top-level via `shared.ts`. What's loop-specific is
- * the analysis (For/While discrimination), the live-out filter
- * against post-siblings, the cacheKey location (per loop AST
- * span), and the `$loop_for` / `$loop_while` synthetic name.
- */
-import type { Interpreter } from "../../interpreter/interpreter.js";
-import type { Stmt } from "../../parser/types.js";
-import type { JitType } from "../../jitTypes.js";
-import type { LoweringResult } from "./lower/jitLower.js";
-import { type SyntheticFnRunResult } from "./shared.js";
-export type LoopKind = "for" | "while";
-export interface LoopClassification {
-    readonly stmt: Stmt & {
-        type: "For" | "While";
-    };
-    readonly kind: LoopKind;
-    readonly inputs: readonly string[];
-    readonly inputTypes: readonly JitType[];
-    readonly outputs: readonly string[];
-    readonly hasReturn: boolean;
-    readonly cacheKey: string;
-}
-export interface LoopLowered {
-    readonly classification: LoopClassification;
-    readonly result: LoweringResult;
-}
-export interface LoopCompiled {
-    readonly fn: (...args: unknown[]) => unknown;
-    readonly source: string;
-}
-export type LoopRunResult = SyntheticFnRunResult;
-/** `postSiblings` / `postIdx` describe the stmt list this loop sits
- *  in; used to compute the live-out filter on outputs. */
-export declare function classifyLoop(interp: Interpreter, stmt: Stmt & {
-    type: "For" | "While";
-}, postSiblings: readonly Stmt[], postIdx: number, prevInputTypes: readonly JitType[] | undefined): LoopClassification | null;
-export declare function lowerLoop(interp: Interpreter, classification: LoopClassification): LoopLowered | null;
-export declare function generateLoopJS(interp: Interpreter, lowered: LoopLowered): LoopCompiled | null;
-export declare function runLoopCompiled(interp: Interpreter, compiled: LoopCompiled, classification: LoopClassification): LoopRunResult;

package/dist-lib/numbl-core/executors/jsJit/jitTopLevel.d.ts

@@ -1,44 +0,0 @@
-/**
- * Top-level script body — phased pipeline.
- *
- *   1. `classifyTopLevel`  — analyze script body, gather typed env
- *      inputs, type widening, cacheKey synthesis.
- *
- *   2. `lowerTopLevel`     — wrap as a synthetic `FunctionDef` and
- *      lower via `lowerSyntheticFn`.
- *
- *   3. `generateTopLevelJS` — `generateSyntheticFnJS` + diagnostics.
- *
- *   4. `runTopLevelCompiled` — `runSyntheticFnAgainstEnv`.
- *
- * The shared mechanics live in `shared.ts`; this module spells out
- * what's actually top-level-specific (whole-script body, no
- * post-loop liveness filter, `$top` synthetic name).
- */
-import type { Interpreter } from "../../interpreter/interpreter.js";
-import type { Stmt } from "../../parser/types.js";
-import type { JitType } from "../../jitTypes.js";
-import type { LoweringResult } from "./lower/jitLower.js";
-import { type SyntheticFnRunResult } from "./shared.js";
-export interface TopLevelClassification {
-    readonly stmts: readonly Stmt[];
-    readonly inputs: readonly string[];
-    readonly inputTypes: readonly JitType[];
-    readonly outputs: readonly string[];
-    readonly currentFile: string;
-    readonly hasReturn: boolean;
-    readonly cacheKey: string;
-}
-export interface TopLevelLowered {
-    readonly classification: TopLevelClassification;
-    readonly result: LoweringResult;
-}
-export interface TopLevelCompiled {
-    readonly fn: (...args: unknown[]) => unknown;
-    readonly source: string;
-}
-export type TopLevelRunResult = SyntheticFnRunResult;
-export declare function classifyTopLevel(interp: Interpreter, stmts: readonly Stmt[], prevInputTypes: readonly JitType[] | undefined): TopLevelClassification | null;
-export declare function lowerTopLevel(interp: Interpreter, classification: TopLevelClassification): TopLevelLowered | null;
-export declare function generateTopLevelJS(interp: Interpreter, lowered: TopLevelLowered): TopLevelCompiled | null;
-export declare function runTopLevelCompiled(interp: Interpreter, compiled: TopLevelCompiled, classification: TopLevelClassification): TopLevelRunResult;

package/dist-lib/numbl-core/executors/jsJit/loopExecutor.d.ts

@@ -1,15 +0,0 @@
-/**
- * js-jit-loop — JS codegen executor for the loop shape.
- *
- *   - `propose()` filters on `lowered.kind === "loop"`, applies
- *     JIT-feasibility checks (hasReturn, IO+bail-risk).
- *
- *   - `compile()` calls `generateLoopJS`. Cached by the registry
- *     under the classification's cacheKey.
- *
- *   - `run()` calls `runLoopCompiled`. JitBailToInterpreter →
- *     transient bail; JitFuncHandleBailError → permanent bail.
- */
-import type { Executor } from "../types.js";
-import { type LoopLowered, type LoopCompiled } from "./jitLoop.js";
-export declare const jsJitLoopExecutor: Executor<LoopLowered, LoopCompiled | null>;