@loopdive/js2 0.57.0

package/dist/compiler.d.ts

@@ -0,0 +1,48 @@
+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';
+/**
+ * #2657 — the source-import module string for js2wasm's raw linear-memory access
+ * intrinsics (`store32`/`load32`/`store8`/`load8`). These are NOT WASI host
+ * functions — they lower to inline `i32.store`/`i32.load`/`i32.store8`/
+ * `i32.load8_u` ops over the module's own exported `memory`. They are honestly
+ * named under a `wasm:` intrinsic namespace (mirroring `wasm:js-string`) so the
+ * source never mislabels a compiler intrinsic as a WASI host import: only
+ * `fd_read`/`fd_write` come from `"wasi_snapshot_preview1"`, the real WASI core
+ * module. (No host provides a `wasi_snapshot_preview1.store32`.)
+ */
+export declare const WASM_MEMORY_INTRINSIC_MODULE = "wasm:memory";
+/**
+ * Orchestrates the full compilation pipeline:
+ * TS Source → tsc Parser+Checker → Codegen → Binary + WAT
+ *
+ * Async because the optional Binaryen optimizer is lazy-loaded only when
+ * wasm-opt is requested (#1757 / GH #986), so normal compilation and
+ * standalone bundles do not need to embed Binaryen.
+ */
+export declare function compileSource(source: string, options?: CompileOptions, 
+/** Optional persistent language service for incremental compilation */
+languageService?: IncrementalLanguageService): Promise<CompileResult>;
+/**
+ * Synchronous compilation core (no Binaryen optimization).
+ *
+ * Identical to {@link compileSource} but never runs the async wasm-opt pass —
+ * the `optimize` option is ignored here. Use this only from synchronous
+ * contexts that cannot await (the `eval` host shim). All other callers should
+ * use the async {@link compileSource}.
+ */
+export declare function compileSourceSync(source: string, options?: CompileOptions, 
+/** Optional persistent language service for incremental compilation */
+languageService?: IncrementalLanguageService): CompileResult;
+/**
+ * Compile multiple TypeScript source files into a single Wasm module.
+ * Supports cross-file imports: `import { foo } from "./bar"`.
+ */
+export declare function compileMultiSource(files: Record<string, string>, entryFile: string, options?: CompileOptions): Promise<CompileResult>;
+/**
+ * Compile a TypeScript project from an entry file on disk.
+ * Uses ts.createProgram with real filesystem access -- TypeScript resolves
+ * all imports automatically via standard module resolution.
+ */
+export declare function compileFilesSource(entryPath: string, options?: CompileOptions): Promise<CompileResult>;

package/dist/define-substitution-BcUeKC2A.js

