@loopdive/js2 0.57.0

package/dist/codegen/typeof-delete.d.ts

@@ -0,0 +1,38 @@
+import { ts } from '../ts-api.js';
+import { ValType } from '../ir/types.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+import { InnerResult } from './shared.js';
+/**
+ * Compile `delete expr`.
+ * - `delete obj.prop` / `delete obj[key]`: set the field to a sentinel (undefined) value, return true
+ * - `delete identifier`: return false (i32 0) — variables are not deletable
+ * - `delete otherExpr`: compile for side effects, drop, return true (i32 1)
+ *
+ * WasmGC struct fields cannot be removed at runtime, so we simulate deletion
+ * by setting the field to a sentinel value (ref.null for ref types, NaN for f64).
+ * Property reads of ref.null / NaN naturally produce undefined-like behavior.
+ */
+export declare function compileDeleteExpression(ctx: CodegenContext, fctx: FunctionContext, expr: ts.DeleteExpression): InnerResult;
+/**
+ * Compile a RegExp literal (e.g. /\d+/g) by desugaring it to new RegExp(pattern, flags).
+ * The pattern and flags strings are loaded from the string pool, then RegExp_new is called.
+ */
+export declare function compileRegExpLiteral(ctx: CodegenContext, fctx: FunctionContext, expr: ts.Expression): ValType | null;
+/**
+ * Compile `expr instanceof ClassName`.
+ * Reads the hidden __tag field (index 0) from the struct and compares
+ * it against the class's compile-time tag value (and all descendant tags
+ * for class hierarchy support).
+ */
+export declare function compileInstanceOf(ctx: CodegenContext, fctx: FunctionContext, expr: ts.BinaryExpression): ValType | null;
+/**
+ * Compile `typeof x` as a standalone expression that returns a type string (externref).
+ * For statically known types, emits the string constant directly.
+ * For externref/union types, calls the __typeof host helper.
+ */
+export declare function compileTypeofExpression(ctx: CodegenContext, fctx: FunctionContext, expr: ts.TypeOfExpression): ValType | null;
+/**
+ * Compile `typeof x === "number"` / `typeof x !== "string"` etc.
+ * Returns i32 result, or null if the expression is not a typeof comparison.
+ */
+export declare function compileTypeofComparison(ctx: CodegenContext, fctx: FunctionContext, expr: ts.BinaryExpression): ValType | null;

package/dist/codegen/uri-encoding-native.d.ts

@@ -0,0 +1,33 @@
+import { CodegenContext } from './context/types.js';
+/** Helper-name -> mask routed at the call site (calls.ts). */
+export declare const URI_ENCODE_MASK: Record<string, number>;
+/**
+ * Helper-name -> reservedMask for `__uri_decode`. `decodeURIComponent` unescapes
+ * everything (reservedSet empty → 0); `decodeURI` keeps the `reservedURISet`
+ * (`; / ? : @ & = + $ , #`) escaped → re-emits those single-octet escapes
+ * verbatim (mask bit 0 set).
+ */
+export declare const URI_DECODE_MASK: Record<string, number>;
+/**
+ * Emit the native `__uri_encode(s: externref, preservedMask: i32) -> externref`
+ * helper and register it in `ctx.funcMap`. Idempotent. Must run after
+ * `ensureNativeStringHelpers` (it calls it) so `__str_flatten` and the
+ * NativeString types exist, and before any function body that calls it.
+ */
+export declare function emitNativeUriEncode(ctx: CodegenContext): void;
+/**
+ * Emit the native `__uri_decode(s: externref, reservedMask: i32) -> externref`
+ * helper (ECMAScript §19.2.6.4 Decode) and register it in `ctx.funcMap`.
+ * Idempotent. Mirrors `emitNativeUriEncode`'s registration discipline (claim the
+ * funcIdx only after `emitWasiErrorConstructor` appends `__new_URIError`).
+ *
+ * Scans the flattened i16 buffer. On `%`, parses 2 hex digits → a UTF-8 leading
+ * byte, determines the sequence length (1-4), reads the continuation `%XX`
+ * octets, validates them (RFC 3629: leading-byte ranges, `10xxxxxx`
+ * continuations, no overlong forms, code point ≤ 0x10FFFF, no surrogate range),
+ * reassembles the code point, and re-encodes it to 1 or 2 UTF-16 code units.
+ * A single-octet ASCII char in the `reservedURISet` (mask bit 0, for decodeURI)
+ * is re-emitted as its original uppercased `%XX` escape verbatim. Any malformed
+ * input → catchable **URIError**.
+ */
+export declare function emitNativeUriDecode(ctx: CodegenContext): void;

