@loopdive/js2 0.57.0 → 0.59.0

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

@@ -315,19 +315,48 @@ export interface CompileOptions {
      *  Default: false (calls to fs.readFileSync / fs.writeFileSync raise a compile error). */
     allowFs?: boolean;
     /**
-     * #2625 / #2633 — emit the per-module linkable `node:<mod>` shims instead of
-     * inlining the host APIs. WASI-only (ignored for other targets). When set,
-     * std-IO is routed through `node:fs`: the user module imports `readSync`/
-     * `writeSync` plus its linear memory from `node:fs` and carries no
-     * `wasi_snapshot_preview1` import for stream IO; console.log / process.std*.write
-     * lower to `writeSync(1|2, …)` and synchronous stdin is `readSync(0, …)`. Link
-     * against `node-fs.wasm` (or `--preload node:fs=node-fs.wasm` under wasmtime).
-     * Default off — the self-contained inline `fd_read`/`fd_write` path stays. The
-     * bespoke `js2wasm:node-process` shim (`process.stdin.read`/`stdout_write`/…)
-     * was retired in #2633; `process.stdin.read(buf, offset)` is no longer a
-     * recognised API (it matched no real Node surface — use `node:fs` `readSync`).
+     * (#2796) Differential-test-harness fidelity flag. In the default JS-host
+     * (WasmGC) target, top-level module code runs via the wasm `start` section —
+     * i.e. DURING `WebAssembly.instantiate`, BEFORE the host can call
+     * `setExports(instance.exports)`. Top-level code that introspects WasmGC
+     * structs (`for…in` / `Object.keys` over a runtime-shaped object) needs the
+     * `__struct_field_names` / `__sget_*` exports, which only exist once the
+     * instance is constructed — so during the start section they resolve to
+     * nothing and a `for…in` enumerates zero keys. The standalone/WASI path does
+     * NOT hit this: it runs top-level code via an explicitly-called `_start`
+     * export AFTER instantiation, when every export is reachable.
+     *
+     * When `true`, emit the top-level `__module_init` as an EXPORT and do NOT run
+     * it via the wasm `start` section, so the host can invoke
+     * `instance.exports.__module_init()` AFTER wiring `setExports` — symmetric
+     * with the standalone `_start` model. The differential-test harness
+     * (`scripts/diff-test.ts`) sets this so the HOST lane runs top-level code with
+     * the same fully-wired runtime the standalone lane uses, rather than tripping
+     * over an exports-timing artifact of the harness. Default `false` →
+     * byte-identical output (top-level runs in the wasm `start` section) for every
+     * other consumer (website, playground, test262, library users).
+     */
+    deferTopLevelInit?: boolean;
+    /**
+     * #2783 — general `--link <namespace>` dynamic-linking axis (the ONLY
+     * link-vs-inline control; the old `linkNodeShims` boolean was removed). Each
+     * listed namespace is left as a **link-time import** (satisfied at
+     * instantiation by a preloaded provider module, e.g.
+     * `wasmtime --preload node:fs=node-fs.wasm`) instead of being inline-lowered to
+     * a self-contained module. "Leave-as-import" is the universal capability (any
+     * external namespace can be a wasm import); "inline-lower" is the special
+     * capability the compiler only has for a known few (`node:fs` fd IO). So for an
+     * arbitrary namespace `link: ["acme:telemetry"]` simply permits its imports
+     * past the strict `--no-host-imports` / WASI gate; for `node:fs` it
+     * additionally selects the import-and-link std-IO path (the user module imports
+     * `readSync`/`writeSync` + its linear memory from `node:fs` and carries no
+     * `wasi_snapshot_preview1` import for stream IO; console.log /
+     * process.std*.write lower to `writeSync(1|2, …)`, stdin is `readSync(0, …)`).
+     *
+     * WASI-gated: ignored for non-WASI targets. Default empty — every namespace
+     * stays standalone / inline-lowered. CLI: `--link <ns>` (repeatable).
      */
-    linkNodeShims?: boolean;
+    link?: string[];
     /**
      * Node API emulation (#2603). Opt-in via `--emulate node`. When set, the
      * checker is given an ambient `process` declaration so Node globals js2wasm
@@ -476,6 +505,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-UuI75J3h.js";
+import { k, l, m, n, o, p, q, s, t } from "./runtime-UuI75J3h.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;