@@ -0,0 +1,109 @@
+class PositionMap {
+  /**
+   * A single-stage map is described by its edit list; a composed map is a
+   * chain `outer → inner` translated by function composition (apply `outer`'s
+   * single-stage transform, then defer to `inner`). Keeping composition as
+   * function composition (rather than flattening two edit lists into one)
+   * avoids the interleaving-delta correctness traps of merging transforms.
+   */
+  edits;
+  inner;
+  constructor(edits, inner) {
+    this.edits = [...edits].sort((a, b) => a.origStart - b.origStart);
+    this.inner = inner;
+  }
+  /** Identity map — output offsets equal input offsets. */
+  static identity() {
+    return new PositionMap([]);
+  }
+  /** Apply only THIS stage's single transform (output → its direct input). */
+  toDirectInputOffset(outOffset) {
+    let delta = 0;
+    for (const e of this.edits) {
+      const outEditStart = e.origStart + delta;
+      const outEditEnd = outEditStart + e.newLength;
+      if (outOffset < outEditStart) {
+        break;
+      }
+      if (outOffset < outEditEnd) {
+        return e.origStart;
+      }
+      delta += e.newLength - (e.origEnd - e.origStart);
+    }
+    return Math.max(0, outOffset - delta);
+  }
+  /**
+   * Translate an offset in this map's OUTPUT text all the way back to the
+   * ORIGINAL source: apply this stage, then defer to the earlier stage(s).
+   */
+  toInputOffset(outOffset) {
+    const direct = this.toDirectInputOffset(outOffset);
+    return this.inner ? this.inner.toInputOffset(direct) : direct;
+  }
+  /**
+   * Compose with the map of an EARLIER pipeline stage. `this` maps
+   * stage-N-output → stage-N-input; `inner` maps stage-N-input (== stage-(N−1)
+   * output) → original. The result maps stage-N-output → original.
+   */
+  compose(inner) {
+    if (inner.isIdentity) return this;
+    if (this.isIdentity) return inner;
+    return new PositionMap(this.edits, this.inner ? this.inner.compose(inner) : inner);
+  }
+  /** True when this is the identity (no edits and no earlier stage). */
+  get isIdentity() {
+    return this.edits.length === 0 && (this.inner?.isIdentity ?? true);
+  }
+}
+function applyDefineSubstitutions(source, defines) {
+  return applyDefineSubstitutionsWithMap(source, defines).source;
+}
+function applyDefineSubstitutionsWithMap(source, defines) {
+  if (!defines || Object.keys(defines).length === 0) {
+    return { source, positionMap: PositionMap.identity() };
+  }
+  const keys = Object.keys(defines).sort((a, b) => b.length - a.length);
+  let current = source;
+  let composed = PositionMap.identity();
+  for (const key of keys) {
+    const replacement = defines[key];
+    const pattern = key.startsWith("typeof ") ? new RegExp(`(?<![.\\w$])typeof\\s+${escapeRegExp(key.slice(7))}(?![\\w$])`, "g") : new RegExp(`(?<![.\\w$])${escapeRegExp(key)}(?![\\w$])`, "g");
+    const edits = [];
+    let out = "";
+    let last = 0;
+    for (const m of current.matchAll(pattern)) {
+      const start = m.index ?? 0;
+      const end = start + m[0].length;
+      out += current.slice(last, start) + replacement;
+      edits.push({ origStart: start, origEnd: end, newLength: replacement.length });
+      last = end;
+    }
+    if (edits.length === 0) continue;
+    out += current.slice(last);
+    current = out;
+    composed = new PositionMap(edits).compose(composed);
+  }
+  return { source: current, positionMap: composed };
+}
+function buildDefaultDefines(mode) {
+  return {
+    "process.env.NODE_ENV": JSON.stringify(mode),
+    "typeof process": JSON.stringify("undefined"),
+    "typeof window": JSON.stringify("undefined")
+  };
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const defineSubstitution = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  applyDefineSubstitutions,
+  applyDefineSubstitutionsWithMap,
+  buildDefaultDefines
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  PositionMap as P,
+  applyDefineSubstitutionsWithMap as a,
+  applyDefineSubstitutions as b,
+  defineSubstitution as d
+};

package/dist/emit/binary.d.ts

@@ -0,0 +1,50 @@
+import { BlockType, FieldDef, GlobalDef, Import, Instr, SourcePos, TypeDef, ValType, WasmExport, WasmFunction, WasmModule } from '../ir/types.js';
+import { WasmEncoder } from './encoder.js';
+/** A source map entry: maps a wasm byte offset to a source position */
+export interface SourceMapEntry {
+    wasmOffset: number;
+    sourcePos: SourcePos;
+}
+/** Result of binary emission with source map data */
+export interface EmitResult {
+    binary: Uint8Array;
+    sourceMapEntries: SourceMapEntry[];
+}
+/**
+ * Compute rec-group boundaries for the type section. Each returned [start, end]
+ * (inclusive) tuple identifies a contiguous run of type definitions that must
+ * be encoded inside a single WasmGC rec group so that forward references between
+ * them validate. Singleton groups (start === end) are emitted without a rec
+ * wrapper, preserving canonical type identity for non-recursive entries.
+ */
+export declare function computeRecGroups(types: TypeDef[]): Array<[number, number]>;
+/** Emit a complete Wasm binary from an IR module */
+export declare function emitBinary(mod: WasmModule): Uint8Array;
+/**
+ * Emit a Wasm binary and collect source map entries.
+ *
+ * Arms the #2043 always-on index validation (see `EmitValidationCtx` above)
+ * for the duration of this emit and disarms it in a finally, so the encode
+ * helpers run unchecked for other callers (the relocatable object emitter).
+ * JS2WASM_SKIP_INDEX_VALIDATION=1 is an escape hatch only.
+ */
+export declare function emitBinaryWithSourceMap(mod: WasmModule): EmitResult;
+export declare function encodeTypeDef(t: TypeDef, enc: WasmEncoder): void;
+export declare function encodeFieldDef(f: FieldDef, enc: WasmEncoder): void;
+export declare function encodeStorageType(t: ValType, enc: WasmEncoder): void;
+export declare function encodeValType(t: ValType, enc: WasmEncoder): void;
+export declare function encodeImport(imp: Import, enc: WasmEncoder): void;
+export declare function encodeGlobal(g: GlobalDef, enc: WasmEncoder): void;
+export declare function encodeExport(exp: WasmExport, enc: WasmEncoder, _numImportFuncs: number): void;
+export declare function encodeFunction(f: WasmFunction, enc: WasmEncoder): void;
+export interface LocalGroup {
+    count: number;
+    type: ValType;
+}
+export declare function groupLocals(locals: {
+    type: ValType;
+}[]): LocalGroup[];
+export declare function encodeBlockType(bt: BlockType, enc: WasmEncoder): void;
+export declare function encodeInstr(instr: Instr, enc: WasmEncoder): void;
+/** Emit a sourceMappingURL custom section */
+export declare function emitSourceMappingURLSection(enc: WasmEncoder, url: string): void;

