@loopdive/js2 0.57.0 → 0.58.0

package/README.md

@@ -57,7 +57,7 @@ STATUS.md rather than duplicating numbers that go stale. Standalone
 README until the current standalone regression is fixed.
 
 <!-- AUTO:conformance-start -->
-**test262 conformance**: 32,456 / 43,135 (75.2 %)
+**test262 conformance**: 32,667 / 43,135 (75.7 %)
 <!-- AUTO:conformance-end -->
 
 ## Current Status

package/dist/cli.js

@@ -13,7 +13,7 @@ const args = process.argv.slice(2);
 if (args.includes("--ts7")) {
   process.env.JS2WASM_TS7 = "1";
 }
-const { compile } = await import("./index.js");
+const { compile, compileProject, entryHasRelativeImports } = await import("./index.js");
 const { buildDefaultDefines } = await import("./define-substitution-BcUeKC2A.js").then((n) => n.d);
 if (args.includes("--version") || args.includes("-v")) {
   console.log(getCliVersion());
@@ -276,7 +276,7 @@ if (!emulateExplicit && !emulateNode && /['"]node:[A-Za-z0-9_./-]+['"]/.test(sou
 }
 const name = basename(absInput, ".ts");
 const dir = outDir ? resolve(outDir) : dirname(absInput);
-const result = await compile(source, {
+const compileOptions = {
   ...optimize ? { optimize } : {},
   ...target ? { target } : {},
   ...allocator ? { allocator } : {},
@@ -289,7 +289,8 @@ const result = await compile(source, {
   fileName: absInput,
   ...strictNoHostImports !== void 0 ? { strictNoHostImports } : {},
   ...Object.keys(defines).length > 0 ? { define: defines } : {}
-});
+};
+const result = entryHasRelativeImports(source) ? await compileProject(absInput, compileOptions) : await compile(source, compileOptions);
 if (!result.success) {
   for (const e of result.errors) {
     const severity = e.severity === "warning" ? "warning" : "error";

package/dist/codegen/context/types.d.ts

@@ -1819,6 +1819,17 @@ export interface CodegenContext {
      * Wasm byte-identical.
      */
     fnctorEscapeGate?: import('../fnctor-escape-gate.js').FnctorEscapeGateResult;
+    /**
+     * #2773 S1 (keystone) — fnctor name → reserved `$__fnctor_<Name>` struct type
+     * index. Populated up-front by `reserveFnctorStructTypes` (index.ts) at the
+     * deterministic type-init phase so the index is IDENTICAL across the hoist pass
+     * and the emit pass (the on-demand registration at the `new F()` site landed at
+     * a pass-dependent index → `ref.test`/`struct.get` desync). When a name is
+     * present here, `compileNewFunctionDeclaration` FILLS the reserved slot in place
+     * instead of pushing a new type (which would re-shift every downstream typeIdx).
+     * Empty for fnctor-free modules ⇒ byte-identical no-op.
+     */
+    fnctorReservedTypeIdx: Map<string, number>;
     /**
      * #1886 Slice B — Func index of the lazily-emitted
      * `__lin_u8_alloc(len:i32)->i32` bump allocator for linear-backed Uint8Array

package/dist/codegen/fnctor-escape-gate.d.ts

@@ -1,4 +1,5 @@
 import { ts } from '../ts-api.js';
+import { FieldDef } from '../ir/types.js';
 import { CodegenContext, FunctionContext } from './context/types.js';
 /** Classification of a `new F()` fnctor allocation site. */
 export type FnctorGateClass = 
@@ -52,6 +53,28 @@ export interface FnctorEscapeGateResult {
      * `resolveReceiverStruct`; no lowering reads it, so emitted Wasm is byte-identical.
      */
     readonly receiverStruct: ReadonlyMap<ts.Expression, string>;
+    /**
+     * #2773 S2b — fnctor NAMES that own a `new this()` reconstruct site (a
+     * `new this()` inside a static / prototype method classified as an `F`
+     * reconstruct). The #2773 S1 up-front struct-type reservation
+     * (`reserveFnctorStructTypes`) unions this with {@link approvedNames} so a
+     * `Parser` reconstructed via `new this()` also gets a reserved
+     * `$__fnctor_Parser` slot. **S1 ships this as an EMPTY set** — S1 only READS it
+     * (so the reservation union is a no-op today); S2b populates it. Landing the
+     * field shape here keeps S2b purely additive.
+     */
+    readonly newThisOwnerNames: ReadonlySet<string>;
+    /**
+     * #2773 S1 — fnctor NAME → its function-like declaration (the body-bearer whose
+     * `this.<field> = …` writes derive the `$__fnctor_<Name>` struct shape). Covers
+     * EVERY fnctor `new F()` site seen (not just approved ones) so
+     * `reserveFnctorStructTypes` can resolve a name to the SAME declaration the
+     * on-demand `compileNewFunctionDeclaration` path uses — guaranteeing identical
+     * field derivation. A name with ≥2 distinct declarations keeps the first
+     * (deterministic by source order); ambiguity here only affects WHICH body shapes
+     * the reserved slot (matching the on-demand resolution at the dominant site).
+     */
+    readonly ctorDeclByName: ReadonlyMap<string, ts.FunctionDeclaration | ts.FunctionExpression>;
 }
 /**
  * Whether `expr` resolves to a plain function constructor (fnctor) rather than a
@@ -90,3 +113,25 @@ export declare function resolveReceiverStruct(ctx: CodegenContext, fctx: Functio
  *          sites exist (so the pass is a no-op for class-only / fnctor-free code).
  */
 export declare function analyzeFnctorEscapeGate(checker: ts.TypeChecker, sourceFile: ts.SourceFile): FnctorEscapeGateResult;
+/**
+ * #2773 S1 (keystone) — derive the WasmGC field shape of a fnctor's
+ * `$__fnctor_<Name>` struct from its constructor body's `this.<field> = …`
+ * assignments. This is the **single source of truth** for the field set,
+ * EXTRACTED verbatim from the on-demand inline logic that lived in
+ * `compileNewFunctionDeclaration` (new-super.ts) so both the up-front reservation
+ * pass and the legacy on-demand fallback produce the SAME shape — divergent field
+ * order would give `struct.new` a different arity than the reserved type and trap.
+ *
+ * Mirrors the original logic exactly:
+ *   - collects EVERY `this.<field>` LHS across (possibly CHAINED) assignments
+ *     (`this.a = this.b = expr`), recursing into if/else and loop blocks;
+ *   - prefers the RHS type when the LHS is `any` (externref) — the RHS carries the
+ *     concrete type (e.g. number → f64);
+ *   - widens non-null `ref` fields to `ref_null` so `struct.new`'s `ref.null`
+ *     default-init is well-typed (a struct.new can't default a non-null ref).
+ *
+ * @param ctx      codegen context (for the checker + `resolveWasmType`)
+ * @param funcDecl the fnctor's function-like declaration (its body is read)
+ * @returns the ordered field set, or `[]` for a body-less / empty-body fnctor.
+ */
+export declare function deriveFnctorFields(ctx: CodegenContext, funcDecl: ts.FunctionDeclaration | ts.FunctionExpression): FieldDef[];

package/dist/codegen/index.d.ts

@@ -183,6 +183,41 @@ export declare function reserveTypedArraySubviewTypes(ctx: CodegenContext): void
  * fallback can't fire without a class).
  */
 export declare function reserveObjVecArrType(ctx: CodegenContext): void;
+/**
+ * #2773 S1 (KEYSTONE) — reserve every reconstructed-fnctor `$__fnctor_<Name>`
+ * struct type at the deterministic up-front type-init phase (the same stable
+ * point as `reserveTypedArraySubviewTypes` / `reserveObjVecArrType`), so the type
+ * index is IDENTICAL across the hoist pass and the emit pass.
+ *
+ * ROOT CAUSE this fixes: the on-demand registration at the `new F()` call site
+ * (`compileNewFunctionDeclaration`, new-super.ts — `ctx.mod.types.length`) assigns
+ * the index at a NON-deterministic mid-compile point that depends on which
+ * function the compiler reached first. The two-pass type numbering then desyncs:
+ * a typed-receiver `ref.test $__fnctor_<Name>` baked in the hoist pass misses the
+ * emit-pass `struct.new` index, and a read site compiled before the `new` site is
+ * excluded from `findAlternateStructsForField`'s candidate set. Reserving up-front
+ * collapses BOTH facets — the index is pass-invariant AND the candidate set is
+ * complete at every read site. This is the one thing the #2674 finalize
+ * dispatcher cannot retroactively fix (it can't rewrite a baked typeIdx).
+ *
+ * Two sub-passes — the ORDER is load-bearing:
+ *   (1) reserve ALL indices + names FIRST (placeholder struct, `structMap`,
+ *       `typeIdxToStructName`, `fnctorReservedTypeIdx`), so a cross-fnctor ref
+ *       field in sub-pass 2 (a `Parser` field typed `Scope` →
+ *       `(ref null $__fnctor_Scope)`) resolves against an already-registered
+ *       `structMap` entry. Do NOT collapse the two sub-passes.
+ *   (2) FILL each placeholder's fields via the shared `deriveFnctorFields`
+ *       (single source of truth — identical to the on-demand derivation) and
+ *       record `structFields` for candidate-set completeness.
+ *
+ * Determinism: the name set is SORTED, and the call-site position is fixed, so the
+ * reserved index is identical across the hoist pass and the emit pass (the entire
+ * point of the slice). Gated on a non-empty approved set ⇒ fnctor-free modules are
+ * byte-identical (a true no-op). Runs in BOTH host and standalone — the on-demand
+ * struct path is target-independent. A reserved-but-never-constructed placeholder
+ * is unreferenced ⇒ `dead-elimination` prunes + renumbers it cleanly.
+ */
+export declare function reserveFnctorStructTypes(ctx: CodegenContext): void;
 export declare function ensureLinearU8AllocHelper(ctx: CodegenContext): number;
 /**
  * #1618: Ensure __wasi_write_any_string(s: ref NativeString) -> void exists and

package/dist/codegen/property-access.d.ts

@@ -289,6 +289,6 @@ export declare function emitThisReceiverGuardConvert(ctx: CodegenContext, fctx:
  * `ref.is_null`, and emit the index + read only in the non-null arm.
  */
 export declare function compileOptionalElementAccess(ctx: CodegenContext, fctx: FunctionContext, expr: ts.ElementAccessExpression): ValType | null;
-export declare function compileElementAccess(ctx: CodegenContext, fctx: FunctionContext, expr: ts.ElementAccessExpression): ValType | null;
+export declare function compileElementAccess(ctx: CodegenContext, fctx: FunctionContext, expr: ts.ElementAccessExpression, expectedType?: ValType): ValType | null;
 /** Inner element access logic — assumes objType is on the stack and non-null */
-export declare function compileElementAccessBody(ctx: CodegenContext, fctx: FunctionContext, expr: ts.ElementAccessExpression, objType: ValType): ValType | null;
+export declare function compileElementAccessBody(ctx: CodegenContext, fctx: FunctionContext, expr: ts.ElementAccessExpression, objType: ValType, expectedType?: ValType): ValType | null;

package/dist/codegen/statements/loops.d.ts

@@ -1,6 +1,36 @@
 import { ts } from '../../ts-api.js';
 import { CodegenContext, FunctionContext } from '../context/types.js';
 export declare function compileWhileStatement(ctx: CodegenContext, fctx: FunctionContext, stmt: ts.WhileStatement): void;
+/**
+ * #1196: Detect mutations of the loop index or array binding inside a for-loop
+ * body. Used by the bounds-check elimination pass — we can only elide bounds
+ * checks for `arr[i]` if both `i` and `arr` are stable across every iteration.
+ *
+ * Returns `true` if the body contains anything that could mutate either
+ * binding:
+ *   - Direct assignment / compound assignment to `i` or `arr`
+ *     (`i = …`, `i += …`, `arr = …`, etc.)
+ *   - `i++ / ++i / i-- / --i` or the same on `arr`
+ *   - Method calls on `arr` (`arr.push()`, `arr.length = …`, etc.)
+ *   - `arr.length = …` assignment
+ *   - Any nested function / arrow / class — closures could capture and mutate
+ *     either binding outside our static view (conservative).
+ *
+ * Notes:
+ *   - `arr[k] = v` writes through the array but does not change the binding
+ *     itself or `arr.length` (when `k < arr.length`), so element writes are
+ *     allowed — they're the whole point of the optimisation.
+ */
+export declare function loopBodyMutatesIndexOrArray(body: ts.Statement, indexName: string, arrayName: string): boolean;
+/**
+ * #2682: the increment must strictly INCREASE `i` so that, combined with a
+ * non-negative init and the strict `i < recv.length` condition, `0 <= i < len`
+ * holds at every body point. `i++`/`++i` and `i += <positive int literal>`
+ * qualify; `i--`/`i -= k`/`i += <non-positive>` do NOT (would break the proof).
+ * Narrower than `detectI32LoopVar`'s incrementor check, which also accepts the
+ * decreasing forms.
+ */
+export declare function isIncreasingStep(incr: ts.Expression | undefined, name: string): boolean;
 export declare function compileForStatement(ctx: CodegenContext, fctx: FunctionContext, stmt: ts.ForStatement): void;
 export declare function compileDoWhileStatement(ctx: CodegenContext, fctx: FunctionContext, stmt: ts.DoStatement): void;
 export declare function compileForOfStatement(ctx: CodegenContext, fctx: FunctionContext, stmt: ts.ForOfStatement): void;

package/dist/compiler.d.ts

@@ -2,6 +2,17 @@ import { IncrementalLanguageService } from './checker/index.js';
 import { CompileOptions, CompileResult } from './index.js';
 export { compileToObjectSource } from './compiler/output.js';
 export type { ObjectCompileResult } from './compiler/output.js';
+/**
+ * #2771 — does the entry source statically import (or `require`) a RELATIVE
+ * module (`./x` / `../x`)? The single-source `compile()` path reads exactly one
+ * file and strips every import in `preprocessImports`, so a relative import is
+ * silently unresolved — its bindings lower to bogus `env.*` host imports (which
+ * the WASI strict-no-host gate then rejects). The CLI uses this to route such an
+ * entry to the multi-file bundler (`compileProject`), which resolves the
+ * relative deps through the TS program. Package / `node:` / bare-specifier
+ * imports are NOT relative and stay on the single-source path (byte-neutral).
+ */
+export declare function entryHasRelativeImports(source: string): boolean;
 /**
  * #2657 — the source-import module string for js2wasm's raw linear-memory access
  * intrinsics (`store32`/`load32`/`store8`/`load8`). These are NOT WASI host

package/dist/index.d.ts

@@ -476,6 +476,7 @@ export declare function createIncrementalCompiler(defaultOptions?: CompileOption
     compile: (source: string, options?: CompileOptions) => Promise<CompileResult>;
     dispose: () => void;
 };
+export { entryHasRelativeImports } from './compiler.js';
 export { getBarePackageName, ModuleResolver, resolveAllImports } from './resolve.js';
 export { preloadLibFiles } from './checker/index.js';
 export { getEntryExportNames, treeshake } from './treeshake.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 import * as path from "path";
-import { i as isKnownLibName, g as getLibSourceFile, a as getDefaultEnvironment, r as rewriteCjsRequire, f as forEachChild, c as compileSource, b as buildImports, d as compileFilesSource, e as compileMultiSource, h as compileToObjectSource } from "./runtime-C-4q_KwU.js";
-import { j, k, l, m, n, o, p, q, s } from "./runtime-C-4q_KwU.js";
+import { i as isKnownLibName, g as getLibSourceFile, a as getDefaultEnvironment, r as rewriteCjsRequire, f as forEachChild, e as entryHasRelativeImports, c as compileSource, b as compileMultiSource, d as buildImports, h as compileFilesSource, j as compileToObjectSource } from "./runtime-d_SmcBlN.js";
+import { k, l, m, n, o, p, q, s, t } from "./runtime-d_SmcBlN.js";
 import ts from "typescript";
 class IncrementalLanguageService {
   currentSource = "";
@@ -549,61 +549,61 @@ const RUNTIME_RECGROUP_TYPE_NAMES = [
 ];
 const RUNTIME_RECGROUP_ABI_VERSION = 1;
 const RUNTIME_NAME_SET = new Set(RUNTIME_RECGROUP_TYPE_NAMES);
-function typeDefName(t) {
-  switch (t.kind) {
+function typeDefName(t2) {
+  switch (t2.kind) {
     case "func":
     case "struct":
     case "array":
-      return t.name;
+      return t2.name;
     case "sub":
-      return t.name;
+      return t2.name;
     case "rec":
       return void 0;
   }
 }
-function valTypeToken(t, localOf) {
-  switch (t.kind) {
+function valTypeToken(t2, localOf) {
+  switch (t2.kind) {
     case "ref":
     case "ref_null": {
-      const local = localOf(t.typeIdx);
-      const nul = t.kind === "ref_null" ? "n" : "";
+      const local = localOf(t2.typeIdx);
+      const nul = t2.kind === "ref_null" ? "n" : "";
       if (local !== void 0) return `${nul}r${local}`;
       return `${nul}x`;
     }
     case "i32":
-      return t.boolean ? "i32b" : "i32";
+      return t2.boolean ? "i32b" : "i32";
     case "i64":
-      return t.bigint ? "i64big" : "i64";
+      return t2.bigint ? "i64big" : "i64";
     default:
-      return t.kind;
+      return t2.kind;
   }
 }
 function fieldToken(f, localOf) {
   return `${f.mutable ? "m" : ""}${valTypeToken(f.type, localOf)}`;
 }
-function structuralToken(t, localOf) {
-  switch (t.kind) {
+function structuralToken(t2, localOf) {
+  switch (t2.kind) {
     case "func": {
-      const p2 = t.params.map((v) => valTypeToken(v, localOf)).join(",");
-      const r = t.results.map((v) => valTypeToken(v, localOf)).join(",");
+      const p2 = t2.params.map((v) => valTypeToken(v, localOf)).join(",");
+      const r = t2.results.map((v) => valTypeToken(v, localOf)).join(",");
       return `func(${p2})->(${r})`;
     }
     case "struct": {
-      const sup = t.superTypeIdx !== void 0 && t.superTypeIdx >= 0 ? (() => {
-        const local = localOf(t.superTypeIdx);
-        return local !== void 0 ? `sub r${local}${t.final ? "!" : ""} ` : `sub x${t.final ? "!" : ""} `;
+      const sup = t2.superTypeIdx !== void 0 && t2.superTypeIdx >= 0 ? (() => {
+        const local = localOf(t2.superTypeIdx);
+        return local !== void 0 ? `sub r${local}${t2.final ? "!" : ""} ` : `sub x${t2.final ? "!" : ""} `;
       })() : "";
-      const fields = t.fields.map((f) => fieldToken(f, localOf)).join(";");
+      const fields = t2.fields.map((f) => fieldToken(f, localOf)).join(";");
       return `${sup}struct{${fields}}`;
     }
     case "array":
-      return `array<${t.mutable ? "m" : ""}${valTypeToken(t.element, localOf)}>`;
+      return `array<${t2.mutable ? "m" : ""}${valTypeToken(t2.element, localOf)}>`;
     case "sub": {
-      const sup = t.superType !== null ? (() => {
-        const local = localOf(t.superType);
-        return local !== void 0 ? `sub r${local}${t.final ? "!" : ""} ` : `sub x${t.final ? "!" : ""} `;
-      })() : t.final ? "final " : "";
-      return `${sup}${structuralToken(t.type, localOf)}`;
+      const sup = t2.superType !== null ? (() => {
+        const local = localOf(t2.superType);
+        return local !== void 0 ? `sub r${local}${t2.final ? "!" : ""} ` : `sub x${t2.final ? "!" : ""} `;
+      })() : t2.final ? "final " : "";
+      return `${sup}${structuralToken(t2.type, localOf)}`;
     }
   }
 }
@@ -631,11 +631,11 @@ function extractRuntimeGroup(mod) {
   const out = [];
   const types = mod.types;
   for (let i = 0; i < types.length; i++) {
-    const t = types[i];
-    if (t.kind === "rec") continue;
-    const name = typeDefName(t);
+    const t2 = types[i];
+    if (t2.kind === "rec") continue;
+    const name = typeDefName(t2);
     if (name !== void 0 && RUNTIME_NAME_SET.has(name)) {
-      out.push({ name, absIndex: i, def: t });
+      out.push({ name, absIndex: i, def: t2 });
     }
   }
   return out;
@@ -729,27 +729,28 @@ export {
   RUNTIME_RECGROUP_ABI_VERSION,
   RUNTIME_RECGROUP_TYPE_NAMES,
   buildImports,
-  j as buildStringConstants,
-  k as buildWasiPolyfill,
+  k as buildStringConstants,
+  l as buildWasiPolyfill,
   canonicalHashOfTypeGroup,
-  l as checkPolicy,
+  m as checkPolicy,
   compile,
-  m as compileAndInstantiate,
+  n as compileAndInstantiate,
   compileFiles,
   compileMulti,
   compileProject,
   compileToObject,
   compileToWat,
   createIncrementalCompiler,
+  entryHasRelativeImports,
   extractRuntimeGroup,
   fingerprintRuntimeGroup,
-  n as generateWit,
+  o as generateWit,
   getBarePackageName,
   getEntryExportNames,
-  o as instantiateWasm,
-  p as instantiateWasmStreaming,
-  q as jsString,
-  s as preloadLibFiles,
+  p as instantiateWasm,
+  q as instantiateWasmStreaming,
+  s as jsString,
+  t as preloadLibFiles,
   resolveAllImports,
   treeshake
 };

package/dist/ir/types.d.ts

@@ -126,6 +126,7 @@ export interface FieldDef {
 export type ValType = {
     kind: "i32";
     boolean?: true;
+    symbol?: true;
 } | {
     kind: "i64";
     bigint?: boolean;