@loopdive/js2 0.58.0 → 0.59.0

package/dist/{runtime-d_SmcBlN.js → runtime-UuI75J3h.js}

@@ -8780,7 +8780,7 @@ function lookupAllowlistEntry(name) {
   }
   return void 0;
 }
-function isHostImportAllowed(module, name) {
+function isHostImportAllowed(module, name, linkedNamespaces) {
   if (module === "env") {
     const entry = lookupAllowlistEntry(name);
     if (entry) return { allowed: true };
@@ -8789,6 +8789,9 @@ function isHostImportAllowed(module, name) {
   if (ALWAYS_ALLOWED_IMPORT_MODULES.has(module)) {
     return { allowed: true };
   }
+  if (linkedNamespaces?.has(module)) {
+    return { allowed: true };
+  }
   return { allowed: false, reason: "non-env-host-module" };
 }
 function buildStrictHostImportError(module, name) {
@@ -8803,14 +8806,14 @@ function buildStrictHostImportError(module, name) {
   }
   return `Host import "${module}.${name}" requested under --no-host-imports / WASI strict mode, but the name is not on the dual-mode allowlist (src/codegen/host-import-allowlist.ts). Either add a Wasm-native fallback for this feature or, if you need a transitional host import, add an entry to HOST_IMPORT_ALLOWLIST citing the tracking issue and include "[allowlist-grow]" in your PR description.`;
 }
-function scanForLeakedHostImports(imports) {
+function scanForLeakedHostImports(imports, linkedNamespaces) {
   const leaks = [];
   const seen = /* @__PURE__ */ new Set();
   for (const imp of imports) {
     const key = `${imp.module}\0${imp.name}`;
     if (seen.has(key)) continue;
     seen.add(key);
-    const decision = isHostImportAllowed(imp.module, imp.name);
+    const decision = isHostImportAllowed(imp.module, imp.name, linkedNamespaces);
     if (!decision.allowed) {
       leaks.push({ module: imp.module, name: imp.name, reason: decision.reason });
     }
@@ -8825,21 +8828,16 @@ function buildLeakedHostImportError(leak) {
   return base + `The name is not on the dual-mode allowlist (src/codegen/host-import-allowlist.ts). Add a Wasm-native fallback for this feature, or — for a transitional host import — add an allowlist entry citing the tracking issue and include "[allowlist-grow]" in your PR description.`;
 }
 function funcTypeKey(params, results) {
-  let key = "";
-  for (let i = 0; i < params.length; i++) {
-    const p = params[i];
-    if (i > 0) key += ",";
-    key += p.kind;
-    if (p.kind === "ref" || p.kind === "ref_null") key += ":" + p.typeIdx;
-  }
-  key += "|";
-  for (let i = 0; i < results.length; i++) {
-    const r = results[i];
-    if (i > 0) key += ",";
-    key += r.kind;
-    if (r.kind === "ref" || r.kind === "ref_null") key += ":" + r.typeIdx;
-  }
-  return key;
+  const part = (v) => {
+    let s = v.kind;
+    if (v.kind === "ref" || v.kind === "ref_null") s += ":" + v.typeIdx;
+    else if (v.kind === "i32") {
+      if (v.boolean) s += ":bool";
+      else if (v.symbol) s += ":sym";
+    }
+    return s;
+  };
+  return params.map(part).join(",") + "|" + results.map(part).join(",");
 }
 function addFuncType(ctx, params, results, name) {
   const key = funcTypeKey(params, results);
@@ -9084,7 +9082,7 @@ function addImport(ctx, module, name, desc) {
     );
   }
   if (ctx.strictNoHostImports) {
-    const decision = isHostImportAllowed(module, name);
+    const decision = isHostImportAllowed(module, name, ctx.linkedNamespaces);
     if (!decision.allowed) {
       const message = buildStrictHostImportError(module, name);
       ctx.errors.push({ message, line: 0, column: 0, severity: "degrade" });
@@ -9130,6 +9128,11 @@ function addStringConstantGlobal(ctx, value) {
 function nextModuleGlobalIdx(ctx) {
   return ctx.numImportGlobals + ctx.mod.globals.length;
 }
+function recordInModuleInitFlagRead(ctx) {
+  const flagGet = { op: "global.get", index: 0 };
+  (ctx.inModuleInitFlagReads ??= []).push(flagGet);
+  return flagGet;
+}
 function localGlobalIdx(ctx, absIdx) {
   return absIdx - ctx.numImportGlobals;
 }
@@ -12515,6 +12518,15 @@ function flushLateImportShifts$1(ctx, fctx) {
 function isAnyValue$1(type, ctx) {
   return (type.kind === "ref" || type.kind === "ref_null") && type.typeIdx === ctx.anyValueTypeIdx && ctx.anyValueTypeIdx >= 0;
 }
+function isStrictBooleanReturnType(t) {
+  return (t.flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) !== 0;
+}
+function brandExternMethodResult(_ctx, tsReturnType, valType) {
+  if (!tsReturnType) return valType;
+  if (valType.kind !== "i32" || valType.boolean) return valType;
+  if (!isStrictBooleanReturnType(tsReturnType)) return valType;
+  return { kind: "i32", boolean: true };
+}
 let _ensureAnyHelpers = () => {
   throw unregisteredDelegateError("ensureAnyHelpers");
 };
@@ -34159,6 +34171,12 @@ function emitToString(ctx, fctx, valType, tsType, hint) {
       return nativeStringType(ctx);
     }
     if (hint === "default") {
+      const refTypeIdx = valType.typeIdx;
+      const structName = refTypeIdx !== void 0 ? ctx.typeIdxToStructName.get(refTypeIdx) : void 0;
+      if (structName !== void 0 && ctx.funcMap.get(`${structName}_toString`) !== void 0 && ctx.funcMap.get(`${structName}_valueOf`) === void 0 && ctx.funcMap.get(`${structName}_@@toPrimitive`) === void 0) {
+        coerceType$1(ctx, fctx, valType, { kind: "externref" }, "string");
+        return { kind: "externref" };
+      }
       coerceType$1(ctx, fctx, valType, { kind: "externref" });
       const toStrIdx = ensureLateImport$1(
         ctx,
@@ -34594,377 +34612,6 @@ function isAllowedUse(checker, id, safe, fnDecls, fnParamSyms, nodeFsBindings) {
   }
   return false;
 }
-const EMPTY_RESULT = {
-  sites: /* @__PURE__ */ new Map(),
-  approved: /* @__PURE__ */ new Set(),
-  approvedNames: /* @__PURE__ */ new Set(),
-  receiverStruct: /* @__PURE__ */ new Map(),
-  newThisOwnerNames: /* @__PURE__ */ new Set(),
-  ctorDeclByName: /* @__PURE__ */ new Map()
-};
-function fnctorDeclFromSymbol(sym) {
-  for (const decl of sym.getDeclarations() ?? []) {
-    if (ts.isFunctionDeclaration(decl) && decl.body) return decl;
-    if (ts.isFunctionExpression(decl) && decl.body) return decl;
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      let init = decl.initializer;
-      while (ts.isParenthesizedExpression(init)) init = init.expression;
-      if (ts.isFunctionExpression(init) && init.body) return init;
-    }
-  }
-  return void 0;
-}
-const RETURN_INFER_MAX_DEPTH = 6;
-const GENERIC_METHOD_CALL = /* @__PURE__ */ new Set(["call", "apply", "bind"]);
-function resolveFnctorSymbol(checker, calleeExpr) {
-  let e = calleeExpr;
-  while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isNonNullExpression(e)) {
-    e = e.expression;
-  }
-  if (!ts.isIdentifier(e)) return void 0;
-  const sym = checker.getSymbolAtLocation(e);
-  const decls = sym?.getDeclarations();
-  if (!sym || !decls) return void 0;
-  for (const decl of decls) {
-    if (ts.isClassDeclaration(decl) || ts.isClassExpression(decl)) return void 0;
-    if (ts.isFunctionDeclaration(decl) && decl.body) return sym;
-    if (ts.isFunctionExpression(decl) && decl.body) return sym;
-    if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      let init = decl.initializer;
-      while (ts.isParenthesizedExpression(init)) init = init.expression;
-      if (ts.isFunctionExpression(init) && init.body) return sym;
-      if (ts.isArrowFunction(init)) return void 0;
-    }
-  }
-  return void 0;
-}
-function collectFnctorOwnFields(ctorSym) {
-  const fields = /* @__PURE__ */ new Set();
-  const decls = ctorSym.getDeclarations() ?? [];
-  for (const decl of decls) {
-    let body;
-    if ((ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl)) && decl.body) body = decl.body;
-    else if (ts.isVariableDeclaration(decl) && decl.initializer) {
-      let init = decl.initializer;
-      while (ts.isParenthesizedExpression(init)) init = init.expression;
-      if (ts.isFunctionExpression(init) && init.body) body = init.body;
-    }
-    if (!body) continue;
-    const walk = (node) => {
-      if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
-        fields.add(node.left.name.text);
-      }
-      forEachChild$1(node, walk);
-    };
-    walk(body);
-  }
-  return fields;
-}
-function classifyUse(checker, idNode, ownFields) {
-  const parent = idNode.parent;
-  if (ts.isPropertyAccessExpression(parent) && parent.expression === idNode) {
-    const name = parent.name.text;
-    if (ownFields.has(name)) return "typed";
-    return "dynamic";
-  }
-  if (ts.isElementAccessExpression(parent) && parent.expression === idNode) {
-    return "dynamic";
-  }
-  if (ts.isCallExpression(parent) && parent.arguments.length > 0 && parent.arguments[0] === idNode) {
-    const callee = parent.expression;
-    if (ts.isPropertyAccessExpression(callee) && GENERIC_METHOD_CALL.has(callee.name.text)) {
-      return "dynamic";
-    }
-  }
-  if (ts.isCallExpression(parent)) {
-    const argIdx = parent.arguments.indexOf(idNode);
-    if (argIdx >= 0) {
-      const sig = checker.getResolvedSignature(parent);
-      const paramSym = sig?.parameters[argIdx];
-      if (paramSym) {
-        const pType = checker.getTypeOfSymbolAtLocation(paramSym, idNode);
-        if (isAnyOrUnknown(pType)) return "dynamic";
-      }
-      return "neutral";
-    }
-  }
-  if (ts.isReturnStatement(parent)) {
-    return "neutral";
-  }
-  return "neutral";
-}
-function isAnyOrUnknown(t) {
-  return (t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
-}
-function bindingOf(newExpr) {
-  const parent = newExpr.parent;
-  if (ts.isVariableDeclaration(parent) && parent.initializer === newExpr && ts.isIdentifier(parent.name)) {
-    return parent.name;
-  }
-  return void 0;
-}
-function unwrapExpr(e) {
-  let cur = e;
-  while (ts.isParenthesizedExpression(cur) || ts.isAsExpression(cur) || ts.isNonNullExpression(cur)) {
-    cur = cur.expression;
-  }
-  return cur;
-}
-function isFunctionLike$2(node) {
-  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
-}
-function buildProtoMethodIndex(sourceFile) {
-  const idx = /* @__PURE__ */ new Map();
-  const walk = (n) => {
-    if (ts.isBinaryExpression(n) && n.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(n.left)) {
-      const rhs = unwrapExpr(n.right);
-      if (isFunctionLike$2(rhs)) {
-        const name = n.left.name.text;
-        const arr = idx.get(name);
-        if (arr) arr.push(rhs);
-        else idx.set(name, [rhs]);
-      }
-    }
-    forEachChild$1(n, walk);
-  };
-  walk(sourceFile);
-  return idx;
-}
-function resolveCalleeFunction(checker, callExpr, protoIndex) {
-  const callee = unwrapExpr(callExpr.expression);
-  let sym;
-  if (ts.isPropertyAccessExpression(callee)) {
-    sym = checker.getSymbolAtLocation(callee.name) ?? checker.getSymbolAtLocation(callee);
-  } else if (ts.isIdentifier(callee)) {
-    sym = checker.getSymbolAtLocation(callee);
-  }
-  if (sym) {
-    for (const decl of sym.getDeclarations() ?? []) {
-      const fn = functionFromDeclaration(decl);
-      if (fn?.body) return fn;
-    }
-  }
-  if (ts.isPropertyAccessExpression(callee)) {
-    const cands = protoIndex.get(callee.name.text);
-    if (cands && cands.length === 1 && cands[0].body) return cands[0];
-  }
-  return void 0;
-}
-function functionFromDeclaration(decl) {
-  if (isFunctionLike$2(decl)) return decl;
-  if (ts.isVariableDeclaration(decl) && decl.initializer) {
-    const init = unwrapExpr(decl.initializer);
-    if (isFunctionLike$2(init)) return init;
-    return void 0;
-  }
-  if (ts.isPropertyAssignment(decl)) {
-    const init = unwrapExpr(decl.initializer);
-    if (isFunctionLike$2(init)) return init;
-    return void 0;
-  }
-  if (ts.isMethodDeclaration(decl)) return decl;
-  if (ts.isPropertyAccessExpression(decl) || ts.isElementAccessExpression(decl)) {
-    const parent = decl.parent;
-    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === decl) {
-      const rhs = unwrapExpr(parent.right);
-      if (isFunctionLike$2(rhs)) return rhs;
-    }
-  }
-  return void 0;
-}
-function singleReturnExpr(fn) {
-  const body = fn.body;
-  if (!body) return void 0;
-  if (!ts.isBlock(body)) return body;
-  const returns = [];
-  const walk = (n) => {
-    if (ts.isReturnStatement(n)) {
-      if (n.expression) returns.push(n.expression);
-      return;
-    }
-    if (isFunctionLike$2(n)) return;
-    forEachChild$1(n, walk);
-  };
-  walk(body);
-  return returns.length === 1 ? returns[0] : void 0;
-}
-function inferReturnStruct(checker, fn, depth, memo, protoIndex) {
-  if (memo.has(fn)) return memo.get(fn);
-  if (depth <= 0) return void 0;
-  memo.set(fn, void 0);
-  const ret2 = singleReturnExpr(fn);
-  let result;
-  if (ret2) {
-    const r = unwrapExpr(ret2);
-    if (ts.isNewExpression(r)) {
-      const ctorSym = resolveFnctorSymbol(checker, r.expression);
-      if (ctorSym) result = `__fnctor_${ctorSym.name}`;
-    } else if (ts.isCallExpression(r)) {
-      const callee = resolveCalleeFunction(checker, r, protoIndex);
-      if (callee) result = inferReturnStruct(checker, callee, depth - 1, memo, protoIndex);
-    }
-  }
-  memo.set(fn, result);
-  return result;
-}
-function buildReceiverStructMap(checker, sourceFile, usesBySymbol) {
-  const map = /* @__PURE__ */ new Map();
-  const memo = /* @__PURE__ */ new Map();
-  const protoIndex = buildProtoMethodIndex(sourceFile);
-  const visit = (node) => {
-    if (ts.isVariableDeclaration(node) && node.initializer && ts.isIdentifier(node.name)) {
-      const init = unwrapExpr(node.initializer);
-      if (ts.isCallExpression(init)) {
-        const callee = resolveCalleeFunction(checker, init, protoIndex);
-        const struct = callee ? inferReturnStruct(checker, callee, RETURN_INFER_MAX_DEPTH, memo, protoIndex) : void 0;
-        if (struct) {
-          const bindSym = checker.getSymbolAtLocation(node.name);
-          const uses = bindSym ? usesBySymbol.get(bindSym) ?? [] : [];
-          for (const use of uses) {
-            if (use === node.name) continue;
-            map.set(use, struct);
-          }
-        }
-      }
-    }
-    forEachChild$1(node, visit);
-  };
-  visit(sourceFile);
-  return map;
-}
-function analyzeFnctorEscapeGate(checker, sourceFile) {
-  const sites = /* @__PURE__ */ new Map();
-  const approved = /* @__PURE__ */ new Set();
-  const approvedNames = /* @__PURE__ */ new Set();
-  const newSites = [];
-  const collect = (node) => {
-    if (ts.isNewExpression(node)) {
-      const ctorSym = resolveFnctorSymbol(checker, node.expression);
-      if (ctorSym) newSites.push({ newExpr: node, ctorSym });
-    }
-    forEachChild$1(node, collect);
-  };
-  collect(sourceFile);
-  if (newSites.length === 0) return EMPTY_RESULT;
-  const ctorDeclByName = /* @__PURE__ */ new Map();
-  for (const { ctorSym } of newSites) {
-    if (ctorDeclByName.has(ctorSym.name)) continue;
-    const decl = fnctorDeclFromSymbol(ctorSym);
-    if (decl) ctorDeclByName.set(ctorSym.name, decl);
-  }
-  const usesBySymbol = /* @__PURE__ */ new Map();
-  const indexUses = (node) => {
-    if (ts.isIdentifier(node)) {
-      const sym = checker.getSymbolAtLocation(node);
-      if (sym) {
-        const arr = usesBySymbol.get(sym);
-        if (arr) arr.push(node);
-        else usesBySymbol.set(sym, [node]);
-      }
-    }
-    forEachChild$1(node, indexUses);
-  };
-  indexUses(sourceFile);
-  for (const { newExpr, ctorSym } of newSites) {
-    const ownFields = collectFnctorOwnFields(ctorSym);
-    let sawDynamic = false;
-    let sawTyped = false;
-    const bind = bindingOf(newExpr);
-    if (bind) {
-      const bindSym = checker.getSymbolAtLocation(bind);
-      const uses = bindSym ? usesBySymbol.get(bindSym) ?? [] : [];
-      for (const use of uses) {
-        if (use === bind) continue;
-        const c = classifyUse(checker, use, ownFields);
-        if (c === "typed") sawTyped = true;
-        else if (c === "dynamic") sawDynamic = true;
-      }
-    } else {
-      let inner = newExpr;
-      let parent = inner.parent;
-      while (ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent) || ts.isNonNullExpression(parent)) {
-        inner = parent;
-        parent = parent.parent;
-      }
-      if (ts.isPropertyAccessExpression(parent) && parent.expression === inner) {
-        if (ownFields.has(parent.name.text)) sawTyped = true;
-        else sawDynamic = true;
-      } else if (ts.isElementAccessExpression(parent) && parent.expression === inner) {
-        sawDynamic = true;
-      } else if (ts.isCallExpression(parent) && parent.arguments.length > 0 && parent.arguments[0] === inner && ts.isPropertyAccessExpression(parent.expression) && GENERIC_METHOD_CALL.has(parent.expression.name.text)) {
-        sawDynamic = true;
-      }
-    }
-    let cls;
-    if (sawTyped) cls = "keep-typed";
-    else if (sawDynamic) cls = "reconstruct";
-    else cls = "keep-static";
-    sites.set(newExpr, cls);
-    if (cls === "reconstruct") {
-      approved.add(newExpr);
-      approvedNames.add(ctorSym.name);
-    }
-  }
-  const receiverStruct = buildReceiverStructMap(checker, sourceFile, usesBySymbol);
-  if (process.env.JS2WASM_LOG_FNCTOR_GATE === "1" && (sites.size > 0 || receiverStruct.size > 0)) {
-    const counts = { reconstruct: 0, "keep-typed": 0, "keep-static": 0 };
-    for (const c of sites.values()) counts[c]++;
-    console.error(
-      `[#2660 fnctor-escape-gate] ${sites.size} new F() site(s): reconstruct=${counts.reconstruct} keep-typed=${counts["keep-typed"]} keep-static=${counts["keep-static"]}; receiverStruct flow-map entries=${receiverStruct.size}`
-    );
-  }
-  const newThisOwnerNames = /* @__PURE__ */ new Set();
-  return { sites, approved, approvedNames, receiverStruct, newThisOwnerNames, ctorDeclByName };
-}
-function deriveFnctorFields(ctx, funcDecl) {
-  const body = funcDecl.body;
-  if (!body) return [];
-  const fields = [];
-  function recordThisField(lhs, valueExpr) {
-    const fieldName = lhs.name.text;
-    if (fields.some((f) => f.name === fieldName)) return;
-    const lhsType = ctx.checker.getTypeAtLocation(lhs);
-    const rhsType = ctx.checker.getTypeAtLocation(valueExpr);
-    const lhsWasm = resolveWasmType(ctx, lhsType);
-    const rhsWasm = resolveWasmType(ctx, rhsType);
-    const fieldType = lhsWasm.kind === "externref" ? rhsWasm : lhsWasm;
-    fields.push({ name: fieldName, type: fieldType, mutable: true });
-  }
-  function collectAssignmentChain(expr) {
-    if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(expr.left) && expr.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
-      recordThisField(expr.left, expr.right);
-      collectAssignmentChain(expr.right);
-    }
-  }
-  function collectThisAssignments(stmts) {
-    for (const stmt of stmts) {
-      if (ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression)) {
-        collectAssignmentChain(stmt.expression);
-      }
-      if (ts.isIfStatement(stmt)) {
-        if (ts.isBlock(stmt.thenStatement)) {
-          collectThisAssignments(stmt.thenStatement.statements);
-        }
-        if (stmt.elseStatement && ts.isBlock(stmt.elseStatement)) {
-          collectThisAssignments(stmt.elseStatement.statements);
-        }
-      }
-      if ((ts.isForStatement(stmt) || ts.isForInStatement(stmt) || ts.isForOfStatement(stmt) || ts.isWhileStatement(stmt) || ts.isDoStatement(stmt)) && ts.isBlock(stmt.statement)) {
-        collectThisAssignments(stmt.statement.statements);
-      }
-    }
-  }
-  collectThisAssignments(body.statements);
-  for (const field of fields) {
-    if (field.type.kind === "ref") {
-      field.type = {
-        kind: "ref_null",
-        typeIdx: field.type.typeIdx
-      };
-    }
-  }
-  return fields;
-}
 function fnSymbolOf(checker, node) {
   if (ts.isFunctionDeclaration(node) && node.name) return checker.getSymbolAtLocation(node.name);
   if (ts.isMethodDeclaration(node) && ts.isIdentifier(node.name)) return checker.getSymbolAtLocation(node.name);
@@ -37361,7 +37008,7 @@ function applyIrTailCalls(ctx, body, funcTypeIdx) {
   };
   return convertBuffer(ctx, body, caller);
 }
-function isFunctionLike$1(node) {
+function isFunctionLike$2(node) {
   return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isAccessor(node) || ts.isConstructorDeclaration(node);
 }
 function containsLinearU8Allocation(ctx, node) {
@@ -37370,7 +37017,7 @@ function containsLinearU8Allocation(ctx, node) {
   let found = false;
   const visit = (child) => {
     if (found) return;
-    if (child !== node && isFunctionLike$1(child)) return;
+    if (child !== node && isFunctionLike$2(child)) return;
     if (ts.isVariableDeclaration(child) && ts.isIdentifier(child.name) && child.initializer && ts.isNewExpression(child.initializer) && ts.isIdentifier(child.initializer.expression) && child.initializer.expression.text === "Uint8Array" && isLinearU8RepresentableNew(ctx, child.initializer)) {
       const sym = ctx.checker.getSymbolAtLocation(child.name);
       if (sym && linear.safeBindings.has(sym)) {
@@ -51355,15 +51002,184 @@ function tryEmitLinearU8StdWrite(ctx, fctx, bufArg, writeSinkIdx, fd) {
   fctx.body.push({ op: "drop" });
   return true;
 }
+function dispatcherName$2(propName, strict) {
+  return strict ? `__set_member_${propName}` : `__set_member_nonstrict_${propName}`;
+}
+function reserveMemberSetDispatch(ctx, propName, strict, fctx) {
+  const name = dispatcherName$2(propName, strict);
+  const existing = ctx.funcMap.get(name);
+  if (existing !== void 0) return existing;
+  const fallbackName = strict ? "__extern_set_strict" : "__extern_set";
+  const setIdx = ensureLateImport$1(
+    ctx,
+    fallbackName,
+    [{ kind: "externref" }, { kind: "externref" }, { kind: "externref" }],
+    []
+  );
+  if (setIdx === void 0) return void 0;
+  addStringConstantGlobal(ctx, propName);
+  addUnionImportsViaRegistry(ctx);
+  if (fctx) flushLateImportShifts$1(ctx, fctx);
+  const typeIdx = addFuncType(ctx, [{ kind: "externref" }, { kind: "externref" }], [], "$member_set_dispatch_type");
+  const funcIdx = ctx.numImportFuncs + ctx.mod.functions.length;
+  ctx.mod.functions.push({
+    name,
+    typeIdx,
+    locals: [],
+    // Placeholder; filled by fillMemberSetDispatch. `unreachable` keeps the stub
+    // valid (no results) if the fill is ever skipped (it never is — the fill
+    // iterates the same name set this reserve populates).
+    body: [{ op: "unreachable" }],
+    exported: false
+  });
+  ctx.funcMap.set(name, funcIdx);
+  (ctx.memberSetDispatchNames ??= /* @__PURE__ */ new Set()).add(`${propName}\0${strict ? "S" : "N"}`);
+  return funcIdx;
+}
+function fillMemberSetDispatch(ctx) {
+  const mod = ctx.mod;
+  for (const key of ctx.memberSetDispatchNames ?? []) {
+    const sep = key.lastIndexOf("\0");
+    const propName = sep >= 0 ? key.slice(0, sep) : key;
+    const strict = sep >= 0 ? key.slice(sep + 1) === "S" : true;
+    const dispIdx = ctx.funcMap.get(dispatcherName$2(propName, strict));
+    if (dispIdx === void 0) continue;
+    const dispFn = mod.functions[dispIdx - ctx.numImportFuncs];
+    if (!dispFn) continue;
+    const candidates = findAlternateStructsForField(ctx, propName, -1).filter((c) => c.mutable);
+    const fallbackIdx = ctx.funcMap.get(strict ? "__extern_set_strict" : "__extern_set");
+    const fallback = fallbackIdx !== void 0 ? [
+      { op: "local.get", index: 0 },
+      // recv
+      ...stringConstantExternrefInstrs(ctx, propName),
+      { op: "local.get", index: 1 },
+      // val
+      { op: "call", funcIdx: fallbackIdx }
+    ] : [];
+    const buildSetDispatch = (idx) => {
+      if (idx >= candidates.length) return fallback;
+      const cand = candidates[idx];
+      const coerce = coercionInstrs(ctx, { kind: "externref" }, cand.fieldType);
+      const setFieldInstrs = [
+        { op: "local.get", index: 2 },
+        // __any
+        { op: "ref.cast", typeIdx: cand.structTypeIdx },
+        { op: "local.get", index: 1 },
+        // val (externref)
+        ...coerce,
+        { op: "struct.set", typeIdx: cand.structTypeIdx, fieldIdx: cand.fieldIdx }
+      ];
+      return [
+        { op: "local.get", index: 2 },
+        // __any
+        { op: "ref.test", typeIdx: cand.structTypeIdx },
+        {
+          op: "if",
+          blockType: { kind: "empty" },
+          then: setFieldInstrs,
+          else: buildSetDispatch(idx + 1)
+        }
+      ];
+    };
+    dispFn.locals = [{ name: "__any", type: { kind: "anyref" } }];
+    dispFn.body = [
+      { op: "local.get", index: 0 },
+      // recv (externref)
+      { op: "any.convert_extern" },
+      { op: "local.set", index: 2 },
+      // __any
+      ...buildSetDispatch(0)
+    ];
+  }
+}
+function dispatcherName$1(propName) {
+  return `__get_member_${propName}`;
+}
+function reserveMemberGetDispatch(ctx, propName, fctx) {
+  const name = dispatcherName$1(propName);
+  const existing = ctx.funcMap.get(name);
+  if (existing !== void 0) return existing;
+  const getIdx = ensureLateImport$1(
+    ctx,
+    "__extern_get",
+    [{ kind: "externref" }, { kind: "externref" }],
+    [{ kind: "externref" }]
+  );
+  if (getIdx === void 0) return void 0;
+  addStringConstantGlobal(ctx, propName);
+  addUnionImportsViaRegistry(ctx);
+  if (fctx) flushLateImportShifts$1(ctx, fctx);
+  const typeIdx = addFuncType(ctx, [{ kind: "externref" }], [{ kind: "externref" }], "$member_get_dispatch_type");
+  const funcIdx = ctx.numImportFuncs + ctx.mod.functions.length;
+  ctx.mod.functions.push({
+    name,
+    typeIdx,
+    locals: [],
+    body: [{ op: "unreachable" }],
+    exported: false
+  });
+  ctx.funcMap.set(name, funcIdx);
+  (ctx.memberGetDispatchNames ??= /* @__PURE__ */ new Set()).add(propName);
+  return funcIdx;
+}
+function fillMemberGetDispatch(ctx) {
+  const mod = ctx.mod;
+  const getIdx = ctx.funcMap.get("__extern_get");
+  for (const propName of ctx.memberGetDispatchNames ?? []) {
+    const dispIdx = ctx.funcMap.get(dispatcherName$1(propName));
+    if (dispIdx === void 0) continue;
+    const dispFn = mod.functions[dispIdx - ctx.numImportFuncs];
+    if (!dispFn) continue;
+    const candidates = findAlternateStructsForField(ctx, propName, -1);
+    const fallback = getIdx !== void 0 ? [
+      { op: "local.get", index: 0 },
+      // recv
+      ...stringConstantExternrefInstrs(ctx, propName),
+      { op: "call", funcIdx: getIdx }
+    ] : [{ op: "ref.null.extern" }];
+    const buildGetDispatch = (idx) => {
+      if (idx >= candidates.length) return fallback;
+      const cand = candidates[idx];
+      const box = coercionInstrs(ctx, cand.fieldType, { kind: "externref" });
+      const readInstrs = [
+        { op: "local.get", index: 1 },
+        // __any
+        { op: "ref.cast", typeIdx: cand.structTypeIdx },
+        { op: "struct.get", typeIdx: cand.structTypeIdx, fieldIdx: cand.fieldIdx },
+        ...box
+      ];
+      return [
+        { op: "local.get", index: 1 },
+        // __any
+        { op: "ref.test", typeIdx: cand.structTypeIdx },
+        {
+          op: "if",
+          blockType: { kind: "val", type: { kind: "externref" } },
+          then: readInstrs,
+          else: buildGetDispatch(idx + 1)
+        }
+      ];
+    };
+    dispFn.locals = [{ name: "__any", type: { kind: "anyref" } }];
+    dispFn.body = [
+      { op: "local.get", index: 0 },
+      // recv (externref)
+      { op: "any.convert_extern" },
+      { op: "local.set", index: 1 },
+      // __any
+      ...buildGetDispatch(0)
+    ];
+  }
+}
 const VEC_SEARCH_METHODS = /* @__PURE__ */ new Set(["indexOf", "lastIndexOf", "includes"]);
-function dispatcherName$2(methodName, arity) {
+function dispatcherName(methodName, arity) {
   return `__call_m_${methodName}_${arity}`;
 }
 function varargDispatcherName(methodName) {
   return `__call_m_${methodName}_vararg`;
 }
 function reserveClosedMethodDispatch(ctx, methodName, arity = 0) {
-  const name = dispatcherName$2(methodName, arity);
+  const name = dispatcherName(methodName, arity);
   const existing = ctx.funcMap.get(name);
   if (existing !== void 0) return existing;
   ensureObjVecBuilders(ctx);
@@ -51488,7 +51304,7 @@ function fillClosedMethodDispatch(ctx) {
     const slash = key.lastIndexOf("/");
     const methodName = slash >= 0 ? key.slice(0, slash) : key;
     const arity = slash >= 0 ? Number.parseInt(key.slice(slash + 1), 10) || 0 : 0;
-    const dispIdx = ctx.funcMap.get(dispatcherName$2(methodName, arity));
+    const dispIdx = ctx.funcMap.get(dispatcherName(methodName, arity));
     if (dispIdx === void 0) continue;
     const dispFn = mod.functions[dispIdx - ctx.numImportFuncs];
     if (!dispFn) continue;
@@ -51686,8 +51502,8 @@ function compileConsoleCall(ctx, fctx, expr, method) {
   }
   for (const arg of expr.arguments) {
     const argType = ctx.checker.getTypeAtLocation(arg);
-    compileExpression$1(ctx, fctx, arg);
     if (isStringType(argType)) {
+      compileExpression$1(ctx, fctx, arg);
       if (ctx.nativeStrings && ctx.nativeStrTypeIdx >= 0) {
         ensureNativeStringExternBridge(ctx);
         flushLateImportShifts(ctx, fctx);
@@ -51705,16 +51521,25 @@ function compileConsoleCall(ctx, fctx, expr, method) {
         fctx.body.push({ op: "call", funcIdx });
       }
     } else if (isBooleanType(argType)) {
+      compileExpression$1(ctx, fctx, arg, { kind: "i32" });
       const funcIdx = ctx.funcMap.get(`console_${method}_bool`);
       if (funcIdx !== void 0) {
         fctx.body.push({ op: "call", funcIdx });
       }
     } else if (isNumberType(argType)) {
+      compileExpression$1(ctx, fctx, arg, { kind: "f64" });
       const funcIdx = ctx.funcMap.get(`console_${method}_number`);
       if (funcIdx !== void 0) {
         fctx.body.push({ op: "call", funcIdx });
       }
     } else {
+      const res = compileExpression$1(ctx, fctx, arg);
+      if (res && typeof res === "object" && "kind" in res) {
+        const k = res.kind;
+        if (k === "f64" || k === "i32" || k === "i64") {
+          coerceType$2(ctx, fctx, res, { kind: "externref" });
+        }
+      }
       const funcIdx = ctx.funcMap.get(`console_${method}_externref`);
       if (funcIdx !== void 0) {
         fctx.body.push({ op: "call", funcIdx });
@@ -60965,7 +60790,8 @@ function compileObjectKeysOrValues(ctx, fctx, method, expr) {
     fctx.body.push({ op: "unreachable" });
     return { kind: "externref" };
   }
-  const structName = resolveStructName(ctx, argType);
+  const argIsHostObjectVar = ts.isIdentifier(arg) && ctx.externrefAccessorVars.has(arg.text);
+  const structName = argIsHostObjectVar ? void 0 : resolveStructName(ctx, argType);
   if (!structName) {
     const isAnyOrUnknown2 = (argType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
     const tsProps = argType.getProperties?.();
@@ -64756,13 +64582,14 @@ function compileVariableStatement(ctx, fctx, stmt) {
       }
       return false;
     });
-    if (initIsAccessorLiteral) {
+    const initIsHostSpreadLiteral = decl.initializer !== void 0 && ts.isObjectLiteralExpression(decl.initializer) && objectLiteralSpreadTakesHostPath(ctx, decl.initializer);
+    if (initIsAccessorLiteral || initIsHostSpreadLiteral) {
       ctx.externrefAccessorVars.add(name);
     }
     const standaloneRegExpMatchArrayType = inferStandaloneRegExpMatchArrayType$1(ctx, decl.initializer);
     const subarraySubviewType = inferSubarraySubviewType(ctx, fctx, decl.initializer);
     const initIsProxy = decl.initializer !== void 0 && isProxyConstruction(decl.initializer) && ts.isIdentifier(decl.name) && !proxyResultEscapesToCall(decl, decl.name.text);
-    const wasmType = initIsAccessorLiteral ? { kind: "externref" } : isI32CoercedLocal ? { kind: "i32" } : isI32SpecializedArray ? { kind: "ref_null", typeIdx: getOrRegisterVecType(ctx, "i32", { kind: "i32" }) } : widenedTypeIdx !== void 0 ? { kind: "ref_null", typeIdx: widenedTypeIdx } : subarraySubviewType ?? inferredVecType ?? standaloneRegExpMatchArrayType ?? (decl.initializer && isStringMethodReturningHostArray(ctx, decl.initializer) ? { kind: "externref" } : decl.initializer && isPromiseHostCall(ctx, decl.initializer) ? { kind: "externref" } : (
+    const wasmType = initIsAccessorLiteral || initIsHostSpreadLiteral ? { kind: "externref" } : isI32CoercedLocal ? { kind: "i32" } : isI32SpecializedArray ? { kind: "ref_null", typeIdx: getOrRegisterVecType(ctx, "i32", { kind: "i32" }) } : widenedTypeIdx !== void 0 ? { kind: "ref_null", typeIdx: widenedTypeIdx } : subarraySubviewType ?? inferredVecType ?? standaloneRegExpMatchArrayType ?? (decl.initializer && isStringMethodReturningHostArray(ctx, decl.initializer) ? { kind: "externref" } : decl.initializer && isPromiseHostCall(ctx, decl.initializer) ? { kind: "externref" } : (
       // (#2615) `new Proxy(target, handler)` returns a host/native
       // Proxy externref. The checker types it as the TARGET's
       // struct (ProxyConstructor returns T), so the default slot
@@ -78146,6 +77973,7 @@ function compileNewExpression(ctx, fctx, expr) {
   const type = ctx.checker.getTypeAtLocation(expr);
   const symbol = type.getSymbol();
   let className = symbol?.name;
+  let thisFnctorSym;
   if (className && !ctx.classSet.has(className)) {
     const mapped = ctx.classExprNameMap.get(className);
     if (mapped) {
@@ -78163,6 +77991,13 @@ function compileNewExpression(ctx, fctx, expr) {
       }
     }
   }
+  if ((!className || !ctx.classSet.has(className)) && expr.expression.kind === ts.SyntaxKind.ThisKeyword) {
+    const owner = resolveEnclosingFnctorOwner(ctx.checker, expr);
+    if (owner && ctx.fnctorEscapeGate?.approvedNames.has(owner.name)) {
+      className = owner.name;
+      thisFnctorSym = owner.sym;
+    }
+  }
   if (ctx.standalone && (isGlobalRegExpType(type) || ts.isIdentifier(expr.expression) && isGlobalRegExpIdentifier(ctx, expr.expression))) {
     return compileStandaloneRegExpConstructor(ctx, fctx, expr.arguments ?? [], expr);
   }
@@ -78186,7 +78021,7 @@ function compileNewExpression(ctx, fctx, expr) {
         return { kind: "ref", typeIdx: cachedFnCtor.structTypeIdx };
       }
     } else {
-      const decls = symbol?.getDeclarations();
+      const decls = (symbol ?? thisFnctorSym)?.getDeclarations();
       if (decls) {
         for (const decl of decls) {
           if (ts.isFunctionDeclaration(decl) && decl.body) {
@@ -81199,8 +81034,41 @@ function isGlobalEvalIdentifier(ident, checker) {
   if (!decls || decls.length === 0) return true;
   return decls.every((d) => d.getSourceFile().isDeclarationFile);
 }
+function ensureFuncValueWrappersRegistered(ctx, sf) {
+  const flag = ctx;
+  if (flag.__funcValueWrappersRegistered) return;
+  flag.__funcValueWrappersRegistered = true;
+  const usedAsValue = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (ts.isIdentifier(node)) {
+      const p = node.parent;
+      const isCallee = p && ts.isCallExpression(p) && p.expression === node;
+      const isNewCallee = p && ts.isNewExpression(p) && p.expression === node;
+      const isOwnName = p && (ts.isFunctionDeclaration(p) || ts.isFunctionExpression(p)) && p.name === node;
+      if (!isCallee && !isNewCallee && !isOwnName) {
+        const sym = ctx.checker.getSymbolAtLocation(node);
+        const decl = sym?.valueDeclaration;
+        if (decl && ts.isFunctionDeclaration(decl) && decl.name) {
+          usedAsValue.add(decl.name.text);
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+  for (const name of usedAsValue) {
+    const funcIdx = ctx.funcMap.get(name);
+    if (funcIdx === void 0) continue;
+    const caps = ctx.nestedFuncCaptures.get(name);
+    if (caps && caps.length > 0) continue;
+    const sig = getFuncSignature(ctx, funcIdx);
+    if (!sig) continue;
+    getOrCreateFuncRefWrapperTypes(ctx, sig.params, sig.results);
+  }
+}
 function tryEmitInlineDynamicCall(ctx, fctx, expr, isKnownVariable) {
   if (!isKnownVariable) return null;
+  ensureFuncValueWrappersRegistered(ctx, expr.getSourceFile());
   const arity = expr.arguments.length;
   const supported = (t) => {
     if (t === null) return true;
@@ -85183,7 +85051,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig);
             if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
             if (wasmFuncReturnsVoid(ctx, finalStaticIdx)) return VOID_RESULT;
-            return getWasmFuncReturnType(ctx, finalStaticIdx) ?? resolveWasmType(ctx, retType);
+            return brandExternMethodResult(
+              ctx,
+              retType,
+              getWasmFuncReturnType(ctx, finalStaticIdx) ?? resolveWasmType(ctx, retType)
+            );
           }
           return VOID_RESULT;
         }
@@ -85665,7 +85537,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig2);
             if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
             if (wasmFuncReturnsVoid(ctx, finalMethodIdx2)) return VOID_RESULT;
-            return getWasmFuncReturnType(ctx, finalMethodIdx2) ?? resolveWasmType(ctx, retType);
+            return brandExternMethodResult(
+              ctx,
+              retType,
+              getWasmFuncReturnType(ctx, finalMethodIdx2) ?? resolveWasmType(ctx, retType)
+            );
           }
           return VOID_RESULT;
         }
@@ -85699,7 +85575,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
           if (sig2) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig2);
             if (!isEffectivelyVoidReturn(ctx, retType, fullName))
-              callReturnType = getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType);
+              callReturnType = brandExternMethodResult(
+                ctx,
+                retType,
+                getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType)
+              );
           }
           const tmp = allocLocal(fctx, `__ng_recv_${fctx.locals.length}`, recvType);
           fctx.body.push({ op: "local.tee", index: tmp });
@@ -85791,7 +85671,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
           const retType = ctx.checker.getReturnTypeOfSignature(sig);
           if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
           if (wasmFuncReturnsVoid(ctx, finalMethodIdx)) return VOID_RESULT;
-          return getWasmFuncReturnType(ctx, finalMethodIdx) ?? resolveWasmType(ctx, retType);
+          return brandExternMethodResult(
+            ctx,
+            retType,
+            getWasmFuncReturnType(ctx, finalMethodIdx) ?? resolveWasmType(ctx, retType)
+          );
         }
         return VOID_RESULT;
       }
@@ -85816,7 +85700,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             if (sig2) {
               const retType = ctx.checker.getReturnTypeOfSignature(sig2);
               if (!isEffectivelyVoidReturn(ctx, retType, fullName))
-                callReturnType = getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType);
+                callReturnType = brandExternMethodResult(
+                  ctx,
+                  retType,
+                  getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType)
+                );
             }
             const tmp = allocLocal(fctx, `__ng_srecv_${fctx.locals.length}`, recvType);
             fctx.body.push({ op: "local.tee", index: tmp });
@@ -85911,7 +85799,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig);
             if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
             if (wasmFuncReturnsVoid(ctx, finalStructMethodIdx)) return VOID_RESULT;
-            return getWasmFuncReturnType(ctx, finalStructMethodIdx) ?? resolveWasmType(ctx, retType);
+            return brandExternMethodResult(
+              ctx,
+              retType,
+              getWasmFuncReturnType(ctx, finalStructMethodIdx) ?? resolveWasmType(ctx, retType)
+            );
           }
           return VOID_RESULT;
         }
@@ -86708,6 +86600,89 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
           fctx.body.push({ op: "call", funcIdx: dispatchResolvedIdx });
           return { kind: "externref" };
         }
+        if (!ctx.standalone && (methodName === "push" || methodName === "pop") && ctx.vecTypeMap.size > 0) {
+          const mcIdx = ensureLateImport(
+            ctx,
+            "__extern_method_call",
+            [{ kind: "externref" }, { kind: "externref" }, { kind: "externref" }],
+            [{ kind: "externref" }]
+          );
+          const arrNewIdx = ensureLateImport(ctx, "__js_array_new", [], [{ kind: "externref" }]);
+          const arrPushIdx = ensureLateImport(
+            ctx,
+            "__js_array_push",
+            [{ kind: "externref" }, { kind: "externref" }],
+            []
+          );
+          const boxNumIdx = methodName === "push" ? ensureLateImport(ctx, "__box_number", [{ kind: "f64" }], [{ kind: "externref" }]) : void 0;
+          addStringConstantGlobal(ctx, methodName);
+          flushLateImportShifts(ctx, fctx);
+          const vecOpIdx = reserveVecMethodHelper(ctx, methodName === "push" ? "push" : "pop");
+          if (vecOpIdx !== void 0 && mcIdx !== void 0 && arrNewIdx !== void 0 && arrPushIdx !== void 0 && (methodName === "pop" || boxNumIdx !== void 0)) {
+            const recvT = compileExpression$1(ctx, fctx, propAccess.expression, { kind: "externref" });
+            if (recvT && recvT.kind !== "externref") coerceType$2(ctx, fctx, recvT, { kind: "externref" });
+            else if (!recvT) fctx.body.push({ op: "ref.null.extern" });
+            const recvLocal = allocLocal(fctx, `__nvm_recv_${fctx.locals.length}`, { kind: "externref" });
+            fctx.body.push({ op: "local.set", index: recvLocal });
+            let argLocal;
+            if (methodName === "push") {
+              const a = expr.arguments[0];
+              if (a) {
+                const at = compileExpression$1(ctx, fctx, a, { kind: "externref" });
+                if (at && at.kind !== "externref") coerceType$2(ctx, fctx, at, { kind: "externref" });
+                else if (!at) fctx.body.push({ op: "ref.null.extern" });
+              } else {
+                fctx.body.push({ op: "ref.null.extern" });
+              }
+              argLocal = allocLocal(fctx, `__nvm_arg_${fctx.locals.length}`, { kind: "externref" });
+              fctx.body.push({ op: "local.set", index: argLocal });
+            }
+            const anyTmp = allocLocal(fctx, `__nvm_any_${fctx.locals.length}`, { kind: "anyref" });
+            fctx.body.push({ op: "local.get", index: recvLocal });
+            fctx.body.push({ op: "any.convert_extern" });
+            fctx.body.push({ op: "local.set", index: anyTmp });
+            let emitted = false;
+            for (const vi of new Set(ctx.vecTypeMap.values())) {
+              fctx.body.push({ op: "local.get", index: anyTmp });
+              fctx.body.push({ op: "ref.test", typeIdx: vi });
+              if (emitted) fctx.body.push({ op: "i32.or" });
+              emitted = true;
+            }
+            const thenStart = fctx.body.length;
+            if (methodName === "push") {
+              fctx.body.push({ op: "local.get", index: recvLocal });
+              fctx.body.push({ op: "local.get", index: argLocal });
+              fctx.body.push({ op: "call", funcIdx: vecOpIdx });
+              fctx.body.push({ op: "f64.convert_i32_s" });
+              fctx.body.push({ op: "call", funcIdx: boxNumIdx });
+            } else {
+              fctx.body.push({ op: "local.get", index: recvLocal });
+              fctx.body.push({ op: "call", funcIdx: vecOpIdx });
+            }
+            const thenInstrs = fctx.body.splice(thenStart);
+            const elseStart = fctx.body.length;
+            fctx.body.push({ op: "call", funcIdx: arrNewIdx });
+            const argsLocal = allocLocal(fctx, `__nvm_args_${fctx.locals.length}`, { kind: "externref" });
+            fctx.body.push({ op: "local.set", index: argsLocal });
+            if (methodName === "push") {
+              fctx.body.push({ op: "local.get", index: argsLocal });
+              fctx.body.push({ op: "local.get", index: argLocal });
+              fctx.body.push({ op: "call", funcIdx: arrPushIdx });
+            }
+            fctx.body.push({ op: "local.get", index: recvLocal });
+            fctx.body.push(...stringConstantExternrefInstrs(ctx, methodName));
+            fctx.body.push({ op: "local.get", index: argsLocal });
+            fctx.body.push({ op: "call", funcIdx: mcIdx });
+            const elseInstrs = fctx.body.splice(elseStart);
+            fctx.body.push({
+              op: "if",
+              blockType: { kind: "val", type: { kind: "externref" } },
+              then: thenInstrs,
+              else: elseInstrs
+            });
+            return { kind: "externref" };
+          }
+        }
         {
           let arrNewIdx;
           let arrPushIdx;
@@ -87842,7 +87817,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
       const retType = ctx.checker.getReturnTypeOfSignature(sig);
       if (isEffectivelyVoidReturn(ctx, retType, funcName)) return VOID_RESULT;
       if (wasmFuncReturnsVoid(ctx, finalFuncIdx)) return VOID_RESULT;
-      return getWasmFuncReturnType(ctx, finalFuncIdx) ?? resolveWasmType(ctx, retType);
+      return brandExternMethodResult(
+        ctx,
+        retType,
+        getWasmFuncReturnType(ctx, finalFuncIdx) ?? resolveWasmType(ctx, retType)
+      );
     }
     return getWasmFuncReturnType(ctx, finalFuncIdx) ?? { kind: "f64" };
   }
@@ -88291,7 +88270,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig);
             if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
             if (wasmFuncReturnsVoid(ctx, funcIdx)) return VOID_RESULT;
-            return getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType);
+            return brandExternMethodResult(
+              ctx,
+              retType,
+              getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType)
+            );
           }
           return VOID_RESULT;
         }
@@ -88309,7 +88292,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             if (sig2) {
               const retType = ctx.checker.getReturnTypeOfSignature(sig2);
               if (!isEffectivelyVoidReturn(ctx, retType, fullName))
-                callReturnType = getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType);
+                callReturnType = brandExternMethodResult(
+                  ctx,
+                  retType,
+                  getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType)
+                );
             }
             const tmp = allocLocal(fctx, `__ng_ea_recv_${fctx.locals.length}`, recvType);
             fctx.body.push({ op: "local.tee", index: tmp });
@@ -88382,7 +88369,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig);
             if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
             if (wasmFuncReturnsVoid(ctx, funcIdx)) return VOID_RESULT;
-            return getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType);
+            return brandExternMethodResult(
+              ctx,
+              retType,
+              getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType)
+            );
           }
           return VOID_RESULT;
         }