package/dist/codegen/value-tags.d.ts

@@ -0,0 +1,74 @@
+import { ts } from '../ts-api.js';
+import { Instr, ValType } from '../ir/types.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+/**
+ * Canonical JS-type tag for the `$AnyValue` boxed representation.
+ *
+ * Invariant V1 (tag fidelity): the tag always equals the value's ECMAScript
+ * type partition (the `typeof` partition with `null` split out). No consumer may
+ * infer a JS type from a Wasm kind.
+ *
+ * Invariant V2 (numeric class): tags 2 and 3 are ONE JS type (`number`) — one
+ * uses the i32 payload, one the f64 payload. Equality / relational / typeof /
+ * ToString helpers must treat `{2,3}` as a single class.
+ *
+ * These values MUST match the runtime tags written by the `__any_box_*` helpers
+ * in `any-helpers.ts` (asserted by tests). `Function` (7) is reserved for a
+ * later phase (today closures box as `Object`).
+ *
+ * (Plain `enum`, not `const enum` — Biome's `noConstEnum` forbids the latter;
+ * the numeric values are still inlined at our use sites.)
+ */
+export declare enum JsTag {
+    Null = 0,
+    Undefined = 1,
+    NumberI32 = 2,
+    NumberF64 = 3,
+    Boolean = 4,
+    String = 5,
+    Object = 6,
+    Function = 7
+}
+/** Static JS-type classification of an expression, resolved from its TS type. */
+export type JsStaticType = "null" | "undefined" | "boolean" | "number" | "string" | "bigint" | "object" | "function" | "unknown";
+/**
+ * Classify a TS type into its JS-type partition. Returns `"unknown"` for
+ * `any`/`unknown`/unions that don't resolve to a single partition — callers
+ * then fall back to the Wasm-kind-keyed boxing path (behaviour-preserving).
+ */
+export declare function jsStaticType(t: ts.Type | undefined): JsStaticType;
+/**
+ * The de-facto undefined-in-f64 sentinel, named once here (14 ad-hoc sites
+ * elsewhere predate this module). It is a SIGNALING NaN — JS arithmetic only
+ * ever produces the quiet NaN `0x7FF8000000000000`, so this bit pattern can
+ * carry "undefined" through an f64 carrier without colliding with a computed
+ * NaN. Observers in unsound contexts (`=== undefined`, `??`, `typeof`,
+ * ToString) test for it; sound contexts (arithmetic, relational, ToBoolean)
+ * ignore it because it already behaves as NaN. P3 (#2106) wires the observers;
+ * Phase 1 only centralizes the constant + emit helpers.
+ */
+export declare const UNDEF_F64_BITS = 9218868440963334366n;
+/** Push the undefined-f64 sentinel onto the stack (`i64.const` + reinterpret). */
+export declare function pushUndefF64(body: Instr[]): void;
+/**
+ * Emit a test that the f64 on the stack is exactly the undefined sentinel,
+ * leaving an i32 (1 = is-undef) on the stack. Uses the i64 bit pattern compare
+ * (NOT `f64.eq`, which is false for any NaN including the sentinel).
+ */
+export declare function emitIsUndefF64(body: Instr[]): void;
+/**
+ * Box a value of Wasm ValType `from` (top of stack) into a `ref $AnyValue`,
+ * the single boxing entry point. `jsType` is the static JS-type hint when
+ * resolvable; `"unknown"` reproduces the historical Wasm-kind-keyed dispatch
+ * exactly so this is behaviour-preserving by construction.
+ *
+ * Returns true if it emitted a box call (caller is done); false if no helper
+ * was available (caller falls through to its prior handling — matches the old
+ * `if (funcIdx !== undefined)` guards).
+ *
+ * `ensureAnyHelpers`/`addUnionImports` are the caller's responsibility (as in
+ * the old `coerceType` arm) — this function only selects + emits the call so it
+ * stays a pure dispatch over `ctx.funcMap` and cannot itself trigger a
+ * late-import funcIdx shift between resolution and call.
+ */
+export declare function boxToAny(ctx: CodegenContext, fctx: FunctionContext, from: ValType, jsType: JsStaticType): boolean;

