@loopdive/js2 0.57.0

package/dist/codegen/custom-iterable.d.ts

@@ -0,0 +1,34 @@
+import { CodegenContext, FunctionContext } from './context/types.js';
+import { ValType } from '../ir/types.js';
+/**
+ * True when `srcType` is a `ref`/`ref_null` to a struct that defines a
+ * `[Symbol.iterator]()` method (registered as `${structName}_@@iterator`), and
+ * is therefore a user-defined iterable that should be drained through the
+ * iterator protocol rather than treated as a vec.
+ *
+ * Known vecs, native generators, native strings and externref JS iterables are
+ * handled by earlier branches at the call sites; this only fires for the
+ * object-literal / class-instance iterable case those branches don't cover.
+ */
+export declare function isCustomIterable(ctx: CodegenContext, srcType: ValType): boolean;
+/**
+ * Drain a user-defined iterable into a freshly built vec struct of element type
+ * `vecTypeIdx` via the iterator protocol, leaving `ref_null $vec` on the stack.
+ * The iterable value must already be stored in `iterableLocal` (a `ref`/
+ * `ref_null` to the iterable struct).
+ *
+ * Emits (using the `__iterator` / `__iterator_next` JS-host bridge):
+ *   iter = __iterator(extern(obj))        // calls obj[Symbol.iterator]()
+ *   cap = 4; data = new arr[cap]; len = 0
+ *   loop:
+ *     (done, val) = __iterator_next(iter)
+ *     if done break
+ *     if len == cap: grow (double, array.copy)
+ *     data[len] = coerce(val: externref -> elemType); len++
+ *   struct.new $vec { len, data }
+ *
+ * Mirrors the doubling-array drain the #1749 override-spread path uses. Returns
+ * `false` (emitting nothing) when the vec type can't be resolved or the
+ * iterator imports are unavailable, so the caller can fall back.
+ */
+export declare function emitDrainCustomIterableToVec(ctx: CodegenContext, fctx: FunctionContext, iterableLocal: number, iterableType: ValType, vecTypeIdx: number): boolean;

package/dist/codegen/dataview-native.d.ts

@@ -0,0 +1,51 @@
+import { ValType } from '../ir/types.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+export declare function isDataViewAccessor(name: string): boolean;
+/**
+ * #1698 — `ab.slice(begin?, end?)` in no-JS-host mode. Returns a new
+ * ArrayBuffer (i32_byte vec struct) holding bytes `[begin, end)` of the
+ * source, with the spec §25.1.5.3 negative-offset / clamp / default-end
+ * normalisation applied at runtime. Receiver and result are externref
+ * (the user's `const sliced = ab.slice(...)` local is typed externref;
+ * matching that here keeps `new Uint8Array(sliced)` working without
+ * additional coercion).
+ */
+export declare function emitArrayBufferSlice(ctx: CodegenContext, fctx: FunctionContext, receiver: import("../ts-api.js").ts.Expression, args: readonly import("../ts-api.js").ts.Expression[], compileExpr: (expr: import("../ts-api.js").ts.Expression, hint?: ValType) => ValType | null): ValType | null;
+/**
+ * (#2159 / #38) Lazily register the standalone `$__dv_window` wrapper struct:
+ * `{buf: (ref null __vec_i32_byte), byteOffset: i32, byteLength: i32}`.
+ *
+ * `new DataView(buffer, byteOffset, byteLength)` produces one of these when the
+ * view is *windowed* (byteOffset > 0 or an explicit byteLength); it shares the
+ * parent buffer's backing array so windowed writes are visible through the full
+ * view, and carries the window's byteOffset/byteLength so `dv.byteOffset` /
+ * `dv.byteLength` reflect the ctor args. Offset-0 default-length views keep the
+ * bare i32_byte vec representation (no wrapper) — the dominant, fully-native
+ * case — so the accessor must accept BOTH a wrapper and a bare vec receiver.
+ */
+export declare function getOrRegisterDvWindowType(ctx: CodegenContext): number;
+export declare function emitDataViewAccessor(ctx: CodegenContext, fctx: FunctionContext, methodName: string, receiver: import("../ts-api.js").ts.Expression, args: readonly import("../ts-api.js").ts.Expression[], compileExpr: (expr: import("../ts-api.js").ts.Expression, hint?: ValType) => ValType | null): {
+    kind: "get";
+    result: ValType;
+} | {
+    kind: "set";
+} | null;
+/**
+ * (#2639) Stage a native DataView's bytes into the linear write scratch so
+ * `node:fs` `writeSync(fd, dv)` can hand the shim a (ptr, len) pair.
+ *
+ * The DataView arg (an externref / GC ref already produced by compiling the
+ * argument expression — its `recvType` passed in) is resolved via
+ * {@link recoverDvBacking} to its i32_byte backing array + base byte offset +
+ * view byte length, mirroring exactly what the DataView accessors use. Then it
+ * copies `viewLen` bytes from `arr[base + j]` (masked to a byte) into
+ * `scratch[scratchStart + j]`. The DataView's backing array is `i32_byte` (one
+ * i32 per byte, 0..255), so each element is `& 0xff`-ed before the byte store.
+ *
+ * Returns the i32 local holding the view byte length (the count to write), or
+ * `-1` when the receiver isn't a resolvable DataView/ArrayBuffer view. The
+ * receiver value must already be on the stack (its `recvType` is consumed here).
+ * Memory is assumed already grown for `[scratchStart, scratchStart+viewLen)` —
+ * the caller grows it (it must, since the length is only known at runtime).
+ */
+export declare function emitDataViewToWriteScratch(ctx: CodegenContext, fctx: FunctionContext, recvType: ValType | null, scratchStart: number): number;