@@ -88416,7 +88407,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
               const retType = ctx.checker.getReturnTypeOfSignature(sig);
               if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
               if (wasmFuncReturnsVoid(ctx, funcIdx)) return VOID_RESULT;
-              return getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType);
+              return brandExternMethodResult(
+                ctx,
+                retType,
+                getWasmFuncReturnType(ctx, funcIdx) ?? resolveWasmType(ctx, retType)
+              );
             }
             return VOID_RESULT;
           }
@@ -88646,7 +88641,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
             const retType = ctx.checker.getReturnTypeOfSignature(sig);
             if (isEffectivelyVoidReturn(ctx, retType, funcName)) return VOID_RESULT;
             if (wasmFuncReturnsVoid(ctx, finalFuncIdx)) return VOID_RESULT;
-            return getWasmFuncReturnType(ctx, finalFuncIdx) ?? resolveWasmType(ctx, retType);
+            return brandExternMethodResult(
+              ctx,
+              retType,
+              getWasmFuncReturnType(ctx, finalFuncIdx) ?? resolveWasmType(ctx, retType)
+            );
           }
           return getWasmFuncReturnType(ctx, finalFuncIdx) ?? { kind: "f64" };
         }
@@ -88693,7 +88692,11 @@ function compileCallExpression(ctx, fctx, expr, expectedType) {
               const retType = ctx.checker.getReturnTypeOfSignature(sig);
               if (isEffectivelyVoidReturn(ctx, retType, fullName)) return VOID_RESULT;
               if (wasmFuncReturnsVoid(ctx, finalCallIdx)) return VOID_RESULT;
-              return getWasmFuncReturnType(ctx, finalCallIdx) ?? resolveWasmType(ctx, retType);
+              return brandExternMethodResult(
+                ctx,
+                retType,
+                getWasmFuncReturnType(ctx, finalCallIdx) ?? resolveWasmType(ctx, retType)
+              );
             }
             return VOID_RESULT;
           }