package/dist/codegen/walk-instructions.d.ts

@@ -0,0 +1,20 @@
+import { Instr } from '../ir/types.js';
+/**
+ * Walk all instructions in `instrs`, calling `visitor` on each one.
+ * Automatically descends into nested blocks: body, then, else, catches, catchAll.
+ *
+ * Implemented iteratively with an explicit frame stack so the JS call stack
+ * depth is O(1) regardless of Wasm block nesting. This matters because the
+ * walker runs synchronously inside already-deep codegen frames (via
+ * flushLateImportShifts → shiftLateImportIndices), and recursive composition
+ * with the compile stack tripped V8 stack limits under tight CI cgroup
+ * budgets. Pre-order semantics preserved: visit(instr) fires before recursion
+ * into its children, and siblings are visited in source order.
+ */
+export declare function walkInstructions(instrs: Instr[], visitor: (instr: Instr) => void): void;
+/**
+ * Invoke `fn` on every nested instruction array (body, then, else, catches, catchAll)
+ * found on a single instruction. Does NOT recurse -- the caller is responsible for
+ * driving recursion (e.g. by calling walkChildren again inside fn).
+ */
+export declare function walkChildren(instr: Instr, fn: (children: Instr[]) => void): void;

package/dist/codegen/weak-collections-runtime.d.ts

@@ -0,0 +1,16 @@
+import { ts } from '../ts-api.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+import { InnerResult } from './shared.js';
+/**
+ * Emit the `__weakset_add(m, v) -> ref $Map` helper (idempotent). WeakSet.add
+ * stores the element as both key and value (so the shared Map lookup sees a
+ * normal entry) and returns the collection (chainable, spec 24.4.3.1).
+ */
+export declare function ensureWeakCollectionHelpers(ctx: CodegenContext): void;
+/**
+ * (#2162) Intercept a `WeakMap.prototype.*` / `WeakSet.prototype.*` method call
+ * in standalone / `nativeStrings` mode and route it to the native Map/weak
+ * runtime. `className` selects the surface (WeakMap has get/set; WeakSet has
+ * add). Returns the result `InnerResult` when handled, else `undefined`.
+ */
+export declare function tryCompileNativeWeakMethodCall(ctx: CodegenContext, fctx: FunctionContext, className: "WeakMap" | "WeakSet", propAccess: ts.PropertyAccessExpression, callExpr: ts.CallExpression): InnerResult | undefined;

package/dist/codegen/with-scope.d.ts