package/dist/codegen/date-parse-native.d.ts

@@ -0,0 +1,13 @@
+import { CodegenContext } from './context/types.js';
+/**
+ * Emit the native `__date_parse` helper if it is not already present.
+ *
+ * Locals (after param 0 = s:externref):
+ *   1 flat:ref$NativeString  2 data:ref$i16arr  3 len:i32  4 i:i32  5 c:i32
+ *   6 sign:i64 (year sign)   7 year:i64  8 month:i64  9 day:i64
+ *  10 hour:i64 11 min:i64   12 sec:i64  13 ms:i64
+ *  14 tzSign:i64 15 tzH:i64 16 tzM:i64
+ *  17 fail:i32  18 acc:i64 (digit accumulator)  19 ndig:i32 (digits read)
+ *  20 days:i64 (days-from-civil)  21 hasTime:i32  22 expanded:i32
+ */
+export declare function emitNativeDateParse(ctx: CodegenContext): void;

package/dist/codegen/dead-elimination.d.ts

@@ -0,0 +1,26 @@
+import { WasmModule } from '../ir/types.js';
+import { CodegenContext } from './context/types.js';
+/**
+ * Eliminate dead (unreferenced) function imports and type definitions
+ * from a compiled WasmModule. Mutates the module in place.
+ *
+ * #1899 — funcIdx-authority contract. This pass REMOVES dead function imports
+ * and remaps every funcIdx referenced from inside `mod` (bodies, exports,
+ * elements, declaredFuncRefs, start) through the authoritative `fR` remap, so
+ * the emitted module is internally consistent. Historically it touched ONLY
+ * `mod` and left the codegen-context side-tables (`funcMap`, `nativeStrHelpers`,
+ * …) stale by the removed-import delta. Any consumer that bakes a NEW `call`
+ * from those maps AFTER this pass (e.g. the `__unbox_number` repair in
+ * `fixups.ts`, which runs in `repairStructTypeMismatches` /
+ * `fixupExternConvertAny` right after dead-elim) would then target the wrong
+ * function — the recurring late-shift / index-desync class (#1677/#1809/#1839/
+ * #1886/#329/#1461/#2043). Pass `ctx` so the SAME authoritative `fR` is applied
+ * to the side-tables, keeping them in lockstep with the module exactly as the
+ * add-shift passes (`shiftLateImportIndices` / `reconcileNativeStrFinalizeShift`)
+ * already do for the import-ADD direction. The `ctx` arg is optional so non-codegen
+ * callers (tests, the standalone module rewriter) need no context; when omitted,
+ * only `mod` is remapped (the prior behaviour). The whole side-table remap is a
+ * no-op when no dead imports were removed (`fR.size === 0`), which is the common
+ * case mid-finalize.
+ */
+export declare function eliminateDeadImports(mod: WasmModule, ctx?: CodegenContext): void;

package/dist/codegen/declarations.d.ts

