goscript 0.2.3 → 0.2.5

package/compiler/lowering.go

@@ -76,6 +76,8 @@ func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel, opts ..
 
 	program := &LoweredProgram{}
 	lazyPackageVars := make(map[string]map[types.Object]bool, len(model.packages))
+	asyncLazyFunctionCache := make(map[*types.Func]bool)
+	asyncLazyFunctionVisiting := make(map[*types.Func]bool)
 	runtimeMethodSets := make(runtimeMethodSetCache)
 	semPkgs := make([]*semanticPackage, 0, len(model.packages))
 	for _, semPkg := range model.packages {
@@ -91,7 +93,15 @@ func (o *LoweringOwner) Build(ctx context.Context, model *SemanticModel, opts ..
 			diagnostics = append(diagnostics, loweringUnsupported("package", semPkg.pkgPath, "missing semantic source package"))
 			continue
 		}
-		loweredPkg, pkgDiagnostics := o.lowerPackage(model, semPkg, lazyPackageVars, runtimeMethodSets, options)
+		loweredPkg, pkgDiagnostics := o.lowerPackage(
+			model,
+			semPkg,
+			lazyPackageVars,
+			asyncLazyFunctionCache,
+			asyncLazyFunctionVisiting,
+			runtimeMethodSets,
+			options,
+		)
 		diagnostics = append(diagnostics, pkgDiagnostics...)
 		if loweredPkg != nil {
 			program.packages = append(program.packages, loweredPkg)
@@ -107,6 +117,8 @@ func (o *LoweringOwner) lowerPackage(
 	model *SemanticModel,
 	semPkg *semanticPackage,
 	lazyPackageVarsByPkg map[string]map[types.Object]bool,
+	asyncLazyFunctionCache map[*types.Func]bool,
+	asyncLazyFunctionVisiting map[*types.Func]bool,
 	runtimeMethodSets runtimeMethodSetCache,
 	options LoweringOptions,
 ) (*loweredPackage, []Diagnostic) {
@@ -143,6 +155,8 @@ func (o *LoweringOwner) lowerPackage(
 				outputNames,
 				lazyPackageVars,
 				lazyPackageVarsByPkg,
+				asyncLazyFunctionCache,
+				asyncLazyFunctionVisiting,
 				runtimeMethodSets,
 				protobufAdapter,
 				options.DisplayRoot,
@@ -163,6 +177,8 @@ func (o *LoweringOwner) lowerPackage(
 			outputNames,
 			lazyPackageVars,
 			lazyPackageVarsByPkg,
+			asyncLazyFunctionCache,
+			asyncLazyFunctionVisiting,
 			runtimeMethodSets,
 			false,
 			options.DisplayRoot,
@@ -199,6 +215,8 @@ func (o *LoweringOwner) lowerFile(
 	outputNames map[string]string,
 	lazyPackageVars map[types.Object]bool,
 	lazyPackageVarsByPkg map[string]map[types.Object]bool,
+	asyncLazyFunctionCache map[*types.Func]bool,
+	asyncLazyFunctionVisiting map[*types.Func]bool,
 	runtimeMethodSets runtimeMethodSetCache,
 	protobufTypeScriptAdapter bool,
 	displayRoot string,
@@ -308,21 +326,23 @@ func (o *LoweringOwner) lowerFile(
 	loweredFile.imports = append(loweredFile.imports, localImports...)
 
 	ctx := lowerFileContext{
-		model:                model,
-		semPkg:               semPkg,
-		file:                 file,
-		importAliases:        importAliases,
-		importPaths:          importPaths,
-		importNames:          importNames,
-		importObjects:        importObjects,
-		sourcePath:           sourcePath,
-		localAliases:         localRefs.aliases,
-		lazyPackageVars:      lazyPackageVars,
-		lazyPackageVarsByPkg: lazyPackageVarsByPkg,
-		tempNames:            newTempNameOwner(),
-		topLevel:             true,
-		protobufTSAdapter:    protobufTypeScriptAdapter,
-		displayRoot:          displayRoot,
+		model:                     model,
+		semPkg:                    semPkg,
+		file:                      file,
+		importAliases:             importAliases,
+		importPaths:               importPaths,
+		importNames:               importNames,
+		importObjects:             importObjects,
+		sourcePath:                sourcePath,
+		localAliases:              localRefs.aliases,
+		lazyPackageVars:           lazyPackageVars,
+		lazyPackageVarsByPkg:      lazyPackageVarsByPkg,
+		asyncLazyFunctionCache:    asyncLazyFunctionCache,
+		asyncLazyFunctionVisiting: asyncLazyFunctionVisiting,
+		tempNames:                 newTempNameOwner(),
+		topLevel:                  true,
+		protobufTSAdapter:         protobufTypeScriptAdapter,
+		displayRoot:               displayRoot,
 	}
 	var diagnostics []Diagnostic
 	var packageInitCalls []string
@@ -1067,7 +1087,7 @@ func safeIdentifier(value string) string {
 	switch identifier {
 	case "abstract", "any", "arguments", "as", "asserts", "async", "await", "boolean",
 		"break", "case", "catch", "class", "const", "constructor", "continue", "debugger",
-		"declare", "default", "delete", "do", "else", "enum", "export", "extends", "false",
+		"declare", "default", "delete", "do", "else", "enum", "eval", "export", "extends", "false",
 		"finally", "for", "from", "function", "get", "if", "implements", "import", "in",
 		"infer", "instanceof", "interface", "is", "keyof", "let", "module", "namespace",
 		"never", "new", "null", "number", "object", "of", "package", "private", "protected",
@@ -1095,40 +1115,42 @@ func safeParamName(param *types.Var, idx int) string {
 }
 
 type lowerFileContext struct {
-	model                *SemanticModel
-	semPkg               *semanticPackage
-	file                 *ast.File
-	importAliases        map[string]string
-	importPaths          map[string]string
-	importNames          map[string]string
-	importObjects        map[*types.PkgName]string
-	sourcePath           string
-	localAliases         map[types.Object]string
-	lazyPackageVars      map[types.Object]bool
-	lazyPackageVarsByPkg map[string]map[types.Object]bool
-	identAliases         map[types.Object]string
-	identAliasRefs       map[types.Object]bool
-	tempNames            *tempNameOwner
-	signature            *types.Signature
-	typeParams           map[string]bool
-	staticTypeParams     map[string]bool
-	asyncFunction        bool
-	functionTypeDepth    int
-	deferState           *loweredDeferState
-	rangeBranch          *loweredRangeBranch
-	rangeBreak           bool
-	rangeContinue        bool
-	gotoLabels           map[string]bool
-	forwardGotos         map[string]bool
-	gotoStateLabels      map[string]bool
-	gotoStateVar         string
-	gotoStateLoop        string
-	functionScopedDecls  bool
-	loopLabel            string
-	switchBreak          bool
-	topLevel             bool
-	protobufTSAdapter    bool
-	displayRoot          string
+	model                     *SemanticModel
+	semPkg                    *semanticPackage
+	file                      *ast.File
+	importAliases             map[string]string
+	importPaths               map[string]string
+	importNames               map[string]string
+	importObjects             map[*types.PkgName]string
+	sourcePath                string
+	localAliases              map[types.Object]string
+	lazyPackageVars           map[types.Object]bool
+	lazyPackageVarsByPkg      map[string]map[types.Object]bool
+	asyncLazyFunctionCache    map[*types.Func]bool
+	asyncLazyFunctionVisiting map[*types.Func]bool
+	identAliases              map[types.Object]string
+	identAliasRefs            map[types.Object]bool
+	tempNames                 *tempNameOwner
+	signature                 *types.Signature
+	typeParams                map[string]bool
+	staticTypeParams          map[string]bool
+	asyncFunction             bool
+	functionTypeDepth         int
+	deferState                *loweredDeferState
+	rangeBranch               *loweredRangeBranch
+	rangeBreak                bool
+	rangeContinue             bool
+	gotoLabels                map[string]bool
+	forwardGotos              map[string]bool
+	gotoStateLabels           map[string]bool
+	gotoStateVar              string
+	gotoStateLoop             string
+	functionScopedDecls       bool
+	loopLabel                 string
+	switchBreak               bool
+	topLevel                  bool
+	protobufTSAdapter         bool
+	displayRoot               string
 }
 
 func (ctx lowerFileContext) diagnosticPosition(pos token.Pos) *DiagnosticPosition {
@@ -1349,7 +1371,12 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 							"if (((" + declName + ") as any) === undefined) {\n\t\t" +
 							declName + " = " + value + "\n\t}\n}"
 						decls = append(decls, loweredDecl{code: initCode, indexExport: initIndexExport})
-						decls = append(decls, loweredDecl{packageInitCall: initName + "()"})
+						readDrivenInit := idx < len(typed.Values) &&
+							asyncLazyInitializerReferencesCyclicOtherFile(ctx, typed.Values[idx]) &&
+							!packageInitFunctionReferencesObject(ctx, obj)
+						if !readDrivenInit {
+							decls = append(decls, loweredDecl{packageInitCall: initName + "()"})
+						}
 						getterCode += "if (((" + declName + ") as any) === undefined) {\n\t\t" +
 							"throw new Error(" + strconv.Quote("goscript package variable "+name.Name+" read before initialization") + ")\n\t}\n"
 					} else {
@@ -1409,21 +1436,33 @@ func (o *LoweringOwner) topLevelInitializerNeedsAwait(ctx lowerFileContext, expr
 	if ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
 	}
-	call, ok := unwrapParenExpr(expr).(*ast.CallExpr)
-	if !ok {
-		return false
-	}
-	if o.callNeedsAwait(ctx, call.Fun) {
+	needsAwait := false
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if needsAwait {
+			return false
+		}
+		if _, ok := node.(*ast.FuncLit); ok {
+			return false
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if o.callNeedsAwait(ctx, call.Fun) {
+			needsAwait = true
+			return false
+		}
+		if o.callUsesOverridePackage(ctx, call.Fun) {
+			return true
+		}
+		fn := calledFunction(ctx.semPkg.source, call.Fun)
+		if fn != nil && fn.Pkg() != nil && fn.Pkg().Path() != ctx.semPkg.pkgPath {
+			needsAwait = true
+			return false
+		}
 		return true
-	}
-	if o.callUsesOverridePackage(ctx, call.Fun) {
-		return false
-	}
-	fn := calledFunction(ctx.semPkg.source, call.Fun)
-	if fn == nil || fn.Pkg() == nil || fn.Pkg().Path() == ctx.semPkg.pkgPath {
-		return false
-	}
-	return true
+	})
+	return needsAwait
 }
 
 func initializerMayHaveRuntimeEffects(ctx lowerFileContext, expr ast.Expr) bool {
@@ -1542,14 +1581,47 @@ func packageDeclFiles(semPkg *semanticPackage) map[types.Object]string {
 		return nil
 	}
 	declFiles := make(map[types.Object]string, len(semPkg.declarations))
+	for idx, file := range semPkg.source.Syntax {
+		sourcePath := sourceFilePath(semPkg, idx, file)
+		for _, decl := range file.Decls {
+			recordDeclFileObjects(semPkg.source.TypesInfo, declFiles, sourcePath, decl)
+		}
+	}
 	for _, decl := range semPkg.declarations {
-		if decl.object != nil && decl.position.file != "" {
+		if decl.object != nil && decl.position.file != "" && declFiles[decl.object] == "" {
 			declFiles[decl.object] = decl.position.file
 		}
 	}
 	return declFiles
 }
 
+func recordDeclFileObjects(info *types.Info, declFiles map[types.Object]string, sourcePath string, decl ast.Decl) {
+	if info == nil || sourcePath == "" {
+		return
+	}
+	switch typed := decl.(type) {
+	case *ast.FuncDecl:
+		if obj := info.Defs[typed.Name]; obj != nil {
+			declFiles[obj] = sourcePath
+		}
+	case *ast.GenDecl:
+		for _, spec := range typed.Specs {
+			switch typedSpec := spec.(type) {
+			case *ast.TypeSpec:
+				if obj := info.Defs[typedSpec.Name]; obj != nil {
+					declFiles[obj] = sourcePath
+				}
+			case *ast.ValueSpec:
+				for _, name := range typedSpec.Names {
+					if obj := info.Defs[name]; obj != nil {
+						declFiles[obj] = sourcePath
+					}
+				}
+			}
+		}
+	}
+}
+
 func packageOutputNames(semPkg *semanticPackage) map[string]string {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
@@ -1624,6 +1696,11 @@ func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage, declFiles map[t
 						lazy[obj] = true
 						continue
 					}
+					if valueIdx < len(valueSpec.Values) &&
+						initializerCallsFunctionReferencingOtherFileObject(semPkg, declFiles, sourcePath, valueSpec.Values[valueIdx]) {
+						lazy[obj] = true
+						continue
+					}
 					if valueIdx < len(valueSpec.Values) &&
 						initializerCallsFunctionReferencingLaterPackageVar(semPkg, varOrder, obj, valueSpec.Values[valueIdx]) {
 						lazy[obj] = true
@@ -1794,7 +1871,14 @@ func (o *LoweringOwner) packageVarNameHasAsyncLazyInit(ctx lowerFileContext, pkg
 	if semPkg == nil || semPkg.source == nil {
 		return false
 	}
-	initCtx := lowerFileContext{model: ctx.model, semPkg: semPkg, topLevel: true}
+	initCtx := lowerFileContext{
+		model:                     ctx.model,
+		semPkg:                    semPkg,
+		lazyPackageVarsByPkg:      ctx.lazyPackageVarsByPkg,
+		asyncLazyFunctionCache:    ctx.asyncLazyFunctionCache,
+		asyncLazyFunctionVisiting: ctx.asyncLazyFunctionVisiting,
+		topLevel:                  true,
+	}
 	for _, file := range semPkg.source.Syntax {
 		for _, decl := range file.Decls {
 			genDecl, ok := decl.(*ast.GenDecl)
@@ -1885,6 +1969,83 @@ func initializerCallsFunctionReferencingLaterPackageVar(
 	return references
 }
 
+func asyncLazyInitializerReferencesCyclicOtherFile(ctx lowerFileContext, expr ast.Expr) bool {
+	if ctx.semPkg == nil || ctx.semPkg.source == nil || expr == nil {
+		return false
+	}
+	declFiles := packageDeclFiles(ctx.semPkg)
+	for otherFile := range initializerReferencedOtherFiles(ctx.semPkg, declFiles, ctx.sourcePath, expr) {
+		if fileRuntimeReferencesSourceFile(ctx.semPkg, declFiles, otherFile, ctx.sourcePath) {
+			return true
+		}
+	}
+	return false
+}
+
+func packageInitFunctionReferencesObject(ctx lowerFileContext, obj types.Object) bool {
+	if obj == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return false
+	}
+	references := false
+	for _, file := range ctx.semPkg.source.Syntax {
+		for _, decl := range file.Decls {
+			fnDecl, ok := decl.(*ast.FuncDecl)
+			if !ok || fnDecl.Recv != nil || fnDecl.Name == nil || fnDecl.Name.Name != "init" || fnDecl.Body == nil {
+				continue
+			}
+			ast.Inspect(fnDecl.Body, func(node ast.Node) bool {
+				if references {
+					return false
+				}
+				if _, ok := node.(*ast.FuncLit); ok {
+					return false
+				}
+				ident, ok := node.(*ast.Ident)
+				if !ok {
+					return true
+				}
+				if ctx.semPkg.source.TypesInfo.Uses[ident] == obj {
+					references = true
+					return false
+				}
+				return true
+			})
+			if references {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func initializerCallsFunctionReferencingOtherFileObject(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	sourcePath string,
+	expr ast.Expr,
+) bool {
+	references := false
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if references {
+			return false
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		fn := calledFunction(semPkg.source, call.Fun)
+		if fn == nil || fn.Pkg() == nil || fn.Pkg().Path() != semPkg.pkgPath {
+			return true
+		}
+		if functionReferencesOtherFileObject(semPkg, declFiles, sourcePath, fn, nil) {
+			references = true
+			return false
+		}
+		return true
+	})
+	return references
+}
+
 func functionReferencesLaterPackageVar(
 	semPkg *semanticPackage,
 	varOrder map[types.Object]int,
@@ -1936,6 +2097,288 @@ func functionReferencesLaterPackageVar(
 	return references
 }
 
+func initializerReferencedOtherFiles(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	sourcePath string,
+	expr ast.Expr,
+) map[string]bool {
+	refs := make(map[string]bool)
+	ast.Inspect(expr, func(node ast.Node) bool {
+		if _, ok := node.(*ast.FuncLit); ok {
+			return false
+		}
+		collectOtherFileReferences(semPkg, declFiles, sourcePath, node, refs)
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		fn := calledFunction(semPkg.source, call.Fun)
+		if fn == nil || fn.Pkg() == nil || fn.Pkg().Path() != semPkg.pkgPath {
+			return true
+		}
+		collectFunctionOtherFileReferences(semPkg, declFiles, sourcePath, fn, nil, refs)
+		return true
+	})
+	return refs
+}
+
+func collectFunctionOtherFileReferences(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	sourcePath string,
+	fn *types.Func,
+	seen map[*types.Func]bool,
+	refs map[string]bool,
+) {
+	if fn == nil {
+		return
+	}
+	if seen == nil {
+		seen = make(map[*types.Func]bool)
+	}
+	if seen[fn] {
+		return
+	}
+	seen[fn] = true
+	fnDecl := functionDeclForObject(semPkg, fn)
+	if fnDecl == nil || fnDecl.Body == nil {
+		return
+	}
+	ast.Inspect(fnDecl.Body, func(node ast.Node) bool {
+		if _, ok := node.(*ast.FuncLit); ok {
+			return false
+		}
+		collectOtherFileReferences(semPkg, declFiles, sourcePath, node, refs)
+		if call, ok := node.(*ast.CallExpr); ok {
+			called := calledFunction(semPkg.source, call.Fun)
+			if called != nil && called.Pkg() != nil && called.Pkg().Path() == semPkg.pkgPath {
+				collectFunctionOtherFileReferences(semPkg, declFiles, sourcePath, called, seen, refs)
+			}
+		}
+		return true
+	})
+}
+
+func collectOtherFileReferences(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	sourcePath string,
+	node ast.Node,
+	refs map[string]bool,
+) {
+	if node == nil {
+		return
+	}
+	if lit, ok := node.(*ast.CompositeLit); ok {
+		collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, semPkg.source.TypesInfo.TypeOf(lit), refs, make(map[types.Type]bool))
+	}
+	switch typed := node.(type) {
+	case *ast.Ident:
+		collectOtherFileObjectReference(declFiles, sourcePath, semPkg.source.TypesInfo.Uses[typed], refs)
+	case *ast.SelectorExpr:
+		collectOtherFileObjectReference(declFiles, sourcePath, semPkg.source.TypesInfo.Uses[typed.Sel], refs)
+		if selection := semPkg.source.TypesInfo.Selections[typed]; selection != nil {
+			collectOtherFileObjectReference(declFiles, sourcePath, selection.Obj(), refs)
+		}
+	}
+}
+
+func collectOtherFileObjectReference(
+	declFiles map[types.Object]string,
+	sourcePath string,
+	obj types.Object,
+	refs map[string]bool,
+) {
+	if obj == nil || obj.Pkg() == nil {
+		return
+	}
+	if declFile := declFiles[obj]; declFile != "" && declFile != sourcePath {
+		refs[declFile] = true
+	}
+}
+
+func collectOtherFileTypeReferences(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	sourcePath string,
+	typ types.Type,
+	refs map[string]bool,
+	seen map[types.Type]bool,
+) {
+	if typ == nil || seen[typ] {
+		return
+	}
+	seen[typ] = true
+	if named := namedStructType(typ); named != nil {
+		collectOtherFileObjectReference(declFiles, sourcePath, named.Obj(), refs)
+	}
+	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Array:
+		collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, typed.Elem(), refs, seen)
+	case *types.Slice:
+		collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, typed.Elem(), refs, seen)
+	case *types.Pointer:
+		collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, typed.Elem(), refs, seen)
+	case *types.Map:
+		collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, typed.Key(), refs, seen)
+		collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, typed.Elem(), refs, seen)
+	case *types.Struct:
+		for field := range typed.Fields() {
+			collectOtherFileTypeReferences(semPkg, declFiles, sourcePath, field.Type(), refs, seen)
+		}
+	}
+}
+
+func fileRuntimeReferencesSourceFile(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	filePath string,
+	sourcePath string,
+) bool {
+	if semPkg == nil || semPkg.source == nil || filePath == "" || sourcePath == "" {
+		return false
+	}
+	for idx, file := range semPkg.source.Syntax {
+		if sourceFilePath(semPkg, idx, file) != filePath {
+			continue
+		}
+		references := false
+		ast.Inspect(file, func(node ast.Node) bool {
+			if references {
+				return false
+			}
+			if _, ok := node.(*ast.FuncLit); ok {
+				return false
+			}
+			if lit, ok := node.(*ast.CompositeLit); ok &&
+				typeReferencesSourceFile(semPkg, declFiles, lit, sourcePath) {
+				references = true
+				return false
+			}
+			if ident, ok := node.(*ast.Ident); ok &&
+				valueIdentReferencesSourceFile(semPkg, declFiles, ident, sourcePath) {
+				references = true
+				return false
+			}
+			if selector, ok := node.(*ast.SelectorExpr); ok {
+				if valueSelectorReferencesSourceFile(semPkg, declFiles, selector, sourcePath) {
+					references = true
+					return false
+				}
+			}
+			if call, ok := node.(*ast.CallExpr); ok {
+				called := calledFunction(semPkg.source, call.Fun)
+				if called != nil && declFiles[called] == sourcePath {
+					references = true
+					return false
+				}
+			}
+			return true
+		})
+		return references
+	}
+	return false
+}
+
+func valueIdentReferencesSourceFile(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	ident *ast.Ident,
+	sourcePath string,
+) bool {
+	if tv, ok := semPkg.source.TypesInfo.Types[ident]; ok && !tv.IsValue() {
+		return false
+	}
+	return declFiles[semPkg.source.TypesInfo.Uses[ident]] == sourcePath
+}
+
+func valueSelectorReferencesSourceFile(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	selector *ast.SelectorExpr,
+	sourcePath string,
+) bool {
+	if tv, ok := semPkg.source.TypesInfo.Types[selector]; ok && !tv.IsValue() {
+		return false
+	}
+	if declFiles[semPkg.source.TypesInfo.Uses[selector.Sel]] == sourcePath {
+		return true
+	}
+	if selection := semPkg.source.TypesInfo.Selections[selector]; selection != nil {
+		return declFiles[selection.Obj()] == sourcePath
+	}
+	return false
+}
+
+func typeReferencesSourceFile(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	expr ast.Expr,
+	sourcePath string,
+) bool {
+	refs := make(map[string]bool)
+	collectOtherFileTypeReferences(semPkg, declFiles, "", semPkg.source.TypesInfo.TypeOf(expr), refs, make(map[types.Type]bool))
+	return refs[sourcePath]
+}
+
+func functionReferencesOtherFileObject(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	sourcePath string,
+	fn *types.Func,
+	seen map[*types.Func]bool,
+) bool {
+	if fn == nil {
+		return false
+	}
+	if seen == nil {
+		seen = make(map[*types.Func]bool)
+	}
+	if seen[fn] {
+		return false
+	}
+	seen[fn] = true
+	fnDecl := functionDeclForObject(semPkg, fn)
+	if fnDecl == nil || fnDecl.Body == nil {
+		return false
+	}
+	references := false
+	ast.Inspect(fnDecl.Body, func(node ast.Node) bool {
+		if references {
+			return false
+		}
+		if _, ok := node.(*ast.FuncLit); ok {
+			return false
+		}
+		if lit, ok := node.(*ast.CompositeLit); ok {
+			if zeroValueReferencesOtherFileObject(semPkg, declFiles, sourcePath, semPkg.source.TypesInfo.TypeOf(lit)) {
+				references = true
+				return false
+			}
+		}
+		if ident, ok := node.(*ast.Ident); ok {
+			obj := semPkg.source.TypesInfo.Uses[ident]
+			if obj != nil && obj.Pkg() != nil && obj.Pkg().Path() == semPkg.pkgPath {
+				if declFile := declFiles[obj]; declFile != "" && declFile != sourcePath {
+					references = true
+					return false
+				}
+			}
+		}
+		if call, ok := node.(*ast.CallExpr); ok {
+			called := calledFunction(semPkg.source, call.Fun)
+			if called != nil && called.Pkg() != nil && called.Pkg().Path() == semPkg.pkgPath &&
+				functionReferencesOtherFileObject(semPkg, declFiles, sourcePath, called, seen) {
+				references = true
+				return false
+			}
+		}
+		return true
+	})
+	return references
+}
+
 func functionDeclForObject(semPkg *semanticPackage, fn *types.Func) *ast.FuncDecl {
 	if semPkg == nil || semPkg.source == nil || fn == nil {
 		return nil
@@ -1962,6 +2405,12 @@ func initializerReferencesOtherFileObject(
 		if references {
 			return false
 		}
+		if lit, ok := node.(*ast.CompositeLit); ok {
+			if zeroValueReferencesOtherFileObject(semPkg, declFiles, sourcePath, semPkg.source.TypesInfo.TypeOf(lit)) {
+				references = true
+				return false
+			}
+		}
 		ident, ok := node.(*ast.Ident)
 		if !ok {
 			return true
@@ -2237,7 +2686,7 @@ func (o *LoweringOwner) lowerGoEmbedFSValue(ctx lowerFileContext, diagPos token.
 		entries = append(entries, "["+strconv.Quote(path)+", "+byteSliceLiteral(filesByPath[path])+"]")
 	}
 	builtinAlias := o.runtimeOwner.BuiltinImport().Alias
-	return builtinAlias + ".markAsStructValue(new " + embedAlias + ".FS(new Map<string, Uint8Array>([" + strings.Join(entries, ", ") + "])))", nil
+	return builtinAlias + ".markAsStructValue(new " + embedAlias + ".FS(new globalThis.Map<string, Uint8Array>([" + strings.Join(entries, ", ") + "])))", nil
 }
 
 type goEmbedFile struct {
@@ -2639,7 +3088,10 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 	}
 
 	methodDecls := o.methodDeclsForType(ctx, semType.named)
-	explicitMethods := make(map[string]bool, len(methodDecls))
+	explicitMethods := make(map[string]bool, len(methodDecls)+len(semType.fields))
+	for _, field := range semType.fields {
+		explicitMethods[field.name] = true
+	}
 	if len(methodDecls) != 0 {
 		lowered.methods = make([]loweredFunction, 0, len(methodDecls))
 		for _, methodDecl := range methodDecls {
@@ -3622,28 +4074,17 @@ func (o *LoweringOwner) lowerStmtListAfter(
 	hasGoto := stmtListHasGoto(stmts)
 	var gotoSpans map[string]int
 	var gotoLabels map[string]bool
-	var forwardStarts map[int]forwardGotoLabelSpan
+	var forwardSpans map[string]forwardGotoLabelSpan
 	if hasGoto {
 		gotoSpans = backwardGotoLabelSpans(stmts)
 		gotoLabels = make(map[string]bool, len(gotoSpans))
 		for label := range gotoSpans {
 			gotoLabels[label] = true
 		}
-		forwardSpans := forwardGotoLabelSpans(stmts, gotoSpans)
-		forwardStarts = make(map[int]forwardGotoLabelSpan, len(forwardSpans))
+		forwardSpans = forwardGotoLabelSpans(stmts, gotoSpans)
 		for label, span := range forwardSpans {
 			span.label = label
-			group := forwardStarts[span.start]
-			if group.forwardLabels == nil {
-				group.forwardLabels = make(map[string]bool)
-			}
-			group.forwardLabels[label] = true
-			if group.label == "" || span.labelIdx > group.labelIdx {
-				group.label = span.label
-				group.start = span.start
-				group.labelIdx = span.labelIdx
-			}
-			forwardStarts[span.start] = group
+			forwardSpans[label] = span
 		}
 	}
 	for idx := 0; idx < len(stmts); idx++ {
@@ -3680,20 +4121,17 @@ func (o *LoweringOwner) lowerStmtListAfter(
 				idx = span.endIdx
 				continue
 			}
-			if span, ok := forwardStarts[idx]; ok {
-				bodyStmts := stmts[idx:span.labelIdx]
-				body, bodyDiagnostics := o.lowerStmtListAfter(
-					ctx.withForwardGotos(span.forwardLabels),
-					bodyStmts,
+			if group, ok := forwardGotoLabelGroupAt(idx, forwardSpans); ok {
+				groupLowered, groupDiagnostics := o.lowerForwardGotoLabelGroup(
+					ctx,
+					stmts,
+					group,
 					prevEndLine,
+					leading,
 				)
-				diagnostics = append(diagnostics, bodyDiagnostics...)
-				block := loweredStmt{hasBlock: true, text: span.label + ":", children: body}
-				if len(leading) != 0 {
-					block.leading = append(leading, block.leading...)
-				}
-				lowered = append(lowered, block)
-				if labeled, ok := stmts[span.labelIdx].(*ast.LabeledStmt); ok {
+				diagnostics = append(diagnostics, groupDiagnostics...)
+				lowered = append(lowered, groupLowered...)
+				if labeled, ok := stmts[group.labelIdx].(*ast.LabeledStmt); ok {
 					labelLowered, labelDiagnostics := o.lowerStmt(ctx, labeled.Stmt)
 					diagnostics = append(diagnostics, labelDiagnostics...)
 					lowered = append(lowered, labelLowered...)
@@ -3701,7 +4139,7 @@ func (o *LoweringOwner) lowerStmtListAfter(
 						prevEndLine = endLine
 					}
 				}
-				idx = span.labelIdx
+				idx = group.labelIdx
 				continue
 			}
 			if labeled, ok := stmt.(*ast.LabeledStmt); ok {
@@ -4033,12 +4471,105 @@ func (o *LoweringOwner) lowerBackwardGotoLoop(
 }
 
 type forwardGotoLabelSpan struct {
-	label         string
+	label    string
+	start    int
+	labelIdx int
+}
+
+type forwardGotoLabelGroup struct {
 	start         int
 	labelIdx      int
+	spans         []forwardGotoLabelSpan
 	forwardLabels map[string]bool
 }
 
+func forwardGotoLabelGroupAt(start int, spans map[string]forwardGotoLabelSpan) (forwardGotoLabelGroup, bool) {
+	var included map[string]bool
+	group := forwardGotoLabelGroup{start: start, labelIdx: -1}
+	for label, span := range spans {
+		if span.start != start {
+			continue
+		}
+		if included == nil {
+			included = make(map[string]bool)
+			group.forwardLabels = make(map[string]bool)
+		}
+		included[label] = true
+		group.spans = append(group.spans, span)
+		group.forwardLabels[label] = true
+		if span.labelIdx > group.labelIdx {
+			group.labelIdx = span.labelIdx
+		}
+	}
+	if len(group.spans) == 0 {
+		return forwardGotoLabelGroup{}, false
+	}
+
+	for {
+		changed := false
+		for label, span := range spans {
+			if included[label] || span.start < start || span.start >= group.labelIdx {
+				continue
+			}
+			included[label] = true
+			group.spans = append(group.spans, span)
+			group.forwardLabels[label] = true
+			if span.labelIdx > group.labelIdx {
+				group.labelIdx = span.labelIdx
+			}
+			changed = true
+		}
+		if !changed {
+			break
+		}
+	}
+
+	slices.SortFunc(group.spans, func(a, b forwardGotoLabelSpan) int {
+		if n := cmp.Compare(a.labelIdx, b.labelIdx); n != 0 {
+			return n
+		}
+		return cmp.Compare(a.label, b.label)
+	})
+	return group, true
+}
+
+func (o *LoweringOwner) lowerForwardGotoLabelGroup(
+	ctx lowerFileContext,
+	stmts []ast.Stmt,
+	group forwardGotoLabelGroup,
+	prevEndLine int,
+	leading []string,
+) ([]loweredStmt, []Diagnostic) {
+	forwardCtx := ctx.withForwardGotos(group.forwardLabels)
+	first := group.spans[0]
+	body, diagnostics := o.lowerStmtListAfter(forwardCtx, stmts[group.start:first.labelIdx], prevEndLine)
+	block := loweredStmt{hasBlock: true, text: first.label + ":", children: body}
+
+	for idx := 1; idx < len(group.spans); idx++ {
+		prev := group.spans[idx-1]
+		next := group.spans[idx]
+		children := []loweredStmt{block}
+		if labeled, ok := stmts[prev.labelIdx].(*ast.LabeledStmt); ok {
+			segment := make([]ast.Stmt, 0, next.labelIdx-prev.labelIdx)
+			segment = append(segment, labeled.Stmt)
+			segment = append(segment, stmts[prev.labelIdx+1:next.labelIdx]...)
+			segmentLowered, segmentDiagnostics := o.lowerStmtListAfter(
+				forwardCtx,
+				segment,
+				sourceLine(ctx, labeled.Label.End()),
+			)
+			diagnostics = append(diagnostics, segmentDiagnostics...)
+			children = append(children, segmentLowered...)
+		}
+		block = loweredStmt{hasBlock: true, text: next.label + ":", children: children}
+	}
+
+	if len(leading) != 0 {
+		block.leading = append(leading, block.leading...)
+	}
+	return []loweredStmt{block}, diagnostics
+}
+
 type leadingGotoBackwardLoop struct {
 	label        string
 	labelIdx     int
@@ -4395,6 +4926,9 @@ func (o *LoweringOwner) lowerMapIndexUpdateStmts(
 	mapExpr, mapDiagnostics := o.lowerExpr(ctx, index.X)
 	keyExpr, keyDiagnostics := o.lowerExpr(ctx, index.Index)
 	diagnostics := append(mapDiagnostics, keyDiagnostics...)
+	if mapType, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(index.X)).Underlying().(*types.Map); ok {
+		keyExpr = o.lowerValueForTarget(ctx, index.Index, mapType.Key(), keyExpr)
+	}
 	if tok == token.ASSIGN {
 		return []loweredStmt{{text: o.runtimeOwner.QualifiedHelper(RuntimeHelperMapSet) + "(" + mapExpr + ", " + keyExpr + ", " + right + ")"}}, diagnostics
 	}
@@ -4802,6 +5336,11 @@ func (o *LoweringOwner) lowerShortDeclNewShadowAliases(
 func shortDeclShadowNonValueIdents(ctx lowerFileContext, expr ast.Expr) map[*ast.Ident]bool {
 	idents := make(map[*ast.Ident]bool)
 	ast.Inspect(expr, func(node ast.Node) bool {
+		if ident, ok := node.(*ast.Ident); ok {
+			if _, ok := ctx.semPkg.source.TypesInfo.Uses[ident].(*types.TypeName); ok {
+				idents[ident] = true
+			}
+		}
 		switch typed := node.(type) {
 		case *ast.CallExpr:
 			if ident, ok := typed.Fun.(*ast.Ident); ok {
@@ -6354,7 +6893,7 @@ func (o *LoweringOwner) lowerTypeSwitchStmt(ctx lowerFileContext, stmt *ast.Type
 func (o *LoweringOwner) tsTypeSwitchCaseTypeFor(ctx lowerFileContext, typ types.Type) string {
 	if named, ok := types.Unalias(typ).(*types.Named); ok {
 		if _, ok := named.Underlying().(*types.Interface); ok {
-			return o.tsNonNilTypeFor(ctx, named)
+			return o.tsTypeFor(ctx, named)
 		}
 	}
 	return o.tsTypeFor(ctx, typ)
@@ -6366,7 +6905,7 @@ func loweredStmtsUseVarRefName(stmts []loweredStmt, name string) bool {
 	}
 	needle := name + ".value"
 	for _, stmt := range stmts {
-		if strings.Contains(stmt.text, needle) {
+		if loweredStmtTextUsesVarRefName(stmt.text, needle) {
 			return true
 		}
 		if loweredStmtsUseVarRefName(stmt.children, name) {
@@ -6393,6 +6932,38 @@ func loweredStmtsUseVarRefName(stmts []loweredStmt, name string) bool {
 	return false
 }
 
+func loweredStmtTextUsesVarRefName(text, needle string) bool {
+	offset := 0
+	for {
+		idx := strings.Index(text[offset:], needle)
+		if idx < 0 {
+			return false
+		}
+		start := offset + idx
+		end := start + len(needle)
+		if tsIdentifierBoundaryBefore(text, start) && tsIdentifierBoundaryAfter(text, end) {
+			return true
+		}
+		offset = start + 1
+	}
+}
+
+func tsIdentifierBoundaryBefore(text string, idx int) bool {
+	if idx == 0 {
+		return true
+	}
+	prev := text[idx-1]
+	return prev != '.' && !isTSIdentifierByte(prev)
+}
+
+func tsIdentifierBoundaryAfter(text string, idx int) bool {
+	return idx >= len(text) || !isTSIdentifierByte(text[idx])
+}
+
+func isTSIdentifierByte(b byte) bool {
+	return b == '$' || b == '_' || ('0' <= b && b <= '9') || ('A' <= b && b <= 'Z') || ('a' <= b && b <= 'z')
+}
+
 func (o *LoweringOwner) lowerTypeSwitchAssign(ctx lowerFileContext, stmt ast.Stmt) (string, string, bool, []Diagnostic) {
 	switch typed := stmt.(type) {
 	case *ast.ExprStmt:
@@ -6847,11 +7418,47 @@ func isLegacyOctalLiteral(value string) bool {
 }
 
 func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (string, bool, []Diagnostic) {
+	return o.lowerFuncLitWithAsyncCalls(ctx, lit, true)
+}
+
+func (o *LoweringOwner) lowerFuncLitForTarget(
+	ctx lowerFileContext,
+	lit *ast.FuncLit,
+	targetType types.Type,
+	allowAsyncOverrideCallback bool,
+) (string, bool, []Diagnostic) {
+	allowAsyncCalls := true
+	if !allowAsyncOverrideCallback && signatureForType(targetType) != nil {
+		allowAsyncCalls = false
+	}
+	return o.lowerFuncLitWithAsyncCalls(ctx, lit, allowAsyncCalls)
+}
+
+func (o *LoweringOwner) lowerFuncLitWithAsyncCalls(
+	ctx lowerFileContext,
+	lit *ast.FuncLit,
+	allowAsyncCalls bool,
+) (string, bool, []Diagnostic) {
+	function, async, signature, diagnostics := o.lowerFuncLitArrowWithAsyncCalls(ctx, lit, allowAsyncCalls)
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFunctionValue) +
+		"(" + function + ", " + o.runtimeFunctionTypeInfo(signature, "") + ")", async, diagnostics
+}
+
+func (o *LoweringOwner) lowerFuncLitCallCallee(ctx lowerFileContext, lit *ast.FuncLit) (string, bool, []Diagnostic) {
+	function, async, _, diagnostics := o.lowerFuncLitArrowWithAsyncCalls(ctx, lit, true)
+	return function, async, diagnostics
+}
+
+func (o *LoweringOwner) lowerFuncLitArrowWithAsyncCalls(
+	ctx lowerFileContext,
+	lit *ast.FuncLit,
+	allowAsyncCalls bool,
+) (string, bool, *types.Signature, []Diagnostic) {
 	signature, _ := ctx.semPkg.source.TypesInfo.TypeOf(lit).(*types.Signature)
 	deferState := &loweredDeferState{}
 	bodyCtx := ctx.withSignature(signature).withAsyncFunction(false).withDeferState(deferState).withoutRangeBranch()
 	asyncCompatibleParams := funcLiteralNeedsAsyncFunctionParamCalls(signature)
-	if asyncCompatibleParams || funcLiteralUsesAwaitableCall(ctx, lit) {
+	if allowAsyncCalls && (asyncCompatibleParams || funcLiteralUsesAwaitableCall(ctx, lit)) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
 	}
 	var params []loweredParam
@@ -6876,8 +7483,7 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	function := prefix + "(" + renderLoweredParams(params) + "): " +
 		asyncResultType(o.tsSignatureResultFor(ctx, signature), async) + " => {\n" +
 		rendered.String() + "}"
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFunctionValue) +
-		"(" + function + ", " + o.runtimeFunctionTypeInfo(signature, "") + ")", async, diagnostics
+	return function, async, signature, diagnostics
 }
 
 func renderLoweredParams(params []loweredParam) string {
@@ -6976,6 +7582,9 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 			return constValue
 		}
 	}
+	if imported, ok := o.lowerImportedIdent(ctx, obj, value, raw); ok {
+		return imported
+	}
 	if alias := ctx.localAliases[obj]; alias != "" {
 		if ctx.lazyPackageVars[obj] {
 			lazyValue := alias + "." + packageVarGetterName(value) + "()"
@@ -7008,6 +7617,29 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 	return value
 }
 
+func (o *LoweringOwner) lowerImportedIdent(ctx lowerFileContext, obj types.Object, value string, raw bool) (string, bool) {
+	if obj == nil || obj.Pkg() == nil || ctx.semPkg == nil || obj.Pkg().Path() == ctx.semPkg.pkgPath {
+		return "", false
+	}
+	alias := ctx.importPaths[obj.Pkg().Path()]
+	if alias == "" {
+		return "", false
+	}
+	qualified := alias + "." + value
+	if varObj, ok := obj.(*types.Var); ok &&
+		(o.packageVarIsLazy(ctx, varObj) || o.packageVarNameIsLazy(ctx, obj.Pkg().Path(), obj.Name())) {
+		qualified = alias + "." + packageVarGetterName(value) + "()"
+		if (ctx.asyncFunction || ctx.topLevel) &&
+			o.packageVarNameHasAsyncLazyInit(ctx, obj.Pkg().Path(), obj.Name()) {
+			qualified = "(await " + alias + "." + packageVarInitName(value) + "(), " + qualified + ")"
+		}
+	}
+	if raw {
+		return qualified, true
+	}
+	return o.lowerPackageVarReadValue(ctx, obj, qualified), true
+}
+
 func (o *LoweringOwner) lowerPackageVarReadValue(ctx lowerFileContext, obj types.Object, value string) string {
 	if obj == nil || ctx.model == nil || !ctx.model.needsVarRef[obj] {
 		return value
@@ -7082,6 +7714,17 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 	}
 
 	args, diagnostics := o.lowerCallArgs(ctx, expr, callTargetSignature(ctx, expr.Fun))
+	if fun, ok := unwrapParenExpr(expr.Fun).(*ast.FuncLit); ok {
+		callee, async, calleeDiagnostics := o.lowerFuncLitCallCallee(ctx, fun)
+		call := "(" + callee + ")(" + strings.Join(args, ", ") + ")"
+		if async {
+			call = "await " + call
+			if ctx.deferState != nil {
+				ctx.deferState.async = true
+			}
+		}
+		return call, append(diagnostics, calleeDiagnostics...)
+	}
 
 	switch fun := expr.Fun.(type) {
 	case *ast.Ident:
@@ -7239,16 +7882,6 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 			ctx.deferState.async = true
 		}
 		return o.awaitCallIfNeeded(ctx, fun, call), append(diagnostics, calleeDiagnostics...)
-	case *ast.FuncLit:
-		callee, async, calleeDiagnostics := o.lowerFuncLit(ctx, fun)
-		call := "(" + callee + ")(" + strings.Join(args, ", ") + ")"
-		if async {
-			call = "await " + call
-			if ctx.deferState != nil {
-				ctx.deferState.async = true
-			}
-		}
-		return call, append(diagnostics, calleeDiagnostics...)
 	default:
 		if callTargetSignature(ctx, expr.Fun) != nil {
 			callee, calleeDiagnostics := o.lowerExpr(ctx, expr.Fun)
@@ -7276,13 +7909,14 @@ func (o *LoweringOwner) lowerCallArgs(
 	signature *types.Signature,
 ) ([]string, []Diagnostic) {
 	overrideCall := o.callUsesOverridePackage(ctx, expr.Fun)
+	allowAsyncOverrideCallback := !overrideCall || o.overrideCallNeedsAwait(ctx, expr.Fun)
 	if args, diagnostics, ok := o.lowerTupleCallArgs(ctx, expr, signature, overrideCall); ok {
 		return args, diagnostics
 	}
 	if signature != nil && signature.Variadic() && overrideCall && !isBuiltinCallTarget(ctx, expr.Fun) {
 		params := signature.Params()
 		if params == nil || params.Len() == 0 {
-			return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall)
+			return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall, allowAsyncOverrideCallback)
 		}
 		fixedCount := params.Len() - 1
 		targetType := params.At(fixedCount).Type()
@@ -7292,7 +7926,7 @@ func (o *LoweringOwner) lowerCallArgs(
 		args := make([]string, 0, len(expr.Args))
 		var diagnostics []Diagnostic
 		for idx, arg := range expr.Args {
-			lowered, argDiagnostics := o.lowerExpr(ctx, arg)
+			lowered, argDiagnostics := o.lowerCallArgExpr(ctx, arg, params.At(min(idx, fixedCount)).Type(), allowAsyncOverrideCallback)
 			diagnostics = append(diagnostics, argDiagnostics...)
 			if idx < fixedCount {
 				lowered = o.lowerCallArgForTarget(ctx, arg, params.At(idx).Type(), lowered, overrideCall)
@@ -7309,11 +7943,11 @@ func (o *LoweringOwner) lowerCallArgs(
 	if signature == nil || !signature.Variadic() ||
 		isBuiltinCallTarget(ctx, expr.Fun) ||
 		overrideCall {
-		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall)
+		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall, allowAsyncOverrideCallback)
 	}
 	params := signature.Params()
 	if params == nil || params.Len() == 0 {
-		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall)
+		return o.lowerFixedCallArgs(ctx, expr.Args, signature, overrideCall, allowAsyncOverrideCallback)
 	}
 
 	fixedCount := params.Len() - 1
@@ -7321,7 +7955,11 @@ func (o *LoweringOwner) lowerCallArgs(
 	var variadicArgs []string
 	var diagnostics []Diagnostic
 	for idx, arg := range expr.Args {
-		lowered, argDiagnostics := o.lowerExpr(ctx, arg)
+		targetType := params.At(fixedCount).Type()
+		if idx < fixedCount {
+			targetType = params.At(idx).Type()
+		}
+		lowered, argDiagnostics := o.lowerCallArgExpr(ctx, arg, targetType, allowAsyncOverrideCallback)
 		diagnostics = append(diagnostics, argDiagnostics...)
 		if idx < fixedCount {
 			lowered = o.lowerCallArgForTarget(ctx, arg, params.At(idx).Type(), lowered, overrideCall)
@@ -7422,6 +8060,7 @@ func (o *LoweringOwner) lowerFixedCallArgs(
 	exprs []ast.Expr,
 	signature *types.Signature,
 	overrideCall bool,
+	allowAsyncOverrideCallback bool,
 ) ([]string, []Diagnostic) {
 	var params *types.Tuple
 	if signature != nil {
@@ -7430,7 +8069,11 @@ func (o *LoweringOwner) lowerFixedCallArgs(
 	args := make([]string, 0, len(exprs))
 	var diagnostics []Diagnostic
 	for idx, expr := range exprs {
-		lowered, exprDiagnostics := o.lowerExpr(ctx, expr)
+		var targetType types.Type
+		if params != nil && idx < params.Len() {
+			targetType = params.At(idx).Type()
+		}
+		lowered, exprDiagnostics := o.lowerCallArgExpr(ctx, expr, targetType, allowAsyncOverrideCallback)
 		diagnostics = append(diagnostics, exprDiagnostics...)
 		if params != nil && idx < params.Len() {
 			lowered = o.lowerCallArgForTarget(ctx, expr, params.At(idx).Type(), lowered, overrideCall)
@@ -7440,6 +8083,19 @@ func (o *LoweringOwner) lowerFixedCallArgs(
 	return args, diagnostics
 }
 
+func (o *LoweringOwner) lowerCallArgExpr(
+	ctx lowerFileContext,
+	expr ast.Expr,
+	targetType types.Type,
+	overrideCall bool,
+) (string, []Diagnostic) {
+	if lit, ok := ast.Unparen(expr).(*ast.FuncLit); ok && targetType != nil {
+		value, _, diagnostics := o.lowerFuncLitForTarget(ctx, lit, targetType, overrideCall)
+		return value, diagnostics
+	}
+	return o.lowerExpr(ctx, expr)
+}
+
 func (o *LoweringOwner) lowerCallArgForTarget(
 	ctx lowerFileContext,
 	expr ast.Expr,
@@ -7636,6 +8292,11 @@ func (o *LoweringOwner) lowerConversionExpr(
 		if value, addressDiagnostics, ok := o.lowerUnsafePointerIntegerExpr(ctx, expr.Args[0]); ok {
 			return value, append(diagnostics, addressDiagnostics...)
 		}
+		if isUintptrType(targetType) {
+			// Opaque unsafe pointers have no JS integer address; keep identity-only
+			// uintptr round trips, such as the standard noescape xor-zero pattern, as pointer tokens.
+			return "(" + value + " as any)", diagnostics
+		}
 	}
 	if helper, addressDiagnostics, ok := o.lowerReflectHeaderPointerConversion(ctx, targetType, expr.Args[0]); ok {
 		return helper, append(diagnostics, addressDiagnostics...)
@@ -7644,6 +8305,9 @@ func (o *LoweringOwner) lowerConversionExpr(
 		return helper, append(diagnostics, addressDiagnostics...)
 	}
 	if isUnsafePointerType(targetType) {
+		if value, identityDiagnostics, ok := o.lowerUnsafePointerIdentityExpr(ctx, expr.Args[0]); ok {
+			return "(" + value + " as any)", append(diagnostics, identityDiagnostics...)
+		}
 		return "(" + value + " as any)", diagnostics
 	}
 	if isNilExpr(expr.Args[0]) && isPointerType(targetType) {
@@ -7794,6 +8458,12 @@ func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *a
 	case token.AND:
 		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64And, RuntimeHelperInt64And)) + "(" + left + ", " + right + ")", true
 	case token.XOR:
+		if isZeroIntegerExpr(ctx, expr.Y) {
+			return left, true
+		}
+		if isZeroIntegerExpr(ctx, expr.X) {
+			return right, true
+		}
 		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Xor, RuntimeHelperInt64Xor)) + "(" + left + ", " + right + ")", true
 	case token.OR:
 		shift, ok := wideLeftShiftExpr(ctx, expr.X)
@@ -7865,6 +8535,11 @@ func lowIntegerBits(ctx lowerFileContext, expr ast.Expr) (int, bool) {
 	return integerBits(ctx.semPkg.source.TypesInfo.TypeOf(expr))
 }
 
+func isZeroIntegerExpr(ctx lowerFileContext, expr ast.Expr) bool {
+	value := ctx.semPkg.source.TypesInfo.Types[unwrapParenExpr(expr)].Value
+	return value != nil && value.Kind() == constant.Int && constant.Sign(value) == 0
+}
+
 func shiftMultiplier(amount int) string {
 	return "(2 ** " + strconv.Itoa(amount) + ")"
 }
@@ -8315,6 +8990,9 @@ func (o *LoweringOwner) lowerFieldSelectionExpr(
 	selection *types.Selection,
 	address bool,
 ) (string, []Diagnostic) {
+	if value, diagnostics, ok := o.lowerUnsafeStructFieldSelectionExpr(ctx, expr, selection, address); ok {
+		return value, diagnostics
+	}
 	receiver, diagnostics := o.lowerFieldReceiverExpr(ctx, expr.X)
 	receiver = parenthesizeAwaitedExpr(receiver)
 	index := selection.Index()
@@ -8353,18 +9031,89 @@ func (o *LoweringOwner) lowerFieldSelectionExpr(
 			typ = pointer.Elem()
 		}
 	}
-
+
+	if address {
+		return o.lowerFieldAddressExpr(ctx, receiver, typ, tsStructFieldName(expr.Sel.Name, 0)), diagnostics
+	}
+	return receiver + "." + tsStructFieldName(expr.Sel.Name, 0), diagnostics
+}
+
+func (o *LoweringOwner) lowerFieldAddressExpr(ctx lowerFileContext, receiver string, typ types.Type, fieldName string) string {
+	if namedStructType(derefPointerType(typ)) != nil {
+		return receiver + "._fields." + fieldName
+	}
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFieldRef) + "(" + receiver + ", " + strconv.Quote(fieldName) + ")"
+}
+
+func (o *LoweringOwner) lowerUnsafeStructFieldSelectionExpr(
+	ctx lowerFileContext,
+	expr *ast.SelectorExpr,
+	selection *types.Selection,
+	address bool,
+) (string, []Diagnostic, bool) {
+	index := selection.Index()
+	if len(index) != 1 {
+		return "", nil, false
+	}
+	targetCall, ok := unwrapParenExpr(expr.X).(*ast.CallExpr)
+	if !ok || len(targetCall.Args) != 1 {
+		return "", nil, false
+	}
+	targetType := typeFromExpr(ctx, targetCall.Fun)
+	if targetType == nil {
+		return "", nil, false
+	}
+	targetPointer, _ := types.Unalias(targetType).Underlying().(*types.Pointer)
+	if targetPointer == nil {
+		return "", nil, false
+	}
+	targetStruct := structUnderlyingType(targetPointer.Elem())
+	if targetStruct == nil || index[0] < 0 || index[0] >= targetStruct.NumFields() {
+		return "", nil, false
+	}
+	unsafeCall, ok := unwrapParenExpr(targetCall.Args[0]).(*ast.CallExpr)
+	if !ok || len(unsafeCall.Args) != 1 || !isUnsafePointerType(typeFromExpr(ctx, unsafeCall.Fun)) {
+		return "", nil, false
+	}
+	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(unsafeCall.Args[0])
+	if sourceType == nil {
+		return "", nil, false
+	}
+	sourcePointer, _ := types.Unalias(sourceType).Underlying().(*types.Pointer)
+	if sourcePointer == nil {
+		return "", nil, false
+	}
+	sourceStruct := structUnderlyingType(sourcePointer.Elem())
+	if sourceStruct == nil || index[0] >= sourceStruct.NumFields() {
+		return "", nil, false
+	}
+	targetField := targetStruct.Field(index[0])
+	sourceField := sourceStruct.Field(index[0])
+	if !unsafeStructFieldLayoutCompatible(targetField, sourceField) {
+		return "", nil, false
+	}
+	receiver, diagnostics := o.lowerFieldReceiverExpr(ctx, unsafeCall.Args[0])
+	fieldName := tsStructFieldName(sourceField.Name(), index[0])
 	if address {
-		return o.lowerFieldAddressExpr(ctx, receiver, typ, tsStructFieldName(expr.Sel.Name, 0)), diagnostics
+		return o.lowerFieldAddressExpr(ctx, receiver, sourcePointer.Elem(), fieldName), diagnostics, true
 	}
-	return receiver + "." + tsStructFieldName(expr.Sel.Name, 0), diagnostics
+	return receiver + "." + fieldName, diagnostics, true
 }
 
-func (o *LoweringOwner) lowerFieldAddressExpr(ctx lowerFileContext, receiver string, typ types.Type, fieldName string) string {
-	if namedStructType(derefPointerType(typ)) != nil {
-		return receiver + "._fields." + fieldName
+func unsafeStructFieldLayoutCompatible(target *types.Var, source *types.Var) bool {
+	if target == nil || source == nil || target.Name() != source.Name() {
+		return false
 	}
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFieldRef) + "(" + receiver + ", " + strconv.Quote(fieldName) + ")"
+	return unsafeFieldTypeLayoutCompatible(target.Type(), source.Type())
+}
+
+func unsafeFieldTypeLayoutCompatible(left types.Type, right types.Type) bool {
+	if types.Identical(left, right) {
+		return true
+	}
+	leftUnderlying := types.Unalias(left).Underlying()
+	rightUnderlying := types.Unalias(right).Underlying()
+	return types.Identical(leftUnderlying, rightUnderlying)
 }
 
 func (o *LoweringOwner) lowerMethodValueClosure(
@@ -8390,7 +9139,12 @@ func (o *LoweringOwner) lowerMethodValueClosure(
 	if includeReceiver {
 		args = append([]string{"__receiver"}, args...)
 	}
-	return "((__receiver) => (" + strings.Join(params, ", ") + ") => " + callee + "(" + strings.Join(args, ", ") + "))(" + receiver + ")"
+	closure := "((__receiver) => (" + strings.Join(params, ", ") + ") => " + callee + "(" + strings.Join(args, ", ") + "))(" + receiver + ")"
+	if signature == nil {
+		return closure
+	}
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFunctionValue) +
+		"(" + closure + ", " + o.runtimeFunctionTypeInfo(signature, "") + ")"
 }
 
 func (o *LoweringOwner) lowerMethodExpressionClosure(ctx lowerFileContext, selection *types.Selection) string {
@@ -8445,6 +9199,9 @@ func fieldReceiverNeedsVarRefValue(ctx lowerFileContext, expr ast.Expr, obj type
 		return true
 	}
 	if ctx.identAliases[obj] != "" {
+		if obj == nil || ctx.model == nil || !ctx.model.needsVarRef[obj] {
+			return false
+		}
 		return !ctx.identAliasRefs[obj]
 	}
 	if ctx.localAliases[obj] != "" {
@@ -8605,6 +9362,10 @@ func (o *LoweringOwner) lowerAddressExpr(ctx lowerFileContext, expr ast.Expr) (s
 		return receiver + "._fields." + typed.Sel.Name, diagnostics
 	case *ast.IndexExpr:
 		return o.lowerIndexAddressExpr(ctx, typed)
+	case *ast.StarExpr:
+		// &*p is the identity address-of-dereference: it yields the original
+		// pointer, not a copy, so emit the pointer expression directly.
+		return o.lowerExpr(ctx, typed.X)
 	default:
 		return "undefined", []Diagnostic{loweringUnsupportedAt(ctx, typed, "expression", ctx.semPkg.pkgPath, "unsupported address expression")}
 	}
@@ -8696,6 +9457,35 @@ func (o *LoweringOwner) lowerUnsafePointerIntegerExpr(
 	return o.lowerIndexByteAddressIntegerExpr(ctx, call.Args[0])
 }
 
+func (o *LoweringOwner) lowerUnsafePointerIdentityExpr(
+	ctx lowerFileContext,
+	expr ast.Expr,
+) (string, []Diagnostic, bool) {
+	expr = unwrapParenExpr(expr)
+	if binary, ok := expr.(*ast.BinaryExpr); ok && binary.Op == token.XOR {
+		switch {
+		case isZeroIntegerExpr(ctx, binary.Y):
+			return o.lowerUnsafePointerIdentityExpr(ctx, binary.X)
+		case isZeroIntegerExpr(ctx, binary.X):
+			return o.lowerUnsafePointerIdentityExpr(ctx, binary.Y)
+		}
+	}
+	call, ok := expr.(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 {
+		return "", nil, false
+	}
+	targetType := typeFromExpr(ctx, call.Fun)
+	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(call.Args[0])
+	if !isUintptrType(targetType) || !isUnsafePointerType(sourceType) {
+		return "", nil, false
+	}
+	if _, _, ok := o.lowerUnsafePointerIntegerExpr(ctx, call.Args[0]); ok {
+		return "", nil, false
+	}
+	value, diagnostics := o.lowerExpr(ctx, call.Args[0])
+	return value, diagnostics, true
+}
+
 func (o *LoweringOwner) lowerIndexAddressIntegerExpr(
 	ctx lowerFileContext,
 	expr ast.Expr,
@@ -8866,6 +9656,9 @@ func (o *LoweringOwner) lowerUnsafeArrayPointerConversion(
 	targetType types.Type,
 	expr ast.Expr,
 ) (string, []Diagnostic, bool) {
+	if targetType == nil {
+		return "", nil, false
+	}
 	targetPointer, _ := types.Unalias(targetType).Underlying().(*types.Pointer)
 	if targetPointer == nil {
 		return "", nil, false
@@ -8874,29 +9667,191 @@ func (o *LoweringOwner) lowerUnsafeArrayPointerConversion(
 	if array == nil {
 		return "", nil, false
 	}
-	unsafeCall, ok := unwrapParenExpr(expr).(*ast.CallExpr)
-	if !ok || len(unsafeCall.Args) != 1 || !isUnsafePointerType(typeFromExpr(ctx, unsafeCall.Fun)) {
-		return "", nil, false
-	}
-	address, ok := unwrapParenExpr(unsafeCall.Args[0]).(*ast.UnaryExpr)
-	if !ok || address.Op != token.AND {
-		return "", nil, false
-	}
-	index, ok := unwrapParenExpr(address.X).(*ast.IndexExpr)
+	ref, sourceType, diagnostics, ok := o.lowerUnsafeArrayPointerSourceRef(ctx, expr)
 	if !ok {
 		return "", nil, false
 	}
-	ref, diagnostics := o.lowerAddressExpr(ctx, index)
-	sourceElementSize := goScriptElementByteSize(ctx, indexElementType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)))
+	sourceElementSize := goScriptElementByteSize(ctx, sourceType)
 	targetElementSize := goScriptElementByteSize(ctx, array.Elem())
+	sourceTypeArg := o.tsTypeFor(ctx, array.Elem())
+	if sourceType != nil {
+		sourceTypeArg = o.tsTypeFor(ctx, sourceType)
+	}
 	helper := o.runtimeOwner.QualifiedHelper(RuntimeHelperArrayPointerFromIndexRef) +
-		"<" + o.tsTypeFor(ctx, array.Elem()) + ">(" + ref + ", " +
+		"<" + sourceTypeArg + ">(" + ref + ", " +
 		strconv.FormatInt(array.Len(), 10) + ", " +
 		strconv.FormatInt(sourceElementSize, 10) + ", " +
 		strconv.FormatInt(targetElementSize, 10) + ")"
 	return "(" + helper + " as unknown as " + o.tsTypeFor(ctx, targetType) + ")", diagnostics, true
 }
 
+func (o *LoweringOwner) lowerUnsafeArrayPointerSourceRef(
+	ctx lowerFileContext,
+	expr ast.Expr,
+) (string, types.Type, []Diagnostic, bool) {
+	if unsafeCall, ok := unwrapParenExpr(expr).(*ast.CallExpr); ok && len(unsafeCall.Args) == 1 {
+		if isUnsafePointerType(typeFromExpr(ctx, unsafeCall.Fun)) {
+			return o.lowerUnsafeArrayPointerAddressSourceRef(ctx, unsafeCall.Args[0])
+		}
+		if arg, ok := unsafePointerIdentityCallArg(ctx, unsafeCall); ok {
+			return o.lowerUnsafeArrayPointerSourceRef(ctx, arg)
+		}
+	}
+	return o.lowerUnsafeArrayPointerAddressSourceRef(ctx, expr)
+}
+
+func (o *LoweringOwner) lowerUnsafeArrayPointerAddressSourceRef(
+	ctx lowerFileContext,
+	expr ast.Expr,
+) (string, types.Type, []Diagnostic, bool) {
+	if source, ok := stringHeaderDataSource(ctx, expr); ok {
+		value, diagnostics := o.lowerExpr(ctx, source)
+		bytes := o.runtimeOwner.QualifiedHelper(RuntimeHelperStringToBytes) + "(" + value + ")"
+		ref := o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexRef) + "(" + bytes + ", 0)"
+		return ref, types.Typ[types.Uint8], diagnostics, true
+	}
+
+	address, ok := unwrapParenExpr(expr).(*ast.UnaryExpr)
+	if !ok || address.Op != token.AND {
+		return "", nil, nil, false
+	}
+	if index, ok := unwrapParenExpr(address.X).(*ast.IndexExpr); ok {
+		ref, diagnostics := o.lowerAddressExpr(ctx, index)
+		return ref, indexElementType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)), diagnostics, true
+	}
+	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(address.X)
+	if isNumericType(sourceType) || isStringType(sourceType) || isComplexType(sourceType) {
+		value, diagnostics := o.lowerExpr(ctx, address.X)
+		ref := o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexRef) + "([" + value + "], 0)"
+		return ref, sourceType, diagnostics, true
+	}
+	ref, diagnostics := o.lowerAddressExpr(ctx, address.X)
+	return ref, sourceType, diagnostics, true
+}
+
+func unsafePointerIdentityCallArg(ctx lowerFileContext, call *ast.CallExpr) (ast.Expr, bool) {
+	if call == nil || len(call.Args) != 1 ||
+		!isUnsafePointerType(ctx.semPkg.source.TypesInfo.TypeOf(call)) ||
+		!isUnsafePointerType(ctx.semPkg.source.TypesInfo.TypeOf(call.Args[0])) {
+		return nil, false
+	}
+	fn := calledFunction(ctx.semPkg.source, call.Fun)
+	decl := functionDeclForObject(ctx.semPkg, fn)
+	if decl == nil || decl.Type == nil || decl.Type.Params == nil ||
+		len(decl.Type.Params.List) != 1 || len(decl.Type.Params.List[0].Names) != 1 ||
+		decl.Body == nil {
+		return nil, false
+	}
+	param := objectForIdent(ctx, decl.Type.Params.List[0].Names[0])
+	if param == nil {
+		return nil, false
+	}
+	aliases := make(map[types.Object]bool)
+	for _, stmt := range decl.Body.List {
+		switch typed := stmt.(type) {
+		case *ast.AssignStmt:
+			if !recordUnsafePointerUintptrAlias(ctx, typed, param, aliases) {
+				return nil, false
+			}
+		case *ast.ReturnStmt:
+			if len(typed.Results) == 1 && unsafePointerIdentityReturnExpr(ctx, typed.Results[0], param, aliases) {
+				return call.Args[0], true
+			}
+			return nil, false
+		default:
+			return nil, false
+		}
+	}
+	return nil, false
+}
+
+func recordUnsafePointerUintptrAlias(ctx lowerFileContext, stmt *ast.AssignStmt, param types.Object, aliases map[types.Object]bool) bool {
+	if stmt == nil || len(stmt.Lhs) != 1 || len(stmt.Rhs) != 1 {
+		return false
+	}
+	ident, ok := unwrapParenExpr(stmt.Lhs[0]).(*ast.Ident)
+	if !ok || ident.Name == "_" {
+		return false
+	}
+	if !unsafePointerUintptrIdentityExpr(ctx, stmt.Rhs[0], param, aliases) {
+		return false
+	}
+	obj := objectForIdent(ctx, ident)
+	if obj == nil {
+		return false
+	}
+	aliases[obj] = true
+	return true
+}
+
+func unsafePointerIdentityReturnExpr(ctx lowerFileContext, expr ast.Expr, param types.Object, aliases map[types.Object]bool) bool {
+	expr = unwrapParenExpr(expr)
+	if ident, ok := expr.(*ast.Ident); ok {
+		return objectForIdent(ctx, ident) == param
+	}
+	call, ok := expr.(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 || !isUnsafePointerType(typeFromExpr(ctx, call.Fun)) {
+		return false
+	}
+	return unsafePointerUintptrIdentityExpr(ctx, call.Args[0], param, aliases)
+}
+
+func unsafePointerUintptrIdentityExpr(ctx lowerFileContext, expr ast.Expr, param types.Object, aliases map[types.Object]bool) bool {
+	expr = unwrapParenExpr(expr)
+	if binary, ok := expr.(*ast.BinaryExpr); ok && binary.Op == token.XOR {
+		switch {
+		case isZeroIntegerExpr(ctx, binary.Y):
+			return unsafePointerUintptrIdentityExpr(ctx, binary.X, param, aliases)
+		case isZeroIntegerExpr(ctx, binary.X):
+			return unsafePointerUintptrIdentityExpr(ctx, binary.Y, param, aliases)
+		}
+		return false
+	}
+	if ident, ok := expr.(*ast.Ident); ok {
+		obj := objectForIdent(ctx, ident)
+		return obj == param || aliases[obj]
+	}
+	call, ok := expr.(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 || !isUintptrType(typeFromExpr(ctx, call.Fun)) {
+		return false
+	}
+	ident, ok := unwrapParenExpr(call.Args[0]).(*ast.Ident)
+	return ok && objectForIdent(ctx, ident) == param
+}
+
+func stringHeaderDataSource(ctx lowerFileContext, expr ast.Expr) (ast.Expr, bool) {
+	selector, ok := unwrapParenExpr(expr).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "Data" {
+		return nil, false
+	}
+	call, ok := unwrapParenExpr(selector.X).(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 {
+		return nil, false
+	}
+	targetType := typeFromExpr(ctx, call.Fun)
+	if targetType == nil {
+		return nil, false
+	}
+	targetPointer, _ := types.Unalias(targetType).Underlying().(*types.Pointer)
+	if targetPointer == nil {
+		return nil, false
+	}
+	header, _ := types.Unalias(targetPointer.Elem()).(*types.Named)
+	if header == nil || header.Obj() == nil || header.Obj().Pkg() == nil ||
+		header.Obj().Pkg().Path() != "reflect" || header.Obj().Name() != "StringHeader" {
+		return nil, false
+	}
+	unsafeCall, ok := unwrapParenExpr(call.Args[0]).(*ast.CallExpr)
+	if !ok || len(unsafeCall.Args) != 1 || !isUnsafePointerType(typeFromExpr(ctx, unsafeCall.Fun)) {
+		return nil, false
+	}
+	address, ok := unwrapParenExpr(unsafeCall.Args[0]).(*ast.UnaryExpr)
+	if !ok || address.Op != token.AND || !isStringType(ctx.semPkg.source.TypesInfo.TypeOf(address.X)) {
+		return nil, false
+	}
+	return address.X, true
+}
+
 func (o *LoweringOwner) lowerAddressedValueRef(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
 	if ident, ok := unwrapParenExpr(expr).(*ast.Ident); ok {
 		if obj := objectForIdent(ctx, ident); obj != nil && ctx.model.needsVarRef[obj] {
@@ -9474,7 +10429,11 @@ func (o *LoweringOwner) lowerMapCompositeLit(
 		value = o.lowerValueForTarget(ctx, keyed.Value, mapType.Elem(), value)
 		entries = append(entries, "["+key+", "+value+"]")
 	}
-	return "new Map<" + o.tsTypeFor(ctx, mapType.Key()) + ", " + o.tsTypeFor(ctx, mapType.Elem()) + ">([" + strings.Join(entries, ", ") + "])", diagnostics
+	return "new " + tsNativeMapType(o.tsTypeFor(ctx, mapType.Key()), o.tsTypeFor(ctx, mapType.Elem())) + "([" + strings.Join(entries, ", ") + "])", diagnostics
+}
+
+func tsNativeMapType(keyType, elemType string) string {
+	return "globalThis.Map<" + keyType + ", " + elemType + ">"
 }
 
 func (o *LoweringOwner) lowerTypeAssertExpr(ctx lowerFileContext, expr *ast.TypeAssertExpr) (string, []Diagnostic) {
@@ -9511,7 +10470,11 @@ func (o *LoweringOwner) lowerMapGetTuple(ctx lowerFileContext, expr *ast.IndexEx
 	mapType, _ := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr.X)).Underlying().(*types.Map)
 	defaultValue := "undefined"
 	if mapType != nil {
+		index = o.lowerValueForTarget(ctx, expr.Index, mapType.Key(), index)
 		defaultValue = o.lowerZeroValueExprFor(ctx, mapType.Elem())
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMapGet) +
+			"<" + o.tsTypeFor(ctx, mapType.Key()) + ", " + o.tsTypeFor(ctx, mapType.Elem()) + ", " + o.tsTypeFor(ctx, mapType.Elem()) + ">(" +
+			target + ", " + index + ", " + defaultValue + ")"
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperMapGet) + "(" + target + ", " + index + ", " + defaultValue + ")"
 }
@@ -10401,7 +11364,7 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 	case *types.Slice:
 		return "$.Slice<" + o.tsSliceElemTypeFor(ctx, typed.Elem()) + ">"
 	case *types.Map:
-		return "Map<" + o.tsTypeFor(ctx, typed.Key()) + ", " + o.tsTypeFor(ctx, typed.Elem()) + "> | null"
+		return tsNativeMapType(o.tsTypeFor(ctx, typed.Key()), o.tsTypeFor(ctx, typed.Elem())) + " | null"
 	case *types.Chan:
 		return "$.Channel<" + o.tsTypeFor(ctx, typed.Elem()) + "> | null"
 	case *types.Struct:
@@ -10420,6 +11383,12 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 			if !ctx.canReferenceNamedType(named) {
 				return "any"
 			}
+			if _, ok := named.Underlying().(*types.Interface); ok {
+				return "$.VarRef<" + o.tsTypeFor(ctx, typed.Elem()) + "> | null"
+			}
+			if _, ok := types.Unalias(named.Underlying()).(*types.Signature); ok {
+				return "$.VarRef<" + o.tsTypeFor(ctx, typed.Elem()) + "> | null"
+			}
 			return "$.VarRef<" + o.namedTypeExpr(ctx, named) + "> | null"
 		}
 		if named := namedStructType(typed.Elem()); named != nil {
@@ -10462,6 +11431,9 @@ func (o *LoweringOwner) tsNonNilTypeFor(ctx lowerFileContext, typ types.Type) st
 		return "Exclude<$.GoError, null>"
 	}
 	if named, ok := types.Unalias(typ).(*types.Named); ok {
+		if crossPackageUnexportedNamedType(ctx, named) {
+			return "any"
+		}
 		if _, ok := named.Underlying().(*types.Interface); ok {
 			if !ctx.canReferenceNamedType(named) {
 				return "any"
@@ -10788,7 +11760,7 @@ func isPointerToStructType(typ types.Type) bool {
 	if !ok {
 		return false
 	}
-	return namedStructType(pointer.Elem()) != nil
+	return structUnderlyingType(pointer.Elem()) != nil
 }
 
 func derefPointerType(typ types.Type) types.Type {
@@ -10865,6 +11837,9 @@ func isChannelType(typ types.Type) bool {
 }
 
 func isComplexType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	return ok && basic.Info()&types.IsComplex != 0
 }
@@ -10878,10 +11853,21 @@ func isPointerType(typ types.Type) bool {
 }
 
 func isUnsafePointerType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	return ok && basic.Kind() == types.UnsafePointer
 }
 
+func isUintptrType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
+	return ok && basic.Kind() == types.Uintptr
+}
+
 func channelDirectionString(dir types.ChanDir) string {
 	switch dir {
 	case types.SendOnly:
@@ -10909,21 +11895,33 @@ func unwrapParenExpr(expr ast.Expr) ast.Expr {
 }
 
 func isStringType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	return ok && basic.Info()&types.IsString != 0
 }
 
 func isNumericType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	return ok && basic.Info()&types.IsNumeric != 0
 }
 
 func isIntegerType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	return ok && basic.Info()&types.IsInteger != 0
 }
 
 func isFloatType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	return ok && basic.Info()&types.IsFloat != 0
 }
@@ -11097,7 +12095,102 @@ func (o *LoweringOwner) functionAsync(ctx lowerFileContext, fn *types.Func) bool
 	if fn == nil || ctx.model == nil {
 		return false
 	}
-	return ctx.model.functionAsync(fn)
+	if ctx.model.functionAsync(fn) {
+		return true
+	}
+	return o.functionReferencesAsyncLazyPackageVar(ctx, fn, make(map[*types.Func]bool))
+}
+
+func (o *LoweringOwner) functionReferencesAsyncLazyPackageVar(
+	ctx lowerFileContext,
+	fn *types.Func,
+	seen map[*types.Func]bool,
+) bool {
+	fn = functionOriginOrSelf(fn)
+	if fn == nil || ctx.model == nil {
+		return false
+	}
+	if cached, ok := ctx.asyncLazyFunctionCache[fn]; ok {
+		return cached
+	}
+	if ctx.asyncLazyFunctionVisiting != nil {
+		if ctx.asyncLazyFunctionVisiting[fn] {
+			return false
+		}
+		ctx.asyncLazyFunctionVisiting[fn] = true
+		defer delete(ctx.asyncLazyFunctionVisiting, fn)
+	} else {
+		if seen[fn] {
+			return false
+		}
+		seen[fn] = true
+	}
+	references := false
+	defer func() {
+		if ctx.asyncLazyFunctionCache != nil {
+			ctx.asyncLazyFunctionCache[fn] = references
+		}
+	}()
+	if fn.Pkg() == nil {
+		return false
+	}
+	semPkg := ctx.model.packages[fn.Pkg().Path()]
+	if semPkg == nil || semPkg.source == nil {
+		return false
+	}
+	decl := functionDeclForObject(semPkg, fn)
+	if decl == nil || decl.Body == nil {
+		return false
+	}
+	analysisCtx := lowerFileContext{
+		model:                     ctx.model,
+		semPkg:                    semPkg,
+		lazyPackageVarsByPkg:      ctx.lazyPackageVarsByPkg,
+		asyncLazyFunctionCache:    ctx.asyncLazyFunctionCache,
+		asyncLazyFunctionVisiting: ctx.asyncLazyFunctionVisiting,
+		topLevel:                  true,
+	}
+	ast.Inspect(decl.Body, func(node ast.Node) bool {
+		if references {
+			return false
+		}
+		if _, ok := node.(*ast.FuncLit); ok {
+			return false
+		}
+		if ident, ok := node.(*ast.Ident); ok {
+			if o.objectIsAsyncLazyPackageVar(analysisCtx, semPkg.source.TypesInfo.Uses[ident]) {
+				references = true
+				return false
+			}
+		}
+		if selector, ok := node.(*ast.SelectorExpr); ok {
+			if o.objectIsAsyncLazyPackageVar(analysisCtx, semPkg.source.TypesInfo.Uses[selector.Sel]) {
+				references = true
+				return false
+			}
+		}
+		call, ok := node.(*ast.CallExpr)
+		if !ok {
+			return true
+		}
+		if o.functionReferencesAsyncLazyPackageVar(ctx, calledFunction(semPkg.source, call.Fun), seen) {
+			references = true
+			return false
+		}
+		return true
+	})
+	return references
+}
+
+func (o *LoweringOwner) objectIsAsyncLazyPackageVar(ctx lowerFileContext, obj types.Object) bool {
+	varObj, _ := obj.(*types.Var)
+	if varObj == nil || varObj.Pkg() == nil {
+		return false
+	}
+	if !o.packageVarIsLazy(ctx, varObj) && !o.packageVarNameIsLazy(ctx, varObj.Pkg().Path(), varObj.Name()) {
+		return false
+	}
+	return o.packageVarHasAsyncLazyInit(ctx, varObj)
 }
 
 func (o *LoweringOwner) callNeedsAwait(ctx lowerFileContext, fun ast.Expr) bool {