@@ -0,0 +1,106 @@
+import { ts } from '../ts-api.js';
+import { FieldDef, ValType } from '../ir/types.js';
+import { CodegenContext, FunctionContext } from './context/types.js';
+/** A static (#1387 Tier-1) `with` scope entry. */
+export type StaticWithScope = Extract<NonNullable<FunctionContext["withScopes"]>[number], {
+    kind: "static";
+}>;
+export interface WithBinding {
+    scope: StaticWithScope;
+    field: FieldDef;
+    fieldIdx: number;
+}
+/** A dynamic (#2663 Tier-2) `with` scope: arbitrary externref target resolved at
+ *  runtime via HasBinding + Get. */
+export type DynamicWithScope = Extract<NonNullable<FunctionContext["withScopes"]>[number], {
+    kind: "dynamic";
+}>;
+/** Result of resolving a bare identifier against the `with` scope stack. */
+export type WithResolution = {
+    kind: "static";
+    binding: WithBinding;
+} | {
+    kind: "dynamic";
+    scope: DynamicWithScope;
+} | null;
+export declare function findWithBinding(fctx: FunctionContext, name: string): WithBinding | null;
+/**
+ * (#2663 Slice 1) Resolve a bare identifier against the `with` scope stack,
+ * innermost-first, across a MIXED static/dynamic stack.
+ *
+ * - A `static` scope hit returns the proven struct field binding (Tier-1
+ *   zero-overhead path) — short-circuits the walk.
+ * - A `dynamic` scope hit returns the scope for a runtime HasBinding-gated
+ *   select (the absent case falls through to the next-outer scope / lexical at
+ *   runtime, but statically we resolve to the innermost non-shadowing dynamic
+ *   scope and let codegen emit the gate + fallback).
+ * - `blockedNames` (body-declared lexical/inner-function names) shadow a scope
+ *   for that name — skip it.
+ */
+export declare function resolveWithBinding(fctx: FunctionContext, name: string): WithResolution;
+export declare function emitWithBindingGet(fctx: FunctionContext, binding: WithBinding): ValType;
+export declare function compileWithBindingAssignment(ctx: CodegenContext, fctx: FunctionContext, binding: WithBinding, rhs: ts.Expression): ValType | null;
+export declare function compileWithStatement(ctx: CodegenContext, fctx: FunctionContext, stmt: ts.WithStatement): void;
+/**
+ * (#2663 Slice 1) Emit the HasBinding-gated READ select for a bare identifier
+ * that resolved to a dynamic `with` scope (§9.1.1.2.1 HasBinding +
+ * §9.1.1.2.5 GetBindingValue):
+ *
+ *   if (HasBinding(recv, name)) result = Get(recv, name) else result = <outer>
+ *
+ * Both arms normalize to `externref` (the `Get` half yields externref; the outer
+ * fallback is coerced). `emitFallback` emits the name's normal (non-with)
+ * lowering into the current body and returns its ValType (or null on error).
+ *
+ * Slice 1 treats HasProperty as HasBinding (no `@@unscopables` — Slice 4). The
+ * gate uses the value-INDEPENDENT host `__extern_has` (NOT `__dyn_has`'s
+ * non-null proxy): a property present with value `undefined` MUST still shadow
+ * the outer binding (§7.3.12).
+ */
+export declare function emitDynamicWithGet(ctx: CodegenContext, fctx: FunctionContext, scope: DynamicWithScope, name: string, emitFallback: () => ValType | null): ValType;
+/**
+ * (#2663 Slice 2) Emit the HasBinding-gated WRITE for `name = <value in
+ * rhsLocalIdx>` where `name` resolved to a dynamic `with` scope (§9.1.1.2.4
+ * SetMutableBinding), STATEMENT form (leaves nothing on the stack):
+ *
+ *   if (HasBinding(recv, name)) __extern_set(recv, name, rhsVal) else <fallback>
+ *
+ * The RHS is pre-evaluated ONCE by the caller into the externref temp
+ * `rhsLocalIdx` (§13.15.2). `with` is sloppy-only, so the write uses
+ * `__extern_set` (silent-on-failure, not the strict variant).
+ * `emitFallbackWrite()` emits the next-outer write (another dynamic-with gate,
+ * or the lexical write) using the same temp; it must leave nothing on the stack.
+ */
+/**
+ * (#2663 Slice 2 / #2061 fix) Emit `__extern_has(recv, name) -> i32` into a fresh
+ * i32 local, returning its index. §13.15.2: for a plain `=` assignment the LHS
+ * Reference is resolved (→ HasBinding) BEFORE the RHS is evaluated. So the caller
+ * captures each candidate dynamic-with scope's HasBinding with this helper BEFORE
+ * compiling the RHS; the gated write then branches on the captured i32.
+ *
+ * (Computing HasBinding AFTER the RHS — as the original Slice 2 did — let an RHS
+ * that adds the property to the with-object change the binding decision and
+ * mis-route the write: regressed test262 `S11.13.1_A6_T3` — "PutValue uses the
+ * initially-created Reference even if a more local binding is available".)
+ */
+export declare function emitCaptureWithHasBinding(ctx: CodegenContext, fctx: FunctionContext, scope: DynamicWithScope, name: string): number;
+/**
+ * (#2663 Slice 2) Emit the WRITE for `name = <value in rhsLocalIdx>` gated on a
+ * PRE-CAPTURED HasBinding i32 (`hasLocalIdx`, from `emitCaptureWithHasBinding`,
+ * evaluated BEFORE the RHS per §13.15.2). Statement form (leaves nothing on the
+ * stack): `if (hasLocal) __extern_set(recv,name,rhs) else <fallback>`. `with` is
+ * sloppy-only ⇒ `__extern_set` (silent-on-failure).
+ */
+export declare function emitDynamicWithSet(ctx: CodegenContext, fctx: FunctionContext, scope: DynamicWithScope, name: string, rhsLocalIdx: number, hasLocalIdx: number, emitFallbackWrite: () => void): void;
+/**
+ * (#2663 Slice 3) Emit `delete name` where `name` resolved to a dynamic `with`
+ * scope, leaving an i32 result on the stack (§13.5.1.2 / §8.5.2 DeleteBinding):
+ *
+ *   if (HasBinding(recv, name)) result = __delete_property(recv, name)
+ *   else result = <outer delete>   // a bare variable is not deletable ⇒ 0,
+ *                                  // unless an outer with also binds it (cascade)
+ *
+ * `emitOuterDelete()` emits the next-outer `delete name` result as i32 (another
+ * dynamic-with gate, or the plain "variables not deletable" `i32.const 0`).
+ */
+export declare function emitDynamicWithDelete(ctx: CodegenContext, fctx: FunctionContext, scope: DynamicWithScope, name: string, emitOuterDelete: () => void): ValType;