@@ -0,0 +1,147 @@
+import { ts } from '../ts-api.js';
+import { ValType } from '../ir/types.js';
+import { CodegenContext } from './context/types.js';
+/** Accumulated state for the single-pass collector */
+interface UnifiedCollectorState {
+    consoleNeededByMethod: Map<string, Set<"number" | "bool" | "string" | "externref">>;
+    primitiveNeeded: Set<string>;
+    stringLiterals: Set<string>;
+    hasTypeofExprForStrings: boolean;
+    hasTaggedTemplate: boolean;
+    insideComputedPropertyName: number;
+    stringMethodNeeded: Set<string>;
+    /** String methods called with RegExp args — need host import even in native strings mode */
+    stringRegexpMethodNeeded: Set<string>;
+    mathNeeded: Set<string>;
+    mathNeedsToUint32: boolean;
+    parseNeeded: Set<string>;
+    dateParseHostNeeded: boolean;
+    uriNeeded: Set<string>;
+    needsFromCharCode: boolean;
+    needsFromCodePoint: boolean;
+    promiseNeeded: Set<string>;
+    promiseNeedConstructor: boolean;
+    promiseNeedThen2: boolean;
+    jsonNeedStringify: boolean;
+    jsonNeedParse: boolean;
+    callbackFound: boolean;
+    getterCallbackFound: boolean;
+    asyncCpsFound: boolean;
+    funcArrayNeed1: boolean;
+    funcArrayNeed2: boolean;
+    unionFound: boolean;
+    generatorFound: boolean;
+    iteratorFound: boolean;
+    arrayIteratorFound: boolean;
+    forInFound: boolean;
+    forInLiterals: Set<string>;
+    inExprLiterals: Set<string>;
+    objectMethodLiterals: Set<string>;
+    objectMethodHasValues: boolean;
+    wrapperFound: boolean;
+    unknownCtorNeeded: Map<string, number>;
+    sourceFile: ts.SourceFile;
+}
+export declare function createUnifiedCollectorState(sourceFile: ts.SourceFile): UnifiedCollectorState;
+/** Single-pass visitor called on every AST node */
+export declare function unifiedVisitNode(ctx: CodegenContext, state: UnifiedCollectorState, node: ts.Node): void;
+/** Run all post-walk finalization (register imports based on collected state) */
+export declare function finalizeUnifiedCollector(ctx: CodegenContext, state: UnifiedCollectorState): void;
+/**
+ * Perform a single AST walk that collects all import-phase information.
+ * Replaces 19 separate collect* passes with one O(n) traversal.
+ * (#592)
+ */
+export declare function resolveGenericCallSiteTypes(ctx: CodegenContext, funcName: string, sourceFile: ts.SourceFile): {
+    params: ValType[];
+    results: ValType[];
+} | null;
+/**
+ * Infer a concrete type for an untyped function parameter by scanning call sites.
+ * When a parameter has no type annotation (TS gives it `any`), we look at every
+ * call to that function and collect the argument types at the given index.
+ * If all call sites agree on a single concrete wasm type, we return it.
+ * Returns null if no call site found or types disagree.
+ */
+export declare function inferParamTypeFromCallSites(ctx: CodegenContext, funcName: string, paramIndex: number, sourceFile: ts.SourceFile): ValType | null;
+/**
+ * #1121: Fallback param-type inference from body usage. Used when
+ * `inferParamTypeFromCallSites` finds no call sites (e.g. an exported
+ * entrypoint that is only called from JS host) but the function body
+ * itself reveals how the parameter is used.
+ *
+ * Recognises three numeric-flow patterns:
+ *  1. `param` passed as an argument to a function whose return is in
+ *     `ctx.numericReturnTypes` (the recursive numeric kernels detected
+ *     by inferNumericReturnTypes).
+ *  2. `param` used as an operand of a numeric binary operator
+ *     (+, -, *, /, %, **, |, &, ^, <<, >>, >>>, ToInt32 coercion).
+ *  3. `param` used as a numeric loop bound / comparison operand
+ *     (<, <=, >, >=).
+ *
+ * Returns null if none of those patterns are found, leaving the param
+ * unchanged. This is intentionally conservative — the call-site path
+ * is still preferred when it has information.
+ */
+export declare function inferParamTypeFromBody(ctx: CodegenContext, decl: ts.FunctionLikeDeclaration, paramIndex: number): ValType | null;
+/**
+ * #1121: Infer numeric (f64) return types for functions whose body is a
+ * purely-numeric kernel even when TypeScript reports the return as
+ * `any`/`unknown` (e.g. unannotated recursive helpers like
+ * `function fib(n) { ... }`).
+ *
+ * We do a fixpoint over the entire source file:
+ *  1. Seed: every function declaration whose TS return type is implicit
+ *     any/unknown becomes a candidate for f64 promotion (assuming numeric).
+ *  2. Iterate: a candidate stays in the set only while every `return X`
+ *     in its body produces a value whose type is structurally numeric
+ *     under the assumption that all other candidates also return f64.
+ *  3. The fixpoint converges in O(N * passes) where passes is bounded by
+ *     the number of candidates.
+ *
+ * This intentionally does NOT consider parameter types — by the time we
+ * are called, the param-inference pass has already retyped each
+ * implicit-any parameter via `inferParamTypeFromCallSites`. We only need
+ * to fix the return-type side, which is what TS gives up on for
+ * recursive numeric kernels.
+ */
+export declare function inferNumericReturnTypes(ctx: CodegenContext, sourceFile: ts.SourceFile): Map<string, ValType>;
+/**
+ * Pre-pass: detect empty object literals (`var obj = {}`) that later receive
+ * property assignments (`obj.prop = val`) and record the extra properties so
+ * that ensureStructForType creates a struct with the correct fields.
+ *
+ * This runs *before* collectDeclarations so the struct type is correct from
+ * the start.
+ */
+export declare function collectEmptyObjectWidening(ctx: CodegenContext, checker: ts.TypeChecker, sourceFile: ts.SourceFile): void;
+export declare function collectPropsFromStatements(checker: ts.TypeChecker, ctx: CodegenContext, stmts: readonly ts.Statement[], varName: string, extraProps: {
+    name: string;
+    type: ValType;
+}[], seenProps: Set<string>): void;
+/**
+ * Apply shape inference: detect module-level variables used as array-like objects
+ * and override their global types from externref/AnyValue to vec struct types.
+ * Must be called after collectDeclarations (which registers module globals).
+ */
+export declare function applyShapeInference(ctx: CodegenContext, checker: ts.TypeChecker, sourceFile: ts.SourceFile): void;
+export declare function collectDeclarations(ctx: CodegenContext, sourceFile: ts.SourceFile, isEntryFile?: boolean): void;
+export declare function collectInterface(ctx: CodegenContext, decl: ts.InterfaceDeclaration): void;
+/**
+ * After all interfaces and type aliases are collected, re-resolve field types
+ * that were initially mapped to externref but should be ref $struct.
+ * This handles cross-references between interfaces regardless of declaration order.
+ */
+export declare function resolveStructFieldTypes(ctx: CodegenContext, sourceFile: ts.SourceFile): void;
+export declare function collectObjectType(ctx: CodegenContext, name: string, type: ts.Type): void;
+/** Compile all function bodies (including class constructors and methods) */
+export declare function compileDeclarations(ctx: CodegenContext, sourceFile: ts.SourceFile): void;
+export {};
+/**
+ * Post-compilation fixup: insert extern.convert_any after struct.new when
+ * the result is stored into an externref local (local.set / local.tee).
+ *
+ * This happens when a vec/class struct is created but the target variable
+ * was typed as externref by the compiler.
+ */
+/** Internal field names that are not user-visible properties */