package/dist/emit/c-header.d.ts

@@ -0,0 +1,23 @@
+import { ValType, WasmModule } from '../ir/types.js';
+/** Information about a single exported function for C header generation */
+export interface CHeaderExport {
+    /** C function name */
+    name: string;
+    /** Wasm parameter types */
+    params: ValType[];
+    /** Wasm result types */
+    results: ValType[];
+}
+/**
+ * Generate a C header file for the exported functions.
+ *
+ * @param moduleName - Used for the include guard (e.g. "my_module" → MY_MODULE_H)
+ * @param exports - List of exported functions with their signatures
+ * @returns The C header file content as a string
+ */
+export declare function generateCHeader(moduleName: string, exports: CHeaderExport[]): string;
+/**
+ * Extract C header export info from a WasmModule.
+ * Only includes function exports (not memory, tables, etc.)
+ */
+export declare function extractCHeaderExports(mod: WasmModule): CHeaderExport[];

package/dist/emit/canonical-recgroup.d.ts

@@ -0,0 +1,86 @@
+import { ArrayTypeDef, FuncTypeDef, StructTypeDef, SubTypeDef, WasmModule } from '../ir/types.js';
+/**
+ * The closed, ordered set of runtime GC type names that form the shared
+ * runtime-type boundary rec group (#2514). These are the WasmGC types whose
+ * objects cross a core-wasm link boundary between a user module and the shared
+ * runtime: the string family and the vec/array family.
+ *
+ * Order here is the *canonical* member order the ABI freezes; the emit phase
+ * (follow-on) will lay these out contiguously in this order so every artifact
+ * produces a byte-identical group. The hash below is order-sensitive, so this
+ * list IS the versioned ABI contract for membership + order.
+ *
+ * NOTE: not every module declares every one of these (DCE prunes unused types),
+ * so the verifier works on the *subset present*, preserving relative order.
+ *
+ * IMPORTANT — names are the *in-memory* TypeDef names (no `$` prefix). The `$`
+ * appears only in WAT rendering, not in the IR `name` field, so the verifier
+ * (which reads `mod.types[i].name`) matches the bare names below.
+ *
+ * Only types with a *name-stable* identity belong here. The externref vec/arr
+ * variants are emitted with an index-suffixed name (`__arr_ref_6`,
+ * `__vec_ref_6`, where `6` is the referenced type index) which is NOT stable
+ * across modules — so they are intentionally excluded from the name-keyed ABI
+ * boundary. Their structural identity is still verified transitively when a
+ * group member refs them (as an external `x` token).
+ */
+export declare const RUNTIME_RECGROUP_TYPE_NAMES: readonly string[];
+/** ABI version of the canonical runtime rec group. Bump on any membership,
+ *  order, or structural change to a type in {@link RUNTIME_RECGROUP_TYPE_NAMES}. */
+export declare const RUNTIME_RECGROUP_ABI_VERSION = 1;
+/** A flat type table member (no nested `rec` wrappers). */
+type FlatTypeDef = FuncTypeDef | StructTypeDef | ArrayTypeDef | SubTypeDef;
+/**
+ * Compute a deterministic, name-independent, absolute-index-independent
+ * structural canonical hash of an ordered group of type defs.
+ *
+ * `absIndices[i]` is the absolute type index of `group[i]` in the owning
+ * module's type space (used to resolve intra-group refs to local positions).
+ *
+ * Two groups that are structurally identical modulo type names and absolute
+ * placement produce the same hash; any change in member set, member order, or
+ * the structure/intra-group topology of any member changes it. This is the
+ * soundness proxy for "the engine canonicalizes these to the same runtime
+ * type".
+ */
+export declare function canonicalHashOfTypeGroup(group: readonly FlatTypeDef[], absIndices: readonly number[]): string;
+/** A member of the extracted runtime group: its name + absolute index + def. */
+export interface RuntimeGroupMember {
+    name: string;
+    absIndex: number;
+    def: FlatTypeDef;
+}
+/**
+ * Locate the runtime-type members present in a module's flat type table, in
+ * the module's emission order. Only types whose name is in
+ * {@link RUNTIME_RECGROUP_TYPE_NAMES} are returned (a module that doesn't use
+ * strings/vecs simply yields a subset, or none).
+ *
+ * Requires a *flat* type table (no nested `rec` wrappers), which is the shape
+ * codegen produces today (`computeRecGroups` derives groups at emit time, the
+ * `mod.types` array itself is flat).
+ */
+export declare function extractRuntimeGroup(mod: WasmModule): RuntimeGroupMember[];
+/** Result of fingerprinting a module's runtime rec group. */
+export interface RuntimeGroupFingerprint {
+    /** ABI version this fingerprint was computed under. */
+    abiVersion: number;
+    /** Canonical structural hash (the identity proxy). */
+    hash: string;
+    /** Member names in emission order — the membership+order half of the ABI. */
+    members: string[];
+    /** Number of runtime types present. */
+    count: number;
+}
+/**
+ * Produce a stable fingerprint of a module's runtime rec group: the structural
+ * canonical hash plus the ordered member list. Equal fingerprints across two
+ * artifacts ⇒ their runtime GC types will canonicalize to the same runtime
+ * type, so GC objects can cross a core-wasm link between them.
+ *
+ * This is the building block for a drift gate: capture the fingerprint of a
+ * reference artifact (e.g. the future `runtime.wasm`) and assert every user
+ * module reproduces it, including AFTER `wasm-opt` (the #2514 risk #2 check).
+ */
+export declare function fingerprintRuntimeGroup(mod: WasmModule): RuntimeGroupFingerprint;
+export {};