package/dist/codegen-linear/c-abi.d.ts

@@ -0,0 +1,74 @@
+import { ValType, WasmModule } from '../ir/types.js';
+/** Describes the TS-level semantic type of a parameter */
+export type TsSemanticType = "number_i32" | "number_f64" | "boolean" | "string" | "array" | "object";
+/** A parameter definition with TS semantic info */
+export interface ParamDef {
+    name: string;
+    wasmType: ValType;
+    semantic: TsSemanticType;
+}
+/** A C ABI parameter (may be one of a pair for strings/arrays) */
+export interface CabiParam {
+    name: string;
+    wasmType: ValType;
+    /** Which original param index this came from */
+    sourceParamIdx: number;
+    /** "ptr" | "len" for expanded params, "direct" for scalar */
+    role: "direct" | "ptr" | "len";
+    /**
+     * For expanded (ptr/len) params, the underlying aggregate kind so the
+     * wrapper can pick the right runtime constructor (`__str_from_data` for
+     * strings, `__arr_from_data` for arrays). Undefined for scalar/direct.
+     */
+    aggregate?: "string" | "array";
+}
+/** C ABI return value descriptor */
+export interface CabiResult {
+    wasmTypes: ValType[];
+    semantic: TsSemanticType | "void";
+}
+/** Information about an exported function for C header generation */
+export interface CabiExportInfo {
+    /** Original TS function name */
+    tsName: string;
+    /** C ABI export name (e.g. MyClass_bar) */
+    cabiName: string;
+    /** C ABI parameter list */
+    params: CabiParam[];
+    /** C ABI return type */
+    result: CabiResult;
+}
+/**
+ * Expand TS parameter definitions into C ABI parameters.
+ * Strings and arrays become (ptr, len) pairs.
+ */
+export declare function mapParamsToCabi(params: ParamDef[]): CabiParam[];
+/**
+ * Map a TS return type to a C ABI return descriptor.
+ */
+export declare function mapResultToCabi(result: ValType | null, semantic: TsSemanticType | "void"): CabiResult;
+/**
+ * Mangle a function name for C ABI export.
+ * Simple function names are unchanged; class methods use ClassName_method.
+ */
+export declare function mangleCabiName(name: string): string;
+/**
+ * Emit C ABI wrapper functions for all exported functions in the module.
+ *
+ * For each exported function with string or array parameters, we generate
+ * a `__cabi_<name>` wrapper with C-compatible signatures. The wrapper
+ * marshals the (ptr, len) pairs by creating internal string/array
+ * representations, calls the original function, and returns the result
+ * in C ABI form.
+ *
+ * For functions that already have C-compatible signatures (all scalar
+ * params/returns), the original export is simply renamed — no wrapper
+ * is needed.
+ *
+ * Returns the list of CabiExportInfo describing the new C ABI exports.
+ */
+export declare function emitCabiWrappers(mod: WasmModule, exportInfos: CabiExportInfo[]): void;
+/**
+ * Infer the TS semantic type from a ValType and TS type text.
+ */
+export declare function inferSemantic(wasmType: ValType, tsTypeText: string | undefined): TsSemanticType;