package/dist/codegen/deno-api.d.ts

@@ -0,0 +1,11 @@
+import { ts } from '../ts-api.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+import { InnerResult } from './shared.js';
+/**
+ * Recognize + lower a Deno synchronous stdio call under `--target wasi`. Returns
+ * the result (`number | null` externref for readSync, `number` f64 for
+ * writeSync), or `undefined` when this isn't a Deno stdio call (the generic
+ * compiler then proceeds). Non-WASI targets fall through entirely — a Deno
+ * program "runs under real Deno" uncompiled; we only LOWER it under wasi.
+ */
+export declare function tryCompileDenoStdioCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression): InnerResult | undefined;

package/dist/codegen/destructuring-params.d.ts

@@ -0,0 +1,102 @@
+import { ts } from '../ts-api.js';
+import { Instr, ValType } from '../ir/types.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+/**
+ * Number of iterator steps an array binding/assignment pattern consumes
+ * (§8.5.3 IteratorBindingInitialization). Each element — INCLUDING elision
+ * holes (`OmittedExpression`) — costs exactly one IteratorStep. A rest element
+ * drains the remainder of the iterator → unbounded → -1.
+ *
+ * Binding patterns mark rest via `BindingElement.dotDotDotToken`; assignment
+ * patterns use `SpreadElement`. The returned count feeds `__array_from_iter_n`
+ * so a no-rest pattern materializes EXACTLY `elements.length` steps instead of
+ * draining a lazy generator to completion (#1592). `-1` routes through the
+ * unbounded (legacy `__array_from_iter`) path, preserving all IteratorClose
+ * tuning (#1219).
+ */
+export declare function patternIteratorStepCount(elements: readonly (ts.ArrayBindingElement | ts.Expression)[]): number;
+/**
+ * Destructuring mode for the param-destructure helpers (#1553a).
+ *
+ * - `"param"` (default): function-parameter destructuring; emits no TDZ flags.
+ * - `"catch"`: catch-clause destructuring; behaves like `"param"` today
+ *   (centralised here so #1552's catch helper can opt in later).
+ * - `"decl"`: declaration-form (`let`/`const`/`var`) destructuring; emits
+ *   `emitLocalTdzInit` after every binding `local.set`, and (for `let`/`const`)
+ *   calls `ensureLetConstBindingPatternTdzFlags` at entry so each bound
+ *   identifier has a TDZ flag local before its sibling defaults run.
+ */
+export type DestructureMode = "param" | "catch" | "decl";
+/**
+ * Caller-declared binding kind. Only meaningful when `mode === "decl"`:
+ *
+ * - `"let"` / `"const"`: requires per-binding TDZ flags.
+ * - `"var"`: `emitLocalTdzInit` is a no-op (no flag was allocated by the
+ *   pre-pass), so behaviour is correct without an extra branch.
+ * - `"param"`: catch-mode + param-mode default; the helper ignores it.
+ */
+export type BindingKind = "let" | "const" | "var" | "param";
+export interface DestructureOpts {
+    mode?: DestructureMode;
+    bindingKind?: BindingKind;
+}
+export declare function buildDestructureNullThrow(ctx: CodegenContext, fctx?: FunctionContext): Instr[];
+/**
+ * Returns true when `expr` is a literal `null` or `undefined` — which per spec
+ * must throw TypeError when used as the source value for a destructuring pattern
+ * (RequireObjectCoercible / GetIterator).
+ *
+ * Used by parameter default-emission to statically reject `({pat} = null)` and
+ * `({pat} = undefined)` even when paramType is numeric (loses null/undef info).
+ */
+export declare function isNullOrUndefinedLiteral(expr: ts.Expression): boolean;
+/**
+ * Destructure a function parameter (externref) using __extern_get for property access.
+ * This handles primitives, objects, and any externref value safely — no struct cast needed.
+ * Used as fallback when the value is not the expected struct type (#852).
+ */
+export declare function destructureParamObjectExternref(ctx: CodegenContext, fctx: FunctionContext, paramIdx: number, pattern: ts.ObjectBindingPattern, opts?: DestructureOpts): void;
+/**
+ * Emit a null/undefined check for an externref destructuring parameter.
+ * Checks both ref.is_null (Wasm null) and __extern_is_undefined (JS undefined).
+ * Throws TypeError if either is true.
+ */
+export declare function emitExternrefDestructureGuard(ctx: CodegenContext, fctx: FunctionContext, paramIdx: number): void;
+/**
+ * (#2568) Derive the WasmGC struct type a destructuring object binding pattern
+ * resolves to, as a `ref`-typed compile hint for the pattern's default object
+ * literal. Mirrors the struct-type derivation in `destructureParamObject` below
+ * so an outer param default materializes in the SAME shape the destructuring
+ * `ref.test`/`ref.cast` expects (otherwise the default boxes its nested fields
+ * to externref → a `{ field: externref }` struct that fails the `ref.test`, drops
+ * to the `__extern_get` else-branch, and reads 0). Returns `undefined` when no
+ * resolvable struct exists (rest pattern, missing fields, primitive) — the
+ * caller then keeps the externref hint. Shared by the class-method
+ * (class-bodies.ts) and plain-function (function-body.ts) param-default sites.
+ */
+export declare function structHintForBindingPattern(ctx: CodegenContext, pattern: ts.ObjectBindingPattern): ValType | undefined;
+/**
+ * Destructure a function parameter that is an ObjectBindingPattern.
+ * The parameter value (a struct ref) is at param index `paramIdx`.
+ * We extract each bound field into a new local.
+ */
+export declare function destructureParamObject(ctx: CodegenContext, fctx: FunctionContext, paramIdx: number, pattern: ts.ObjectBindingPattern, paramType: ValType, opts?: DestructureOpts): void;
+/**
+ * Destructure a function parameter that is an ArrayBindingPattern.
+ * The parameter value (a vec struct ref) is at param index `paramIdx`.
+ * We extract each element into a new local.
+ */
+export declare function destructureParamArray(ctx: CodegenContext, fctx: FunctionContext, paramIdx: number, pattern: ts.ArrayBindingPattern, paramType: ValType, opts?: DestructureOpts): void;
+/**
+ * Cache string literal thunk calls in locals for the given function.
+ *
+ * After a function body has been compiled, this scans all instructions
+ * (including nested blocks/loops/ifs) for `call` instructions that invoke
+ * string literal thunks (__str_N).  For each unique thunk found it:
+ *   1. Allocates an `externref` local to hold the cached value.
+ *   2. Prepends `call $__str_N` + `local.set $cached` at function entry.
+ *   3. Replaces every matching `call` in the body with `local.get $cached`.
+ *
+ * This avoids repeated import calls for the same string literal, which is
+ * especially beneficial inside loops.
+ */

package/dist/codegen/dyn-read.d.ts

@@ -0,0 +1,26 @@
+import { CodegenContext, FunctionContext } from './context/types.js';
+/**
+ * Register the `__dyn_has` / `__dyn_get` runtime read primitives. Idempotent and
+ * **gated on `ctx.usesDynRead`** — a no-op unless a call site (M1+) has flagged
+ * that the module needs them, so M0 (no call sites) emits nothing.
+ *
+ * Call this in the finalize phase, after `ensureObjectRuntime`/`ensureAnyHelpers`
+ * (the helpers reference `$AnyValue` + `__extern_get`). It must run before
+ * dead-elim / late-import settle so the baked funcIdx values are stable.
+ */
+export declare function ensureDynReadHelpers(ctx: CodegenContext): void;
+/**
+ * (#2580 M1) Call-site helper: emit a `__dyn_get(recv, "<keyName>")` at a property
+ * read site. The RECEIVER externref must already be on the stack; this pushes the
+ * key string (externref) and the `call __dyn_get`, leaving the value externref
+ * (the property, or `undefined` when absent) on the stack.
+ *
+ * Runs during BODY compilation (not finalize): it eagerly `ensureObjectRuntime`
+ * (so `__extern_get` exists — safe to register its struct types here, the normal
+ * path) and eagerly emits the dyn-read helpers (so `__dyn_get`'s funcIdx is known
+ * for the `call` below). Sets `ctx.usesDynRead` so the finalize pass is a no-op
+ * (the latch is already set). Returns true on success; false (no-op, receiver
+ * left on stack) if the runtime is unavailable — the caller then keeps its prior
+ * lowering.
+ */
+export declare function emitDynGet(ctx: CodegenContext, fctx: FunctionContext, keyName: string): boolean;

package/dist/codegen/eval-tiering.d.ts

@@ -0,0 +1,19 @@
+import { default as ts } from 'typescript';
+export declare enum EvalTier {
+    /** No eval anywhere — full optimization. */
+    NoEval = 1,
+    /** Only static-literal eval — inlined at compile time (#1163). */
+    StaticLiteral = 2,
+    /** Indirect eval — affects global scope only; locals unaffected. */
+    Indirect = 3,
+    /** Direct eval, strict mode — locals stay unboxed, no function replacement. */
+    DirectStrict = 4,
+    /** Direct eval, sloppy mode — full boxing + mutable funcref globals. */
+    DirectSloppy = 5
+}
+/**
+ * Classify a module's eval usage into its worst-case tier. Read-only.
+ *
+ * Returns `EvalTier.NoEval` when the module contains no real eval call.
+ */
+export declare function classifyEvalTier(sourceFile: ts.SourceFile, checker: ts.TypeChecker): EvalTier;

package/dist/codegen/expressions/assignment.d.ts

@@ -0,0 +1,61 @@
+import { ts } from '../../ts-api.js';
+import { ValType } from '../../ir/types.js';
+import { CodegenContext, FunctionContext } from '../context/types.js';
+import { InnerResult } from '../shared.js';
+export declare function compileAssignment(ctx: CodegenContext, fctx: FunctionContext, expr: ts.BinaryExpression): InnerResult;
+/**
+ * Detect strict-mode context for a node (§10.2.1).
+ * A node is in strict mode if:
+ *   - Containing source file starts with `"use strict";` directive.
+ *   - Inside a class body (classes are always strict).
+ *   - Inside a function whose body begins with `"use strict";`.
+ */
+export declare function isStrictContext(node: ts.Node): boolean;
+/**
+ * True if `id` is an identifier that cannot be resolved to any binding the
+ * compiler knows about. Mirrors the check in identifiers.ts:393 for reads
+ * but also excludes bindings that only exist in the codegen (locals, captures,
+ * globals, func imports).
+ */
+export declare function isUnresolvableIdent(ctx: CodegenContext, fctx: FunctionContext, id: ts.Identifier): boolean;
+export declare function findUnresolvableInObjectPattern(ctx: CodegenContext, fctx: FunctionContext, target: ts.ObjectLiteralExpression): boolean;
+export declare function findUnresolvableInArrayPattern(ctx: CodegenContext, fctx: FunctionContext, target: ts.ArrayLiteralExpression): boolean;
+declare function compileDestructuringAssignment(ctx: CodegenContext, fctx: FunctionContext, target: ts.ObjectLiteralExpression, value: ts.Expression): InnerResult;
+declare function compileArrayDestructuringAssignment(ctx: CodegenContext, fctx: FunctionContext, target: ts.ArrayLiteralExpression, value: ts.Expression): InnerResult;
+declare function compilePropertyAssignment(ctx: CodegenContext, fctx: FunctionContext, target: ts.PropertyAccessExpression, value: ts.Expression): InnerResult;
+declare function compileElementAssignment(ctx: CodegenContext, fctx: FunctionContext, target: ts.ElementAccessExpression, value: ts.Expression): InnerResult;
+/**
+ * Fallback for element assignment on non-array types.
+ * Converts the object to externref and calls __extern_set(obj, key, val).
+ * The object value is already on the stack.
+ */
+declare function compileExternSetFallback(ctx: CodegenContext, fctx: FunctionContext, target: ts.ElementAccessExpression, value: ts.Expression, objType: ValType): InnerResult;
+/**
+ * Compile logical assignment operators: ??=, ||=, &&=
+ *
+ * Desugars to value-preserving semantics:
+ *   a ??= b  →  if (a is null) a = b; result = a
+ *   a ||= b  →  if (!a) a = b; result = a
+ *   a &&= b  →  if (a) a = b; result = a
+ */
+export declare function compileLogicalAssignment(ctx: CodegenContext, fctx: FunctionContext, expr: ts.BinaryExpression, op: ts.SyntaxKind): ValType | null;
+export declare function isCompoundAssignment(op: ts.SyntaxKind): boolean;
+export declare function compileCompoundAssignment(ctx: CodegenContext, fctx: FunctionContext, expr: ts.BinaryExpression, op: ts.SyntaxKind): ValType | null;
+/**
+ * (#2666) ToPropertyKey §7.1.19, applied EXACTLY ONCE to the key externref on
+ * the stack, leaving the coerced key externref on the stack. For a member
+ * read-modify-write (`o[key] op= rhs`, `o[key]++`) the LHS Reference is
+ * evaluated once (§13.15.2 / §13.4), so the key's ToPropertyKey must fire once —
+ * but the raw key flows to both `__extern_get` and `__extern_set`, each of which
+ * ToPropertyKeys internally, double-firing a side-effecting `toString`/`valueOf`.
+ * Coercing here once yields a primitive (string) or a preserved Symbol, which is
+ * idempotent under the host's internal ToPropertyKey (string→string,
+ * symbol→symbol) so the subsequent get/set do not re-coerce.
+ *
+ * HOST mode: the `__to_property_key` JS import wraps `_toPropertyKey` (§7.1.19,
+ * Symbol-preserving). STANDALONE: the native `__to_property_key` helper
+ * (object-runtime.ts) — ensure the object runtime so it is emitted.
+ */
+export declare function emitToPropertyKeyOnce(ctx: CodegenContext, fctx: FunctionContext): void;
+/** Unwrap parenthesized expressions: (x) -> x, ((x)) -> x, etc. */
+export { compileArrayDestructuringAssignment, compileDestructuringAssignment, compileElementAssignment, compileExternSetFallback, compilePropertyAssignment, };

package/dist/codegen/expressions/builtins.d.ts

@@ -0,0 +1,26 @@
+import { ts } from '../../ts-api.js';
+import { ValType } from '../../ir/types.js';
+import { CodegenContext, FunctionContext } from '../context/types.js';
+import { InnerResult } from '../shared.js';
+declare function compileConsoleCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, method: string): InnerResult;
+/** Ensure the $__Date struct type exists, return its type index. */
+export declare function ensureDateStruct(ctx: CodegenContext): number;
+/**
+ * Ensure the __date_days_from_civil helper function exists.
+ * Signature: (i64 year, i64 month, i64 day) -> i64 days_since_epoch
+ *
+ * Implements Hinnant's days_from_civil algorithm (inverse of civil_from_days).
+ */
+export declare function ensureDateDaysFromCivilHelper(ctx: CodegenContext): number;
+/**
+ * Compile a Date method call on a Date struct receiver.
+ * Returns undefined if this is not a Date method (caller should continue).
+ */
+declare function compileDateMethodCall(ctx: CodegenContext, fctx: FunctionContext, propAccess: ts.PropertyAccessExpression, callExpr: ts.CallExpression, receiverType: ts.Type): InnerResult | undefined;
+/** Allocate a UTF-8 string in a data segment and return its offset/length */
+declare function wasiAllocStringData(ctx: CodegenContext, str: string): {
+    offset: number;
+    length: number;
+};
+declare function compileMathCall(ctx: CodegenContext, fctx: FunctionContext, method: string, expr: ts.CallExpression): ValType | null | undefined;
+export { compileConsoleCall, compileDateMethodCall, compileMathCall, wasiAllocStringData };

package/dist/codegen/expressions/calls-closures.d.ts

@@ -0,0 +1,54 @@
+import { ts } from '../../ts-api.js';
+import { ClosureInfo, CodegenContext, FunctionContext } from '../context/types.js';
+import { InnerResult } from '../shared.js';
+/** Compile a call to a closure variable: closureVar(args...) */
+export declare function compileClosureCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, varName: string, info: ClosureInfo): InnerResult;
+/**
+ * Handle calls where the property is a getter that returns a callable:
+ * c.method(args) where `get method()` returns a function reference.
+ *
+ * Strategy: check if the getter returns a method of the same class
+ * (common pattern: `get method() { return this.#method; }`).
+ * If so, call the underlying method directly with the receiver.
+ * Otherwise, call the getter and invoke the result via host import.
+ */
+export declare function compileGetterCallable(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression, receiverClassName: string, getterIdx: number): InnerResult | undefined;
+/**
+ * Object.prototype method fallback for known class instances (#799 WI1).
+ *
+ * When a method call like `obj.toString()` cannot be resolved on a user-defined
+ * class or its ancestors, this function checks if the method is an Object.prototype
+ * method and emits host-delegated code via externref conversion.
+ */
+export declare function compileObjectPrototypeFallback(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression, receiverClassName: string, methodName: string): InnerResult | undefined;
+/**
+ * Handle calls to callable struct fields: obj.callback() where callback
+ * is a function-typed property stored in a struct field (not a method).
+ * Returns undefined if the property is not a callable struct field,
+ * allowing the caller to fall through to other handling.
+ */
+export declare function compileCallablePropertyCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression, className: string): InnerResult | undefined;
+/**
+ * Handle calls where the callee is an element-access expression on a value
+ * whose element type has TS call signatures: `arr[i](args)`, `arr[const](args)`,
+ * `arr["0"](args)`. This mirrors the externref-field branch of
+ * `compileCallablePropertyCall` but routes through the existing element-access
+ * codegen for the receiver, so it works for vec-of-callable, ref-of-callable,
+ * tuple-of-callable, and any other element-access shape.
+ *
+ * Returns undefined when the element type has no call signature (e.g. native
+ * `i32[]` / `f64[]`), letting the caller fall through to the historical
+ * `ref.null.extern; drop` fallback.
+ *
+ * #1306: `mws[idx](c, next)` on a closure-typed array previously dropped the
+ * call. With this helper the value is loaded via __vec_get / array.get, unboxed
+ * (externref → __fn_wrap struct) and dispatched via call_ref.
+ */
+export declare function compileCallableElementAccessCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, elemAccess: ts.ElementAccessExpression): InnerResult | undefined;
+/**
+ * Try to resolve a method call on an `any`-typed receiver through registered extern classes.
+ * When the type checker resolves the receiver as `any` (e.g. when lib files aren't loaded
+ * in ESM/bundled contexts), we dispatch known collection methods (Set.union, Map.get, etc.)
+ * by looking them up in ctx.externClasses and lazily registering the import.
+ */
+export declare function tryExternClassMethodOnAny(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression, propAccess: ts.PropertyAccessExpression, methodName: string): InnerResult;