@@ -89043,7 +89046,11 @@ function compileConditionalCallee(ctx, fctx, expr, condExpr) {
           const retType = ctx.checker.getReturnTypeOfSignature(branchSigs[0]);
           if (isEffectivelyVoidReturn(ctx, retType, funcName)) return VOID_RESULT;
           if (wasmFuncReturnsVoid(ctx, finalFuncIdx)) return VOID_RESULT;
-          return getWasmFuncReturnType(ctx, finalFuncIdx) ?? resolveWasmType(ctx, retType);
+          return brandExternMethodResult(
+            ctx,
+            retType,
+            getWasmFuncReturnType(ctx, finalFuncIdx) ?? resolveWasmType(ctx, retType)
+          );
         }
         return callRetType ?? getWasmFuncReturnType(ctx, finalFuncIdx) ?? { kind: "f64" };
       }
@@ -91197,6 +91204,50 @@ function emitExternrefBackedOwnFieldWrite(ctx, fctx, target, value, fieldName) {
   fctx.body.push({ op: "local.get", index: tmpBoxed });
   return { kind: "externref" };
 }
+function tryEmitPinnedStructMemberSet(ctx, fctx, target, value) {
+  if (ts.isPrivateIdentifier(target.name)) return void 0;
+  const propName = target.name.text;
+  if (propName === "length" || propName === "constructor" || propName === "__proto__" || propName === "prototype" || propName === "name") {
+    return void 0;
+  }
+  const accessType = ctx.checker.getTypeAtLocation(target);
+  if (accessType.getCallSignatures && accessType.getCallSignatures().length > 0) return void 0;
+  if (reserveMemberSetDispatch(
+    ctx,
+    propName,
+    /*strict*/
+    true,
+    fctx
+  ) === void 0) return void 0;
+  const objResult = compileExpression$1(ctx, fctx, target.expression);
+  if (objResult && objResult.kind !== "externref") {
+    coerceType$2(ctx, fctx, objResult, { kind: "externref" });
+  } else if (!objResult) {
+    fctx.body.push({ op: "ref.null.extern" });
+  }
+  const objLocal = allocLocal(fctx, `__pset_obj_${fctx.locals.length}`, { kind: "externref" });
+  fctx.body.push({ op: "local.set", index: objLocal });
+  const valResult = compileExpression$1(ctx, fctx, value);
+  if (valResult && valResult.kind !== "externref") {
+    coerceType$2(ctx, fctx, valResult, { kind: "externref" });
+  } else if (!valResult) {
+    fctx.body.push({ op: "ref.null.extern" });
+  }
+  const valLocal = allocLocal(fctx, `__pset_val_${fctx.locals.length}`, { kind: "externref" });
+  fctx.body.push({ op: "local.set", index: valLocal });
+  const dispatched = emitAlternateStructSetDispatch(
+    ctx,
+    fctx,
+    objLocal,
+    valLocal,
+    propName,
+    /*strict*/
+    true
+  );
+  if (!dispatched) return void 0;
+  fctx.body.push({ op: "local.get", index: valLocal });
+  return { kind: "externref" };
+}
 function compilePropertyAssignment(ctx, fctx, target, value) {
   const objType = ctx.checker.getTypeAtLocation(target.expression);
   {
@@ -91377,6 +91428,14 @@ function compilePropertyAssignment(ctx, fctx, target, value) {
       return ctx.fast ? { kind: "i32" } : { kind: "f64" };
     }
   }
+  {
+    const pinnedThis = target.expression.kind === ts.SyntaxKind.ThisKeyword && fctx.thisStructName !== void 0 ? fctx.thisStructName : void 0;
+    const pinned = pinnedThis ?? resolveReceiverStruct(ctx, fctx, target.expression);
+    if (pinned !== void 0) {
+      const pinnedSet = tryEmitPinnedStructMemberSet(ctx, fctx, target, value);
+      if (pinnedSet !== void 0) return pinnedSet;
+    }
+  }
   {
     const dynPropName = ts.isPrivateIdentifier(target.name) ? "__priv_" + target.name.text.slice(1) : target.name.text;
     const dynSet = tryEmitDeleteAwareDynamicSet(ctx, fctx, target, value, objType, dynPropName);
@@ -93555,17 +93614,23 @@ function compilePropertyCompoundAssignmentExternref(ctx, fctx, target, rhs, op,
     kind: "externref"
   });
   fctx.body.push({ op: "local.set", index: keyLocal });
+  const pinnedCompound = target.expression.kind === ts.SyntaxKind.ThisKeyword && fctx.thisStructName !== void 0 || resolveReceiverStruct(ctx, fctx, target.expression) !== void 0;
   fctx.body.push({ op: "local.get", index: objLocal });
-  fctx.body.push({ op: "local.get", index: keyLocal });
-  const getIdx = ensureLateImport(
-    ctx,
-    "__extern_get",
-    [{ kind: "externref" }, { kind: "externref" }],
-    [{ kind: "externref" }]
-  );
-  flushLateImportShifts(ctx, fctx);
-  if (getIdx === void 0) return null;
-  fctx.body.push({ op: "call", funcIdx: getIdx });
+  const getDispIdx = pinnedCompound ? reserveMemberGetDispatch(ctx, propName, fctx) : void 0;
+  if (getDispIdx !== void 0) {
+    fctx.body.push({ op: "call", funcIdx: getDispIdx });
+  } else {
+    fctx.body.push({ op: "local.get", index: keyLocal });
+    const getIdx = ensureLateImport(
+      ctx,
+      "__extern_get",
+      [{ kind: "externref" }, { kind: "externref" }],
+      [{ kind: "externref" }]
+    );
+    flushLateImportShifts(ctx, fctx);
+    if (getIdx === void 0) return null;
+    fctx.body.push({ op: "call", funcIdx: getIdx });
+  }
   addUnionImports(ctx);
   const unboxIdx = ctx.funcMap.get("__unbox_number");
   if (unboxIdx === void 0) {
@@ -93598,7 +93663,7 @@ function compilePropertyCompoundAssignmentExternref(ctx, fctx, target, rhs, op,
     []
   );
   flushLateImportShifts(ctx, fctx);
-  const cmpdDispatched = emitAlternateStructSetDispatch(
+  const cmpdDispatched = pinnedCompound && emitAlternateStructSetDispatch(
     ctx,
     fctx,
     objLocal,
@@ -98664,18 +98729,7 @@ function compileStringBinaryOp(ctx, fctx, expr, op) {
       }
     }
   } else if (op === ts.SyntaxKind.PlusToken && leftType && (leftType.kind === "ref" || leftType.kind === "ref_null")) {
-    coerceType$1(ctx, fctx, leftType, { kind: "externref" });
-    const toStrIdx = ensureLateImport$1(
-      ctx,
-      "__extern_to_string_default",
-      [{ kind: "externref" }],
-      [{ kind: "externref" }]
-    );
-    flushLateImportShifts$1(ctx, fctx);
-    const finalIdx = ctx.funcMap.get("__extern_to_string_default") ?? toStrIdx;
-    if (finalIdx !== void 0) {
-      fctx.body.push({ op: "call", funcIdx: finalIdx });
-    }
+    emitToString(ctx, fctx, leftType, leftTsType, "default");
   }
   const isEqOrNeq = op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken;
   const isLeftStringWrapper = (leftTsType.flags & ts.TypeFlags.Object) !== 0 && leftTsType.getSymbol()?.name === "String";
@@ -98721,18 +98775,7 @@ function compileStringBinaryOp(ctx, fctx, expr, op) {
       }
     }
   } else if (op === ts.SyntaxKind.PlusToken && rightType && (rightType.kind === "ref" || rightType.kind === "ref_null")) {
-    coerceType$1(ctx, fctx, rightType, { kind: "externref" });
-    const toStrIdx = ensureLateImport$1(
-      ctx,
-      "__extern_to_string_default",
-      [{ kind: "externref" }],
-      [{ kind: "externref" }]
-    );
-    flushLateImportShifts$1(ctx, fctx);
-    const finalIdx = ctx.funcMap.get("__extern_to_string_default") ?? toStrIdx;
-    if (finalIdx !== void 0) {
-      fctx.body.push({ op: "call", funcIdx: finalIdx });
-    }
+    emitToString(ctx, fctx, rightType, rightTsType, "default");
   }
   const isRightStringWrapper = (rightTsType.flags & ts.TypeFlags.Object) !== 0 && rightTsType.getSymbol()?.name === "String";
   if (isEqOrNeq && isRightStringWrapper && rightType?.kind === "externref") {
@@ -100276,174 +100319,6 @@ function emitSymbolToString(ctx, fctx) {
   compileNativeStringLiteral(ctx, fctx, ")");
   fctx.body.push({ op: "call", funcIdx: concatIdx });
 }
-function dispatcherName$1(propName, strict) {
-  return strict ? `__set_member_${propName}` : `__set_member_nonstrict_${propName}`;
-}
-function reserveMemberSetDispatch(ctx, propName, strict) {
-  const name = dispatcherName$1(propName, strict);
-  const existing = ctx.funcMap.get(name);
-  if (existing !== void 0) return existing;
-  const fallbackName = strict ? "__extern_set_strict" : "__extern_set";
-  const setIdx = ensureLateImport$1(
-    ctx,
-    fallbackName,
-    [{ kind: "externref" }, { kind: "externref" }, { kind: "externref" }],
-    []
-  );
-  if (setIdx === void 0) return void 0;
-  addStringConstantGlobal(ctx, propName);
-  addUnionImportsViaRegistry(ctx);
-  const typeIdx = addFuncType(ctx, [{ kind: "externref" }, { kind: "externref" }], [], "$member_set_dispatch_type");
-  const funcIdx = ctx.numImportFuncs + ctx.mod.functions.length;
-  ctx.mod.functions.push({
-    name,
-    typeIdx,
-    locals: [],
-    // Placeholder; filled by fillMemberSetDispatch. `unreachable` keeps the stub
-    // valid (no results) if the fill is ever skipped (it never is — the fill
-    // iterates the same name set this reserve populates).
-    body: [{ op: "unreachable" }],
-    exported: false
-  });
-  ctx.funcMap.set(name, funcIdx);
-  (ctx.memberSetDispatchNames ??= /* @__PURE__ */ new Set()).add(`${propName}\0${strict ? "S" : "N"}`);
-  return funcIdx;
-}
-function fillMemberSetDispatch(ctx) {
-  const mod = ctx.mod;
-  for (const key of ctx.memberSetDispatchNames ?? []) {
-    const sep = key.lastIndexOf("\0");
-    const propName = sep >= 0 ? key.slice(0, sep) : key;
-    const strict = sep >= 0 ? key.slice(sep + 1) === "S" : true;
-    const dispIdx = ctx.funcMap.get(dispatcherName$1(propName, strict));
-    if (dispIdx === void 0) continue;
-    const dispFn = mod.functions[dispIdx - ctx.numImportFuncs];
-    if (!dispFn) continue;
-    const candidates = findAlternateStructsForField(ctx, propName, -1).filter((c) => c.mutable);
-    const fallbackIdx = ctx.funcMap.get(strict ? "__extern_set_strict" : "__extern_set");
-    const fallback = fallbackIdx !== void 0 ? [
-      { op: "local.get", index: 0 },
-      // recv
-      ...stringConstantExternrefInstrs(ctx, propName),
-      { op: "local.get", index: 1 },
-      // val
-      { op: "call", funcIdx: fallbackIdx }
-    ] : [];
-    const buildSetDispatch = (idx) => {
-      if (idx >= candidates.length) return fallback;
-      const cand = candidates[idx];
-      const coerce = coercionInstrs(ctx, { kind: "externref" }, cand.fieldType);
-      const setFieldInstrs = [
-        { op: "local.get", index: 2 },
-        // __any
-        { op: "ref.cast", typeIdx: cand.structTypeIdx },
-        { op: "local.get", index: 1 },
-        // val (externref)
-        ...coerce,
-        { op: "struct.set", typeIdx: cand.structTypeIdx, fieldIdx: cand.fieldIdx }
-      ];
-      return [
-        { op: "local.get", index: 2 },
-        // __any
-        { op: "ref.test", typeIdx: cand.structTypeIdx },
-        {
-          op: "if",
-          blockType: { kind: "empty" },
-          then: setFieldInstrs,
-          else: buildSetDispatch(idx + 1)
-        }
-      ];
-    };
-    dispFn.locals = [{ name: "__any", type: { kind: "anyref" } }];
-    dispFn.body = [
-      { op: "local.get", index: 0 },
-      // recv (externref)
-      { op: "any.convert_extern" },
-      { op: "local.set", index: 2 },
-      // __any
-      ...buildSetDispatch(0)
-    ];
-  }
-}
-function dispatcherName(propName) {
-  return `__get_member_${propName}`;
-}
-function reserveMemberGetDispatch(ctx, propName, fctx) {
-  const name = dispatcherName(propName);
-  const existing = ctx.funcMap.get(name);
-  if (existing !== void 0) return existing;
-  const getIdx = ensureLateImport$1(
-    ctx,
-    "__extern_get",
-    [{ kind: "externref" }, { kind: "externref" }],
-    [{ kind: "externref" }]
-  );
-  if (getIdx === void 0) return void 0;
-  addStringConstantGlobal(ctx, propName);
-  addUnionImportsViaRegistry(ctx);
-  const typeIdx = addFuncType(ctx, [{ kind: "externref" }], [{ kind: "externref" }], "$member_get_dispatch_type");
-  const funcIdx = ctx.numImportFuncs + ctx.mod.functions.length;
-  ctx.mod.functions.push({
-    name,
-    typeIdx,
-    locals: [],
-    body: [{ op: "unreachable" }],
-    exported: false
-  });
-  ctx.funcMap.set(name, funcIdx);
-  (ctx.memberGetDispatchNames ??= /* @__PURE__ */ new Set()).add(propName);
-  if (fctx) flushLateImportShifts$1(ctx, fctx);
-  return funcIdx;
-}
-function fillMemberGetDispatch(ctx) {
-  const mod = ctx.mod;
-  const getIdx = ctx.funcMap.get("__extern_get");
-  for (const propName of ctx.memberGetDispatchNames ?? []) {
-    const dispIdx = ctx.funcMap.get(dispatcherName(propName));
-    if (dispIdx === void 0) continue;
-    const dispFn = mod.functions[dispIdx - ctx.numImportFuncs];
-    if (!dispFn) continue;
-    const candidates = findAlternateStructsForField(ctx, propName, -1);
-    const fallback = getIdx !== void 0 ? [
-      { op: "local.get", index: 0 },
-      // recv
-      ...stringConstantExternrefInstrs(ctx, propName),
-      { op: "call", funcIdx: getIdx }
-    ] : [{ op: "ref.null.extern" }];
-    const buildGetDispatch = (idx) => {
-      if (idx >= candidates.length) return fallback;
-      const cand = candidates[idx];
-      const box = coercionInstrs(ctx, cand.fieldType, { kind: "externref" });
-      const readInstrs = [
-        { op: "local.get", index: 1 },
-        // __any
-        { op: "ref.cast", typeIdx: cand.structTypeIdx },
-        { op: "struct.get", typeIdx: cand.structTypeIdx, fieldIdx: cand.fieldIdx },
-        ...box
-      ];
-      return [
-        { op: "local.get", index: 1 },
-        // __any
-        { op: "ref.test", typeIdx: cand.structTypeIdx },
-        {
-          op: "if",
-          blockType: { kind: "val", type: { kind: "externref" } },
-          then: readInstrs,
-          else: buildGetDispatch(idx + 1)
-        }
-      ];
-    };
-    dispFn.locals = [{ name: "__any", type: { kind: "anyref" } }];
-    dispFn.body = [
-      { op: "local.get", index: 0 },
-      // recv (externref)
-      { op: "any.convert_extern" },
-      { op: "local.set", index: 1 },
-      // __any
-      ...buildGetDispatch(0)
-    ];
-  }
-}
 const BUILTIN_CTOR_NAMES = /* @__PURE__ */ new Set([
   "Object",
   "Array",
@@ -101136,7 +101011,7 @@ function emitNullCheckThrow(ctx, fctx, refType, node) {
   releaseTempLocal(fctx, tmp);
 }
 function emitAlternateStructSetDispatch(ctx, fctx, recvExtLocal, valExtLocal, propName, strict) {
-  const dispIdx = reserveMemberSetDispatch(ctx, propName, strict);
+  const dispIdx = reserveMemberSetDispatch(ctx, propName, strict, fctx);
   if (dispIdx === void 0) return false;
   fctx.body.push({ op: "local.get", index: recvExtLocal });
   fctx.body.push({ op: "local.get", index: valExtLocal });
@@ -101624,6 +101499,40 @@ function emitGuardedNativeStringLength(ctx, fctx, buildElseInstrs) {
     else: buildElseInstrs(recvExtern)
   });
 }
+function tryEmitPinnedStructMemberGet(ctx, fctx, expr, propName) {
+  if (propName === "length" || propName === "constructor" || propName === "__proto__" || propName === "prototype" || propName === "name") {
+    return void 0;
+  }
+  const accessType = ctx.checker.getTypeAtLocation(expr);
+  if (accessType.getCallSignatures && accessType.getCallSignatures().length > 0) return void 0;
+  const objResult = compileExpression$1(ctx, fctx, expr.expression);
+  if (objResult && objResult.kind !== "externref") {
+    coerceType$2(ctx, fctx, objResult, { kind: "externref" });
+  } else if (!objResult) {
+    fctx.body.push({ op: "ref.null.extern" });
+  }
+  const getDispIdx = reserveMemberGetDispatch(ctx, propName, fctx);
+  if (getDispIdx === void 0) {
+    const getIdx = ensureLateImport$1(
+      ctx,
+      "__extern_get",
+      [{ kind: "externref" }, { kind: "externref" }],
+      [{ kind: "externref" }]
+    );
+    flushLateImportShifts$1(ctx, fctx);
+    if (getIdx === void 0) {
+      fctx.body.push({ op: "drop" });
+      fctx.body.push({ op: "ref.null.extern" });
+      return { kind: "externref" };
+    }
+    addStringConstantGlobal(ctx, propName);
+    fctx.body.push(...stringConstantExternrefInstrs(ctx, propName));
+    fctx.body.push({ op: "call", funcIdx: getIdx });
+    return { kind: "externref" };
+  }
+  fctx.body.push({ op: "call", funcIdx: getDispIdx });
+  return { kind: "externref" };
+}
 function tryEmitDeleteAwareDynamicGet(ctx, fctx, expr, objType, propName) {
   if (!ctx.moduleUsesDelete || ctx.standalone) return void 0;
   const isAnyOrUnknown2 = (objType.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
@@ -101639,17 +101548,35 @@ function tryEmitDeleteAwareDynamicGet(ctx, fctx, expr, objType, propName) {
     [{ kind: "externref" }, { kind: "externref" }],
     [{ kind: "externref" }]
   );
-  flushLateImportShifts$1(ctx, fctx);
   if (getIdx === void 0) return void 0;
+  const getMemberIdx = ctx.wasi ? void 0 : reserveMemberGetDispatch(ctx, propName, fctx);
+  addStringConstantGlobal(ctx, propName);
+  flushLateImportShifts$1(ctx, fctx);
   const objResult = compileExpression$1(ctx, fctx, expr.expression);
   if (objResult && objResult.kind !== "externref") {
     coerceType$2(ctx, fctx, objResult, { kind: "externref" });
   } else if (!objResult) {
     fctx.body.push({ op: "ref.null.extern" });
   }
-  addStringConstantGlobal(ctx, propName);
-  fctx.body.push(...stringConstantExternrefInstrs(ctx, propName));
-  fctx.body.push({ op: "call", funcIdx: getIdx });
+  if (getMemberIdx === void 0) {
+    fctx.body.push(...stringConstantExternrefInstrs(ctx, propName));
+    fctx.body.push({ op: "call", funcIdx: getIdx });
+    return { kind: "externref" };
+  }
+  const flagGet = recordInModuleInitFlagRead(ctx);
+  const recvLocal = allocLocal(fctx, `__dadg_recv_${fctx.locals.length}`, { kind: "externref" });
+  fctx.body.push({ op: "local.set", index: recvLocal });
+  fctx.body.push(flagGet);
+  fctx.body.push({
+    op: "if",
+    blockType: { kind: "val", type: { kind: "externref" } },
+    then: [{ op: "local.get", index: recvLocal }, { op: "call", funcIdx: getMemberIdx }],
+    else: [
+      { op: "local.get", index: recvLocal },
+      ...stringConstantExternrefInstrs(ctx, propName),
+      { op: "call", funcIdx: getIdx }
+    ]
+  });
   return { kind: "externref" };
 }
 function tryEmitDeleteAwareDynamicSet(ctx, fctx, target, value, objType, propName) {
@@ -101809,6 +101736,14 @@ function compilePropertyAccess(ctx, fctx, expr) {
     const fnctorProto = tryEmitFnctorPrototypeRead(ctx, fctx, expr, propName);
     if (fnctorProto !== void 0) return fnctorProto;
   }
+  {
+    const pinnedThis = expr.expression.kind === ts.SyntaxKind.ThisKeyword && fctx.thisStructName !== void 0 ? fctx.thisStructName : void 0;
+    const pinned = pinnedThis ?? resolveReceiverStruct(ctx, fctx, expr.expression);
+    if (pinned !== void 0) {
+      const routed = tryEmitPinnedStructMemberGet(ctx, fctx, expr, propName);
+      if (routed !== void 0) return routed;
+    }
+  }
   {
     const dyn = tryEmitDeleteAwareDynamicGet(ctx, fctx, expr, objType, propName);
     if (dyn !== void 0) return dyn;
@@ -103577,6 +103512,9 @@ function f1ElementBoxType(ctx, expr, elementType) {
   if (valueParts.every((p) => (p.flags & ts.TypeFlags.BooleanLike) !== 0)) {
     return { kind: "i32", boolean: true };
   }
+  if (!noJsHost(ctx) && valueParts.every((p) => (p.flags & (ts.TypeFlags.ESSymbol | ts.TypeFlags.UniqueESSymbol)) !== 0)) {
+    return { kind: "i32", symbol: true };
+  }
   return null;
 }
 function emitPlainArrayUndefinedOobGet(ctx, fctx, arrTypeIdx, elementType, boxType = elementType) {
@@ -103608,6 +103546,41 @@ function emitPlainArrayUndefinedOobGet(ctx, fctx, arrTypeIdx, elementType, boxTy
     else: [{ op: "local.get", index: undefLocal }]
   });
 }
+function emitTypedArrayUndefinedOobGet(ctx, fctx, arrTypeIdx, elementType, signedness) {
+  const idxLocal = allocLocal(fctx, `__taoob_idx_${fctx.locals.length}`, { kind: "i32" });
+  const arrLocal = allocLocal(fctx, `__taoob_arr_${fctx.locals.length}`, { kind: "ref", typeIdx: arrTypeIdx });
+  fctx.body.push({ op: "local.set", index: idxLocal });
+  fctx.body.push({ op: "local.set", index: arrLocal });
+  const inBoundsLocal = allocLocal(fctx, `__taoob_in_${fctx.locals.length}`, { kind: "i32" });
+  fctx.body.push({ op: "local.get", index: idxLocal });
+  fctx.body.push({ op: "local.get", index: arrLocal });
+  fctx.body.push({ op: "array.len" });
+  fctx.body.push({ op: "i32.lt_u" });
+  fctx.body.push({ op: "local.set", index: inBoundsLocal });
+  fctx.body.push({ op: "local.get", index: arrLocal });
+  fctx.body.push({ op: "local.get", index: idxLocal });
+  emitBoundsCheckedArrayGet(fctx, arrTypeIdx, elementType, ctx, false, signedness);
+  if (elementType.kind === "i8" || elementType.kind === "i16") {
+    fctx.body.push({ op: "f64.convert_i32_s" });
+  } else if (elementType.kind === "i32") {
+    fctx.body.push({ op: signedness === "u" ? "f64.convert_i32_u" : "f64.convert_i32_s" });
+  } else if (elementType.kind === "f32") {
+    fctx.body.push({ op: "f64.promote_f32" });
+  }
+  coerceType$2(ctx, fctx, { kind: "f64" }, { kind: "externref" });
+  const boxedLocal = allocLocal(fctx, `__taoob_box_${fctx.locals.length}`, { kind: "externref" });
+  fctx.body.push({ op: "local.set", index: boxedLocal });
+  emitUndefined(ctx, fctx);
+  const undefLocal = allocLocal(fctx, `__taoob_undef_${fctx.locals.length}`, { kind: "externref" });
+  fctx.body.push({ op: "local.set", index: undefLocal });
+  fctx.body.push({ op: "local.get", index: inBoundsLocal });
+  fctx.body.push({
+    op: "if",
+    blockType: { kind: "val", type: { kind: "externref" } },
+    then: [{ op: "local.get", index: boxedLocal }],
+    else: [{ op: "local.get", index: undefLocal }]
+  });
+}
 function emitThisReceiverGuardConvert(ctx, fctx, targetTypeIdxs, resultType, thenEmit, elseEmit) {
   const externrefTmp = allocTempLocal(fctx, { kind: "externref" });
   fctx.body.push({ op: "local.tee", index: externrefTmp });
@@ -103910,6 +103883,55 @@ function isNumericIndexExpression(ctx, index) {
 }
 function compileElementAccessBody(ctx, fctx, expr, objType, expectedType) {
   if (objType.kind === "externref") {
+    if (!ctx.standalone && ctx.vecTypeMap.size > 0 && isNumericIndexExpression(ctx, expr.argumentExpression)) {
+      const vecGetIdx = ctx.funcMap.get("__vec_get");
+      const extGetIdx = ensureLateImport$1(
+        ctx,
+        "__extern_get",
+        [{ kind: "externref" }, { kind: "externref" }],
+        [{ kind: "externref" }]
+      );
+      const boxNumIdx = ensureLateImport$1(ctx, "__box_number", [{ kind: "f64" }], [{ kind: "externref" }]);
+      flushLateImportShifts$1(ctx, fctx);
+      const vgIdx = vecGetIdx ?? reserveVecMethodHelper(ctx, "get");
+      if (vgIdx !== void 0 && extGetIdx !== void 0 && boxNumIdx !== void 0) {
+        const recvLocal = allocLocal(fctx, `__nve_recv_${fctx.locals.length}`, { kind: "externref" });
+        fctx.body.push({ op: "local.set", index: recvLocal });
+        compileExpression$1(ctx, fctx, expr.argumentExpression, { kind: "f64" });
+        const idxLocal = allocLocal(fctx, `__nve_idx_${fctx.locals.length}`, { kind: "f64" });
+        fctx.body.push({ op: "local.set", index: idxLocal });
+        const anyTmp = allocLocal(fctx, `__nve_any_${fctx.locals.length}`, { kind: "anyref" });
+        fctx.body.push({ op: "local.get", index: recvLocal });
+        fctx.body.push({ op: "any.convert_extern" });
+        fctx.body.push({ op: "local.set", index: anyTmp });
+        let emitted = false;
+        for (const vi of new Set(ctx.vecTypeMap.values())) {
+          fctx.body.push({ op: "local.get", index: anyTmp });
+          fctx.body.push({ op: "ref.test", typeIdx: vi });
+          if (emitted) fctx.body.push({ op: "i32.or" });
+          emitted = true;
+        }
+        const thenStart = fctx.body.length;
+        fctx.body.push({ op: "local.get", index: recvLocal });
+        fctx.body.push({ op: "local.get", index: idxLocal });
+        fctx.body.push({ op: "i32.trunc_sat_f64_s" });
+        fctx.body.push({ op: "call", funcIdx: vgIdx });
+        const thenInstrs = fctx.body.splice(thenStart);
+        const elseStart = fctx.body.length;
+        fctx.body.push({ op: "local.get", index: recvLocal });
+        fctx.body.push({ op: "local.get", index: idxLocal });
+        fctx.body.push({ op: "call", funcIdx: boxNumIdx });
+        fctx.body.push({ op: "call", funcIdx: extGetIdx });
+        const elseInstrs = fctx.body.splice(elseStart);
+        fctx.body.push({
+          op: "if",
+          blockType: { kind: "val", type: { kind: "externref" } },
+          then: thenInstrs,
+          else: elseInstrs
+        });
+        return { kind: "externref" };
+      }
+    }
     if (ctx.standalone && isNumericIndexExpression(ctx, expr.argumentExpression)) {
       compileExpression$1(ctx, fctx, expr.argumentExpression, { kind: "f64" });
       const getIdxFn = ensureLateImport$1(
@@ -104154,7 +104176,9 @@ function compileElementAccessBody(ctx, fctx, expr, objType, expectedType) {
     const taSignedness = typedArrayViewSignedness(ctx, expr.expression);
     const isRegexMatchVec = typeDef.fields.length >= 4 && typeDef.fields[2]?.name === "index";
     const numericHint = expectedType?.kind === "f64" || expectedType?.kind === "i32";
-    const oobUndefined = !numericHint && classifyTypedArrayType(ctx.checker.getTypeAtLocation(expr.expression), ctx.checker) === "other" && !isRegexMatchVec;
+    const taClass = classifyTypedArrayType(ctx.checker.getTypeAtLocation(expr.expression), ctx.checker);
+    const oobUndefined = !numericHint && taClass === "other" && !isRegexMatchVec;
+    const oobUndefinedTypedArray = !numericHint && taClass !== "other";
     const f1BoxType = f1ElementBoxType(ctx, expr, arrDef.element);
     fctx.body.push({ op: "struct.get", typeIdx, fieldIdx: 1 });
     compileExpression$1(ctx, fctx, expr.argumentExpression, { kind: "i32" });
@@ -104166,6 +104190,9 @@ function compileElementAccessBody(ctx, fctx, expr, objType, expectedType) {
     } else if (oobUndefined && f1BoxType !== null) {
       emitPlainArrayUndefinedOobGet(ctx, fctx, arrTypeIdx, arrDef.element, f1BoxType);
       return { kind: "externref" };
+    } else if (oobUndefinedTypedArray) {
+      emitTypedArrayUndefinedOobGet(ctx, fctx, arrTypeIdx, arrDef.element, taSignedness);
+      return { kind: "externref" };
     } else {
       emitBoundsCheckedArrayGet(fctx, arrTypeIdx, arrDef.element, ctx, false, taSignedness);
     }
@@ -104180,7 +104207,10 @@ function compileElementAccessBody(ctx, fctx, expr, objType, expectedType) {
     return null;
   }
   const taSignednessArr = typedArrayViewSignedness(ctx, expr.expression);
-  const oobUndefinedArr = !(expectedType?.kind === "f64" || expectedType?.kind === "i32") && classifyTypedArrayType(ctx.checker.getTypeAtLocation(expr.expression), ctx.checker) === "other";
+  const numericHintArr = expectedType?.kind === "f64" || expectedType?.kind === "i32";
+  const taClassArr = classifyTypedArrayType(ctx.checker.getTypeAtLocation(expr.expression), ctx.checker);
+  const oobUndefinedArr = !numericHintArr && taClassArr === "other";
+  const oobUndefinedTypedArrayArr = !numericHintArr && taClassArr !== "other";
   const f1BoxTypeArr = f1ElementBoxType(ctx, expr, typeDef.element);
   compileExpression$1(ctx, fctx, expr.argumentExpression, { kind: "i32" });
   const valueType = typeDef.element.kind === "i8" || typeDef.element.kind === "i16" ? { kind: "i32" } : typeDef.element;
@@ -104191,6 +104221,9 @@ function compileElementAccessBody(ctx, fctx, expr, objType, expectedType) {
   } else if (oobUndefinedArr && f1BoxTypeArr !== null) {
     emitPlainArrayUndefinedOobGet(ctx, fctx, typeIdx, typeDef.element, f1BoxTypeArr);
     return { kind: "externref" };
+  } else if (oobUndefinedTypedArrayArr) {
+    emitTypedArrayUndefinedOobGet(ctx, fctx, typeIdx, typeDef.element, taSignednessArr);
+    return { kind: "externref" };
   } else {
     emitBoundsCheckedArrayGet(fctx, typeIdx, typeDef.element, ctx, false, taSignednessArr);
   }
@@ -104972,6 +105005,12 @@ function _hasRuntimeComputedKey(ctx, expr) {
   }
   return false;
 }
+function objectLiteralSpreadTakesHostPath(ctx, expr) {
+  if (expr.properties.length === 0) return false;
+  if (!expr.properties.some((p) => ts.isSpreadAssignment(p))) return false;
+  const spreadCtxType = ctx.checker.getContextualType(expr);
+  return !spreadCtxType || (spreadCtxType.flags & ts.TypeFlags.Any) !== 0 || (spreadCtxType.flags & ts.TypeFlags.Unknown) !== 0 || (spreadCtxType.flags & ts.TypeFlags.NonPrimitive) !== 0 || spreadCtxType.getProperties().length === 0;
+}
 function compileObjectLiteral(ctx, fctx, expr) {
   if (expr.properties.length > 0 && (expr.properties.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p)) || _hasDisposalMethod(expr) || _hasRuntimeComputedKey(ctx, expr))) {
     return compileObjectLiteralWithAccessors(ctx, fctx, expr);
@@ -104979,12 +105018,8 @@ function compileObjectLiteral(ctx, fctx, expr) {
   if (expr.properties.length > 0 && _hasAccessorSpreadSource(ctx, expr)) {
     return compileObjectLiteralWithAccessors(ctx, fctx, expr);
   }
-  if (expr.properties.length > 0 && expr.properties.some((p) => ts.isSpreadAssignment(p))) {
-    const spreadCtxType = ctx.checker.getContextualType(expr);
-    const nonSpecificCtx = !spreadCtxType || (spreadCtxType.flags & ts.TypeFlags.Any) !== 0 || (spreadCtxType.flags & ts.TypeFlags.Unknown) !== 0 || (spreadCtxType.flags & ts.TypeFlags.NonPrimitive) !== 0 || spreadCtxType.getProperties().length === 0;
-    if (nonSpecificCtx) {
-      return compileObjectLiteralWithAccessors(ctx, fctx, expr);
-    }
+  if (objectLiteralSpreadTakesHostPath(ctx, expr)) {
+    return compileObjectLiteralWithAccessors(ctx, fctx, expr);
   }
   if (expr.properties.length === 0 && ts.isVariableDeclaration(expr.parent) && ts.isIdentifier(expr.parent.name)) {
     const widenedProps = ctx.widenedTypeProperties.get(expr.parent.name.text);
@@ -113961,7 +113996,7 @@ function buildLocalCallGraph(decls, localClasses) {
     if (!fn.body) continue;
     const localBindings = collectLocalClosureBindings(fn);
     const visit = (node) => {
-      if (node !== fn && isFunctionLike(node)) return;
+      if (node !== fn && isFunctionLike$1(node)) return;
       if (ts.isNewExpression(node)) {
         if (ts.isIdentifier(node.expression) && (localClasses.has(node.expression.text) || isKnownExternClass(node.expression.text))) {
           if (node.arguments) {
@@ -114016,7 +114051,7 @@ function collectLocalClosureBindings(fn) {
   const names = /* @__PURE__ */ new Set();
   if (!fn.body) return names;
   const visit = (node) => {
-    if (node !== fn && isFunctionLike(node)) return;
+    if (node !== fn && isFunctionLike$1(node)) return;
     if (ts.isFunctionDeclaration(node) && node !== fn && node.name) {
       names.add(node.name.text);
     }
@@ -114035,7 +114070,7 @@ function collectLocalClosureBindings(fn) {
   forEachChild$1(fn.body, visit);
   return names;
 }
-function isFunctionLike(node) {
+function isFunctionLike$1(node) {
   return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node);
 }
 function lowerFunctionAstToIr(fn, options = {}) {
@@ -114394,8 +114429,9 @@ function lowerVarDecl(stmt, cx) {
       }
     }
     if (!proveUnboxedNumberLocal(d.name, inferred, cx)) {
+      const boundKind = asVal(inferred)?.kind === "i32" ? "i32" : "f64";
       throw new Error(
-        `ir/from-ast: local '${name}' is bound as an unboxed f64 but its TS type is not provably a pure number — keeping the no-box number representation is unsound (the f64 Wasm kind conflates number / boolean / any); demote to the SAFE boxed legacy lowering in ${cx.funcName} (#2782)`
+        `ir/from-ast: local '${name}' is bound as an unboxed ${boundKind} but its TS type is not provably a pure number${boundKind === "i32" ? " or boolean" : ""} — keeping the no-box number representation is unsound (the ${boundKind} Wasm kind conflates number / boolean / any); demote to the SAFE boxed legacy lowering in ${cx.funcName} (#2782/#2790)`
       );
     }
     if (!isConst && cx.mutatedLets.has(name)) {
@@ -116063,12 +116099,21 @@ function proveAdditiveOperand(node, cx) {
   if (!checker) return "no-checker";
   return classifyPrimitiveProof(checker.getTypeAtLocation(node));
 }
+function isProvablyBoolean(t) {
+  if (t.isUnion()) {
+    return t.types.length > 0 && t.types.every(isProvablyBoolean);
+  }
+  return (t.flags & ts.TypeFlags.BooleanLike) !== 0;
+}
 function proveUnboxedNumberLocal(name, boundType, cx) {
   const bv = asVal(boundType);
-  if (!bv || bv.kind !== "f64") return true;
+  if (!bv || bv.kind !== "f64" && bv.kind !== "i32") return true;
   const checker = cx.checker;
   if (!checker) return true;
-  return classifyPrimitiveProof(checker.getTypeAtLocation(name)) === "number";
+  const tsType = checker.getTypeAtLocation(name);
+  if (classifyPrimitiveProof(tsType) === "number") return true;
+  if (bv.kind === "f64") return false;
+  return isProvablyBoolean(tsType);
 }
 function lowerBinary(expr, cx, hint) {
   const op = expr.operatorToken.kind;
@@ -124027,6 +124072,7 @@ function walkBodyForReturns(body, paramScope, entries, cb) {
 function createCodegenContext(mod, checker, options) {
   const strictNoHostImports = options?.strictNoHostImports ?? options?.wasi ?? false;
   const nativeStrings = options?.nativeStrings ?? !!(options?.fast || options?.wasi || options?.standalone || strictNoHostImports || options?.utf8Storage);
+  const linkedNamespaces = new Set(options?.wasi ? options?.link ?? [] : []);
   const ctx = {
     mod,
     checker,
@@ -124090,6 +124136,10 @@ function createCodegenContext(mod, checker, options) {
     // (#2001 S1) $Hole struct type; lazily registered
     holeGlobalIdx: void 0,
     // (#2001 S1) $__hole singleton global
+    inModuleInitFlagReads: void 0,
+    // (#2800) recorded __in_module_init flag reads
+    inModuleInitGlobalIdx: void 0,
+    // (#2800) __in_module_init flag global (set at finalize)
     usesDynRead: false,
     // (#2580 M0) set by a __dyn_has/__dyn_get call site (M1+); M0 adds none
     dynReadHelpersEmitted: false,
@@ -124235,11 +124285,17 @@ function createCodegenContext(mod, checker, options) {
     // (#2025)
     funcClosureGlobals: /* @__PURE__ */ new Map(),
     wasi: options?.wasi ?? false,
-    // #2625 — the linkable js2wasm:node-<mod> shims only apply under WASI; ignored otherwise.
-    linkNodeShims: !!(options?.wasi && options?.linkNodeShims),
+    // #2783 — namespaces left as link-time imports (WASI-gated above).
+    linkedNamespaces,
+    // #2625/#2783 — the linkable js2wasm:node-<mod> std-IO path only applies under
+    // WASI; derived from `node:fs` membership in the (already WASI-gated) link set.
+    linkNodeShims: linkedNamespaces.has("node:fs"),
     nodeFsReadSyncIdx: -1,
     nodeFsWriteSyncIdx: -1,
     standalone: options?.standalone ?? false,
+    // (#2796) Diff-test-harness fidelity — export __module_init + skip the wasm
+    // start section so the host runs top-level code after setExports.
+    deferTopLevelInit: options?.deferTopLevelInit ?? false,
     // #682 — native standalone RegExp engine hook. Standalone mode enables the
     // reduced literal-substring backend; broader QuickJS libregexp ABI linking
     // remains the follow-up path for near-JS parity.
@@ -130319,9 +130375,14 @@ function isI32SafeExprForArray(expr, i32Locals, depth = 0) {
   }
   if (ts.isPrefixUnaryExpression(expr)) {
     const op = expr.operator;
-    if (op === ts.SyntaxKind.PlusToken || op === ts.SyntaxKind.MinusToken || op === ts.SyntaxKind.TildeToken) {
+    if (op === ts.SyntaxKind.PlusToken || op === ts.SyntaxKind.TildeToken) {
       return isI32SafeExprForArray(expr.operand, i32Locals, depth + 1);
     }
+    if (op === ts.SyntaxKind.MinusToken) {
+      if (!ts.isNumericLiteral(expr.operand)) return false;
+      if (!isI32SafeExprForArray(expr.operand, i32Locals, depth + 1)) return false;
+      return Number(expr.operand.text.replace(/_/g, "")) !== 0;
+    }
     return false;
   }
   if (ts.isBinaryExpression(expr)) {
@@ -130333,7 +130394,7 @@ function isI32SafeExprForArray(expr, i32Locals, depth = 0) {
       return true;
     }
     if (op === ts.SyntaxKind.PlusToken || op === ts.SyntaxKind.MinusToken || op === ts.SyntaxKind.AsteriskToken) {
-      return isI32SafeExprForArray(expr.left, i32Locals, depth + 1) && isI32SafeExprForArray(expr.right, i32Locals, depth + 1);
+      return false;
     }
     return false;
   }
@@ -130439,7 +130500,7 @@ function collectI32SpecializedArrays(decl, i32CoercedLocals) {
     if (ts.isBinaryExpression(node) && node.operatorToken.kind !== ts.SyntaxKind.EqualsToken && isCompoundAssignment(node.operatorToken.kind) && ts.isElementAccessExpression(node.left) && ts.isIdentifier(node.left.expression) && candidates.has(node.left.expression.text)) {
       const arrName = node.left.expression.text;
       const isBitwiseCompound = node.operatorToken.kind === ts.SyntaxKind.BarEqualsToken || node.operatorToken.kind === ts.SyntaxKind.AmpersandEqualsToken || node.operatorToken.kind === ts.SyntaxKind.CaretEqualsToken || node.operatorToken.kind === ts.SyntaxKind.LessThanLessThanEqualsToken || node.operatorToken.kind === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken;
-      if (!isBitwiseCompound && !isI32SafeExprForArray(node.right, i32Locals)) {
+      if (!isBitwiseCompound) {
         disqualified.add(arrName);
       }
     }
@@ -132693,9 +132754,52 @@ function inferNumericReturnTypes(ctx, sourceFile) {
       }
     }
   }
+  const isBooleanExpr = (expr, depth = 0) => {
+    if (depth > MAX_NUMERIC_DEPTH) return false;
+    if (ts.isParenthesizedExpression(expr)) return isBooleanExpr(expr.expression, depth + 1);
+    if (ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr) || ts.isNonNullExpression(expr)) {
+      return isBooleanExpr(expr.expression, depth + 1);
+    }
+    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword) return true;
+    if (ts.isPrefixUnaryExpression(expr)) {
+      return expr.operator === ts.SyntaxKind.ExclamationToken;
+    }
+    if (ts.isBinaryExpression(expr)) {
+      const op = expr.operatorToken.kind;
+      if (op === ts.SyntaxKind.LessThanToken || op === ts.SyntaxKind.LessThanEqualsToken || op === ts.SyntaxKind.GreaterThanToken || op === ts.SyntaxKind.GreaterThanEqualsToken || op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken || op === ts.SyntaxKind.ExclamationEqualsEqualsToken || op === ts.SyntaxKind.InstanceOfKeyword || op === ts.SyntaxKind.InKeyword) {
+        return true;
+      }
+      if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
+        return isBooleanExpr(expr.left, depth + 1) && isBooleanExpr(expr.right, depth + 1);
+      }
+      return false;
+    }
+    if (ts.isConditionalExpression(expr)) {
+      return isBooleanExpr(expr.whenTrue, depth + 1) && isBooleanExpr(expr.whenFalse, depth + 1);
+    }
+    if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+      if (boolean.has(expr.expression.text)) return true;
+      if (expr.expression.text === "Boolean") return true;
+      return false;
+    }
+    return false;
+  };
+  const boolean = new Set(numeric);
+  let bChanged = true;
+  let bSafety = boolean.size + 1;
+  while (bChanged && bSafety-- > 0) {
+    bChanged = false;
+    for (const fnName of [...boolean]) {
+      const info = fnInfo.get(fnName);
+      if (!info.returns.every((r) => isBooleanExpr(r))) {
+        boolean.delete(fnName);
+        bChanged = true;
+      }
+    }
+  }
   const result = /* @__PURE__ */ new Map();
   for (const fnName of numeric) {
-    result.set(fnName, { kind: "f64" });
+    result.set(fnName, boolean.has(fnName) ? { kind: "i32", boolean: true } : { kind: "f64" });
   }
   return result;
 }
@@ -133715,6 +133819,12 @@ function collectDeclarations(ctx, sourceFile, isEntryFile = true) {
         }
       }
     }
+    if (decl.initializer.properties.some((p) => ts.isSpreadAssignment(p))) {
+      const spreadCtxType = ctx.checker.getContextualType(decl.initializer);
+      if (!spreadCtxType || (spreadCtxType.flags & ts.TypeFlags.Any) !== 0 || (spreadCtxType.flags & ts.TypeFlags.Unknown) !== 0 || (spreadCtxType.flags & ts.TypeFlags.NonPrimitive) !== 0 || spreadCtxType.getProperties().length === 0) {
+        return true;
+      }
+    }
     return false;
   }
   function moduleGlobalWasmType(decl, varType) {
@@ -134256,6 +134366,7 @@ function compileDeclarations(ctx, sourceFile) {
   ctx.pendingInitBody = null;
   if (compiledInitFctx && compiledInitFctx.body.length > 0) {
     ctx.mod.hasTopLevelStatements = true;
+    const exportModuleInit = ctx.deferTopLevelInit && !ctx.wasi;
     const initTypeIdx = addFuncType(ctx, [], [], "__module_init_type");
     const initFuncIdx = ctx.numImportFuncs + ctx.mod.functions.length;
     ctx.mod.functions.push({
@@ -134263,9 +134374,15 @@ function compileDeclarations(ctx, sourceFile) {
       typeIdx: initTypeIdx,
       locals: compiledInitFctx.locals,
       body: compiledInitFctx.body,
-      exported: false
+      exported: exportModuleInit
     });
-    if (!ctx.wasi) {
+    if (exportModuleInit) {
+      ctx.mod.exports.push({
+        name: "__module_init",
+        desc: { kind: "func", index: initFuncIdx }
+      });
+    }
+    if (!ctx.wasi && !exportModuleInit) {
       ctx.mod.startFuncIdx = initFuncIdx;
     }
   }
@@ -134976,6 +135093,7 @@ function generateModule(ast, options) {
     fillExternGetIdxVecArms(ctx);
     fillArrayToPrimitive(ctx);
     emitIsClosureExport(ctx);
+    emitIsDataStructExport(ctx);
     fillStandaloneTypeofClosureArms(ctx);
     emitToPrimitiveMethodExports(ctx);
     fillClassToPrimitive(ctx);
@@ -134991,6 +135109,7 @@ function generateModule(ast, options) {
       });
     }
     ensureDynReadHelpers(ctx);
+    finalizeInModuleInitFlag(ctx);
     markLeafStructsFinal(mod, ctx.wasi);
     eliminateDeadImports(mod, ctx);
     repairStructTypeMismatches(mod);
@@ -135012,7 +135131,7 @@ function generateModule(ast, options) {
 }
 function assertNoLeakedHostImports(ctx, mod) {
   if (!ctx.strictNoHostImports) return;
-  const leaks = scanForLeakedHostImports(mod.imports);
+  const leaks = scanForLeakedHostImports(mod.imports, ctx.linkedNamespaces);
   for (const leak of leaks) {
     reportErrorNoNode(ctx, buildLeakedHostImportError(leak));
   }
@@ -135029,6 +135148,35 @@ function drainStackBalanceTelemetry(ctx, fileLabel) {
     ctx.errors.push({ message: diag.message, line: diag.line, column: diag.column, severity: diag.severity });
   }
 }
+function finalizeInModuleInitFlag(ctx) {
+  const reads = ctx.inModuleInitFlagReads;
+  if (!reads || reads.length === 0) return;
+  const flagIdx = ctx.numImportGlobals + ctx.mod.globals.length;
+  ctx.mod.globals.push({
+    name: "__in_module_init",
+    type: { kind: "i32" },
+    mutable: true,
+    init: [{ op: "i32.const", value: 0 }]
+  });
+  ctx.inModuleInitGlobalIdx = flagIdx;
+  for (const r of reads) r.index = flagIdx;
+  let initArrayIdx = -1;
+  for (let i = 0; i < ctx.mod.functions.length; i++) {
+    if (ctx.mod.functions[i].name === "__module_init") {
+      initArrayIdx = i;
+      break;
+    }
+  }
+  if (initArrayIdx < 0) return;
+  const initFn = ctx.mod.functions[initArrayIdx];
+  initFn.body = [
+    { op: "i32.const", value: 1 },
+    { op: "global.set", index: flagIdx },
+    ...initFn.body,
+    { op: "i32.const", value: 0 },
+    { op: "global.set", index: flagIdx }
+  ];
+}
 function applyModuleInitGuard(ctx) {
   if (ctx.moduleInitGuardApplied) return;
   let initArrayIdx = -1;
@@ -136196,6 +136344,50 @@ function emitIsClosureExport(ctx) {
     desc: { kind: "func", index: funcIdx }
   });
 }
+function emitIsDataStructExport(ctx) {
+  const mod = ctx.mod;
+  const dataTypeIdxs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [structName] of ctx.structFields) {
+    if (structName.startsWith("Wrapper") || structName === "$AnyValue" || structName.startsWith("__vec_") || structName.startsWith("__arr_"))
+      continue;
+    const typeIdx = ctx.structMap.get(structName);
+    if (typeIdx === void 0 || seen.has(typeIdx)) continue;
+    const typeDef = mod.types[typeIdx];
+    if (!typeDef || typeDef.kind !== "struct") continue;
+    seen.add(typeIdx);
+    dataTypeIdxs.push(typeIdx);
+  }
+  if (dataTypeIdxs.length === 0) return;
+  const isDataTypeIdx = addFuncType(ctx, [{ kind: "externref" }], [{ kind: "i32" }], "$is_data_struct_type");
+  const funcIdx = ctx.numImportFuncs + mod.functions.length;
+  const body = [
+    { op: "local.get", index: 0 },
+    { op: "any.convert_extern" },
+    { op: "local.set", index: 1 }
+  ];
+  for (const dataType of dataTypeIdxs) {
+    body.push({ op: "local.get", index: 1 });
+    body.push({ op: "ref.test", typeIdx: dataType });
+    body.push({
+      op: "if",
+      blockType: { kind: "empty" },
+      then: [{ op: "i32.const", value: 1 }, { op: "return" }]
+    });
+  }
+  body.push({ op: "i32.const", value: 0 });
+  mod.functions.push({
+    name: "__is_data_struct",
+    typeIdx: isDataTypeIdx,
+    locals: [{ name: "__any", type: { kind: "anyref" } }],
+    body,
+    exported: true
+  });
+  mod.exports.push({
+    name: "__is_data_struct",
+    desc: { kind: "func", index: funcIdx }
+  });
+}
 function fillStandaloneTypeofClosureArms(ctx) {
   if (!ctx.nativeStrings) return;
   const baseTypeIdxs = collectClosureBaseWrapperTypeIdxs(ctx);
@@ -136449,6 +136641,19 @@ function emitToPrimitiveMethodExports(ctx) {
   emitDispatchForMethod("toString", "__call_toString");
   emitDispatchForMethod("valueOf", "__call_valueOf");
 }
+function reserveVecMethodHelper(ctx, kind) {
+  const name = kind === "push" ? "__vec_push" : kind === "pop" ? "__vec_pop" : "__vec_get";
+  const existing = ctx.funcMap.get(name);
+  if (existing !== void 0) return existing;
+  const typeIdx = kind === "push" ? addFuncType(ctx, [{ kind: "externref" }, { kind: "externref" }], [{ kind: "i32" }], "$__vec_push_type") : kind === "pop" ? addFuncType(ctx, [{ kind: "externref" }], [{ kind: "externref" }], "$__vec_pop_type") : addFuncType(ctx, [{ kind: "externref" }, { kind: "i32" }], [{ kind: "externref" }], "$__vec_get_type");
+  const idx = ctx.numImportFuncs + ctx.mod.functions.length;
+  const placeholder = kind === "push" ? [{ op: "i32.const", value: 0 }] : [{ op: "ref.null.extern" }];
+  ctx.mod.functions.push({ name, typeIdx, locals: [], body: placeholder, exported: true });
+  ctx.mod.exports.push({ name, desc: { kind: "func", index: idx } });
+  ctx.funcMap.set(name, idx);
+  ctx.usesVecValue = true;
+  return idx;
+}
 function emitVecAccessExports(ctx) {
   if (!ctx.funcMap.has("__iterator") && !ctx.funcMap.has("JSON_stringify") && !ctx.funcMap.has("__make_iterable") && !ctx.funcMap.has("Promise_all") && !ctx.funcMap.has("Promise_race") && !ctx.funcMap.has("Promise_allSettled") && !ctx.funcMap.has("Promise_any") && !ctx.funcMap.has("__crypto_get_random_values") && // (#1503)
   !ctx.funcMap.has("__extern_get") && !ctx.usesVecValue) {
@@ -136609,24 +136814,29 @@ function _emitVecAccessExportsInner(ctx) {
       ];
     }
     body.push(...current);
-    mod.functions.push({
-      name: "__vec_get",
-      typeIdx: getTypeIdx,
-      // local 2 = __any (anyref). (#2001 S1 regress) When the module has holes,
-      // local 3 = __hole_scratch (externref) backs the `$Hole → undefined`
-      // read-boundary map (`local.tee 3` above). Declared ONLY then, so a
-      // hole-free module's `__vec_get` is byte-identical to pre-fix.
-      locals: holeMapInVecGet ? [
-        { name: "__any", type: { kind: "anyref" } },
-        { name: "__hole_scratch", type: { kind: "externref" } }
-      ] : [{ name: "__any", type: { kind: "anyref" } }],
-      body,
-      exported: true
-    });
-    mod.exports.push({
-      name: "__vec_get",
-      desc: { kind: "func", index: getFuncIdx }
-    });
+    const getLocals = holeMapInVecGet ? [
+      { name: "__any", type: { kind: "anyref" } },
+      { name: "__hole_scratch", type: { kind: "externref" } }
+    ] : [{ name: "__any", type: { kind: "anyref" } }];
+    const reservedGet = ctx.funcMap.get("__vec_get");
+    if (reservedGet !== void 0) {
+      const fn = mod.functions[reservedGet - ctx.numImportFuncs];
+      fn.locals = getLocals;
+      fn.body = body;
+    } else {
+      mod.functions.push({
+        name: "__vec_get",
+        typeIdx: getTypeIdx,
+        locals: getLocals,
+        body,
+        exported: true
+      });
+      mod.exports.push({
+        name: "__vec_get",
+        desc: { kind: "func", index: getFuncIdx }
+      });
+      ctx.funcMap.set("__vec_get", getFuncIdx);
+    }
   }
   const unboxNumIdx = ctx.funcMap.get("__unbox_number");
   const boxNumIdx2 = ctx.funcMap.get("__box_number");
@@ -136820,14 +137030,22 @@ function _emitVecAccessExportsInner(ctx) {
       ];
     }
     body.push(...current);
-    mod.functions.push({
-      name: "__vec_push",
-      typeIdx: pushTypeIdx,
-      locals,
-      body,
-      exported: true
-    });
-    mod.exports.push({ name: "__vec_push", desc: { kind: "func", index: pushFuncIdx } });
+    const reservedPush = ctx.funcMap.get("__vec_push");
+    if (reservedPush !== void 0) {
+      const fn = mod.functions[reservedPush - ctx.numImportFuncs];
+      fn.locals = locals;
+      fn.body = body;
+    } else {
+      mod.functions.push({
+        name: "__vec_push",
+        typeIdx: pushTypeIdx,
+        locals,
+        body,
+        exported: true
+      });
+      mod.exports.push({ name: "__vec_push", desc: { kind: "func", index: pushFuncIdx } });
+      ctx.funcMap.set("__vec_push", pushFuncIdx);
+    }
   }
   {
     const popTypeIdx = addFuncType(ctx, [{ kind: "externref" }], [{ kind: "externref" }], "$__vec_pop_type");
@@ -136895,14 +137113,22 @@ function _emitVecAccessExportsInner(ctx) {
       ];
     }
     body.push(...current);
-    mod.functions.push({
-      name: "__vec_pop",
-      typeIdx: popTypeIdx,
-      locals,
-      body,
-      exported: true
-    });
-    mod.exports.push({ name: "__vec_pop", desc: { kind: "func", index: popFuncIdx } });
+    const reservedPop = ctx.funcMap.get("__vec_pop");
+    if (reservedPop !== void 0) {
+      const fn = mod.functions[reservedPop - ctx.numImportFuncs];
+      fn.locals = locals;
+      fn.body = body;
+    } else {
+      mod.functions.push({
+        name: "__vec_pop",
+        typeIdx: popTypeIdx,
+        locals,
+        body,
+        exported: true
+      });
+      mod.exports.push({ name: "__vec_pop", desc: { kind: "func", index: popFuncIdx } });
+      ctx.funcMap.set("__vec_pop", popFuncIdx);
+    }
   }
 }
 function emitVecSetByteExport(ctx) {
@@ -137371,6 +137597,7 @@ function generateMultiModule(multiAst, options) {
     emitClosureCallExport(ctx);
     emitClosureCallExport1(ctx);
     emitIsClosureExport(ctx);
+    emitIsDataStructExport(ctx);
     fillStandaloneTypeofClosureArms(ctx);
     emitToPrimitiveMethodExports(ctx);
     emitToPrimitiveMethodExport(ctx);
@@ -137386,6 +137613,7 @@ function generateMultiModule(multiAst, options) {
       });
     }
     ensureDynReadHelpers(ctx);
+    finalizeInModuleInitFlag(ctx);
     markLeafStructsFinal(mod, ctx.wasi);
     eliminateDeadImports(mod, ctx);
     repairStructTypeMismatches(mod);
@@ -139117,6 +139345,10 @@ function addUnionImports(ctx) {
     kind: "func",
     typeIdx: boxBoolType
   });
+  addImport(ctx, "env", "__box_symbol", {
+    kind: "func",
+    typeIdx: boxBoolType
+  });
   const boxBigType = addFuncType(ctx, [{ kind: "i64" }], [{ kind: "externref" }]);
   addImport(ctx, "env", "__box_bigint", { kind: "func", typeIdx: boxBigType });
   const toBigType = addFuncType(ctx, [{ kind: "externref" }], [{ kind: "i64" }]);
@@ -139165,6 +139397,7 @@ function addUnionImports(ctx) {
       "__unbox_boolean",
       "__box_number",
       "__box_boolean",
+      "__box_symbol",
       "__box_bigint",
       "__to_bigint",
       "__bigint_ctor",
@@ -140763,7 +140996,7 @@ function collectExternClass(ctx, decl, namespacePath) {
           if (!p.questionToken && !p.initializer) requiredParams++;
         }
         const retType = ctx.checker.getReturnTypeOfSignature(sig);
-        const results = isVoidType(retType) ? [] : [mapTsTypeToWasm(retType, ctx.checker)];
+        const results = isVoidType(retType) ? [] : [brandExternMethodResult(ctx, retType, mapTsTypeToWasm(retType, ctx.checker))];
         info.methods.set(methodName, { params, results, requiredParams });
       }
     }
@@ -140877,7 +141110,7 @@ function collectInterfaceMembers(ctx, iface, info, locationNode) {
           if (!p.questionToken && !p.initializer) requiredParams++;
         }
         const retType = ctx.checker.getReturnTypeOfSignature(sig);
-        const results = isVoidType(retType) ? [] : [mapTsTypeToWasm(retType, ctx.checker)];
+        const results = isVoidType(retType) ? [] : [brandExternMethodResult(ctx, retType, mapTsTypeToWasm(retType, ctx.checker))];
         info.methods.set(methodName, { params, results, requiredParams });
       }
     }
@@ -141421,6 +141654,11 @@ function hoistVarDecl(ctx, fctx, decl) {
           }
         }
       }
+      if (!initForcesExternref && decl.initializer.properties.some((p) => ts.isSpreadAssignment(p))) {
+        const spreadCtxType = ctx.checker.getContextualType(decl.initializer);
+        const nonSpecificCtx = !spreadCtxType || (spreadCtxType.flags & ts.TypeFlags.Any) !== 0 || (spreadCtxType.flags & ts.TypeFlags.Unknown) !== 0 || (spreadCtxType.flags & ts.TypeFlags.NonPrimitive) !== 0 || spreadCtxType.getProperties().length === 0;
+        if (nonSpecificCtx) initForcesExternref = true;
+      }
     }
     const wasmType = initForcesExternref || isNullablePrimitiveType(varType) ? { kind: "externref" } : resolveWasmType(ctx, varType);
     if (initForcesExternref) ctx.externrefAccessorVars.add(name);
@@ -141728,10 +141966,15 @@ function walkStmtForLetConst(ctx, fctx, stmt) {
         const varType = ctx.checker.getTypeAtLocation(decl);
         const isI32Coerced = fctx.i32CoercedLocals?.has(name) === true && (varType.flags & ts.TypeFlags.NumberLike) !== 0;
         const initIsAccessorLiteral = decl.initializer !== void 0 && ts.isObjectLiteralExpression(decl.initializer) && decl.initializer.properties.some((p) => ts.isGetAccessorDeclaration(p) || ts.isSetAccessorDeclaration(p));
-        if (initIsAccessorLiteral) {
+        let initIsHostSpreadLiteral = false;
+        if (!initIsAccessorLiteral && decl.initializer !== void 0 && ts.isObjectLiteralExpression(decl.initializer) && decl.initializer.properties.some((p) => ts.isSpreadAssignment(p))) {
+          const spreadCtxType = ctx.checker.getContextualType(decl.initializer);
+          initIsHostSpreadLiteral = !spreadCtxType || (spreadCtxType.flags & ts.TypeFlags.Any) !== 0 || (spreadCtxType.flags & ts.TypeFlags.Unknown) !== 0 || (spreadCtxType.flags & ts.TypeFlags.NonPrimitive) !== 0 || spreadCtxType.getProperties().length === 0;
+        }
+        if (initIsAccessorLiteral || initIsHostSpreadLiteral) {
           ctx.externrefAccessorVars.add(name);
         }
-        const wasmType = initIsAccessorLiteral ? { kind: "externref" } : isI32Coerced ? { kind: "i32" } : isNullablePrimitiveType(varType) ? { kind: "externref" } : inferLetConstInitializerWasmType(ctx, fctx, decl.initializer) ?? resolveWasmType(ctx, varType);
+        const wasmType = initIsAccessorLiteral || initIsHostSpreadLiteral ? { kind: "externref" } : isI32Coerced ? { kind: "i32" } : isNullablePrimitiveType(varType) ? { kind: "externref" } : inferLetConstInitializerWasmType(ctx, fctx, decl.initializer) ?? resolveWasmType(ctx, varType);
         allocLocal(fctx, name, wasmType);
         if (needsTdzFlag(ctx, decl)) {
           if (!fctx.tdzFlagLocals) fctx.tdzFlagLocals = /* @__PURE__ */ new Map();
@@ -141894,6 +142137,448 @@ function ensureI32Condition(fctx, condType, ctx) {
     fctx.body.push({ op: "i32.eqz" });
   }
 }
+const EMPTY_RESULT = {
+  sites: /* @__PURE__ */ new Map(),
+  approved: /* @__PURE__ */ new Set(),
+  approvedNames: /* @__PURE__ */ new Set(),
+  receiverStruct: /* @__PURE__ */ new Map(),
+  newThisOwnerNames: /* @__PURE__ */ new Set(),
+  ctorDeclByName: /* @__PURE__ */ new Map()
+};
+function fnctorDeclFromSymbol(sym) {
+  for (const decl of sym.getDeclarations() ?? []) {
+    if (ts.isFunctionDeclaration(decl) && decl.body) return decl;
+    if (ts.isFunctionExpression(decl) && decl.body) return decl;
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      let init = decl.initializer;
+      while (ts.isParenthesizedExpression(init)) init = init.expression;
+      if (ts.isFunctionExpression(init) && init.body) return init;
+    }
+  }
+  return void 0;
+}
+const RETURN_INFER_MAX_DEPTH = 6;
+const GENERIC_METHOD_CALL = /* @__PURE__ */ new Set(["call", "apply", "bind"]);
+function resolveFnctorSymbol(checker, calleeExpr) {
+  let e = calleeExpr;
+  while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isNonNullExpression(e)) {
+    e = e.expression;
+  }
+  if (!ts.isIdentifier(e)) return void 0;
+  const sym = checker.getSymbolAtLocation(e);
+  const decls = sym?.getDeclarations();
+  if (!sym || !decls) return void 0;
+  for (const decl of decls) {
+    if (ts.isClassDeclaration(decl) || ts.isClassExpression(decl)) return void 0;
+    if (ts.isFunctionDeclaration(decl) && decl.body) return sym;
+    if (ts.isFunctionExpression(decl) && decl.body) return sym;
+    if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      let init = decl.initializer;
+      while (ts.isParenthesizedExpression(init)) init = init.expression;
+      if (ts.isFunctionExpression(init) && init.body) return sym;
+      if (ts.isArrowFunction(init)) return void 0;
+    }
+  }
+  return void 0;
+}
+function resolveEnclosingFnctorOwner(checker, node) {
+  let fn = node;
+  while (fn && !ts.isFunctionExpression(fn) && !ts.isFunctionDeclaration(fn)) {
+    fn = fn.parent;
+  }
+  if (!fn) return void 0;
+  const assign = fn.parent;
+  if (!ts.isBinaryExpression(assign) || assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken || assign.right !== fn || !ts.isPropertyAccessExpression(assign.left)) {
+    return void 0;
+  }
+  const left = assign.left;
+  if (ts.isPropertyAccessExpression(left.expression) && ts.isIdentifier(left.expression.name) && left.expression.name.text === "prototype") {
+    const sym = resolveFnctorSymbol(checker, left.expression.expression);
+    if (sym) return { name: sym.name, sym, viaPrototype: true };
+    return void 0;
+  }
+  const holder = left.expression;
+  const direct = resolveFnctorSymbol(checker, holder);
+  if (direct) return { name: direct.name, sym: direct, viaPrototype: false };
+  if (ts.isIdentifier(holder)) {
+    const hsym = checker.getSymbolAtLocation(holder);
+    for (const decl of hsym?.getDeclarations() ?? []) {
+      if (ts.isVariableDeclaration(decl) && decl.initializer) {
+        let init = decl.initializer;
+        while (ts.isParenthesizedExpression(init)) init = init.expression;
+        if (ts.isPropertyAccessExpression(init) && ts.isIdentifier(init.name) && init.name.text === "prototype") {
+          const fsym = resolveFnctorSymbol(checker, init.expression);
+          if (fsym) return { name: fsym.name, sym: fsym, viaPrototype: true };
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function resolveLiftedMethodThisStruct(ctx, fn) {
+  const owner = resolveEnclosingFnctorOwner(ctx.checker, fn);
+  if (!owner || !owner.viaPrototype) return void 0;
+  if (!ctx.fnctorEscapeGate?.approvedNames.has(owner.name)) return void 0;
+  return `__fnctor_${owner.name}`;
+}
+function collectFnctorOwnFields(ctorSym) {
+  const fields = /* @__PURE__ */ new Set();
+  const decls = ctorSym.getDeclarations() ?? [];
+  for (const decl of decls) {
+    let body;
+    if ((ts.isFunctionDeclaration(decl) || ts.isFunctionExpression(decl)) && decl.body) body = decl.body;
+    else if (ts.isVariableDeclaration(decl) && decl.initializer) {
+      let init = decl.initializer;
+      while (ts.isParenthesizedExpression(init)) init = init.expression;
+      if (ts.isFunctionExpression(init) && init.body) body = init.body;
+    }
+    if (!body) continue;
+    const walk = (node) => {
+      if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(node.left) && node.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+        fields.add(node.left.name.text);
+      }
+      forEachChild$1(node, walk);
+    };
+    walk(body);
+  }
+  return fields;
+}
+function classifyUse(checker, idNode, ownFields) {
+  const parent = idNode.parent;
+  if (ts.isPropertyAccessExpression(parent) && parent.expression === idNode) {
+    const name = parent.name.text;
+    if (ownFields.has(name)) return "typed";
+    return "dynamic";
+  }
+  if (ts.isElementAccessExpression(parent) && parent.expression === idNode) {
+    return "dynamic";
+  }
+  if (ts.isCallExpression(parent) && parent.arguments.length > 0 && parent.arguments[0] === idNode) {
+    const callee = parent.expression;
+    if (ts.isPropertyAccessExpression(callee) && GENERIC_METHOD_CALL.has(callee.name.text)) {
+      return "dynamic";
+    }
+  }
+  if (ts.isCallExpression(parent)) {
+    const argIdx = parent.arguments.indexOf(idNode);
+    if (argIdx >= 0) {
+      const sig = checker.getResolvedSignature(parent);
+      const paramSym = sig?.parameters[argIdx];
+      if (paramSym) {
+        const pType = checker.getTypeOfSymbolAtLocation(paramSym, idNode);
+        if (isAnyOrUnknown(pType)) return "dynamic";
+      }
+      return "neutral";
+    }
+  }
+  if (ts.isReturnStatement(parent)) {
+    return "neutral";
+  }
+  return "neutral";
+}
+function isAnyOrUnknown(t) {
+  return (t.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0;
+}
+function bindingOf(newExpr) {
+  const parent = newExpr.parent;
+  if (ts.isVariableDeclaration(parent) && parent.initializer === newExpr && ts.isIdentifier(parent.name)) {
+    return parent.name;
+  }
+  return void 0;
+}
+function unwrapExpr(e) {
+  let cur = e;
+  while (ts.isParenthesizedExpression(cur) || ts.isAsExpression(cur) || ts.isNonNullExpression(cur)) {
+    cur = cur.expression;
+  }
+  return cur;
+}
+function isFunctionLike(node) {
+  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node);
+}
+function buildProtoMethodIndex(sourceFile) {
+  const idx = /* @__PURE__ */ new Map();
+  const walk = (n) => {
+    if (ts.isBinaryExpression(n) && n.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(n.left)) {
+      const rhs = unwrapExpr(n.right);
+      if (isFunctionLike(rhs)) {
+        const name = n.left.name.text;
+        const arr = idx.get(name);
+        if (arr) arr.push(rhs);
+        else idx.set(name, [rhs]);
+      }
+    }
+    forEachChild$1(n, walk);
+  };
+  walk(sourceFile);
+  return idx;
+}
+function resolveCalleeFunction(checker, callExpr, protoIndex) {
+  const callee = unwrapExpr(callExpr.expression);
+  let sym;
+  if (ts.isPropertyAccessExpression(callee)) {
+    sym = checker.getSymbolAtLocation(callee.name) ?? checker.getSymbolAtLocation(callee);
+  } else if (ts.isIdentifier(callee)) {
+    sym = checker.getSymbolAtLocation(callee);
+  }
+  if (sym) {
+    for (const decl of sym.getDeclarations() ?? []) {
+      const fn = functionFromDeclaration(decl);
+      if (fn?.body) return fn;
+    }
+  }
+  if (ts.isPropertyAccessExpression(callee)) {
+    const cands = protoIndex.get(callee.name.text);
+    if (cands && cands.length === 1 && cands[0].body) return cands[0];
+  }
+  return void 0;
+}
+function functionFromDeclaration(decl) {
+  if (isFunctionLike(decl)) return decl;
+  if (ts.isVariableDeclaration(decl) && decl.initializer) {
+    const init = unwrapExpr(decl.initializer);
+    if (isFunctionLike(init)) return init;
+    return void 0;
+  }
+  if (ts.isPropertyAssignment(decl)) {
+    const init = unwrapExpr(decl.initializer);
+    if (isFunctionLike(init)) return init;
+    return void 0;
+  }
+  if (ts.isMethodDeclaration(decl)) return decl;
+  if (ts.isPropertyAccessExpression(decl) || ts.isElementAccessExpression(decl)) {
+    const parent = decl.parent;
+    if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.EqualsToken && parent.left === decl) {
+      const rhs = unwrapExpr(parent.right);
+      if (isFunctionLike(rhs)) return rhs;
+    }
+  }
+  return void 0;
+}
+function singleReturnExpr(fn) {
+  const body = fn.body;
+  if (!body) return void 0;
+  if (!ts.isBlock(body)) return body;
+  const returns = [];
+  const walk = (n) => {
+    if (ts.isReturnStatement(n)) {
+      if (n.expression) returns.push(n.expression);
+      return;
+    }
+    if (isFunctionLike(n)) return;
+    forEachChild$1(n, walk);
+  };
+  walk(body);
+  return returns.length === 1 ? returns[0] : void 0;
+}
+function inferReturnStruct(checker, fn, depth, memo, protoIndex) {
+  if (memo.has(fn)) return memo.get(fn);
+  if (depth <= 0) return void 0;
+  memo.set(fn, void 0);
+  const ret2 = singleReturnExpr(fn);
+  let result;
+  if (ret2) {
+    const r = unwrapExpr(ret2);
+    if (ts.isNewExpression(r)) {
+      let ctorSym = resolveFnctorSymbol(checker, r.expression);
+      if (!ctorSym && r.expression.kind === ts.SyntaxKind.ThisKeyword) {
+        ctorSym = resolveEnclosingFnctorOwner(checker, r)?.sym;
+      }
+      if (ctorSym) result = `__fnctor_${ctorSym.name}`;
+    } else if (ts.isCallExpression(r)) {
+      const callee = resolveCalleeFunction(checker, r, protoIndex);
+      if (callee) result = inferReturnStruct(checker, callee, depth - 1, memo, protoIndex);
+    }
+  }
+  memo.set(fn, result);
+  return result;
+}
+function buildReceiverStructMap(checker, sourceFile, usesBySymbol) {
+  const map = /* @__PURE__ */ new Map();
+  const memo = /* @__PURE__ */ new Map();
+  const protoIndex = buildProtoMethodIndex(sourceFile);
+  const visit = (node) => {
+    if (ts.isVariableDeclaration(node) && node.initializer && ts.isIdentifier(node.name)) {
+      const init = unwrapExpr(node.initializer);
+      let struct;
+      if (ts.isCallExpression(init)) {
+        const callee = resolveCalleeFunction(checker, init, protoIndex);
+        struct = callee ? inferReturnStruct(checker, callee, RETURN_INFER_MAX_DEPTH, memo, protoIndex) : void 0;
+      } else if (ts.isNewExpression(init)) {
+        let ctorSym = resolveFnctorSymbol(checker, init.expression);
+        if (!ctorSym && init.expression.kind === ts.SyntaxKind.ThisKeyword) {
+          ctorSym = resolveEnclosingFnctorOwner(checker, init)?.sym;
+        }
+        struct = ctorSym ? `__fnctor_${ctorSym.name}` : void 0;
+      }
+      if (struct) {
+        const bindSym = checker.getSymbolAtLocation(node.name);
+        const uses = bindSym ? usesBySymbol.get(bindSym) ?? [] : [];
+        for (const use of uses) {
+          if (use === node.name) continue;
+          map.set(use, struct);
+        }
+      }
+    }
+    forEachChild$1(node, visit);
+  };
+  visit(sourceFile);
+  return map;
+}
+function resolveReceiverStruct(ctx, fctx, recvExpr) {
+  const recv = unwrapExpr(recvExpr);
+  let name;
+  if (recv.kind === ts.SyntaxKind.ThisKeyword) {
+    name = fctx.thisStructName;
+  } else {
+    name = ctx.fnctorEscapeGate?.receiverStruct.get(recv);
+  }
+  if (name !== void 0 && ctx.structMap.has(name)) return name;
+  return void 0;
+}
+function analyzeFnctorEscapeGate(checker, sourceFile) {
+  const sites = /* @__PURE__ */ new Map();
+  const approved = /* @__PURE__ */ new Set();
+  const approvedNames = /* @__PURE__ */ new Set();
+  const newSites = [];
+  const newThisSites = /* @__PURE__ */ new Set();
+  const collect = (node) => {
+    if (ts.isNewExpression(node)) {
+      let ctorSym = resolveFnctorSymbol(checker, node.expression);
+      if (!ctorSym && node.expression.kind === ts.SyntaxKind.ThisKeyword) {
+        const owner = resolveEnclosingFnctorOwner(checker, node);
+        if (owner) {
+          ctorSym = owner.sym;
+          newThisSites.add(node);
+        }
+      }
+      if (ctorSym) newSites.push({ newExpr: node, ctorSym });
+    }
+    forEachChild$1(node, collect);
+  };
+  collect(sourceFile);
+  if (newSites.length === 0) return EMPTY_RESULT;
+  const ctorDeclByName = /* @__PURE__ */ new Map();
+  for (const { ctorSym } of newSites) {
+    if (ctorDeclByName.has(ctorSym.name)) continue;
+    const decl = fnctorDeclFromSymbol(ctorSym);
+    if (decl) ctorDeclByName.set(ctorSym.name, decl);
+  }
+  const usesBySymbol = /* @__PURE__ */ new Map();
+  const indexUses = (node) => {
+    if (ts.isIdentifier(node)) {
+      const sym = checker.getSymbolAtLocation(node);
+      if (sym) {
+        const arr = usesBySymbol.get(sym);
+        if (arr) arr.push(node);
+        else usesBySymbol.set(sym, [node]);
+      }
+    }
+    forEachChild$1(node, indexUses);
+  };
+  indexUses(sourceFile);
+  const newThisOwnerNames = /* @__PURE__ */ new Set();
+  for (const { newExpr, ctorSym } of newSites) {
+    const ownFields = collectFnctorOwnFields(ctorSym);
+    let sawDynamic = false;
+    let sawTyped = false;
+    const bind = bindingOf(newExpr);
+    if (bind) {
+      const bindSym = checker.getSymbolAtLocation(bind);
+      const uses = bindSym ? usesBySymbol.get(bindSym) ?? [] : [];
+      for (const use of uses) {
+        if (use === bind) continue;
+        const c = classifyUse(checker, use, ownFields);
+        if (c === "typed") sawTyped = true;
+        else if (c === "dynamic") sawDynamic = true;
+      }
+    } else {
+      let inner = newExpr;
+      let parent = inner.parent;
+      while (ts.isParenthesizedExpression(parent) || ts.isAsExpression(parent) || ts.isNonNullExpression(parent)) {
+        inner = parent;
+        parent = parent.parent;
+      }
+      if (ts.isPropertyAccessExpression(parent) && parent.expression === inner) {
+        if (ownFields.has(parent.name.text)) sawTyped = true;
+        else sawDynamic = true;
+      } else if (ts.isElementAccessExpression(parent) && parent.expression === inner) {
+        sawDynamic = true;
+      } else if (ts.isCallExpression(parent) && parent.arguments.length > 0 && parent.arguments[0] === inner && ts.isPropertyAccessExpression(parent.expression) && GENERIC_METHOD_CALL.has(parent.expression.name.text)) {
+        sawDynamic = true;
+      }
+    }
+    let cls;
+    if (newThisSites.has(newExpr)) cls = "reconstruct";
+    else if (sawTyped) cls = "keep-typed";
+    else if (sawDynamic) cls = "reconstruct";
+    else cls = "keep-static";
+    sites.set(newExpr, cls);
+    if (cls === "reconstruct") {
+      approved.add(newExpr);
+      approvedNames.add(ctorSym.name);
+      if (newThisSites.has(newExpr)) newThisOwnerNames.add(ctorSym.name);
+    }
+  }
+  const receiverStruct = buildReceiverStructMap(checker, sourceFile, usesBySymbol);
+  if (process.env.JS2WASM_LOG_FNCTOR_GATE === "1" && (sites.size > 0 || receiverStruct.size > 0)) {
+    const counts = { reconstruct: 0, "keep-typed": 0, "keep-static": 0 };
+    for (const c of sites.values()) counts[c]++;
+    console.error(
+      `[#2660 fnctor-escape-gate] ${sites.size} new F() site(s): reconstruct=${counts.reconstruct} keep-typed=${counts["keep-typed"]} keep-static=${counts["keep-static"]}; receiverStruct flow-map entries=${receiverStruct.size}`
+    );
+  }
+  return { sites, approved, approvedNames, receiverStruct, newThisOwnerNames, ctorDeclByName };
+}
+function deriveFnctorFields(ctx, funcDecl) {
+  const body = funcDecl.body;
+  if (!body) return [];
+  const fields = [];
+  function recordThisField(lhs, valueExpr) {
+    const fieldName = lhs.name.text;
+    if (fields.some((f) => f.name === fieldName)) return;
+    const lhsType = ctx.checker.getTypeAtLocation(lhs);
+    const rhsType = ctx.checker.getTypeAtLocation(valueExpr);
+    const lhsWasm = resolveWasmType(ctx, lhsType);
+    const rhsWasm = resolveWasmType(ctx, rhsType);
+    const fieldType = lhsWasm.kind === "externref" ? rhsWasm : lhsWasm;
+    fields.push({ name: fieldName, type: fieldType, mutable: true });
+  }
+  function collectAssignmentChain(expr) {
+    if (ts.isBinaryExpression(expr) && expr.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(expr.left) && expr.left.expression.kind === ts.SyntaxKind.ThisKeyword) {
+      recordThisField(expr.left, expr.right);
+      collectAssignmentChain(expr.right);
+    }
+  }
+  function collectThisAssignments(stmts) {
+    for (const stmt of stmts) {
+      if (ts.isExpressionStatement(stmt) && ts.isBinaryExpression(stmt.expression)) {
+        collectAssignmentChain(stmt.expression);
+      }
+      if (ts.isIfStatement(stmt)) {
+        if (ts.isBlock(stmt.thenStatement)) {
+          collectThisAssignments(stmt.thenStatement.statements);
+        }
+        if (stmt.elseStatement && ts.isBlock(stmt.elseStatement)) {
+          collectThisAssignments(stmt.elseStatement.statements);
+        }
+      }
+      if ((ts.isForStatement(stmt) || ts.isForInStatement(stmt) || ts.isForOfStatement(stmt) || ts.isWhileStatement(stmt) || ts.isDoStatement(stmt)) && ts.isBlock(stmt.statement)) {
+        collectThisAssignments(stmt.statement.statements);
+      }
+    }
+  }
+  collectThisAssignments(body.statements);
+  for (const field of fields) {
+    if (field.type.kind === "ref") {
+      field.type = {
+        kind: "ref_null",
+        typeIdx: field.type.typeIdx
+      };
+    }
+  }
+  return fields;
+}
 function isFunctionScopeBoundary(node) {
   return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node);
 }
@@ -142999,7 +143684,15 @@ function compileArrowAsClosure(ctx, fctx, arrow) {
     // which installs the host receiver into `__current_this`. Allow `this`
     // (with no other binding) to read that global. Named functions / methods
     // are NOT lifted here and keep `undefined`/globalObject `this`.
-    readsCurrentThis: true
+    readsCurrentThis: true,
+    // (#2681/#2686 A3) When this lifted closure is a fnctor PROTOTYPE method of an
+    // approved-for-reconstruction fnctor (`F.prototype.m = fn` / aliased `var pp =
+    // F.prototype; pp.m = fn`), pin its `this` receiver to `__fnctor_F` so the
+    // dynamic `this.<field>` read dispatch (property-access.ts) routes through the
+    // finalize-filled `__get_member_<name>` struct dispatcher instead of the
+    // host-proxy `__extern_get` (whose externref identity diverges from the stored
+    // native struct → the #2681/#2686 throw).
+    thisStructName: resolveLiftedMethodThisStruct(ctx, arrow)
   };
   ctx.liveBodies.add(liftedFctx.body);
   for (let i = 0; i < liftedFctx.params.length; i++) {
@@ -144869,7 +145562,7 @@ function compileStaticPropIncDec(ctx, fctx, globalIdx, f64Op, mode) {
   fctx.body.push({ op: "local.get", index: mode === "postfix" ? oldTmp : newTmp });
   return { kind: "f64" };
 }
-function emitExternrefMemberIncDec(ctx, fctx, objLocal, propName, f64Op, mode) {
+function emitExternrefMemberIncDec(ctx, fctx, objLocal, propName, f64Op, mode, pinned) {
   addStringConstantGlobal(ctx, propName);
   const keyResult = compileStringLiteral(ctx, fctx, propName);
   if (keyResult && keyResult.kind !== "externref") {
@@ -144878,16 +145571,21 @@ function emitExternrefMemberIncDec(ctx, fctx, objLocal, propName, f64Op, mode) {
   const keyLocal = allocLocal(fctx, `__incdec_ekey_${fctx.locals.length}`, { kind: "externref" });
   fctx.body.push({ op: "local.set", index: keyLocal });
   fctx.body.push({ op: "local.get", index: objLocal });
-  fctx.body.push({ op: "local.get", index: keyLocal });
-  const getIdx = ensureLateImport(
-    ctx,
-    "__extern_get",
-    [{ kind: "externref" }, { kind: "externref" }],
-    [{ kind: "externref" }]
-  );
-  flushLateImportShifts(ctx, fctx);
-  if (getIdx !== void 0) {
-    fctx.body.push({ op: "call", funcIdx: getIdx });
+  const getDispIdx = pinned ? reserveMemberGetDispatch(ctx, propName, fctx) : void 0;
+  if (getDispIdx !== void 0) {
+    fctx.body.push({ op: "call", funcIdx: getDispIdx });
+  } else {
+    fctx.body.push({ op: "local.get", index: keyLocal });
+    const getIdx = ensureLateImport(
+      ctx,
+      "__extern_get",
+      [{ kind: "externref" }, { kind: "externref" }],
+      [{ kind: "externref" }]
+    );
+    flushLateImportShifts(ctx, fctx);
+    if (getIdx !== void 0) {
+      fctx.body.push({ op: "call", funcIdx: getIdx });
+    }
   }
   addUnionImports(ctx);
   const unboxIdx = ctx.funcMap.get("__unbox_number");
@@ -144914,7 +145612,7 @@ function emitExternrefMemberIncDec(ctx, fctx, objLocal, propName, f64Op, mode) {
     []
   );
   flushLateImportShifts(ctx, fctx);
-  const dispatched = emitAlternateStructSetDispatch(
+  const dispatched = pinned && emitAlternateStructSetDispatch(
     ctx,
     fctx,
     objLocal,
@@ -144975,25 +145673,10 @@ function emitExternrefElementIncDec(ctx, fctx, baseLocal, keyExpr, f64Op, mode)
     []
   );
   flushLateImportShifts(ctx, fctx);
-  const litName = ts.isStringLiteral(keyExpr) ? keyExpr.text : void 0;
-  let dispatched = false;
-  if (litName !== void 0) {
-    dispatched = emitAlternateStructSetDispatch(
-      ctx,
-      fctx,
-      baseLocal,
-      boxedLocal,
-      litName,
-      /*strict*/
-      false
-    );
-  }
-  if (!dispatched) {
-    fctx.body.push({ op: "local.get", index: baseLocal });
-    fctx.body.push({ op: "local.get", index: keyLocal });
-    fctx.body.push({ op: "local.get", index: boxedLocal });
-    if (setIdx !== void 0) fctx.body.push({ op: "call", funcIdx: setIdx });
-  }
+  fctx.body.push({ op: "local.get", index: baseLocal });
+  fctx.body.push({ op: "local.get", index: keyLocal });
+  fctx.body.push({ op: "local.get", index: boxedLocal });
+  if (setIdx !== void 0) fctx.body.push({ op: "call", funcIdx: setIdx });
   fctx.body.push({ op: "local.get", index: mode === "postfix" ? oldTmp : newTmp });
   return { kind: "f64" };
 }
@@ -145019,6 +145702,7 @@ function compileMemberIncDec(ctx, fctx, operand, arithOp, mode) {
       typeName = ctx.widenedVarStructMap.get(operand.expression.text);
     }
     if (!typeName) {
+      const incDecPinned = operand.expression.kind === ts.SyntaxKind.ThisKeyword && fctx.thisStructName !== void 0 || resolveReceiverStruct(ctx, fctx, operand.expression) !== void 0;
       const objResult2 = compileExpression$1(ctx, fctx, operand.expression);
       if (objResult2) {
         const objLocal = allocLocal(fctx, `__incdec_eobj_${fctx.locals.length}`, { kind: "externref" });
@@ -145026,7 +145710,7 @@ function compileMemberIncDec(ctx, fctx, operand, arithOp, mode) {
           coerceType$2(ctx, fctx, objResult2, { kind: "externref" });
         }
         fctx.body.push({ op: "local.set", index: objLocal });
-        return emitExternrefMemberIncDec(ctx, fctx, objLocal, propName, f64Op, mode);
+        return emitExternrefMemberIncDec(ctx, fctx, objLocal, propName, f64Op, mode, incDecPinned);
       }
       reportSilentFallback(ctx, "const-fallback", "unary-updates:incdec-unresolvable-receiver-type", operand);
       fctx.body.push({ op: "f64.const", value: NaN });
@@ -146647,11 +147331,11 @@ function compileExpressionInner(ctx, fctx, expr, expectedType) {
   }
   if (expr.kind === ts.SyntaxKind.TrueKeyword) {
     fctx.body.push({ op: "i32.const", value: 1 });
-    return { kind: "i32" };
+    return { kind: "i32", boolean: true };
   }
   if (expr.kind === ts.SyntaxKind.FalseKeyword) {
     fctx.body.push({ op: "i32.const", value: 0 });
-    return { kind: "i32" };
+    return { kind: "i32", boolean: true };
   }
   if (expr.kind === ts.SyntaxKind.NullKeyword) {
     fctx.body.push({ op: "ref.null.extern" });
@@ -154570,7 +155254,18 @@ declare function __wasiStdinSetReader(cb: () => void): void;
 declare function __wasiStdinStop(): void;
 
 class __Js2wasmReadable {
-  private chunk: string = "";
+  // #2777 — accumulate drained bytes in an amortized-growth byte buffer instead
+  // of building each 'data' chunk via per-byte string concatenation. Building the
+  // chunk by \`this.chunk = this.chunk + String.fromCharCode(b)\` made a large
+  // frame's read side quadratic (the consumer then re-flattened the growing
+  // cons-rope on every charCodeAt/substring), which SIGKILLed nm_node_process at
+  // multi-MiB. The bytes now live in \`buf[head..tail)\`; the chunk STRING the
+  // Node 'data' contract delivers is materialised ONCE per emit/read from that
+  // slice (a single flatten), so consumers receive a FLAT string and their
+  // charCodeAt/substring over it is O(1)/O(k), not a re-flatten per access.
+  private buf: Uint8Array = new Uint8Array(64);
+  private head: number = 0;
+  private tail: number = 0;
   private dataCbs: ((c: string) => void)[] = [];
   private endCbs: (() => void)[] = [];
   private readableCbs: (() => void)[] = [];
@@ -154582,17 +155277,60 @@ class __Js2wasmReadable {
   private eofReadableFired: boolean = false;
   private destroyed: boolean = false;
 
+  // Buffered byte count.
+  private avail(): number { return this.tail - this.head; }
+
+  // Ensure room for \`extra\` more bytes at \`tail\`: first reclaim any consumed
+  // prefix (head > 0), then amortized-double the backing array until it fits.
+  private ensure(extra: number): void {
+    if (this.tail + extra <= this.buf.length) { return; }
+    if (this.head > 0) {
+      const m = this.tail - this.head;
+      let i = 0;
+      while (i < m) { this.buf[i] = this.buf[this.head + i]; i = i + 1; }
+      this.head = 0;
+      this.tail = m;
+      if (this.tail + extra <= this.buf.length) { return; }
+    }
+    let cap = this.buf.length;
+    if (cap < 16) { cap = 16; }
+    while (cap < this.tail + extra) { cap = cap * 2; }
+    const nb = new Uint8Array(cap);
+    let j = 0;
+    while (j < this.tail) { nb[j] = this.buf[j]; j = j + 1; }
+    this.buf = nb;
+  }
+
+  // Materialise buf[start..end) as a FLAT string (one char per byte). The
+  // trailing substring(0, len) forces a SINGLE flatten of the cons-rope built by
+  // the per-byte concat, so the delivered chunk is flat — a consumer's
+  // charCodeAt/substring over it is then O(1)/O(k), never a re-flatten per call.
+  private slice(start: number, end: number): string {
+    let s = "";
+    let i = start;
+    while (i < end) { s = s + String.fromCharCode(this.buf[i]); i = i + 1; }
+    return s.substring(0, end - start);
+  }
+
+  // Append all currently-buffered stdin bytes into \`buf\` — O(n), no string ops.
   private drainBytes(): number {
     let n = 0;
     let b = __wasiStdinReadByte();
-    while (b >= 0) { this.chunk = this.chunk + String.fromCharCode(b); n = n + 1; b = __wasiStdinReadByte(); }
+    while (b >= 0) {
+      this.ensure(1);
+      this.buf[this.tail] = b;
+      this.tail = this.tail + 1;
+      n = n + 1;
+      b = __wasiStdinReadByte();
+    }
     return n;
   }
 
   private emitChunk(): void {
-    if (this.chunk.length === 0) return;
-    const out = this.chunk;
-    this.chunk = "";
+    if (this.tail <= this.head) { return; }
+    const out = this.slice(this.head, this.tail);
+    this.head = 0;
+    this.tail = 0;
     for (let i = 0; i < this.dataCbs.length; i = i + 1) { this.dataCbs[i](out); }
   }
 
@@ -154605,7 +155343,7 @@ class __Js2wasmReadable {
     // 'readable' fires when new bytes arrived OR when the stream has just reached
     // EOF with bytes still buffered (Node emits a final 'readable' at end-of-
     // stream so the consumer can read the last partial chunk before 'end').
-    const eofFlush = atEof && !this.eofReadableFired && this.chunk.length > 0;
+    const eofFlush = atEof && !this.eofReadableFired && this.avail() > 0;
     if (got > 0 || eofFlush) {
       if (eofFlush) { this.eofReadableFired = true; }
       for (let i = 0; i < this.readableCbs.length; i = i + 1) { this.readableCbs[i](); }
@@ -154614,7 +155352,7 @@ class __Js2wasmReadable {
     // 'end' only after fd EOF AND the stream's own buffer is fully delivered
     // (a paused stream withholds bytes in this.chunk, so EOF alone is not the
     // end of the readable side -- matches Node).
-    if (atEof && this.chunk.length === 0 && !this.ended) {
+    if (atEof && this.avail() === 0 && !this.ended) {
       this.ended = true;
       for (let i = 0; i < this.endCbs.length; i = i + 1) { this.endCbs[i](); }
     }
@@ -154657,24 +155395,27 @@ class __Js2wasmReadable {
     if (this.destroyed) { return null; }
     // Pull any freshly-ready bytes so a paused .read() sees the latest buffer.
     this.drainBytes();
-    const avail = this.chunk.length;
+    const avail = this.avail();
     if (size === undefined || size < 0) {
       if (avail === 0) { return null; }
-      const all = this.chunk;
-      this.chunk = "";
+      const all = this.slice(this.head, this.tail);
+      this.head = 0;
+      this.tail = 0;
       return all;
     }
     if (avail < size) {
       if (__wasiStdinEof() && avail > 0) {
-        const rest = this.chunk;
-        this.chunk = "";
+        const rest = this.slice(this.head, this.tail);
+        this.head = 0;
+        this.tail = 0;
         return rest;
       }
       return null;
     }
-    const head = this.chunk.substring(0, size);
-    this.chunk = this.chunk.substring(size);
-    return head;
+    const out = this.slice(this.head, this.head + size);
+    this.head = this.head + size;
+    if (this.head >= this.tail) { this.head = 0; this.tail = 0; }
+    return out;
   }
 
   pause(): __Js2wasmReadable { this.paused = true; return this; }
@@ -155522,8 +156263,14 @@ function buildCodegenOptions(options, emitSourceMap, prep) {
     utf8Storage: options.utf8Storage,
     testRuntime: options.testRuntime,
     wasi: options.target === "wasi",
-    linkNodeShims: options.linkNodeShims,
+    // #2783 — the dynamic-linking axis: namespaces to leave as link-time imports
+    // (deduped). `link: ["node:fs"]` is the only spelling; the old `linkNodeShims`
+    // boolean was removed.
+    link: [...new Set(options.link ?? [])],
     standalone: options.target === "standalone",
+    // (#2796) Diff-test-harness fidelity — defer top-level init to an export so
+    // the host runs it after setExports (symmetric with standalone `_start`).
+    deferTopLevelInit: options.deferTopLevelInit,
     strictNoHostImports: options.strictNoHostImports,
     // (#2119) thread module-strictness inference uniformly across all drivers.
     inferModuleStrictArguments: options.inferModuleStrictArguments,
@@ -157704,6 +158451,7 @@ const _PROTO_CB_SLOTS = {
   catch: { argIdx: 0, arity: 1 },
   finally: { argIdx: 0, arity: 0 }
 };
+const _VEC_PRIMITIVE_READ_METHODS = /* @__PURE__ */ new Set(["indexOf", "lastIndexOf", "includes", "join"]);
 function _readIterResultField(result, field, exports$1) {
   if (result != null && typeof result === "object" && _isWasmStruct(result)) {
     const getter = exports$1?.[`__sget_${field}`];
@@ -159370,9 +160118,97 @@ function _setLikeRecordForHost(arg, exports$1, state) {
   };
   return { size: fixField("size"), has: fixField("has"), keys: fixField("keys") };
 }
+function _asArrayIndex(key) {
+  if (key === "0") return 0;
+  if (key.length === 0 || key.charCodeAt(0) === 48) return void 0;
+  const n = Number(key);
+  if (Number.isInteger(n) && n >= 0 && n < 4294967295 && String(n) === key) return n;
+  return void 0;
+}
+function _wrapVecForHost(vec, exports$1) {
+  const cached = _hostProxyCache.get(vec);
+  if (cached) return cached;
+  const lenFn = exports$1.__vec_len;
+  const getFn = exports$1.__vec_get;
+  if (typeof lenFn !== "function" || typeof getFn !== "function") return void 0;
+  const liveLen = () => {
+    try {
+      const n = lenFn(vec);
+      return typeof n === "number" && n >= 0 ? n : 0;
+    } catch {
+      return 0;
+    }
+  };
+  const elemAt = (i) => {
+    try {
+      return _wrapForHost(getFn(vec, i), exports$1);
+    } catch {
+      return void 0;
+    }
+  };
+  const target = [];
+  const handler = {
+    get(_t, key) {
+      if (key === "length") return liveLen();
+      if (typeof key === "string") {
+        const idx = _asArrayIndex(key);
+        if (idx !== void 0) return idx < liveLen() ? elemAt(idx) : void 0;
+      }
+      return target[key];
+    },
+    has(_t, key) {
+      if (key === "length") return true;
+      if (typeof key === "string") {
+        const idx = _asArrayIndex(key);
+        if (idx !== void 0) return idx < liveLen();
+      }
+      return key in target;
+    },
+    ownKeys() {
+      const n = liveLen();
+      const keys = [];
+      for (let i = 0; i < n; i++) keys.push(String(i));
+      keys.push("length");
+      return keys;
+    },
+    getOwnPropertyDescriptor(_t, key) {
+      if (key === "length") {
+        return { value: liveLen(), writable: true, enumerable: false, configurable: false };
+      }
+      if (typeof key === "string") {
+        const idx = _asArrayIndex(key);
+        if (idx !== void 0 && idx < liveLen()) {
+          return { value: elemAt(idx), writable: true, enumerable: true, configurable: true };
+        }
+      }
+      return void 0;
+    },
+    // Host-side writes are not part of the AST-read contract and the vec has no
+    // general element-setter export; accept silently (keep the target clean) so
+    // a stray host write neither throws nor leaves a phantom element. acorn's
+    // own mutations go through `__extern_method_call` (unwrap → `__vec_push`).
+    set() {
+      return true;
+    }
+  };
+  const proxy = new Proxy(target, handler);
+  _hostProxyCache.set(vec, proxy);
+  _hostProxyReverse.set(proxy, vec);
+  return proxy;
+}
 function _wrapForHost(obj, exports$1) {
   if (obj == null || typeof obj !== "object") return obj;
   if (!_isWasmStruct(obj)) return obj;
+  if (exports$1) {
+    try {
+      const isVecFn = exports$1.__is_vec;
+      if (typeof isVecFn === "function" && isVecFn(obj) === 1) {
+        const vecView = _wrapVecForHost(obj, exports$1);
+        if (vecView !== void 0) return vecView;
+      }
+    } catch {
+    }
+  }
   const cached = _hostProxyCache.get(obj);
   if (cached) return cached;
   const target = /* @__PURE__ */ Object.create(null);
@@ -159418,6 +160254,13 @@ function _wrapForHost(obj, exports$1) {
           }
         } catch {
         }
+        try {
+          const isDataFn = exports$1.__is_data_struct;
+          if (typeof isDataFn === "function" && isDataFn(val) === 1) {
+            return _wrapForHost(val, exports$1);
+          }
+        } catch {
+        }
         const exportKey = typeof key === "string" ? key : typeof key === "symbol" ? _symbolToWasm.get(key) : void 0;
         if (exportKey !== void 0) {
           const callFn = exports$1[`__call_${exportKey}`];
@@ -162305,6 +163148,27 @@ if (__fail) throw new Test262Error('eval harness assertion ' + __fail + ' failed
                     return exports$1.__vec_pop(rawVec);
                   }
                 }
+                if (_VEC_PRIMITIVE_READ_METHODS.has(method) && typeof exports$1.__vec_len === "function" && typeof exports$1.__vec_get === "function") {
+                  const isVecFn = exports$1.__is_vec;
+                  let isVec = false;
+                  try {
+                    isVec = typeof isVecFn === "function" && isVecFn(rawVec) === 1;
+                  } catch {
+                    isVec = false;
+                  }
+                  if (isVec) {
+                    const len = exports$1.__vec_len(rawVec);
+                    if (typeof len === "number" && len >= 0) {
+                      const getFn = exports$1.__vec_get;
+                      const arr = new Array(len);
+                      for (let i = 0; i < len; i++) arr[i] = wrapHostValue(getFn(rawVec, i));
+                      const nativeFn = Array.prototype[method];
+                      if (typeof nativeFn === "function") {
+                        return nativeFn.apply(arr, wrappedArgs);
+                      }
+                    }
+                  }
+                }
               }
             }
             if ((method === "getOrInsert" || method === "getOrInsertComputed") && (wrappedObj instanceof Map || wrappedObj instanceof WeakMap)) {
@@ -162504,6 +163368,31 @@ if (__fail) throw new Test262Error('eval harness assertion ' + __fail + ' failed
             const wrappedTarget = _wrapForHost(target, exports$1);
             const wrappedSources2 = (sources ?? []).map((s) => _isWasmStruct(s) ? _wrapForHost(s, exports$1) : s);
             Object.assign(wrappedTarget, ...wrappedSources2);
+            const targetDescs = _getSidecarDescs(target);
+            const staticFieldNames = new Set(_getStructFieldNames(target, exports$1) ?? []);
+            for (const ws of wrappedSources2) {
+              if (ws == null || typeof ws !== "object" && typeof ws !== "function") continue;
+              let keys;
+              try {
+                keys = Reflect.ownKeys(ws);
+              } catch {
+                continue;
+              }
+              for (const k of keys) {
+                let enumerable;
+                try {
+                  enumerable = Object.getOwnPropertyDescriptor(ws, k)?.enumerable === true;
+                } catch {
+                  enumerable = false;
+                }
+                if (!enumerable) continue;
+                if (typeof k === "string" && staticFieldNames.has(k)) continue;
+                const nk = _normalizeDescKey(k);
+                if (!targetDescs.has(nk)) {
+                  targetDescs.set(nk, _SC_WRITABLE | _SC_ENUMERABLE | _SC_CONFIGURABLE | _SC_DEFINED);
+                }
+              }
+            }
             return target;
           }
           const wrappedSources = (sources ?? []).map((s) => _isWasmStruct(s) ? _wrapForHost(s, exports$1) : s);