package/dist/codegen-linear/context.d.ts

@@ -0,0 +1,86 @@
+import { ts } from '../ts-api.js';
+import { Instr, LocalDef, ValType, WasmModule } from '../ir/types.js';
+import { ClassLayout } from './layout.js';
+/** Module-level context for linear-memory codegen */
+export interface LinearContext {
+    mod: WasmModule;
+    checker: ts.TypeChecker;
+    /** Map from function name to its absolute index (imports + locals) */
+    funcMap: Map<string, number>;
+    /** Number of imported functions */
+    numImportFuncs: number;
+    /** Current function context (set during function compilation) */
+    currentFunc: LinearFuncContext | null;
+    /** Errors accumulated during codegen */
+    errors: {
+        message: string;
+        line: number;
+        column: number;
+    }[];
+    /** Class layouts for class declarations */
+    classLayouts: Map<string, ClassLayout>;
+    /** String literal data segment: string value → data segment offset */
+    stringLiterals: Map<string, number>;
+    /** Current data segment write offset */
+    dataSegmentOffset: number;
+    /** Counter for generating unique lambda function names */
+    lambdaCounter: number;
+    /** Function indices to populate in the funcref table */
+    tableEntries: number[];
+    /** Global index for __closure_env (env pointer for closures) */
+    closureEnvGlobalIdx: number;
+    /** Module-level variables → wasm global index */
+    moduleGlobals: Map<string, number>;
+    /** Module-level collection types (for Set, Map, Array globals) */
+    moduleCollectionTypes: Map<string, CollectionKind>;
+}
+/** Collection type tag for tracking variable types */
+export type CollectionKind = "Array" | "Uint8Array" | "ArrayOrUint8Array" | "Map" | "Set";
+/** (#2716) A `finally` block pending replay on early-exit paths out of its try. */
+export interface FinallyEntry {
+    /** The `finally` block statements to replay. */
+    block: ts.Block;
+    /** `breakStack.length` at try-entry — used to decide if a `break` replays it. */
+    breakDepth: number;
+    /** `continueStack.length` at try-entry — used to decide if a `continue` replays it. */
+    continueDepth: number;
+}
+/** Per-function context for linear-memory codegen */
+export interface LinearFuncContext {
+    /** Function name */
+    name: string;
+    /** Parameters (the first N locals) */
+    params: {
+        name: string;
+        type: ValType;
+    }[];
+    /** Additional locals declared in the body */
+    locals: LocalDef[];
+    /** All local names → index (params first, then locals) */
+    localMap: Map<string, number>;
+    /** Return type */
+    returnType: ValType | null;
+    /** Accumulated body instructions */
+    body: Instr[];
+    /** Block depth for br labels */
+    blockDepth: number;
+    /** Break label depth stack */
+    breakStack: number[];
+    /** Continue label depth stack */
+    continueStack: number[];
+    /**
+     * (#2716) Stack of enclosing `try { … } finally { … }` blocks whose `finally`
+     * must run on every completion path out of the try. Normal fall-through runs
+     * the finally inline; `return` / `break` / `continue` replay the applicable
+     * finally blocks before the jump. Each entry records the break/continue
+     * nesting at try-entry so a `break`/`continue` only replays the finallys that
+     * sit BETWEEN it and its target loop/switch.
+     */
+    finallyStack: FinallyEntry[];
+    /** Track which locals are collection types (varName → kind) */
+    collectionTypes: Map<string, CollectionKind>;
+    /** Parameters that are callback/function-typed (param name → call_indirect type index) */
+    callbackParams: Map<string, number>;
+}
+/** Add a local variable to the current function context */
+export declare function addLocal(fctx: LinearFuncContext, name: string, type: ValType): number;