package/dist/codegen/expressions/calls-guards.d.ts

@@ -0,0 +1,49 @@
+import { ts } from '../../ts-api.js';
+import { CodegenContext, FunctionContext } from '../context/types.js';
+import { InnerResult } from '../shared.js';
+/**
+ * (#1732) Calling a built-in non-constructor namespace — `Math()`, `JSON()`,
+ * `Reflect()`, `Atomics()` — must throw TypeError ("no [[Call]]"). These
+ * namespace objects have neither a [[Call]] nor [[Construct]] internal method
+ * (§sec-math-object etc.). The `new`-site already throws via the mirror guard
+ * in new-super.ts (NAMESPACE_NON_CONSTRUCTORS); this closes the call-as-function
+ * form (built-ins/Math/prop-desc.js "no [[Call]]"). Unwrap paren/as/!-assertion
+ * wrappers so `(Math as any)()` also fires.
+ *
+ * Returns an externref result when it throws; `undefined` when the callee is not
+ * a non-callable namespace identifier (caller continues dispatch).
+ */
+export declare function tryNamespaceNonCallable(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression): InnerResult | undefined;
+/**
+ * (#1540) JSX runtime call intercept — `_jsx(type, props, key?)` /
+ * `_jsxs(type, props, key?)` / `_jsxDEV(...)`. TypeScript emits these
+ * automatically when `jsx: react-jsx` is set; preprocessImports recorded the
+ * actual local-binding names in `ctx.jsxRuntime`. We route the call to the
+ * matching `__jsx_runtime_*` host import (registered in
+ * `registerJsxRuntimeImports`), passing args as externref.
+ *
+ * Returns an externref result when it intercepts; `undefined` otherwise.
+ */
+export declare function tryJsxRuntimeCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression): InnerResult | undefined;
+/**
+ * `RegExp(pattern, flags)` called without `new` — per spec, equivalent to
+ * `new RegExp(pattern, flags)` (unless pattern is already a RegExp with flags
+ * undefined, an edge case we accept). Host mode emits RegExp_new directly;
+ * standalone mode routes static literal patterns to #682's native subset and
+ * keeps unsupported forms on the explicit refusal path.
+ *
+ * Returns an externref result when it handles the call; `undefined` otherwise.
+ */
+export declare function tryRegExpConstructorCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression): InnerResult | undefined;
+/**
+ * `Object(x)` called without `new` — ECMAScript §20.1.1.1 / §7.1.18 ToObject.
+ * Per spec: Object() / Object(null) / Object(undefined) → fresh empty object;
+ * Object(number) → new Number wrapper (typeof === "object");
+ * Object(string) → new String wrapper; Object(boolean) → new Boolean wrapper;
+ * Object(object) → return the argument unchanged.
+ * (#1129) Without this, `Object(42)` fell through to the generic builtin path
+ * which produced `ref.null.extern`.
+ *
+ * Returns an externref result when the callee is `Object`; `undefined` otherwise.
+ */
+export declare function tryObjectCoercionCall(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression): InnerResult | undefined;

package/dist/codegen/expressions/calls-optional.d.ts

@@ -0,0 +1,4 @@
+import { ts } from '../../ts-api.js';
+import { CodegenContext, FunctionContext } from '../context/types.js';
+import { InnerResult } from '../shared.js';
+export declare function compileOptionalCallExpression(ctx: CodegenContext, fctx: FunctionContext, expr: ts.CallExpression): InnerResult;