package/dist/emit/encoder.d.ts

@@ -0,0 +1,28 @@
+export declare class WasmEncoder {
+    private buf;
+    byte(b: number): void;
+    bytes(bs: number[] | Uint8Array): void;
+    /** Unsigned LEB128 */
+    u32(value: number): void;
+    /** Signed LEB128 */
+    i32(value: number): void;
+    /** Signed LEB128 i64 — truncate to 64 bits to prevent overflow */
+    i64(value: bigint): void;
+    /** IEEE 754 f64 little-endian */
+    f64(value: number): void;
+    /** IEEE 754 f32 little-endian */
+    f32(value: number): void;
+    /** v128 constant — 16 bytes little-endian */
+    v128(bytes: Uint8Array): void;
+    /** UTF-8 string with length prefix */
+    name(s: string): void;
+    /** Section: id + length-prefixed content */
+    section(id: number, content: (enc: WasmEncoder) => void): void;
+    /** Vector: u32 count + items */
+    vector<T>(items: T[], encode: (item: T, enc: WasmEncoder) => void): void;
+    /** Get current buffer length */
+    get length(): number;
+    /** Get current write position (alias for length, used by relocation tracking) */
+    get position(): number;
+    finish(): Uint8Array;
+}

package/dist/emit/object.d.ts

@@ -0,0 +1,14 @@
+import { WasmModule } from '../ir/types.js';
+export interface RelocEntry {
+    type: number;
+    offset: number;
+    symbolIndex: number;
+}
+export interface SymbolInfo {
+    kind: number;
+    name: string;
+    index: number;
+    flags: number;
+}
+/** Emit a relocatable Wasm object file (.o) from an IR module */
+export declare function emitObject(mod: WasmModule): Uint8Array;