package/dist/codegen-linear/index.d.ts

@@ -0,0 +1,28 @@
+import { ts } from '../ts-api.js';
+import { MultiTypedAST, TypedAST } from '../checker/index.js';
+import { WasmModule } from '../ir/types.js';
+import { LinearContext, LinearFuncContext } from './context.js';
+/**
+ * Options for the linear-memory backend (#1856).
+ */
+export interface LinearOptions {
+    /**
+     * Expose the explicit arena-management exports `__arena_reset` /
+     * `__arena_used` on the bump allocator. Useful for embedders that reuse a
+     * single instance across many short-lived tasks; off by default so the
+     * common "allocate-and-exit" program pays nothing for them.
+     * See {@link import("./runtime.js").ArenaOptions}.
+     */
+    exposeArenaReset?: boolean;
+}
+/**
+ * Generate a WasmModule using the linear-memory backend.
+ * Compiles TS functions to standard Wasm with i32/f64 values.
+ */
+export declare function generateLinearModule(ast: TypedAST, opts?: LinearOptions): WasmModule;
+/**
+ * Generate a WasmModule from multiple TS source files using the linear-memory backend.
+ * Cross-file imports are resolved by the TypeScript checker; we iterate all source files.
+ */
+export declare function generateLinearMultiModule(multiAst: MultiTypedAST, opts?: LinearOptions): WasmModule;
+export declare function compileExpression(ctx: LinearContext, fctx: LinearFuncContext, expr: ts.Expression): void;

package/dist/codegen-linear/layout.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Class layout computation for the linear-memory backend.
+ *
+ * Each class instance is stored on the heap with the following layout:
+ *   [type_tag: u8 at +0][padding 3B][payload_size: u32 at +4][field0: 8B at +8][field1: 8B at +16]...
+ *
+ * The header is 8 bytes (tag + padding + payload_size).
+ * Each field occupies 8 bytes for uniform access (f64 for numbers, i32 stored in
+ * the low 4 bytes for object references).
+ */
+export interface ClassLayout {
+    name: string;
+    /** Total allocation size: header (8) + 8 bytes per field */
+    totalSize: number;
+    /** Map from field name to its memory offset and wasm type */
+    fields: Map<string, {
+        offset: number;
+        type: "i32" | "f64";
+    }>;
+    /** Map from field name to TS collection kind (for nested property access) */
+    fieldCollectionKinds: Map<string, "Array" | "Uint8Array" | "Map" | "Set">;
+    /** Map from method name to its wasm function name */
+    methods: Map<string, string>;
+    /** Map from getter property name to its wasm function name */
+    getters: Map<string, string>;
+    /** Wasm function name for the constructor */
+    ctorFuncName: string;
+}
+/**
+ * Compute the memory layout for a class with the given fields.
+ *
+ * @param name - The class name
+ * @param fieldDefs - Array of { name, type } where type is "i32" or "f64"
+ * @returns The computed ClassLayout
+ */
+export declare function computeClassLayout(name: string, fieldDefs: {
+    name: string;
+    type: "i32" | "f64";
+}[]): ClassLayout;