goscript 0.1.1 → 0.1.3

package/compiler/lowering.go

@@ -15,6 +15,7 @@ import (
 	"slices"
 	"strconv"
 	"strings"
+	"unicode/utf8"
 )
 
 // LoweringOwner owns conversion from the semantic model to compiler IR.
@@ -86,10 +87,13 @@ func (o *LoweringOwner) lowerPackage(model *SemanticModel, semPkg *semanticPacka
 		pkgPath: semPkg.pkgPath,
 		name:    semPkg.name,
 	}
+	declFiles := packageDeclFiles(semPkg)
+	outputNames := packageOutputNames(semPkg)
+	lazyPackageVars := o.lazyPackageVars(semPkg, declFiles)
 	var diagnostics []Diagnostic
 	for idx, file := range semPkg.source.Syntax {
 		sourcePath := sourceFilePath(semPkg, idx, file)
-		loweredFile, fileDiagnostics := o.lowerFile(model, semPkg, file, sourcePath)
+		loweredFile, fileDiagnostics := o.lowerFile(model, semPkg, file, sourcePath, declFiles, outputNames, lazyPackageVars)
 		diagnostics = append(diagnostics, fileDiagnostics...)
 		if loweredFile != nil {
 			loweredPkg.files = append(loweredPkg.files, loweredFile)
@@ -118,6 +122,9 @@ func (o *LoweringOwner) lowerFile(
 	semPkg *semanticPackage,
 	file *ast.File,
 	sourcePath string,
+	declFiles map[types.Object]string,
+	outputNames map[string]string,
+	lazyPackageVars map[types.Object]bool,
 ) (*loweredFile, []Diagnostic) {
 	associatedMethods := o.methodDeclsForFileTypes(semPkg, file)
 	relevantImportFiles := map[string]bool{sourcePath: true}
@@ -138,7 +145,9 @@ func (o *LoweringOwner) lowerFile(
 	importAliases := make(map[string]string)
 	importPaths := make(map[string]string)
 	importNames := make(map[string]string)
-	reservedImportAliases := localDeclarationNames(semPkg, file, associatedMethods)
+	importObjects := make(map[*types.PkgName]string)
+	localRefs := o.analyzeLocalFileReferences(semPkg, file, sourcePath, associatedMethods, declFiles, outputNames)
+	reservedImportAliases := localRefs.reservedNames
 	seenImport := make(map[string]bool)
 	for idx, importFile := range semPkg.source.Syntax {
 		importSourcePath := sourceFilePath(semPkg, idx, importFile)
@@ -170,36 +179,51 @@ func (o *LoweringOwner) lowerFile(
 			importAliases[alias] = pkgName.Imported().Path()
 			importPaths[pkgName.Imported().Path()] = alias
 			importNames[name] = alias
+			importObjects[pkgName] = alias
 			loweredFile.imports = append(loweredFile.imports, loweredImport{
-				alias:  alias,
-				source: source,
+				alias:      alias,
+				source:     source,
+				sideEffect: true,
 			})
 		}
 	}
-	for importSourcePath := range relevantImportFiles {
-		o.addGeneratedTypeImports(model, semPkg, importSourcePath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
-	}
-	localAliases, localAliasSources, implicitImports := o.localFileAliases(semPkg, file, sourcePath, associatedMethods)
-	lazyPackageVars := o.lazyPackageVars(semPkg)
-	implicitImportPaths := make([]string, 0, len(implicitImports))
-	for pkgPath := range implicitImports {
+	implicitImportPaths := make([]string, 0, len(localRefs.implicitImports))
+	for pkgPath := range localRefs.implicitImports {
 		if pkgPath != "" && pkgPath != semPkg.pkgPath {
 			implicitImportPaths = append(implicitImportPaths, pkgPath)
 		}
 	}
 	slices.Sort(implicitImportPaths)
 	for _, pkgPath := range implicitImportPaths {
-		o.addGeneratedImportPath(model, pkgPath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
+		o.addGeneratedImportPath(
+			model,
+			pkgPath,
+			loweredFile,
+			importAliases,
+			importPaths,
+			reservedImportAliases,
+			seenImport,
+			!localRefs.implicitRuntime[pkgPath],
+		)
+	}
+	for importSourcePath := range relevantImportFiles {
+		o.addGeneratedTypeImports(model, semPkg, importSourcePath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
 	}
-	localImports := make([]loweredImport, 0, len(localAliases))
+	localImports := make([]loweredImport, 0, len(localRefs.aliases))
 	seenLocalImport := make(map[string]bool)
-	for _, alias := range localAliases {
+	for _, alias := range localRefs.aliases {
 		if seenLocalImport[alias] {
 			continue
 		}
 		seenLocalImport[alias] = true
-		source := localAliasSources[alias]
-		localImports = append(localImports, loweredImport{alias: alias, source: source})
+		source := localRefs.aliasSources[alias]
+		typeOnly := !localRefs.runtimeAliases[alias]
+		localImports = append(localImports, loweredImport{
+			alias:      alias,
+			source:     source,
+			sideEffect: !typeOnly,
+			typeOnly:   typeOnly,
+		})
 	}
 	slices.SortFunc(localImports, func(a, b loweredImport) int {
 		return cmp.Compare(a.alias, b.alias)
@@ -213,15 +237,21 @@ func (o *LoweringOwner) lowerFile(
 		importAliases:   importAliases,
 		importPaths:     importPaths,
 		importNames:     importNames,
+		importObjects:   importObjects,
 		sourcePath:      sourcePath,
-		localAliases:    localAliases,
+		localAliases:    localRefs.aliases,
 		lazyPackageVars: lazyPackageVars,
 		tempNames:       newTempNameOwner(),
 		topLevel:        true,
 	}
 	var diagnostics []Diagnostic
+	var packageInitCalls []string
 	appendDecls := func(decls []loweredDecl) {
 		for _, decl := range decls {
+			if decl.packageInitCall != "" {
+				packageInitCalls = append(packageInitCalls, decl.packageInitCall)
+				continue
+			}
 			loweredFile.decls = append(loweredFile.decls, decl)
 			if decl.indexExport != "" {
 				loweredFile.exports = append(loweredFile.exports, decl.indexExport)
@@ -229,6 +259,9 @@ func (o *LoweringOwner) lowerFile(
 			if decl.typeIndexExport != "" {
 				loweredFile.typeExports = append(loweredFile.typeExports, decl.typeIndexExport)
 			}
+			if decl.sideEffect {
+				loweredFile.sideEffect = true
+			}
 			if decl.function != nil && decl.function.indexExported && decl.function.name != "main" {
 				loweredFile.exports = append(loweredFile.exports, decl.function.name)
 			}
@@ -252,6 +285,9 @@ func (o *LoweringOwner) lowerFile(
 			lowerDecl(decl)
 		}
 	}
+	for _, call := range packageInitCalls {
+		loweredFile.decls = append(loweredFile.decls, loweredDecl{code: "await " + call})
+	}
 	for _, decl := range loweredFile.decls {
 		if decl.function == nil || !decl.function.init {
 			continue
@@ -287,7 +323,7 @@ func (o *LoweringOwner) addGeneratedTypeImports(
 	}
 	slices.Sort(pkgPaths)
 	for _, pkgPath := range pkgPaths {
-		o.addGeneratedImportPath(model, pkgPath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport)
+		o.addGeneratedImportPath(model, pkgPath, loweredFile, importAliases, importPaths, reservedImportAliases, seenImport, true)
 	}
 }
 
@@ -299,6 +335,7 @@ func (o *LoweringOwner) addGeneratedImportPath(
 	importPaths map[string]string,
 	reservedImportAliases map[string]bool,
 	seenImport map[string]bool,
+	typeOnly bool,
 ) {
 	if !o.hasGeneratedImportPackage(model, pkgPath) {
 		return
@@ -317,8 +354,10 @@ func (o *LoweringOwner) addGeneratedImportPath(
 	importAliases[alias] = pkgPath
 	importPaths[pkgPath] = alias
 	loweredFile.imports = append(loweredFile.imports, loweredImport{
-		alias:  alias,
-		source: source,
+		alias:      alias,
+		source:     source,
+		sideEffect: !typeOnly,
+		typeOnly:   typeOnly,
 	})
 }
 
@@ -351,36 +390,6 @@ func uniqueImportAlias(alias string, pkgPath string, importAliases map[string]st
 	}
 }
 
-func localDeclarationNames(semPkg *semanticPackage, file *ast.File, associatedMethods []*ast.FuncDecl) map[string]bool {
-	if semPkg == nil || semPkg.source == nil {
-		return nil
-	}
-	names := make(map[string]bool)
-	inspect := func(node ast.Node) bool {
-		ident, ok := node.(*ast.Ident)
-		if !ok {
-			return true
-		}
-		obj := semPkg.source.TypesInfo.Defs[ident]
-		if obj == nil {
-			return true
-		}
-		if _, ok := obj.(*types.PkgName); ok {
-			return true
-		}
-		name := safeIdentifier(obj.Name())
-		if name != "_" {
-			names[name] = true
-		}
-		return true
-	}
-	ast.Inspect(file, inspect)
-	for _, methodDecl := range associatedMethods {
-		ast.Inspect(methodDecl, inspect)
-	}
-	return names
-}
-
 func (o *LoweringOwner) methodDeclsForFileTypes(semPkg *semanticPackage, file *ast.File) []*ast.FuncDecl {
 	if semPkg == nil || semPkg.source == nil || file == nil {
 		return nil
@@ -433,54 +442,89 @@ func (o *LoweringOwner) methodDeclsForFileTypes(semPkg *semanticPackage, file *a
 	return methods
 }
 
-func (o *LoweringOwner) localFileAliases(
+type localFileReferenceAnalysis struct {
+	reservedNames   map[string]bool
+	aliases         map[types.Object]string
+	aliasSources    map[string]string
+	runtimeAliases  map[string]bool
+	implicitImports map[string]bool
+	implicitRuntime map[string]bool
+}
+
+func (o *LoweringOwner) analyzeLocalFileReferences(
 	semPkg *semanticPackage,
 	file *ast.File,
 	sourcePath string,
 	associatedMethods []*ast.FuncDecl,
-) (map[types.Object]string, map[string]string, map[string]bool) {
-	declFiles := make(map[types.Object]string)
-	for _, decl := range semPkg.declarations {
-		if decl.object == nil || decl.position.file == "" {
-			continue
-		}
-		declFiles[decl.object] = decl.position.file
-	}
-	outputNames := make(map[string]string)
-	for idx, syntax := range semPkg.source.Syntax {
-		outputSourcePath := sourceFilePath(semPkg, idx, syntax)
-		outputNames[outputSourcePath] = sourceOutputName(outputSourcePath)
+	declFiles map[types.Object]string,
+	outputNames map[string]string,
+) localFileReferenceAnalysis {
+	analysis := localFileReferenceAnalysis{
+		reservedNames:   make(map[string]bool),
+		aliases:         make(map[types.Object]string),
+		aliasSources:    make(map[string]string),
+		runtimeAliases:  make(map[string]bool),
+		implicitImports: make(map[string]bool),
+		implicitRuntime: make(map[string]bool),
 	}
-	aliases := make(map[types.Object]string)
-	aliasSources := make(map[string]string)
-	implicitImports := make(map[string]bool)
 	seenObjects := make(map[types.Object]bool)
 	seenTypes := make(map[types.Type]bool)
 	var addTypeDeps func(typ types.Type)
-	var addObject func(obj types.Object)
-	addObject = func(obj types.Object) {
-		if obj == nil || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+	var addRuntimeTypeDeps func(typ types.Type)
+	var addRuntimeTypeOwnerDeps func(typ types.Type)
+	var addObject func(obj types.Object, runtime bool)
+	addObject = func(obj types.Object, runtime bool) {
+		if obj == nil || obj.Pkg() == nil {
 			return
 		}
-		if seenObjects[obj] {
+		if obj.Pkg().Path() != semPkg.pkgPath {
+			if runtime {
+				analysis.implicitImports[obj.Pkg().Path()] = true
+				analysis.implicitRuntime[obj.Pkg().Path()] = true
+			}
 			return
 		}
-		seenObjects[obj] = true
 		declFile := declFiles[obj]
+		if declFile == "" {
+			if fn, ok := obj.(*types.Func); ok {
+				if decl := functionDeclForObject(semPkg, fn); decl != nil {
+					declFile = sourcePos(semPkg.source, decl.Pos()).file
+				}
+			}
+		}
 		if declFile != "" && declFile != sourcePath {
 			outputName := outputNames[declFile]
 			if outputName != "" {
 				alias := "__goscript_" + safeIdentifier(strings.TrimSuffix(outputName, ".gs.ts"))
-				aliases[obj] = alias
-				aliasSources[alias] = "./" + outputName
+				analysis.aliases[obj] = alias
+				analysis.aliasSources[alias] = "./" + outputName
+				if runtime {
+					analysis.runtimeAliases[alias] = true
+				}
 			}
 		}
+		if runtime {
+			if alias := analysis.aliases[obj]; alias != "" {
+				analysis.runtimeAliases[alias] = true
+			}
+		}
+		if seenObjects[obj] {
+			return
+		}
+		seenObjects[obj] = true
 		switch typed := obj.(type) {
 		case *types.TypeName:
 			addTypeDeps(typed.Type())
+			if named, ok := types.Unalias(typed.Type()).(*types.Named); ok {
+				if structType := structUnderlyingType(named); structType != nil {
+					for field := range structType.Fields() {
+						addRuntimeTypeDeps(field.Type())
+					}
+				}
+			}
 			if named, ok := types.Unalias(typed.Type()).(*types.Named); ok {
 				for method := range named.Methods() {
-					addObject(method)
+					addObject(method, false)
 				}
 			}
 		case *types.Var:
@@ -514,7 +558,7 @@ func (o *LoweringOwner) localFileAliases(
 		seenTypes[typ] = true
 		if alias, ok := typ.(*types.Alias); ok {
 			if obj := alias.Obj(); obj != nil && obj.Pkg() != nil && obj.Pkg().Path() != semPkg.pkgPath {
-				implicitImports[obj.Pkg().Path()] = true
+				analysis.implicitImports[obj.Pkg().Path()] = true
 				if args := alias.TypeArgs(); args != nil {
 					for t := range args.Types() {
 						addTypeDeps(t)
@@ -523,7 +567,7 @@ func (o *LoweringOwner) localFileAliases(
 				addTypeDeps(alias.Rhs())
 				return
 			}
-			addObject(alias.Obj())
+			addObject(alias.Obj(), false)
 			if args := alias.TypeArgs(); args != nil {
 				for t := range args.Types() {
 					addTypeDeps(t)
@@ -534,7 +578,7 @@ func (o *LoweringOwner) localFileAliases(
 		}
 		if named, ok := types.Unalias(typ).(*types.Named); ok {
 			if obj := named.Obj(); obj != nil && obj.Pkg() != nil && obj.Pkg().Path() != semPkg.pkgPath {
-				implicitImports[obj.Pkg().Path()] = true
+				analysis.implicitImports[obj.Pkg().Path()] = true
 				if args := named.TypeArgs(); args != nil {
 					for t := range args.Types() {
 						addTypeDeps(t)
@@ -542,7 +586,7 @@ func (o *LoweringOwner) localFileAliases(
 				}
 				return
 			}
-			addObject(named.Obj())
+			addObject(named.Obj(), false)
 			if args := named.TypeArgs(); args != nil {
 				for t := range args.Types() {
 					addTypeDeps(t)
@@ -588,20 +632,142 @@ func (o *LoweringOwner) localFileAliases(
 			}
 		}
 	}
+	addRuntimeTypeDeps = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		if alias, ok := typ.(*types.Alias); ok {
+			addObject(alias.Obj(), true)
+			if args := alias.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeDeps(t)
+				}
+			}
+			addRuntimeTypeDeps(alias.Rhs())
+			return
+		}
+		if named, ok := types.Unalias(typ).(*types.Named); ok {
+			addObject(named.Obj(), true)
+			for method := range named.Methods() {
+				addObject(method, true)
+			}
+			methodSet := types.NewMethodSet(types.NewPointer(named))
+			for method := range methodSet.Methods() {
+				addObject(method.Obj(), true)
+			}
+			if args := named.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeDeps(t)
+				}
+			}
+			return
+		}
+		switch typed := types.Unalias(typ).Underlying().(type) {
+		case *types.Pointer:
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Slice:
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Array:
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Map:
+			addRuntimeTypeDeps(typed.Key())
+			addRuntimeTypeDeps(typed.Elem())
+		case *types.Chan:
+			addRuntimeTypeDeps(typed.Elem())
+		}
+	}
+	addRuntimeTypeOwnerDeps = func(typ types.Type) {
+		if typ == nil {
+			return
+		}
+		if alias, ok := typ.(*types.Alias); ok {
+			addObject(alias.Obj(), true)
+			if args := alias.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeOwnerDeps(t)
+				}
+			}
+			addRuntimeTypeOwnerDeps(alias.Rhs())
+			return
+		}
+		if named, ok := types.Unalias(typ).(*types.Named); ok {
+			addObject(named.Obj(), true)
+			if args := named.TypeArgs(); args != nil {
+				for t := range args.Types() {
+					addRuntimeTypeOwnerDeps(t)
+				}
+			}
+			return
+		}
+		switch typed := types.Unalias(typ).Underlying().(type) {
+		case *types.Pointer:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Slice:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Array:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Map:
+			addRuntimeTypeOwnerDeps(typed.Key())
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		case *types.Chan:
+			addRuntimeTypeOwnerDeps(typed.Elem())
+		}
+	}
 	inspect := func(node ast.Node) bool {
 		switch typed := node.(type) {
+		case *ast.ValueSpec:
+			if len(typed.Values) == 0 && typed.Type != nil {
+				addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed.Type))
+			}
 		case *ast.Ident:
-			addObject(semPkg.source.TypesInfo.Uses[typed])
+			if obj := semPkg.source.TypesInfo.Defs[typed]; obj != nil {
+				if _, ok := obj.(*types.PkgName); !ok {
+					name := safeIdentifier(obj.Name())
+					if name != "_" {
+						analysis.reservedNames[name] = true
+					}
+				}
+			}
+			if tv, ok := semPkg.source.TypesInfo.Types[typed]; ok && tv.IsValue() {
+				addObject(semPkg.source.TypesInfo.Uses[typed], true)
+			}
 			addTypeDeps(semPkg.source.TypesInfo.TypeOf(typed))
 		case *ast.SelectorExpr:
 			if selection := semPkg.source.TypesInfo.Selections[typed]; selection != nil {
-				addObject(selection.Obj())
+				switch selection.Kind() {
+				case types.FieldVal, types.MethodVal, types.MethodExpr:
+					addObject(selection.Obj(), true)
+					if selection.Kind() != types.FieldVal {
+						addRuntimeTypeOwnerDeps(selection.Recv())
+					}
+				default:
+					addObject(selection.Obj(), false)
+				}
+				addTypeDeps(selection.Obj().Type())
 			} else if obj := semPkg.source.TypesInfo.Uses[typed.Sel]; obj != nil {
+				if tv, ok := semPkg.source.TypesInfo.Types[typed]; ok && tv.IsValue() {
+					addObject(obj, true)
+				}
 				addTypeDeps(obj.Type())
 			}
 			if pointer, ok := types.Unalias(semPkg.source.TypesInfo.TypeOf(typed.X)).Underlying().(*types.Pointer); ok {
 				addTypeDeps(pointer.Elem())
 			}
+		case *ast.CompositeLit:
+			addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed))
+			addCompositeInterfaceValueDeps(semPkg.source.TypesInfo, typed, addRuntimeTypeDeps)
+		case *ast.CallExpr:
+			if ident, ok := ast.Unparen(typed.Fun).(*ast.Ident); ok && ident.Name == "new" {
+				for _, arg := range typed.Args {
+					addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(arg))
+				}
+			}
+			if ident, ok := ast.Unparen(typed.Fun).(*ast.Ident); ok && ident.Name == "make" && len(typed.Args) != 0 {
+				addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed.Args[0]))
+			}
+			addReflectTypeForRuntimeDeps(semPkg.source.TypesInfo, typed, addRuntimeTypeDeps)
+			addInterfaceArgumentRuntimeDeps(semPkg.source.TypesInfo, typed, addRuntimeTypeDeps)
+			addRuntimeTypeDeps(semPkg.source.TypesInfo.TypeOf(typed.Fun))
 		}
 		return true
 	}
@@ -609,7 +775,163 @@ func (o *LoweringOwner) localFileAliases(
 	for _, methodDecl := range associatedMethods {
 		ast.Inspect(methodDecl, inspect)
 	}
-	return aliases, aliasSources, implicitImports
+	return analysis
+}
+
+func addInterfaceArgumentRuntimeDeps(
+	info *types.Info,
+	call *ast.CallExpr,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if info == nil || call == nil {
+		return
+	}
+	signature, _ := types.Unalias(info.TypeOf(call.Fun)).(*types.Signature)
+	if signature == nil || signature.Params() == nil {
+		return
+	}
+	params := signature.Params()
+	for idx, arg := range call.Args {
+		paramIdx := idx
+		if signature.Variadic() && paramIdx >= params.Len()-1 {
+			paramIdx = params.Len() - 1
+		}
+		if paramIdx < 0 || paramIdx >= params.Len() {
+			continue
+		}
+		paramType := params.At(paramIdx).Type()
+		if signature.Variadic() && idx >= params.Len()-1 {
+			if slice, ok := types.Unalias(paramType).Underlying().(*types.Slice); ok {
+				paramType = slice.Elem()
+			}
+		}
+		if typeIsInterface(paramType) {
+			addRuntimeTypeDeps(info.TypeOf(arg))
+		}
+	}
+}
+
+func addReflectTypeForRuntimeDeps(
+	info *types.Info,
+	call *ast.CallExpr,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if info == nil || call == nil || !isReflectTypeForExpr(info, call.Fun) {
+		return
+	}
+	switch typed := ast.Unparen(call.Fun).(type) {
+	case *ast.IndexExpr:
+		addRuntimeTypeDeps(info.TypeOf(typed.Index))
+	case *ast.IndexListExpr:
+		for _, index := range typed.Indices {
+			addRuntimeTypeDeps(info.TypeOf(index))
+		}
+	}
+}
+
+func isReflectTypeForExpr(info *types.Info, expr ast.Expr) bool {
+	var base ast.Expr
+	switch typed := ast.Unparen(expr).(type) {
+	case *ast.IndexExpr:
+		base = typed.X
+	case *ast.IndexListExpr:
+		base = typed.X
+	default:
+		return false
+	}
+	selector, ok := ast.Unparen(base).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "TypeFor" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := info.Uses[ident].(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "reflect"
+}
+
+func addCompositeInterfaceValueDeps(
+	info *types.Info,
+	lit *ast.CompositeLit,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if info == nil || lit == nil {
+		return
+	}
+	typ := types.Unalias(info.TypeOf(lit))
+	if pointer, ok := typ.Underlying().(*types.Pointer); ok {
+		typ = types.Unalias(pointer.Elem())
+	}
+	switch typed := typ.Underlying().(type) {
+	case *types.Array:
+		addCompositeElementsRuntimeDeps(info, lit.Elts, typed.Elem(), addRuntimeTypeDeps)
+	case *types.Slice:
+		addCompositeElementsRuntimeDeps(info, lit.Elts, typed.Elem(), addRuntimeTypeDeps)
+	case *types.Map:
+		for _, elt := range lit.Elts {
+			keyValue, ok := elt.(*ast.KeyValueExpr)
+			if !ok {
+				continue
+			}
+			if typeIsInterface(typed.Key()) {
+				addRuntimeTypeDeps(info.TypeOf(keyValue.Key))
+			}
+			if typeIsInterface(typed.Elem()) {
+				addRuntimeTypeDeps(info.TypeOf(keyValue.Value))
+			}
+		}
+	case *types.Struct:
+		nextField := 0
+		for _, elt := range lit.Elts {
+			fieldIdx := nextField
+			value := elt
+			if keyValue, ok := elt.(*ast.KeyValueExpr); ok {
+				value = keyValue.Value
+				if ident, ok := keyValue.Key.(*ast.Ident); ok {
+					for idx := range typed.NumFields() {
+						if typed.Field(idx).Name() == ident.Name {
+							fieldIdx = idx
+							break
+						}
+					}
+				}
+			} else {
+				nextField++
+			}
+			if fieldIdx < 0 || fieldIdx >= typed.NumFields() {
+				continue
+			}
+			if typeIsInterface(typed.Field(fieldIdx).Type()) {
+				addRuntimeTypeDeps(info.TypeOf(value))
+			}
+		}
+	}
+}
+
+func addCompositeElementsRuntimeDeps(
+	info *types.Info,
+	elements []ast.Expr,
+	elemType types.Type,
+	addRuntimeTypeDeps func(types.Type),
+) {
+	if !typeIsInterface(elemType) {
+		return
+	}
+	for _, elt := range elements {
+		if keyValue, ok := elt.(*ast.KeyValueExpr); ok {
+			elt = keyValue.Value
+		}
+		addRuntimeTypeDeps(info.TypeOf(elt))
+	}
+}
+
+func typeIsInterface(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	_, ok := types.Unalias(typ).Underlying().(*types.Interface)
+	return ok
 }
 
 func safeIdentifier(value string) string {
@@ -668,12 +990,16 @@ type lowerFileContext struct {
 	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
 	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
@@ -694,6 +1020,30 @@ type tempNameOwner struct {
 	counters map[string]int
 }
 
+func (ctx lowerFileContext) canReferenceNamedType(named *types.Named) bool {
+	if named == nil || named.Obj() == nil {
+		return true
+	}
+	return ctx.canReferenceObjectPackage(named.Obj())
+}
+
+func (ctx lowerFileContext) canReferenceObjectPackage(obj types.Object) bool {
+	if obj == nil || obj.Pkg() == nil || ctx.semPkg == nil {
+		return true
+	}
+	pkgPath := obj.Pkg().Path()
+	if pkgPath == "" || pkgPath == ctx.semPkg.pkgPath {
+		return true
+	}
+	if ctx.importPaths[pkgPath] != "" {
+		return true
+	}
+	if ctx.localAliases[obj] != "" {
+		return true
+	}
+	return false
+}
+
 func newTempNameOwner() *tempNameOwner {
 	return &tempNameOwner{counters: make(map[string]int)}
 }
@@ -720,6 +1070,20 @@ func (ctx lowerFileContext) withIdentAliases(aliases map[types.Object]string) lo
 	return ctx
 }
 
+func (ctx lowerFileContext) withIdentRefAliases(aliases map[types.Object]string) lowerFileContext {
+	if len(aliases) == 0 {
+		return ctx
+	}
+	ctx = ctx.withIdentAliases(aliases)
+	refs := make(map[types.Object]bool, len(ctx.identAliasRefs)+len(aliases))
+	maps.Copy(refs, ctx.identAliasRefs)
+	for obj := range aliases {
+		refs[obj] = true
+	}
+	ctx.identAliasRefs = refs
+	return ctx
+}
+
 func (o *tempNameOwner) next(prefix string) string {
 	idx := o.counters[prefix]
 	o.counters[prefix] = idx + 1
@@ -825,8 +1189,8 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				lazy := ctx.topLevel && ctx.lazyPackageVars[obj]
 				code := keyword + " " + declName + ": " + variableType + " = " + value
 				if lazy {
-					keyword = "let"
-					code = "let " + declName + ": " + variableType + " = undefined as unknown as " + variableType
+					keyword = "var"
+					code = "var " + declName + ": " + variableType + " = undefined as unknown as " + variableType
 				}
 				indexExport := ""
 				if ctx.topLevel && name.Name != "_" {
@@ -838,9 +1202,29 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 				decls = append(decls, loweredDecl{code: code, indexExport: indexExport})
 				if lazy {
 					getterName := packageVarGetterName(name.Name)
-					getterCode := "export function " + getterName + "(): " + variableType + " {\n\t" +
-						"if (((" + declName + ") as any) === undefined) {\n\t\t" +
-						declName + " = " + value + "\n\t}\n\treturn " + declName + "\n}"
+					initName := packageVarInitName(name.Name)
+					initIndexExport := ""
+					if ast.IsExported(name.Name) {
+						initIndexExport = initName
+					}
+					getterCode := "export function " + getterName + "(): " + variableType + " {\n\t"
+					if strings.Contains(value, "await ") {
+						initCode := "export async function " + initName + "(): globalThis.Promise<void> {\n\t" +
+							"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 + "()"})
+						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 {
+						initCode := "export function " + initName + "(): void {\n\t" +
+							"if (((" + declName + ") as any) === undefined) {\n\t\t" +
+							declName + " = " + value + "\n\t}\n}"
+						decls = append(decls, loweredDecl{code: initCode, indexExport: initIndexExport})
+						getterCode += "if (((" + declName + ") as any) === undefined) {\n\t\t" +
+							initName + "()\n\t}\n"
+					}
+					getterCode += "\treturn " + declName + "\n}"
 					getterIndexExport := ""
 					if ast.IsExported(name.Name) {
 						getterIndexExport = getterName
@@ -852,10 +1236,15 @@ func (o *LoweringOwner) lowerGenDecl(ctx lowerFileContext, decl *ast.GenDecl) ([
 					setterType := o.tsPackageVarSetterValueTypeFor(ctx, obj.Type())
 					setterTarget := declName
 					if ctx.model.needsVarRef[obj] {
-						setterTarget += ".value"
+						if lazy {
+							setterTarget = packageVarGetterName(name.Name) + "().value"
+						} else {
+							setterTarget += ".value"
+						}
 					}
-					setterCode := "export function " + setterName + "(value: " + setterType + "): void {\n\t" +
-						setterTarget + " = value\n}"
+					setterValue := "__goscriptValue"
+					setterCode := "export function " + setterName + "(" + setterValue + ": " + setterType + "): void {\n\t" +
+						setterTarget + " = " + setterValue + "\n}"
 					setterIndexExport := ""
 					if ast.IsExported(name.Name) {
 						setterIndexExport = setterName
@@ -909,6 +1298,9 @@ func initializerMayHaveRuntimeEffects(ctx lowerFileContext, expr ast.Expr) bool
 		}
 		switch typed := node.(type) {
 		case *ast.CallExpr:
+			if isEffectFreePackageInitializerCall(ctx, typed) {
+				return true
+			}
 			if callTargetSignature(ctx, typed.Fun) != nil {
 				hasEffects = true
 				return false
@@ -924,23 +1316,322 @@ func initializerMayHaveRuntimeEffects(ctx lowerFileContext, expr ast.Expr) bool
 	return hasEffects
 }
 
-func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage) map[types.Object]bool {
+func isEffectFreePackageInitializerCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	if call == nil {
+		return false
+	}
+	if isEffectFreePackageInitializerBuiltin(ctx, call.Fun) {
+		return true
+	}
+	if isReflectTypeOfCall(ctx, call) {
+		return true
+	}
+	if isReflectTypeForCall(ctx, call) {
+		return true
+	}
+	if isMathBigNewIntCall(ctx, call) {
+		return true
+	}
+	selector, ok := ast.Unparen(call.Fun).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "Elem" {
+		return false
+	}
+	receiver, ok := ast.Unparen(selector.X).(*ast.CallExpr)
+	return ok && isReflectTypeOfCall(ctx, receiver)
+}
+
+func isEffectFreePackageInitializerBuiltin(ctx lowerFileContext, expr ast.Expr) bool {
+	ident, ok := expr.(*ast.Ident)
+	if !ok {
+		return false
+	}
+	if ident.Name != "make" && ident.Name != "new" {
+		return false
+	}
+	_, ok = objectForIdent(ctx, ident).(*types.Builtin)
+	return ok
+}
+
+func isReflectTypeOfCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	selector, ok := ast.Unparen(call.Fun).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "TypeOf" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "reflect"
+}
+
+func isReflectTypeForCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	fun := ast.Unparen(call.Fun)
+	switch typed := fun.(type) {
+	case *ast.IndexExpr:
+		fun = ast.Unparen(typed.X)
+	case *ast.IndexListExpr:
+		fun = ast.Unparen(typed.X)
+	}
+	selector, ok := fun.(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "TypeFor" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "reflect"
+}
+
+func isMathBigNewIntCall(ctx lowerFileContext, call *ast.CallExpr) bool {
+	selector, ok := ast.Unparen(call.Fun).(*ast.SelectorExpr)
+	if !ok || selector.Sel.Name != "NewInt" {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	return pkgName != nil && pkgName.Imported() != nil && pkgName.Imported().Path() == "math/big"
+}
+
+func packageDeclFiles(semPkg *semanticPackage) map[types.Object]string {
+	if semPkg == nil || semPkg.source == nil {
+		return nil
+	}
+	declFiles := make(map[types.Object]string)
+	for _, decl := range semPkg.declarations {
+		if decl.object != nil && decl.position.file != "" {
+			declFiles[decl.object] = decl.position.file
+		}
+	}
+	return declFiles
+}
+
+func packageOutputNames(semPkg *semanticPackage) map[string]string {
+	if semPkg == nil || semPkg.source == nil {
+		return nil
+	}
+	outputNames := make(map[string]string, len(semPkg.source.Syntax))
+	for idx, syntax := range semPkg.source.Syntax {
+		outputSourcePath := sourceFilePath(semPkg, idx, syntax)
+		outputNames[outputSourcePath] = sourceOutputName(outputSourcePath)
+	}
+	return outputNames
+}
+
+func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage, declFiles map[types.Object]string) map[types.Object]bool {
 	if semPkg == nil || semPkg.source == nil {
 		return nil
 	}
-	declFiles := make(map[types.Object]string)
-	for _, decl := range semPkg.declarations {
-		if decl.object != nil && decl.position.file != "" {
-			declFiles[decl.object] = decl.position.file
-		}
+	varOrder := make(map[types.Object]int)
+	for idx, obj := range semPkg.initOrder {
+		varOrder[obj] = idx
+	}
+	funcRefs := packageVarsReferencedFromOtherFileTopLevelCalls(semPkg, declFiles)
+	lazy := make(map[types.Object]bool)
+	for idx, file := range semPkg.source.Syntax {
+		sourcePath := sourceFilePath(semPkg, idx, file)
+		for _, decl := range file.Decls {
+			genDecl, ok := decl.(*ast.GenDecl)
+			if !ok || genDecl.Tok != token.VAR {
+				continue
+			}
+			for _, spec := range genDecl.Specs {
+				valueSpec, ok := spec.(*ast.ValueSpec)
+				if !ok {
+					continue
+				}
+				for valueIdx, name := range valueSpec.Names {
+					obj, _ := semPkg.source.TypesInfo.Defs[name].(*types.Var)
+					if obj == nil {
+						continue
+					}
+					if valueIdx < len(valueSpec.Values) &&
+						initializerReferencesLaterPackageVar(semPkg, varOrder, obj, valueSpec.Values[valueIdx]) {
+						lazy[obj] = true
+						continue
+					}
+					if valueIdx < len(valueSpec.Values) &&
+						initializerReferencesOtherFileObject(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
+						continue
+					}
+					if valueIdx >= len(valueSpec.Values) &&
+						zeroValueReferencesOtherFileObject(semPkg, declFiles, sourcePath, obj.Type()) {
+						lazy[obj] = true
+						continue
+					}
+					if funcRefs[obj] &&
+						(valueIdx >= len(valueSpec.Values) ||
+							!initializerMayHaveRuntimeEffects(lowerFileContext{semPkg: semPkg}, valueSpec.Values[valueIdx])) {
+						lazy[obj] = true
+					}
+				}
+			}
+		}
+	}
+	return lazy
+}
+
+func packageVarsReferencedFromOtherFileTopLevelCalls(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+) map[*types.Var]bool {
+	refs := make(map[*types.Var]bool)
+	if semPkg == nil || semPkg.source == nil || semPkg.source.TypesInfo == nil {
+		return refs
+	}
+	var collectFuncRefs func(rootSource string, fn *types.Func, seen map[*types.Func]bool)
+	collectFuncRefs = func(rootSource string, fn *types.Func, seen map[*types.Func]bool) {
+		if fn == nil || seen[fn] {
+			return
+		}
+		seen[fn] = true
+		decl := functionDeclForObject(semPkg, fn)
+		if decl == nil || decl.Body == nil {
+			return
+		}
+		ast.Inspect(decl.Body, func(node ast.Node) bool {
+			switch typed := node.(type) {
+			case *ast.Ident:
+				obj, _ := semPkg.source.TypesInfo.Uses[typed].(*types.Var)
+				if obj == nil || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+					return true
+				}
+				if declFiles[obj] != "" && declFiles[obj] != rootSource {
+					refs[obj] = true
+				}
+			case *ast.CallExpr:
+				called := calledFunction(semPkg.source, typed.Fun)
+				if called != nil && called.Pkg() != nil && called.Pkg().Path() == semPkg.pkgPath {
+					collectFuncRefs(rootSource, called, seen)
+				}
+			}
+			return true
+		})
+	}
+	for _, file := range semPkg.source.Syntax {
+		sourcePath := sourcePos(semPkg.source, file.Pos()).file
+		for _, decl := range file.Decls {
+			switch typed := decl.(type) {
+			case *ast.GenDecl:
+				if typed.Tok != token.VAR {
+					continue
+				}
+				for _, spec := range typed.Specs {
+					valueSpec, ok := spec.(*ast.ValueSpec)
+					if !ok {
+						continue
+					}
+					for _, value := range valueSpec.Values {
+						collectTopLevelRefs(semPkg, declFiles, refs, sourcePath, value, collectFuncRefs)
+					}
+				}
+			case *ast.FuncDecl:
+				if typed.Name.Name == "init" && typed.Body != nil {
+					collectTopLevelRefs(semPkg, declFiles, refs, sourcePath, typed.Body, collectFuncRefs)
+				}
+			}
+		}
+	}
+	return refs
+}
+
+func collectTopLevelRefs(
+	semPkg *semanticPackage,
+	declFiles map[types.Object]string,
+	refs map[*types.Var]bool,
+	sourcePath string,
+	node ast.Node,
+	collectFuncRefs func(string, *types.Func, map[*types.Func]bool),
+) {
+	ast.Inspect(node, func(node ast.Node) bool {
+		switch typed := node.(type) {
+		case *ast.Ident:
+			obj, _ := semPkg.source.TypesInfo.Uses[typed].(*types.Var)
+			if obj == nil || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+				return true
+			}
+			if declFiles[obj] != "" && declFiles[obj] != sourcePath {
+				refs[obj] = true
+			}
+		case *ast.CallExpr:
+			called := calledFunction(semPkg.source, typed.Fun)
+			if called == nil || called.Pkg() == nil || called.Pkg().Path() != semPkg.pkgPath {
+				return true
+			}
+			collectFuncRefs(sourcePath, called, make(map[*types.Func]bool))
+		}
+		return true
+	})
+}
+
+func (o *LoweringOwner) packageVarIsLazy(ctx lowerFileContext, obj *types.Var) bool {
+	if obj == nil {
+		return false
+	}
+	if ctx.lazyPackageVars[obj] {
+		return true
+	}
+	if ctx.model == nil || obj.Pkg() == nil {
+		return false
+	}
+	semPkg := ctx.model.packages[obj.Pkg().Path()]
+	if semPkg == nil {
+		return false
+	}
+	for lazyObj := range o.lazyPackageVars(semPkg, packageDeclFiles(semPkg)) {
+		if lazyObj != nil && lazyObj.Name() == obj.Name() &&
+			lazyObj.Pkg() != nil && lazyObj.Pkg().Path() == obj.Pkg().Path() {
+			return true
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) packageVarNameIsLazy(ctx lowerFileContext, pkgPath, name string) bool {
+	if ctx.model == nil || pkgPath == "" || name == "" {
+		return false
+	}
+	semPkg := ctx.model.packages[pkgPath]
+	if semPkg == nil {
+		return false
+	}
+	for lazyObj := range o.lazyPackageVars(semPkg, packageDeclFiles(semPkg)) {
+		if lazyObj != nil && lazyObj.Name() == name {
+			return true
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) packageVarHasAsyncLazyInit(ctx lowerFileContext, obj types.Object) bool {
+	varObj, _ := obj.(*types.Var)
+	if varObj == nil || varObj.Pkg() == nil {
+		return false
+	}
+	return o.packageVarNameHasAsyncLazyInit(ctx, varObj.Pkg().Path(), varObj.Name())
+}
+
+func (o *LoweringOwner) packageVarNameHasAsyncLazyInit(ctx lowerFileContext, pkgPath, name string) bool {
+	if ctx.model == nil || pkgPath == "" || name == "" {
+		return false
 	}
-	varOrder := make(map[types.Object]int)
-	for idx, obj := range semPkg.initOrder {
-		varOrder[obj] = idx
+	semPkg := ctx.model.packages[pkgPath]
+	if semPkg == nil || semPkg.source == nil {
+		return false
 	}
-	lazy := make(map[types.Object]bool)
-	for idx, file := range semPkg.source.Syntax {
-		sourcePath := sourceFilePath(semPkg, idx, file)
+	initCtx := lowerFileContext{model: ctx.model, semPkg: semPkg, topLevel: true}
+	for _, file := range semPkg.source.Syntax {
 		for _, decl := range file.Decls {
 			genDecl, ok := decl.(*ast.GenDecl)
 			if !ok || genDecl.Tok != token.VAR {
@@ -951,30 +1642,51 @@ func (o *LoweringOwner) lazyPackageVars(semPkg *semanticPackage) map[types.Objec
 				if !ok {
 					continue
 				}
-				for valueIdx, name := range valueSpec.Names {
-					obj, _ := semPkg.source.TypesInfo.Defs[name].(*types.Var)
-					if obj == nil {
-						continue
-					}
-					if valueIdx < len(valueSpec.Values) &&
-						initializerReferencesOtherFileObject(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
+				for idx, ident := range valueSpec.Names {
+					if ident.Name != name || idx >= len(valueSpec.Values) {
 						continue
 					}
-					if valueIdx >= len(valueSpec.Values) &&
-						zeroValueReferencesOtherFileObject(semPkg, declFiles, sourcePath, obj.Type()) {
-						lazy[obj] = true
-					}
+					return o.topLevelInitializerNeedsAwait(initCtx, valueSpec.Values[idx])
 				}
 			}
 		}
 	}
-	return lazy
+	return false
+}
+
+func initializerReferencesLaterPackageVar(
+	semPkg *semanticPackage,
+	varOrder map[types.Object]int,
+	current types.Object,
+	expr ast.Expr,
+) bool {
+	currentIdx, ok := varOrder[current]
+	if !ok {
+		return false
+	}
+	references := false
+	ast.Inspect(expr, 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
+		}
+		obj, ok := semPkg.source.TypesInfo.Uses[ident].(*types.Var)
+		if !ok || obj.Pkg() == nil || obj.Pkg().Path() != semPkg.pkgPath {
+			return true
+		}
+		if idx, ok := varOrder[obj]; ok && idx > currentIdx {
+			references = true
+			return false
+		}
+		return true
+	})
+	return references
 }
 
 func initializerCallsFunctionReferencingLaterPackageVar(
@@ -1164,7 +1876,7 @@ func (o *LoweringOwner) lowerTupleValueSpec(
 	tupleExpr := tempName
 	if lazyTuple {
 		tupleGetterName := packageVarGetterName(tempName)
-		decls = append(decls, loweredDecl{code: "let " + tempName + ": any = undefined as any"})
+		decls = append(decls, loweredDecl{code: "var " + tempName + ": any = undefined as any"})
 		decls = append(decls, loweredDecl{code: "function " + tupleGetterName + "(): any {\n\t" +
 			"if (((" + tempName + ") as any) === undefined) {\n\t\t" +
 			tempName + " = " + right + "\n\t}\n\treturn " + tempName + "\n}"})
@@ -1189,8 +1901,8 @@ func (o *LoweringOwner) lowerTupleValueSpec(
 		code := keyword + " " + o.lowerIdent(ctx, name, true) + ": " + variableType + " = " + value
 		lazy := lazyTuple || ctx.topLevel && ctx.lazyPackageVars[obj]
 		if lazy {
-			keyword = "let"
-			code = "let " + o.lowerIdent(ctx, name, true) + ": " + variableType + " = undefined as unknown as " + variableType
+			keyword = "var"
+			code = "var " + o.lowerIdent(ctx, name, true) + ": " + variableType + " = undefined as unknown as " + variableType
 		}
 		indexExport := ""
 		if ctx.topLevel {
@@ -1223,7 +1935,7 @@ func lowerConstantValue(value constant.Value) (string, bool) {
 	case constant.Bool:
 		return strconv.FormatBool(constant.BoolVal(value)), true
 	case constant.String:
-		return strconv.Quote(constant.StringVal(value)), true
+		return lowerGoStringLiteral(constant.StringVal(value)), true
 	case constant.Int:
 		if intValue, ok := constant.Int64Val(value); ok {
 			return strconv.FormatInt(intValue, 10), true
@@ -1237,7 +1949,7 @@ func lowerConstantValue(value constant.Value) (string, bool) {
 	case constant.Complex:
 		real := constant.Real(value).ExactString()
 		imag := constant.Imag(value).ExactString()
-		return "({ real: " + real + ", imag: " + imag + " })", true
+		return "$.complex(" + real + ", " + imag + ")", true
 	default:
 		return "", false
 	}
@@ -1333,6 +2045,13 @@ func byteSliceLiteral(data []byte) string {
 	return "new Uint8Array([" + strings.Join(values, ", ") + "])"
 }
 
+func lowerGoStringLiteral(value string) string {
+	if utf8.ValidString(value) {
+		return strconv.Quote(value)
+	}
+	return "$.bytesToString(" + byteSliceLiteral([]byte(value)) + ")"
+}
+
 func (o *LoweringOwner) lowerTypeSpec(ctx lowerFileContext, spec *ast.TypeSpec) (loweredDecl, []Diagnostic) {
 	obj, _ := ctx.semPkg.source.TypesInfo.Defs[spec.Name].(*types.TypeName)
 	if obj == nil {
@@ -1372,12 +2091,13 @@ func (o *LoweringOwner) lowerTypeSpec(ctx lowerFileContext, spec *ast.TypeSpec)
 	if signature, ok := named.Underlying().(*types.Signature); ok {
 		loweredType = o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
 	}
-	code := "type " + semType.name + " = " + loweredType
+	typeName := safeIdentifier(semType.name)
+	code := "type " + typeName + " = " + loweredType
 	typeIndexExport := ""
 	if ctx.topLevel {
 		code = "export " + code
 		if ast.IsExported(semType.name) {
-			typeIndexExport = semType.name
+			typeIndexExport = typeName
 		}
 	}
 	return loweredDecl{code: code, typeIndexExport: typeIndexExport}, nil
@@ -1385,18 +2105,19 @@ func (o *LoweringOwner) lowerTypeSpec(ctx lowerFileContext, spec *ast.TypeSpec)
 
 func (o *LoweringOwner) lowerInterfaceType(ctx lowerFileContext, semType *semanticType, iface *types.Interface) loweredDecl {
 	iface.Complete()
-	code := "type " + semType.name + " = " + o.tsInterfaceType(ctx, iface)
+	typeName := safeIdentifier(semType.name)
+	code := "type " + typeName + " = " + o.tsInterfaceType(ctx, iface)
 	typeIndexExport := ""
 	if ctx.topLevel {
 		code = "export " + code
 		if ast.IsExported(semType.name) {
-			typeIndexExport = semType.name
+			typeIndexExport = typeName
 		}
 	}
 	code = code + "\n\n" + o.runtimeOwner.QualifiedHelper(RuntimeHelperRegisterInterfaceType) +
 		"(\n\t" + strconv.Quote(runtimeNamedTypeName(semType.named)) +
 		",\n\tnull,\n\t" + o.runtimeMethodSignatures(iface) + "\n)"
-	return loweredDecl{code: code, typeIndexExport: typeIndexExport}
+	return loweredDecl{code: code, typeIndexExport: typeIndexExport, sideEffect: true}
 }
 
 func (o *LoweringOwner) tsInterfaceType(ctx lowerFileContext, iface *types.Interface) string {
@@ -1407,7 +2128,7 @@ func (o *LoweringOwner) tsInterfaceType(ctx lowerFileContext, iface *types.Inter
 	for method := range iface.Methods() {
 		methods = append(methods, o.tsMethodSignature(ctx, method))
 	}
-	return "null | {\n\t" + strings.Join(methods, "\n\t") + "\n}"
+	return "{\n\t" + strings.Join(methods, "\n\t") + "\n}"
 }
 
 func (o *LoweringOwner) tsMethodSignature(ctx lowerFileContext, method *types.Func) string {
@@ -1417,7 +2138,7 @@ func (o *LoweringOwner) tsMethodSignature(ctx lowerFileContext, method *types.Fu
 	}
 	async := o.functionAsync(ctx, method)
 	return method.Name() + "(" + o.tsSignatureParamsFor(ctx, signature, async) + "): " +
-		asyncResultType(o.tsSignatureResultFor(ctx, signature), async)
+		asyncCompatibleMethodResultType(o.tsSignatureResultFor(ctx, signature), async)
 }
 
 func (o *LoweringOwner) runtimeMethodSignatures(iface *types.Interface) string {
@@ -1478,11 +2199,15 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 	lowered := &loweredStruct{
 		exported:      ctx.topLevel,
 		indexExported: ctx.topLevel && ast.IsExported(semType.name),
-		name:          semType.name,
+		name:          safeIdentifier(semType.name),
 		typeName:      runtimeNamedTypeName(semType.named),
 		cloneMethod:   "clone",
 	}
 	for idx, field := range semType.fields {
+		structValue := isStructValueType(field.typ)
+		if named := namedStructType(field.typ); named != nil && crossPackageUnexportedNamedType(ctx, named) {
+			structValue = false
+		}
 		fieldName := tsStructFieldName(field.name, idx)
 		runtimeName := ""
 		if fieldName != field.name {
@@ -1496,11 +2221,18 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 			runtimeType: o.runtimeTypeInfoExpr(field.typ),
 			doc:         field.doc,
 			tag:         field.tag,
-			structValue: isStructValueType(field.typ),
+			structValue: structValue,
+			arrayValue:  isArrayType(field.typ),
 		})
 	}
 
 	methodDecls := o.methodDeclsForType(ctx, semType.named)
+	explicitMethods := make(map[string]bool, len(methodDecls))
+	for _, methodDecl := range methodDecls {
+		if methodDecl != nil {
+			explicitMethods[methodDecl.Name.Name] = true
+		}
+	}
 	var diagnostics []Diagnostic
 	for _, methodDecl := range methodDecls {
 		method, methodDiagnostics := o.lowerFuncDecl(ctx, methodDecl)
@@ -1512,9 +2244,121 @@ func (o *LoweringOwner) lowerStructType(ctx lowerFileContext, semType *semanticT
 			lowered.methods = append(lowered.methods, *method)
 		}
 	}
+	for _, field := range semType.fields {
+		methods := o.lowerEmbeddedMethodForwarders(ctx, field, explicitMethods)
+		lowered.methods = append(lowered.methods, methods...)
+	}
 	return lowered, diagnostics
 }
 
+func (o *LoweringOwner) lowerEmbeddedMethodForwarders(
+	ctx lowerFileContext,
+	field semanticField,
+	explicitMethods map[string]bool,
+) []loweredFunction {
+	if !field.embedded {
+		return nil
+	}
+	methodSetType := field.typ
+	if named := namedStructType(field.typ); named != nil {
+		methodSetType = types.NewPointer(field.typ)
+	} else if pointerToNamedStructType(field.typ) != nil {
+		methodSetType = field.typ
+	} else if _, ok := types.Unalias(field.typ).Underlying().(*types.Interface); !ok {
+		return nil
+	}
+	methodSet := types.NewMethodSet(methodSetType)
+	if methodSet.Len() == 0 {
+		return nil
+	}
+	var methods []loweredFunction
+	for selection := range methodSet.Methods() {
+		method, _ := selection.Obj().(*types.Func)
+		if method == nil || explicitMethods[method.Name()] {
+			continue
+		}
+		if !ast.IsExported(method.Name()) && method.Pkg() != nil && method.Pkg().Path() != ctx.semPkg.pkgPath {
+			continue
+		}
+		signature, _ := method.Type().(*types.Signature)
+		if signature == nil {
+			continue
+		}
+		async := o.functionAsync(ctx, method)
+		targetType := o.tsEmbeddedForwarderTargetType(ctx, field.typ)
+		lowered := loweredFunction{
+			async:       async,
+			name:        methodMemberName(method.Name()),
+			runtimeName: method.Name(),
+			result:      asyncResultType("any", async),
+			deferState:  &loweredDeferState{},
+		}
+		args := make([]string, 0, signature.Params().Len())
+		for idx := range signature.Params().Len() {
+			param := signature.Params().At(idx)
+			name := safeParamName(param, idx)
+			args = append(args, name)
+			lowered.params = append(lowered.params, loweredParam{name: name, typ: "any"})
+		}
+		target := o.embeddedForwarderTargetExpr(ctx, field, selection, targetType)
+		call := target + "." + method.Name() + "(" + strings.Join(args, ", ") + ")"
+		if async {
+			call = "await " + call
+		}
+		lowered.body = []loweredStmt{{text: "return " + call}}
+		methods = append(methods, lowered)
+		explicitMethods[method.Name()] = true
+	}
+	return methods
+}
+
+func (o *LoweringOwner) embeddedForwarderTargetExpr(
+	ctx lowerFileContext,
+	field semanticField,
+	selection *types.Selection,
+	targetType string,
+) string {
+	pointerValue := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue)
+	expr := pointerValue + "<" + targetType + ">(this." + tsStructFieldName(field.name, 0) + ")"
+	if selection == nil || len(selection.Index()) <= 1 {
+		return expr
+	}
+
+	typ := field.typ
+	for _, index := range selection.Index()[:len(selection.Index())-1] {
+		structType, ok := types.Unalias(derefPointerType(typ)).Underlying().(*types.Struct)
+		if !ok || index < 0 || index >= structType.NumFields() {
+			return expr
+		}
+		field := structType.Field(index)
+		expr += "." + tsStructFieldName(field.Name(), index)
+		typ = field.Type()
+		expr = o.embeddedForwarderSelectableExpr(ctx, typ, expr)
+	}
+	return expr
+}
+
+func (o *LoweringOwner) embeddedForwarderSelectableExpr(ctx lowerFileContext, typ types.Type, expr string) string {
+	pointerValue := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue)
+	if named := pointerToNamedStructType(typ); named != nil {
+		return pointerValue + "<any>(" + expr + ")"
+	}
+	if _, ok := types.Unalias(typ).Underlying().(*types.Interface); ok {
+		return pointerValue + "<any>(" + expr + ")"
+	}
+	return expr
+}
+
+func (o *LoweringOwner) tsEmbeddedForwarderTargetType(ctx lowerFileContext, typ types.Type) string {
+	if named := pointerToNamedStructType(typ); named != nil {
+		return o.namedTypeExpr(ctx, named)
+	}
+	if named := namedStructType(typ); named != nil {
+		return o.namedTypeExpr(ctx, named)
+	}
+	return "Exclude<" + o.tsStructFieldTypeFor(ctx, typ) + ", null>"
+}
+
 func (o *LoweringOwner) methodDeclsForType(ctx lowerFileContext, named *types.Named) []*ast.FuncDecl {
 	if named == nil {
 		return nil
@@ -1574,7 +2418,8 @@ func (o *LoweringOwner) lowerNamedReceiverMethodDecl(
 		return nil, nil
 	}
 	async := o.functionAsync(ctx, fnObj)
-	resultCtx := ctx.withAsyncFunction(async)
+	functionCtx := ctx.withSignature(signature)
+	resultCtx := functionCtx.withAsyncFunction(async)
 	result := o.tsSignatureResultFor(resultCtx, signature)
 	receiverName := "recv"
 	if len(decl.Recv.List) != 0 && len(decl.Recv.List[0].Names) != 0 {
@@ -1634,7 +2479,11 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 		return nil, nil
 	}
 	async := o.functionAsync(ctx, fnObj)
-	resultCtx := ctx.withAsyncFunction(async)
+	if decl.Name.Name == "main" {
+		async = true
+	}
+	functionCtx := ctx.withSignature(signature)
+	resultCtx := functionCtx.withAsyncFunction(async)
 	result := o.tsSignatureResultFor(resultCtx, signature)
 	deferState := &loweredDeferState{}
 	name := safeIdentifier(decl.Name.Name)
@@ -1659,9 +2508,10 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 		runtimeName:   runtimeName,
 		result:        asyncResultType(result, async),
 		deferState:    deferState,
-		namedResults:  o.lowerNamedResults(ctx, signature),
+		namedResults:  o.lowerNamedResults(functionCtx, signature),
 	}
 	if signature.TypeParams() != nil && signature.TypeParams().Len() != 0 {
+		lowered.typeParams = signatureTypeParamNames(signature)
 		lowered.params = append(lowered.params, loweredParam{
 			name: "__typeArgs",
 			typ:  "$.GenericTypeArgs | undefined",
@@ -1684,24 +2534,20 @@ func (o *LoweringOwner) lowerFuncDecl(ctx lowerFileContext, decl *ast.FuncDecl)
 			lowered.receiverValue = o.runtimeOwner.QualifiedHelper(RuntimeHelperVarRef) + "(this)"
 		}
 	}
-	if decl.Name.Name == "main" {
-		lowered.async = true
-		lowered.result = asyncResultType(o.tsSignatureResultFor(ctx.withAsyncFunction(true), signature), true)
-	}
 	for idx := range signature.Params().Len() {
 		param := signature.Params().At(idx)
-		lowered.params, lowered.paramBindings = o.appendLoweredParam(ctx, lowered.params, lowered.paramBindings, param, idx, decl.Body == nil || async)
+		lowered.params, lowered.paramBindings = o.appendLoweredParam(functionCtx, lowered.params, lowered.paramBindings, param, idx, decl.Body == nil || async)
 	}
 	if decl.Body != nil {
-		body, diagnostics := o.lowerBlock(ctx.withSignature(signature).withAsyncFunction(async).withDeferState(deferState), decl.Body)
+		body, diagnostics := o.lowerBlock(functionCtx.withAsyncFunction(async).withDeferState(deferState), decl.Body)
 		lowered.body = body
 		if deferState.async && !lowered.async {
 			lowered.async = true
-			lowered.result = asyncResultType(o.tsSignatureResultFor(ctx.withAsyncFunction(true), signature), true)
+			lowered.result = asyncResultType(o.tsSignatureResultFor(functionCtx.withAsyncFunction(true), signature), true)
 		}
 		return lowered, diagnostics
 	}
-	if zeroReturn, ok := o.lowerBodylessReturnStmt(ctx, signature); ok {
+	if zeroReturn, ok := o.lowerBodylessReturnStmt(functionCtx, signature); ok {
 		lowered.body = []loweredStmt{{text: zeroReturn}}
 	}
 	return lowered, nil
@@ -1754,6 +2600,54 @@ func rangeBindingAssignedInBody(ctx lowerFileContext, expr ast.Expr, body *ast.B
 	return objectAssignedInBlock(ctx, obj, body)
 }
 
+func (o *LoweringOwner) lowerMapRangeBinding(
+	ctx lowerFileContext,
+	expr ast.Expr,
+	name string,
+	fallback string,
+	tempPrefix string,
+	declare bool,
+) (string, []loweredStmt, []Diagnostic) {
+	if expr == nil {
+		return fallback, nil, nil
+	}
+	if ident, ok := expr.(*ast.Ident); ok && ident.Name == "_" {
+		return fallback, nil, nil
+	}
+	if declare {
+		obj := rangeBindingObject(ctx, expr)
+		if name == "" || obj == nil || !ctx.model.needsVarRef[obj] {
+			if name != "" {
+				return name, nil, nil
+			}
+			return fallback, nil, nil
+		}
+		rawName := ctx.tempName(tempPrefix)
+		value := rawName
+		if isStructValueType(obj.Type()) {
+			value = o.lowerStructClone(value)
+		}
+		return rawName, []loweredStmt{{
+			text: "let " + name + ": " + o.tsVariableTypeFor(ctx, obj.Type(), true) + " = " +
+				o.runtimeOwner.QualifiedHelper(RuntimeHelperVarRef) + "(" + value + ")",
+		}}, nil
+	}
+	rawName := ctx.tempName(tempPrefix)
+	left, diagnostics := o.lowerAssignmentTarget(ctx, expr, false)
+	return rawName, []loweredStmt{{text: left + " = " + rawName}}, diagnostics
+}
+
+func rangeBindingObject(ctx lowerFileContext, expr ast.Expr) types.Object {
+	ident, ok := expr.(*ast.Ident)
+	if !ok || ident.Name == "_" || ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return nil
+	}
+	if obj := ctx.semPkg.source.TypesInfo.Defs[ident]; obj != nil {
+		return obj
+	}
+	return ctx.semPkg.source.TypesInfo.Uses[ident]
+}
+
 func expressionUsesObject(ctx lowerFileContext, expr ast.Expr, obj types.Object) bool {
 	if expr == nil || obj == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
@@ -1803,6 +2697,20 @@ func (o *LoweringOwner) appendLoweredParam(
 
 func (ctx lowerFileContext) withSignature(signature *types.Signature) lowerFileContext {
 	ctx.signature = signature
+	if signature != nil && signature.TypeParams() != nil && signature.TypeParams().Len() != 0 {
+		next := make(map[string]bool, len(ctx.typeParams)+signature.TypeParams().Len())
+		maps.Copy(next, ctx.typeParams)
+		nextStatic := make(map[string]bool, len(ctx.staticTypeParams)+signature.TypeParams().Len())
+		maps.Copy(nextStatic, ctx.staticTypeParams)
+		for typeParam := range signature.TypeParams().TypeParams() {
+			next[typeParam.Obj().Name()] = true
+			if signatureUsesTypeParamAsSliceElem(signature, typeParam) {
+				nextStatic[typeParam.Obj().Name()] = true
+			}
+		}
+		ctx.typeParams = next
+		ctx.staticTypeParams = nextStatic
+	}
 	return ctx
 }
 
@@ -1852,7 +2760,18 @@ func (ctx lowerFileContext) withoutRangeBreak() lowerFileContext {
 }
 
 func (ctx lowerFileContext) withGotoLabels(labels map[string]bool) lowerFileContext {
-	ctx.gotoLabels = labels
+	if len(ctx.gotoLabels) == 0 {
+		ctx.gotoLabels = labels
+		return ctx
+	}
+	merged := make(map[string]bool, len(ctx.gotoLabels)+len(labels))
+	for label := range ctx.gotoLabels {
+		merged[label] = true
+	}
+	for label := range labels {
+		merged[label] = true
+	}
+	ctx.gotoLabels = merged
 	return ctx
 }
 
@@ -1884,6 +2803,11 @@ func (ctx lowerFileContext) withLoopLabel(label string) lowerFileContext {
 	return ctx
 }
 
+func (ctx lowerFileContext) withoutLoopLabel() lowerFileContext {
+	ctx.loopLabel = ""
+	return ctx
+}
+
 func (ctx lowerFileContext) withSwitchBreak() lowerFileContext {
 	ctx.switchBreak = true
 	return ctx
@@ -1999,6 +2923,22 @@ func (o *LoweringOwner) lowerStmt(ctx lowerFileContext, stmt ast.Stmt) ([]lowere
 			expr, diagnostics := o.lowerPointerStorageExpr(ctx, star.X)
 			return []loweredStmt{{text: expr + typed.Tok.String()}}, diagnostics
 		}
+		if index, ok := unwrapParenExpr(typed.X).(*ast.IndexExpr); ok && isMapType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)) {
+			right := "1"
+			tok := token.ADD_ASSIGN
+			if typed.Tok == token.DEC {
+				tok = token.SUB_ASSIGN
+			}
+			return o.lowerMapIndexUpdateStmts(ctx, index, tok, right, ctx.semPkg.source.TypesInfo.TypeOf(typed.X))
+		}
+		if setter, ok := o.packageVarSetterForAssignment(ctx, typed.X); ok {
+			expr, diagnostics := o.lowerExpr(ctx, typed.X)
+			op := "+"
+			if typed.Tok == token.DEC {
+				op = "-"
+			}
+			return []loweredStmt{{text: setter + "(" + expr + " " + op + " 1)"}}, diagnostics
+		}
 		expr, diagnostics := o.lowerExpr(ctx, typed.X)
 		return []loweredStmt{{text: expr + typed.Tok.String()}}, diagnostics
 	case *ast.BranchStmt:
@@ -2068,6 +3008,10 @@ func packageVarGetterName(name string) string {
 	return "__goscript_get_" + safeIdentifier(name)
 }
 
+func packageVarInitName(name string) string {
+	return "__goscript_init_" + safeIdentifier(name)
+}
+
 func (o *LoweringOwner) lowerElse(ctx lowerFileContext, stmt ast.Stmt) ([]loweredStmt, []Diagnostic) {
 	switch typed := stmt.(type) {
 	case *ast.BlockStmt:
@@ -2190,6 +3134,19 @@ func (o *LoweringOwner) lowerStmtListAfter(
 				continue
 			}
 		}
+		if stmtCtx, nextCtx, ok := o.lowerDeclStatementContext(ctx, stmt); ok {
+			stmtLowered, stmtDiagnostics := o.lowerStmt(stmtCtx, stmt)
+			diagnostics = append(diagnostics, stmtDiagnostics...)
+			if len(stmtLowered) != 0 && len(leading) != 0 {
+				stmtLowered[0].leading = append(leading, stmtLowered[0].leading...)
+			}
+			lowered = append(lowered, stmtLowered...)
+			ctx = nextCtx
+			if endLine := sourceLine(ctx, stmt.End()); endLine != 0 {
+				prevEndLine = endLine
+			}
+			continue
+		}
 		if stmtCtx, nextCtx, prelude, ok := o.lowerShortDeclStatementContext(ctx, stmt); ok {
 			stmtLowered, stmtDiagnostics := o.lowerStmt(stmtCtx, stmt)
 			diagnostics = append(diagnostics, stmtDiagnostics...)
@@ -2221,6 +3178,44 @@ func (o *LoweringOwner) lowerStmtListAfter(
 	return lowered, diagnostics
 }
 
+func (o *LoweringOwner) lowerDeclStatementContext(
+	ctx lowerFileContext,
+	stmt ast.Stmt,
+) (lowerFileContext, lowerFileContext, bool) {
+	declStmt, ok := stmt.(*ast.DeclStmt)
+	if !ok {
+		return ctx, ctx, false
+	}
+	genDecl, ok := declStmt.Decl.(*ast.GenDecl)
+	if !ok || genDecl.Tok != token.VAR {
+		return ctx, ctx, false
+	}
+	aliases := make(map[types.Object]string)
+	for _, spec := range genDecl.Specs {
+		valueSpec, ok := spec.(*ast.ValueSpec)
+		if !ok {
+			continue
+		}
+		for _, name := range valueSpec.Names {
+			if name.Name == "_" {
+				continue
+			}
+			def := ctx.semPkg.source.TypesInfo.Defs[name]
+			if def == nil || aliases[def] != "" {
+				continue
+			}
+			if shortDeclDefShadowsOuterName(name.Name, def) {
+				aliases[def] = ctx.tempName("Shadow")
+			}
+		}
+	}
+	if len(aliases) == 0 {
+		return ctx, ctx, false
+	}
+	nextCtx := ctx.withIdentRefAliases(aliases)
+	return nextCtx, nextCtx, true
+}
+
 type gotoStateCluster struct {
 	startIdx      int
 	firstLabelIdx int
@@ -2387,10 +3382,8 @@ func (o *LoweringOwner) lowerShortDeclStatementContext(
 	if len(oldAliases) == 0 && len(newAliases) == 0 {
 		return ctx, ctx, nil, false
 	}
-	stmtAliases := make(map[types.Object]string, len(oldAliases)+len(newAliases))
-	maps.Copy(stmtAliases, oldAliases)
-	maps.Copy(stmtAliases, newAliases)
-	return ctx.withIdentAliases(stmtAliases), ctx.withIdentAliases(newAliases), prelude, true
+	stmtCtx := ctx.withIdentAliases(oldAliases).withIdentRefAliases(newAliases)
+	return stmtCtx, ctx.withIdentRefAliases(newAliases), prelude, true
 }
 
 func (o *LoweringOwner) lowerBackwardGotoLoop(
@@ -2605,6 +3598,9 @@ func (o *LoweringOwner) lowerSendStmt(ctx lowerFileContext, stmt *ast.SendStmt)
 	channel, channelDiagnostics := o.lowerExpr(ctx, stmt.Chan)
 	value, valueDiagnostics := o.lowerExpr(ctx, stmt.Value)
 	diagnostics := append(channelDiagnostics, valueDiagnostics...)
+	if channelType, _ := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(stmt.Chan)).Underlying().(*types.Chan); channelType != nil {
+		value = o.lowerValueForTarget(ctx, stmt.Value, channelType.Elem(), value)
+	}
 	return "await " + o.runtimeOwner.QualifiedHelper(RuntimeHelperChanSend) + "(" + channel + ", " + value + ")", diagnostics
 }
 
@@ -2616,6 +3612,25 @@ func (o *LoweringOwner) lowerGoStmt(ctx lowerFileContext, stmt *ast.GoStmt) (str
 }
 
 func (o *LoweringOwner) lowerDeferStmt(ctx lowerFileContext, stmt *ast.DeferStmt) (string, []Diagnostic) {
+	if nestedCall, ok := stmt.Call.Fun.(*ast.CallExpr); ok {
+		callee, diagnostics := o.lowerCallExpr(ctx, nestedCall)
+		args, argDiagnostics := o.lowerCallArgs(ctx, stmt.Call, callTargetSignature(ctx, stmt.Call.Fun))
+		diagnostics = append(diagnostics, argDiagnostics...)
+		calleeTemp := ctx.tempName("DeferCallee")
+		call := o.lowerCallableExpr(ctx, stmt.Call.Fun, calleeTemp) + "(" + strings.Join(args, ", ") + ")"
+		call = o.awaitCallIfNeeded(ctx, stmt.Call.Fun, call)
+		async := strings.Contains(callee, "await ") || strings.Contains(call, "await ")
+		if ctx.deferState != nil {
+			ctx.deferState.used = true
+			if async {
+				ctx.deferState.async = true
+			}
+		}
+		if async {
+			return "const " + calleeTemp + " = " + callee + "\n__defer.defer(async () => { " + call + " })", diagnostics
+		}
+		return "const " + calleeTemp + " = " + callee + "\n__defer.defer(() => { " + call + " })", diagnostics
+	}
 	call, diagnostics := o.lowerCallExpr(ctx, stmt.Call)
 	async := strings.Contains(call, "await ")
 	if ctx.deferState != nil {
@@ -2682,41 +3697,51 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 		isShortDecl := stmt.Tok == token.DEFINE && isShortAssignTargetNew(ctx, lhs)
 		right, rightDiagnostics := o.lowerExpr(ctx, stmt.Rhs[idx])
 		diagnostics = append(diagnostics, rightDiagnostics...)
-		targetType := ctx.semPkg.source.TypesInfo.TypeOf(lhs)
+		targetType := assignmentTargetType(ctx, lhs)
 		right = o.lowerValueForTarget(ctx, stmt.Rhs[idx], targetType, right)
-		if setter, ok := o.packageVarSetterForAssignment(ctx, lhs); ok && stmt.Tok == token.ASSIGN {
-			stmts = append(stmts, loweredStmt{text: setter + "(" + right + ")"})
+		if targetType != nil && genericCallResultUsesTypeParam(ctx, stmt.Rhs[idx]) {
+			right = "(" + right + " as " + o.tsTypeFor(ctx, targetType) + ")"
+		}
+		if setter, ok := o.packageVarSetterForAssignment(ctx, lhs); ok {
+			value, ok := o.packageVarAssignmentValue(ctx, lhs, targetType, right, stmt.Tok)
+			if !ok {
+				value = right
+			}
+			stmts = append(stmts, loweredStmt{text: setter + "(" + value + ")"})
 			continue
 		}
-		left, leftDiagnostics := o.lowerAssignmentTarget(ctx, lhs, isShortDecl)
-		diagnostics = append(diagnostics, leftDiagnostics...)
-		if index, ok := lhs.(*ast.IndexExpr); ok && isMapType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)) && stmt.Tok == token.ASSIGN {
-			mapExpr, mapDiagnostics := o.lowerExpr(ctx, index.X)
-			keyExpr, keyDiagnostics := o.lowerExpr(ctx, index.Index)
-			diagnostics = append(diagnostics, mapDiagnostics...)
-			diagnostics = append(diagnostics, keyDiagnostics...)
-			stmts = append(stmts, loweredStmt{text: o.runtimeOwner.QualifiedHelper(RuntimeHelperMapSet) + "(" + mapExpr + ", " + keyExpr + ", " + right + ")"})
+		if index, ok := lhs.(*ast.IndexExpr); ok && isMapType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)) && stmt.Tok != token.DEFINE {
+			update, updateDiagnostics := o.lowerMapIndexUpdateStmts(ctx, index, stmt.Tok, right, targetType)
+			diagnostics = append(diagnostics, updateDiagnostics...)
+			stmts = append(stmts, update...)
 			continue
 		}
-		if star, ok := lhs.(*ast.StarExpr); ok && stmt.Tok == token.ASSIGN && isStructValueType(targetType) {
+		left, leftDiagnostics := o.lowerAssignmentTarget(ctx, lhs, isShortDecl)
+		diagnostics = append(diagnostics, leftDiagnostics...)
+		star, starTarget := unwrapParenExpr(lhs).(*ast.StarExpr)
+		if starTarget && stmt.Tok == token.ASSIGN && isStructValueType(targetType) {
 			pointer, pointerDiagnostics := o.lowerPointerValueExpr(ctx, star.X)
 			diagnostics = append(diagnostics, pointerDiagnostics...)
 			stmts = append(stmts, loweredStmt{text: o.runtimeOwner.QualifiedHelper(RuntimeHelperAssignStruct) + "(" + pointer + ", " + right + ")"})
 			continue
 		}
-		if star, ok := lhs.(*ast.StarExpr); ok && stmt.Tok == token.ASSIGN {
+		if starTarget && stmt.Tok == token.ASSIGN {
 			pointer, pointerDiagnostics := o.lowerPointerStorageExpr(ctx, star.X)
 			diagnostics = append(diagnostics, pointerDiagnostics...)
 			stmts = append(stmts, loweredStmt{text: pointer + " = " + right})
 			continue
 		}
-		if star, ok := lhs.(*ast.StarExpr); ok && stmt.Tok != token.DEFINE {
+		if starTarget && stmt.Tok != token.DEFINE {
 			pointer, pointerDiagnostics := o.lowerPointerStorageExpr(ctx, star.X)
 			diagnostics = append(diagnostics, pointerDiagnostics...)
 			if stmt.Tok == token.AND_NOT_ASSIGN {
 				stmts = append(stmts, loweredStmt{text: pointer + " = " + pointer + " & ~(" + right + ")"})
 				continue
 			}
+			if value, ok := integerQuotientAssignExpr(targetType, pointer, right, stmt.Tok); ok {
+				stmts = append(stmts, loweredStmt{text: value})
+				continue
+			}
 			stmts = append(stmts, loweredStmt{text: pointer + " " + stmt.Tok.String() + " " + right})
 			continue
 		}
@@ -2735,13 +3760,109 @@ func (o *LoweringOwner) lowerAssignStmt(ctx lowerFileContext, stmt *ast.AssignSt
 			stmts = append(stmts, loweredStmt{text: left + " = " + o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")"})
 			continue
 		}
+		if value, ok := integerQuotientAssignExpr(targetType, left, right, stmt.Tok); ok {
+			stmts = append(stmts, loweredStmt{text: value})
+			continue
+		}
 		op := stmt.Tok.String()
 		if stmt.Tok == token.DEFINE {
 			op = "="
 		}
-		stmts = append(stmts, loweredStmt{text: left + " " + op + " " + right})
+		stmts = append(stmts, loweredStmt{text: left + " " + op + " " + right})
+	}
+	return stmts, diagnostics
+}
+
+func (o *LoweringOwner) lowerMapIndexUpdateStmts(
+	ctx lowerFileContext,
+	index *ast.IndexExpr,
+	tok token.Token,
+	right string,
+	targetType types.Type,
+) ([]loweredStmt, []Diagnostic) {
+	mapExpr, mapDiagnostics := o.lowerExpr(ctx, index.X)
+	keyExpr, keyDiagnostics := o.lowerExpr(ctx, index.Index)
+	diagnostics := append(mapDiagnostics, keyDiagnostics...)
+	if tok == token.ASSIGN {
+		return []loweredStmt{{text: o.runtimeOwner.QualifiedHelper(RuntimeHelperMapSet) + "(" + mapExpr + ", " + keyExpr + ", " + right + ")"}}, diagnostics
+	}
+	mapTemp := ctx.tempName("Map")
+	keyTemp := ctx.tempName("MapKey")
+	current := o.lowerMapGetValue(ctx, index, mapTemp, keyTemp)
+	value := lowerCompoundAssignValue(o.runtimeOwner, targetType, current, right, tok)
+	return []loweredStmt{
+		{text: "const " + mapTemp + " = " + mapExpr},
+		{text: "const " + keyTemp + " = " + keyExpr},
+		{text: o.runtimeOwner.QualifiedHelper(RuntimeHelperMapSet) + "(" + mapTemp + ", " + keyTemp + ", " + value + ")"},
+	}, diagnostics
+}
+
+func lowerCompoundAssignValue(
+	runtimeOwner *RuntimeContractOwner,
+	targetType types.Type,
+	left string,
+	right string,
+	tok token.Token,
+) string {
+	if helper, ok := wideIntegerAssignHelper(targetType, tok); ok {
+		return runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")"
+	}
+	if value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok); ok {
+		return value
+	}
+	switch tok {
+	case token.ADD_ASSIGN:
+		return left + " + " + right
+	case token.SUB_ASSIGN:
+		return left + " - " + right
+	case token.MUL_ASSIGN:
+		return left + " * " + right
+	case token.QUO_ASSIGN:
+		return left + " / " + right
+	case token.REM_ASSIGN:
+		return left + " % " + right
+	case token.AND_ASSIGN:
+		return left + " & " + right
+	case token.OR_ASSIGN:
+		return left + " | " + right
+	case token.XOR_ASSIGN:
+		return left + " ^ " + right
+	case token.SHL_ASSIGN:
+		return left + " << " + right
+	case token.SHR_ASSIGN:
+		return left + " >> " + right
+	case token.AND_NOT_ASSIGN:
+		return left + " & ~(" + right + ")"
+	default:
+		return right
+	}
+}
+
+func integerQuotientAssignExpr(targetType types.Type, left string, right string, tok token.Token) (string, bool) {
+	value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok)
+	if !ok {
+		return "", false
+	}
+	return left + " = " + value, true
+}
+
+func assignmentTargetType(ctx lowerFileContext, lhs ast.Expr) types.Type {
+	if ident, ok := lhs.(*ast.Ident); ok {
+		if obj := ctx.semPkg.source.TypesInfo.Defs[ident]; obj != nil {
+			return obj.Type()
+		}
 	}
-	return stmts, diagnostics
+	return ctx.semPkg.source.TypesInfo.TypeOf(lhs)
+}
+
+func integerQuotientAssignValueExpr(targetType types.Type, left string, right string, tok token.Token) (string, bool) {
+	if tok != token.QUO_ASSIGN || !isIntegerType(targetType) {
+		return "", false
+	}
+	if bits, ok := unsignedIntegerBits(targetType); ok && bits <= 32 {
+		return "(" + left + " / " + right + ") >>> 0", true
+	}
+	return "Math.trunc(" + left + " / " + right + ")", true
 }
 
 func wideIntegerAssignHelper(targetType types.Type, tok token.Token) (RuntimeHelper, bool) {
@@ -2754,17 +3875,21 @@ func wideIntegerAssignHelper(targetType types.Type, tok token.Token) (RuntimeHel
 	case token.SHR_ASSIGN:
 		return RuntimeHelperUint64Shr, true
 	case token.MUL_ASSIGN:
-		return RuntimeHelperUint64Mul, true
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Mul, RuntimeHelperInt64Mul), true
+	case token.QUO_ASSIGN:
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Div, RuntimeHelperInt64Div), true
+	case token.REM_ASSIGN:
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Mod, RuntimeHelperInt64Mod), true
 	case token.ADD_ASSIGN:
-		return RuntimeHelperUint64Add, true
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Add, RuntimeHelperInt64Add), true
 	case token.SUB_ASSIGN:
-		return RuntimeHelperUint64Sub, true
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Sub, RuntimeHelperInt64Sub), true
 	case token.AND_ASSIGN:
-		return RuntimeHelperUint64And, true
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64And, RuntimeHelperInt64And), true
 	case token.OR_ASSIGN:
-		return RuntimeHelperUint64Or, true
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Or, RuntimeHelperInt64Or), true
 	case token.XOR_ASSIGN:
-		return RuntimeHelperUint64Xor, true
+		return wideIntegerHelper(isFixedSignedWideIntegerType(targetType), RuntimeHelperUint64Xor, RuntimeHelperInt64Xor), true
 	default:
 		return "", false
 	}
@@ -2834,14 +3959,15 @@ func (o *LoweringOwner) shortDeclTypeAnnotation(ctx lowerFileContext, lhs ast.Ex
 	if obj == nil {
 		return ""
 	}
-	if signature := unnamedSignatureForType(obj.Type()); signature != nil && rhsIsMethodValue(ctx, rhs) {
-		return ": " + o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
-	}
 	if signature := unnamedSignatureForType(obj.Type()); signature != nil {
-		value := ctx.model.values[obj]
-		if value != nil && value.asyncCompatibleFunction {
-			return ": " + o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
+		typ := o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
+		if ctx.model.needsVarRef[obj] {
+			typ = "$.VarRef<" + typ + ">"
 		}
+		return ": " + typ
+	}
+	if rhs != nil && isIdentLikeExpr(rhs) && isInterfaceType(obj.Type()) {
+		return ": " + o.tsVariableTypeFor(ctx, obj.Type(), ctx.model.needsVarRef[obj])
 	}
 	if !shortDeclNeedsTypeAnnotation(obj.Type()) {
 		return ""
@@ -2849,12 +3975,19 @@ func (o *LoweringOwner) shortDeclTypeAnnotation(ctx lowerFileContext, lhs ast.Ex
 	return ": " + o.tsVariableTypeFor(ctx, obj.Type(), ctx.model.needsVarRef[obj])
 }
 
+func isIdentLikeExpr(expr ast.Expr) bool {
+	_, ok := ast.Unparen(expr).(*ast.Ident)
+	return ok
+}
+
 func shortDeclNeedsTypeAnnotation(typ types.Type) bool {
 	switch typed := types.Unalias(typ).Underlying().(type) {
 	case *types.Pointer:
-		return namedStructType(typed.Elem()) != nil
+		return namedStructType(typed.Elem()) != nil || namedNonStructType(typed.Elem()) != nil
 	case *types.Map:
 		return true
+	case *types.Slice:
+		return true
 	default:
 		return false
 	}
@@ -2876,6 +4009,15 @@ func (o *LoweringOwner) lowerTupleTargetAssignmentStmt(
 	declare bool,
 ) (loweredStmt, []Diagnostic) {
 	if !declare {
+		if index, ok := unwrapParenExpr(lhs).(*ast.IndexExpr); ok && isMapType(ctx.semPkg.source.TypesInfo.TypeOf(index.X)) {
+			targetType := assignmentTargetType(ctx, lhs)
+			value = o.lowerValueForTarget(ctx, lhs, targetType, value)
+			stmts, diagnostics := o.lowerMapIndexUpdateStmts(ctx, index, token.ASSIGN, value, targetType)
+			if len(stmts) != 0 {
+				return stmts[0], diagnostics
+			}
+			return loweredStmt{}, diagnostics
+		}
 		if stmt, diagnostics, ok := o.lowerStarTargetAssignmentStmt(ctx, lhs, value); ok {
 			return stmt, diagnostics
 		}
@@ -2895,7 +4037,7 @@ func (o *LoweringOwner) lowerStarTargetAssignmentStmt(
 	lhs ast.Expr,
 	right string,
 ) (loweredStmt, []Diagnostic, bool) {
-	star, ok := lhs.(*ast.StarExpr)
+	star, ok := unwrapParenExpr(lhs).(*ast.StarExpr)
 	if !ok {
 		return loweredStmt{}, nil, false
 	}
@@ -2915,7 +4057,7 @@ func (o *LoweringOwner) lowerTupleReassignmentStmt(
 	diagnostics []Diagnostic,
 ) ([]loweredStmt, []Diagnostic) {
 	tempName := ctx.tempName("Tuple")
-	stmts := []loweredStmt{{text: "let " + tempName + " = " + right}}
+	stmts := []loweredStmt{{text: "let " + tempName + ": any = " + right}}
 	for idx, lhs := range stmt.Lhs {
 		if ident, ok := lhs.(*ast.Ident); ok && ident.Name == "_" {
 			continue
@@ -3064,8 +4206,8 @@ func shortDeclDefShadowsOuterName(name string, def types.Object) bool {
 		if scope == def.Parent() {
 			continue
 		}
-		obj, ok := scope.Lookup(name).(*types.Var)
-		if ok && obj.Pos().IsValid() && obj.Pos() < def.Pos() {
+		obj := scope.Lookup(name)
+		if obj != nil && obj.Pos().IsValid() && obj.Pos() < def.Pos() {
 			return true
 		}
 	}
@@ -3281,6 +4423,9 @@ func (o *LoweringOwner) lowerReturnStmt(ctx lowerFileContext, stmt *ast.ReturnSt
 	if ctx.rangeBranch != nil {
 		return o.lowerRangeFuncReturnStmt(ctx, stmt)
 	}
+	if o.returnNeedsNamedResultDefer(ctx) {
+		return o.lowerNamedResultDeferReturnStmt(ctx, stmt)
+	}
 	if len(stmt.Results) == 0 {
 		if result, ok := o.lowerNamedResultReturn(ctx); ok {
 			return "return " + result, nil
@@ -3313,6 +4458,125 @@ func (o *LoweringOwner) lowerReturnStmt(ctx lowerFileContext, stmt *ast.ReturnSt
 	return "return [" + strings.Join(parts, ", ") + "]", diagnostics
 }
 
+func (o *LoweringOwner) returnNeedsNamedResultDefer(ctx lowerFileContext) bool {
+	if ctx.deferState == nil || !ctx.deferState.used || ctx.signature == nil || ctx.signature.Results() == nil {
+		return false
+	}
+	for result := range ctx.signature.Results().Variables() {
+		if result.Name() != "" {
+			return true
+		}
+	}
+	return false
+}
+
+func (o *LoweringOwner) lowerNamedResultDeferReturnStmt(ctx lowerFileContext, stmt *ast.ReturnStmt) (string, []Diagnostic) {
+	var diagnostics []Diagnostic
+	var lines []string
+	explicitTemp := ""
+	if len(stmt.Results) != 0 {
+		var value string
+		var values []string
+		if len(stmt.Results) == 1 && ctx.signature.Results().Len() > 1 {
+			expr, exprDiagnostics := o.lowerExpr(ctx, stmt.Results[0])
+			diagnostics = append(diagnostics, exprDiagnostics...)
+			if prefix, tuple, ok := o.lowerTupleReturnValue(ctx, stmt.Results[0], expr); ok {
+				lines = append(lines, prefix)
+				value = tuple
+			} else {
+				value = expr
+			}
+		} else {
+			values = make([]string, 0, len(stmt.Results))
+			for idx, result := range stmt.Results {
+				expr, exprDiagnostics := o.lowerExpr(ctx, result)
+				diagnostics = append(diagnostics, exprDiagnostics...)
+				if idx < ctx.signature.Results().Len() {
+					expr = o.lowerValueForTarget(ctx, result, ctx.signature.Results().At(idx).Type(), expr)
+				}
+				values = append(values, expr)
+			}
+		}
+		temp := ctx.tempName("Return")
+		explicitTemp = temp
+		tempType := o.tsSignatureResultFor(ctx, ctx.signature)
+		if value != "" {
+			lines = append(lines, "const "+temp+": "+tempType+" = "+value)
+		} else if len(values) == 1 {
+			lines = append(lines, "const "+temp+": "+tempType+" = "+values[0])
+		} else {
+			lines = append(lines, "const "+temp+": "+tempType+" = ["+strings.Join(values, ", ")+"]")
+		}
+		for idx := range ctx.signature.Results().Len() {
+			result := ctx.signature.Results().At(idx)
+			name := result.Name()
+			if name == "" || name == "_" {
+				continue
+			}
+			target := safeIdentifier(name)
+			if ctx.model.needsVarRef[result] {
+				target += ".value"
+			}
+			source := temp
+			if ctx.signature.Results().Len() > 1 {
+				source += "[" + strconv.Itoa(idx) + "]"
+			}
+			lines = append(lines, target+" = "+source)
+		}
+	}
+	lines = append(lines, o.lowerDeferDisposeStmt(ctx))
+	if result, ok := o.lowerNamedResultReturnWithExplicitTemp(ctx, explicitTemp); ok {
+		lines = append(lines, "return "+result)
+	} else {
+		lines = append(lines, "return")
+	}
+	return strings.Join(lines, "\n"), diagnostics
+}
+
+func (o *LoweringOwner) lowerNamedResultReturnWithExplicitTemp(ctx lowerFileContext, explicitTemp string) (string, bool) {
+	if explicitTemp == "" {
+		return o.lowerNamedResultReturn(ctx)
+	}
+	parts := make([]string, 0, ctx.signature.Results().Len())
+	hasNamedResult := false
+	multi := ctx.signature.Results().Len() > 1
+	for idx := range ctx.signature.Results().Len() {
+		result := ctx.signature.Results().At(idx)
+		name := result.Name()
+		if name == "" || name == "_" {
+			source := explicitTemp
+			if multi {
+				source += "[" + strconv.Itoa(idx) + "]"
+			}
+			parts = append(parts, source)
+			if name != "" {
+				hasNamedResult = true
+			}
+			continue
+		}
+		hasNamedResult = true
+		returnExpr := safeIdentifier(name)
+		if ctx.model.needsVarRef[result] {
+			returnExpr += ".value"
+		}
+		parts = append(parts, returnExpr)
+	}
+	if !hasNamedResult {
+		return "", false
+	}
+	if len(parts) == 1 {
+		return parts[0], true
+	}
+	return "[" + strings.Join(parts, ", ") + "]", true
+}
+
+func (o *LoweringOwner) lowerDeferDisposeStmt(ctx lowerFileContext) string {
+	if ctx.deferState != nil && ctx.deferState.async {
+		return "await __defer[Symbol.asyncDispose]()"
+	}
+	return "__defer[Symbol.dispose]()"
+}
+
 func (o *LoweringOwner) lowerBodylessReturnStmt(ctx lowerFileContext, signature *types.Signature) (string, bool) {
 	if signature.Results().Len() == 0 {
 		return "", false
@@ -3434,6 +4698,9 @@ func genericCallResultUsesTypeParam(ctx lowerFileContext, expr ast.Expr) bool {
 		return false
 	}
 	signature := genericFunctionSignatureForCall(ctx, call.Fun)
+	if signature == nil {
+		signature = sourceFunctionSignatureForCall(ctx, call.Fun)
+	}
 	if signature == nil || signature.Results() == nil || signature.Results().Len() != 1 {
 		return false
 	}
@@ -3446,6 +4713,9 @@ func genericCallTupleResultTypeParamIndexes(ctx lowerFileContext, expr ast.Expr)
 		return nil
 	}
 	signature := genericFunctionSignatureForCall(ctx, call.Fun)
+	if signature == nil {
+		signature = sourceFunctionSignatureForCall(ctx, call.Fun)
+	}
 	if signature == nil || signature.Results() == nil || signature.Results().Len() < 2 {
 		return nil
 	}
@@ -3471,6 +4741,30 @@ func genericFunctionSignatureForCall(ctx lowerFileContext, fun ast.Expr) *types.
 	}
 }
 
+func sourceFunctionSignatureForCall(ctx lowerFileContext, fun ast.Expr) *types.Signature {
+	for {
+		switch typed := ast.Unparen(fun).(type) {
+		case *ast.IndexExpr:
+			fun = typed.X
+		case *ast.IndexListExpr:
+			fun = typed.X
+		default:
+			if ctx.semPkg == nil || ctx.semPkg.source == nil {
+				return nil
+			}
+			fn := calledFunction(ctx.semPkg.source, fun)
+			if fn == nil {
+				return nil
+			}
+			if origin := fn.Origin(); origin != nil {
+				fn = origin
+			}
+			signature, _ := fn.Type().(*types.Signature)
+			return signature
+		}
+	}
+}
+
 func typeContainsTypeParam(typ types.Type) bool {
 	return typeContainsTypeParamSeen(typ, make(map[types.Type]bool))
 }
@@ -3569,27 +4863,57 @@ func (o *LoweringOwner) lowerNamedResults(ctx lowerFileContext, signature *types
 }
 
 func (o *LoweringOwner) lowerNamedResultReturn(ctx lowerFileContext) (string, bool) {
-	results := o.lowerNamedResults(ctx, ctx.signature)
-	if len(results) == 0 {
+	if ctx.signature == nil || ctx.signature.Results() == nil || ctx.signature.Results().Len() == 0 {
 		return "", false
 	}
-	if len(results) == 1 {
-		return results[0].returnExpr, true
+	parts := make([]string, 0, ctx.signature.Results().Len())
+	hasNamedResult := false
+	for result := range ctx.signature.Results().Variables() {
+		name := result.Name()
+		if name == "" {
+			parts = append(parts, o.lowerDeclarationZeroValueExpr(ctx, result.Type()))
+			continue
+		}
+		hasNamedResult = true
+		if name == "_" {
+			parts = append(parts, o.lowerDeclarationZeroValueExpr(ctx, result.Type()))
+			continue
+		}
+		returnExpr := safeIdentifier(name)
+		if ctx.model.needsVarRef[result] {
+			returnExpr += ".value"
+		}
+		parts = append(parts, returnExpr)
+	}
+	if !hasNamedResult {
+		return "", false
 	}
-	parts := make([]string, 0, len(results))
-	for _, result := range results {
-		parts = append(parts, result.returnExpr)
+	if len(parts) == 1 {
+		return parts[0], true
 	}
 	return "[" + strings.Join(parts, ", ") + "]", true
 }
 
 func (o *LoweringOwner) lowerForStmt(ctx lowerFileContext, stmt *ast.ForStmt) (loweredStmt, []Diagnostic) {
-	bodyCtx := ctx.withoutRangeLoopBranches()
+	bodyCtx := ctx.withoutRangeLoopBranches().withoutLoopLabel()
 	loopLabel := ""
 	if stmtListNeedsLoopBranchLabel(stmt.Body.List) {
 		loopLabel = ctx.tempName("Loop")
 		bodyCtx = bodyCtx.withLoopLabel(loopLabel)
 	}
+	initCtx := ctx
+	loopCtx := ctx
+	var initPrelude []loweredStmt
+	if assign, ok := stmt.Init.(*ast.AssignStmt); ok && assign.Tok == token.DEFINE {
+		oldAliases, prelude := o.lowerShortDeclShadowAliases(ctx, assign)
+		newAliases := o.lowerShortDeclNewShadowAliases(ctx, assign)
+		if len(oldAliases) != 0 || len(newAliases) != 0 {
+			initCtx = ctx.withIdentAliases(oldAliases).withIdentRefAliases(newAliases)
+			loopCtx = ctx.withIdentRefAliases(newAliases)
+			bodyCtx = bodyCtx.withIdentRefAliases(newAliases)
+			initPrelude = prelude
+		}
+	}
 	if stmt.Init == nil && stmt.Post == nil {
 		cond := "true"
 		var diagnostics []Diagnostic
@@ -3614,19 +4938,19 @@ func (o *LoweringOwner) lowerForStmt(ctx lowerFileContext, stmt *ast.ForStmt) (l
 	init := ""
 	var diagnostics []Diagnostic
 	if stmt.Init != nil {
-		lowered, initDiagnostics := o.lowerForInitStmt(ctx, stmt.Init)
+		lowered, initDiagnostics := o.lowerForInitStmt(initCtx, stmt.Init)
 		diagnostics = append(diagnostics, initDiagnostics...)
 		init = lowered
 	}
 	cond := ""
 	if stmt.Cond != nil {
 		var condDiagnostics []Diagnostic
-		cond, condDiagnostics = o.lowerExpr(ctx, stmt.Cond)
+		cond, condDiagnostics = o.lowerExpr(loopCtx, stmt.Cond)
 		diagnostics = append(diagnostics, condDiagnostics...)
 	}
 	post := ""
 	if stmt.Post != nil {
-		lowered, postDiagnostics := o.lowerForPostStmt(ctx, stmt.Post)
+		lowered, postDiagnostics := o.lowerForPostStmt(loopCtx, stmt.Post)
 		diagnostics = append(diagnostics, postDiagnostics...)
 		post = lowered
 	}
@@ -3636,11 +4960,15 @@ func (o *LoweringOwner) lowerForStmt(ctx lowerFileContext, stmt *ast.ForStmt) (l
 	if loopLabel != "" {
 		text = loopLabel + ": " + text
 	}
-	return loweredStmt{
+	forStmt := loweredStmt{
 		hasBlock: true,
 		text:     text,
 		children: body,
-	}, diagnostics
+	}
+	if len(initPrelude) != 0 {
+		return loweredStmt{children: append(initPrelude, forStmt)}, diagnostics
+	}
+	return forStmt, diagnostics
 }
 
 func (o *LoweringOwner) lowerForInitStmt(ctx lowerFileContext, stmt ast.Stmt) (string, []Diagnostic) {
@@ -3729,9 +5057,13 @@ func (o *LoweringOwner) lowerForPostStmt(ctx lowerFileContext, stmt ast.Stmt) (s
 			diagnostics = append(diagnostics, leftDiagnostics...)
 			lefts = append(lefts, left)
 		}
-		for _, rhs := range assign.Rhs {
+		for idx, rhs := range assign.Rhs {
 			right, rightDiagnostics := o.lowerExpr(ctx, rhs)
 			diagnostics = append(diagnostics, rightDiagnostics...)
+			if idx < len(assign.Lhs) {
+				targetType := ctx.semPkg.source.TypesInfo.TypeOf(assign.Lhs[idx])
+				right = o.lowerValueForTarget(ctx, rhs, targetType, right)
+			}
 			rights = append(rights, right)
 		}
 		return "[" + strings.Join(lefts, ", ") + "] = [" + strings.Join(rights, ", ") + "]", diagnostics
@@ -3746,7 +5078,7 @@ func (o *LoweringOwner) lowerForPostStmt(ctx lowerFileContext, stmt ast.Stmt) (s
 func (o *LoweringOwner) lowerRangeStmt(ctx lowerFileContext, stmt *ast.RangeStmt) (loweredStmt, []Diagnostic) {
 	rangeValue, diagnostics := o.lowerExpr(ctx, stmt.X)
 	aliases := o.lowerRangeDeclShadowAliases(ctx, stmt)
-	bodyCtx := ctx
+	bodyCtx := ctx.withoutLoopLabel()
 	if len(aliases) != 0 {
 		bodyCtx = bodyCtx.withIdentAliases(aliases)
 	}
@@ -3795,23 +5127,21 @@ func (o *LoweringOwner) lowerRangeStmt(ctx lowerFileContext, stmt *ast.RangeStmt
 		if strings.HasPrefix(rangeTarget, "await ") {
 			rangeTarget = "(" + rangeTarget + ")"
 		}
-		key := keyName
-		if key == "" {
-			key = "__rangeKey"
-		}
-		value := valueName
-		if value == "" {
-			value = "__rangeValue"
-		}
+		key, keyBindings, keyDiagnostics := o.lowerMapRangeBinding(ctx, stmt.Key, keyName, "__rangeKey", "RangeKey", stmt.Tok == token.DEFINE)
+		value, valueBindings, valueDiagnostics := o.lowerMapRangeBinding(ctx, stmt.Value, valueName, "__rangeValue", "RangeValue", stmt.Tok == token.DEFINE)
+		diagnostics = append(diagnostics, keyDiagnostics...)
+		diagnostics = append(diagnostics, valueDiagnostics...)
 		binding := "const"
 		if rangeBindingAssignedInBody(ctx, stmt.Key, stmt.Body) ||
 			rangeBindingAssignedInBody(ctx, stmt.Value, stmt.Body) {
 			binding = "let"
 		}
+		children := append(keyBindings, valueBindings...)
+		children = append(children, body...)
 		return loweredStmt{
 			hasBlock: true,
 			text:     "for (" + binding + " [" + key + ", " + value + "] of " + rangeTarget + "?.entries() ?? [])",
-			children: body,
+			children: children,
 		}, diagnostics
 	}
 	if isStringType(rangeType) {
@@ -3848,8 +5178,12 @@ func (o *LoweringOwner) lowerRangeStmt(ctx lowerFileContext, stmt *ast.RangeStmt
 
 	body, bodyDiagnostics := o.lowerBlock(bodyCtx.withoutRangeLoopBranches(), stmt.Body)
 	diagnostics = append(diagnostics, bodyDiagnostics...)
-	rangeTarget := o.lowerArrayPointerTarget(ctx, rangeValue, rangeType)
-	indexTarget := o.lowerIndexTarget(ctx, rangeValue, rangeType)
+	rangeTarget := ctx.tempName("RangeTarget")
+	rangeTargetValue := o.lowerArrayPointerTarget(ctx, rangeValue, rangeType)
+	indexTarget := rangeTarget
+	if isNilableType(rangeType) {
+		indexTarget += "!"
+	}
 	indexName := keyName
 	if indexName == "" {
 		indexName = "__rangeIndex"
@@ -3864,7 +5198,7 @@ func (o *LoweringOwner) lowerRangeStmt(ctx lowerFileContext, stmt *ast.RangeStmt
 	}
 	return loweredStmt{
 		hasBlock: true,
-		text:     "for (let " + indexName + " = 0; " + indexName + " < " + o.runtimeOwner.QualifiedHelper(RuntimeHelperLen) + "(" + rangeTarget + "); " + indexName + "++)",
+		text:     "for (let " + rangeTarget + " = " + rangeTargetValue + ", " + indexName + " = 0; " + indexName + " < " + o.runtimeOwner.QualifiedHelper(RuntimeHelperLen) + "(" + rangeTarget + "); " + indexName + "++)",
 		children: children,
 	}, diagnostics
 }
@@ -3933,18 +5267,19 @@ func (o *LoweringOwner) lowerRangeFuncStmt(
 		rangeBranch.value = ctx.tempName("RangeReturnValue")
 		rangeBranch.resultType = o.tsSignatureResultFor(ctx, ctx.signature)
 	}
-	body, diagnostics := o.lowerBlock(ctx.withRangeBranch(rangeBranch), stmt.Body)
+	body, diagnostics := o.lowerBlock(ctx.withoutLoopLabel().withRangeBranch(rangeBranch), stmt.Body)
 	if stmt.Tok != token.DEFINE {
 		assignments, assignmentDiagnostics := o.lowerRangeFuncAssignments(ctx, stmt, paramNames)
 		diagnostics = append(diagnostics, assignmentDiagnostics...)
 		body = append(assignments, body...)
 	}
+	async := ctx.asyncFunction
 
 	return loweredStmt{rangeFunc: &loweredRangeFunc{
 		value:        rangeValue,
 		params:       paramNames,
 		body:         body,
-		async:        stmtsContainAwait(body) || o.rangeFunctionValueNeedsAwait(ctx, stmt.X),
+		async:        async,
 		returnBranch: rangeBranch,
 		parentBranch: parentBranch,
 	}}, diagnostics
@@ -3989,6 +5324,7 @@ func (o *LoweringOwner) lowerSelectStmt(ctx lowerFileContext, stmt *ast.SelectSt
 	lowered := &loweredSelect{
 		hasReturn:  selectName + "HasReturn",
 		value:      selectName + "Value",
+		result:     selectName + "Result",
 		resultType: resultType,
 	}
 	var diagnostics []Diagnostic
@@ -4025,7 +5361,7 @@ func (o *LoweringOwner) lowerSelectStmt(ctx lowerFileContext, stmt *ast.SelectSt
 			})
 			caseID++
 		case *ast.ExprStmt:
-			channel, prelude, receiveDiagnostics := o.lowerSelectReceiveComm(ctx, nil, comm.X)
+			channel, prelude, receiveDiagnostics := o.lowerSelectReceiveComm(ctx, nil, comm.X, lowered.result)
 			body, bodyDiagnostics := o.lowerStmtList(ctx.withLocalScope().withoutRangeBreak(), clause.Body)
 			diagnostics = append(diagnostics, receiveDiagnostics...)
 			diagnostics = append(diagnostics, bodyDiagnostics...)
@@ -4037,7 +5373,7 @@ func (o *LoweringOwner) lowerSelectStmt(ctx lowerFileContext, stmt *ast.SelectSt
 			})
 			caseID++
 		case *ast.AssignStmt:
-			channel, prelude, receiveDiagnostics := o.lowerSelectReceiveComm(ctx, comm, nil)
+			channel, prelude, receiveDiagnostics := o.lowerSelectReceiveComm(ctx, comm, nil, lowered.result)
 			body, bodyDiagnostics := o.lowerStmtList(ctx.withLocalScope().withoutRangeBreak(), clause.Body)
 			diagnostics = append(diagnostics, receiveDiagnostics...)
 			diagnostics = append(diagnostics, bodyDiagnostics...)
@@ -4083,11 +5419,22 @@ func stmtsEndInReturn(stmts []loweredStmt) bool {
 		return false
 	}
 	last := stmts[len(stmts)-1]
-	if strings.HasPrefix(strings.TrimSpace(last.text), "return") {
+	return stmtEndsInReturn(last)
+}
+
+func stmtEndsInReturn(stmt loweredStmt) bool {
+	trimmed := strings.TrimSpace(stmt.text)
+	if strings.HasPrefix(trimmed, "return") {
 		return true
 	}
-	if last.selectStmt != nil {
-		return last.selectStmt.returns
+	if stmt.selectStmt != nil {
+		return stmt.selectStmt.returns
+	}
+	if trimmed == "" && (stmt.hasBlock || len(stmt.children) != 0) {
+		return stmtsEndInReturn(stmt.children)
+	}
+	if strings.HasPrefix(trimmed, "if ") && len(stmt.elseBody) != 0 {
+		return stmtsEndInReturn(stmt.children) && stmtsEndInReturn(stmt.elseBody)
 	}
 	return false
 }
@@ -4134,6 +5481,7 @@ func (o *LoweringOwner) lowerSelectReceiveComm(
 	ctx lowerFileContext,
 	assign *ast.AssignStmt,
 	expr ast.Expr,
+	resultName string,
 ) (string, []loweredStmt, []Diagnostic) {
 	receiveExpr := expr
 	if assign != nil && len(assign.Rhs) == 1 {
@@ -4162,7 +5510,7 @@ func (o *LoweringOwner) lowerSelectReceiveComm(
 		if assign.Tok == token.DEFINE && isShortAssignTargetNew(ctx, lhs) {
 			prefix = "let "
 		}
-		prelude = append(prelude, loweredStmt{text: prefix + left + " = result" + fields[idx]})
+		prelude = append(prelude, loweredStmt{text: prefix + left + " = " + resultName + fields[idx]})
 	}
 	return channel, prelude, diagnostics
 }
@@ -4177,15 +5525,24 @@ func (o *LoweringOwner) lowerSwitchStmt(ctx lowerFileContext, stmt *ast.SwitchSt
 	}
 
 	value := "true"
+	var tagType types.Type
 	if stmt.Tag != nil {
 		var valueDiagnostics []Diagnostic
 		value, valueDiagnostics = o.lowerExpr(ctx, stmt.Tag)
 		diagnostics = append(diagnostics, valueDiagnostics...)
 		value = lowerConstantComparableValue(ctx, stmt.Tag, value)
+		tagType = ctx.semPkg.source.TypesInfo.TypeOf(stmt.Tag)
 	} else if switchHasConstantCaseExpr(ctx, stmt) {
 		value = "(true as boolean)"
 	}
 
+	compareCases := tagType != nil && isInterfaceType(tagType)
+	compareValue := value
+	if compareCases {
+		compareValue = ctx.tempName("Switch")
+		init = append(init, loweredStmt{text: "let " + compareValue + " = " + value})
+		value = "true"
+	}
 	switchIR := &loweredSwitch{value: value}
 	for _, raw := range stmt.Body.List {
 		clause, ok := raw.(*ast.CaseClause)
@@ -4207,6 +5564,11 @@ func (o *LoweringOwner) lowerSwitchStmt(ctx lowerFileContext, stmt *ast.SwitchSt
 		for _, expr := range clause.List {
 			lowered, exprDiagnostics := o.lowerExpr(ctx, expr)
 			diagnostics = append(diagnostics, exprDiagnostics...)
+			if compareCases {
+				sourceType := ctx.semPkg.source.TypesInfo.TypeOf(expr)
+				lowered = o.lowerValueForTargetTypes(ctx, tagType, sourceType, lowered, shouldCloneStructValue(expr))
+				lowered = o.runtimeOwner.QualifiedHelper(RuntimeHelperComparableEqual) + "(" + compareValue + ", " + lowered + ")"
+			}
 			values = append(values, lowered)
 		}
 		switchIR.cases = append(switchIR.cases, loweredSwitchCase{
@@ -4309,7 +5671,7 @@ func (o *LoweringOwner) lowerTypeSwitchStmt(ctx lowerFileContext, stmt *ast.Type
 			if typ == nil {
 				tsTypes = append(tsTypes, "any")
 			} else {
-				tsTypes = append(tsTypes, o.tsTypeFor(ctx, typ))
+				tsTypes = append(tsTypes, o.tsTypeSwitchCaseTypeFor(ctx, typ))
 			}
 		}
 		switchIR.cases = append(switchIR.cases, loweredTypeSwitchCase{
@@ -4323,6 +5685,15 @@ func (o *LoweringOwner) lowerTypeSwitchStmt(ctx lowerFileContext, stmt *ast.Type
 	return lowered, diagnostics
 }
 
+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, typ)
+}
+
 func loweredStmtsUseVarRefName(stmts []loweredStmt, name string) bool {
 	if name == "" {
 		return false
@@ -4518,7 +5889,108 @@ func (o *LoweringOwner) lowerArrayEqualityExpr(ctx lowerFileContext, expr *ast.B
 	return value, true
 }
 
+func (o *LoweringOwner) lowerComplexEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
+	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
+	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
+	if !isComplexType(leftType) || !isComplexType(rightType) {
+		return "", false
+	}
+	value := o.runtimeOwner.QualifiedHelper(RuntimeHelperArrayEqual) + "(" + left + ", " + right + ")"
+	if expr.Op == token.NEQ {
+		value = "!" + value
+	}
+	return value, true
+}
+
+func (o *LoweringOwner) lowerStringEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
+	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
+	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
+	if !isStringType(leftType) || !isStringType(rightType) {
+		return "", false
+	}
+	value := o.runtimeOwner.QualifiedHelper(RuntimeHelperStringEqual) + "(" + left + ", " + right + ")"
+	if expr.Op == token.NEQ {
+		value = "!" + value
+	}
+	return value, true
+}
+
+func (o *LoweringOwner) lowerInterfaceEqualityExpr(ctx lowerFileContext, expr *ast.BinaryExpr, left string, right string) (string, bool) {
+	if isNilExpr(expr.X) || isNilExpr(expr.Y) {
+		return "", false
+	}
+	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
+	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
+	if !isInterfaceType(leftType) && !isInterfaceType(rightType) {
+		return "", false
+	}
+	value := o.runtimeOwner.QualifiedHelper(RuntimeHelperComparableEqual) + "(" + left + ", " + right + ")"
+	if expr.Op == token.NEQ {
+		value = "!" + value
+	}
+	return value, true
+}
+
+func (o *LoweringOwner) lowerStringOrderExpr(
+	ctx lowerFileContext,
+	expr *ast.BinaryExpr,
+	left string,
+	right string,
+	leftDiagnostics []Diagnostic,
+	rightDiagnostics []Diagnostic,
+) (string, []Diagnostic, bool) {
+	leftType := ctx.semPkg.source.TypesInfo.TypeOf(expr.X)
+	rightType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Y)
+	if !isStringType(leftType) || !isStringType(rightType) {
+		return "", nil, false
+	}
+	left, leftDiagnostics = o.lowerStringOrderOperand(ctx, expr.X, left, leftDiagnostics)
+	right, rightDiagnostics = o.lowerStringOrderOperand(ctx, expr.Y, right, rightDiagnostics)
+	compare := o.runtimeOwner.QualifiedHelper(RuntimeHelperStringCompare) + "(" + left + ", " + right + ")"
+	switch expr.Op {
+	case token.LSS:
+		return compare + " < 0", append(leftDiagnostics, rightDiagnostics...), true
+	case token.LEQ:
+		return compare + " <= 0", append(leftDiagnostics, rightDiagnostics...), true
+	case token.GTR:
+		return compare + " > 0", append(leftDiagnostics, rightDiagnostics...), true
+	case token.GEQ:
+		return compare + " >= 0", append(leftDiagnostics, rightDiagnostics...), true
+	default:
+		return "", nil, false
+	}
+}
+
+func (o *LoweringOwner) lowerStringOrderOperand(
+	ctx lowerFileContext,
+	expr ast.Expr,
+	fallback string,
+	fallbackDiagnostics []Diagnostic,
+) (string, []Diagnostic) {
+	call, ok := unwrapParenExpr(expr).(*ast.CallExpr)
+	if !ok || len(call.Args) != 1 {
+		return fallback, fallbackDiagnostics
+	}
+	targetType := typeFromExpr(ctx, call.Fun)
+	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(call.Args[0])
+	if targetType == nil || sourceType == nil || !isStringType(targetType) || !isByteSliceType(sourceType) {
+		return fallback, fallbackDiagnostics
+	}
+	return o.lowerExpr(ctx, call.Args[0])
+}
+
+func binaryOperandUsesTypeParam(ctx lowerFileContext, expr ast.Expr) bool {
+	typ := ctx.semPkg.source.TypesInfo.TypeOf(expr)
+	_, ok := types.Unalias(typ).(*types.TypeParam)
+	return ok
+}
+
 func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
+	if value := ctx.semPkg.source.TypesInfo.Types[unwrapParenExpr(expr)].Value; value != nil && value.Kind() == constant.Complex {
+		if constantValue, ok := lowerConstantValue(value); ok {
+			return constantValue, nil
+		}
+	}
 	switch typed := expr.(type) {
 	case *ast.BasicLit:
 		return lowerBasicLit(typed), nil
@@ -4526,6 +5998,11 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 		return o.lowerIdent(ctx, typed, false), nil
 	case *ast.BinaryExpr:
 		if value := ctx.semPkg.source.TypesInfo.Types[typed].Value; value != nil {
+			if (typed.Op == token.SHL || typed.Op == token.SHR) && (value.Kind() == constant.Int || value.Kind() == constant.Float) {
+				if constantValue, ok := lowerConstantValue(value); ok {
+					return constantValue, nil
+				}
+			}
 			if constantValue, ok := lowerLargeIntegerConstantValue(value); ok {
 				return constantValue, nil
 			}
@@ -4550,8 +6027,20 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 			if value, ok := o.lowerArrayEqualityExpr(ctx, typed, left, right); ok {
 				return value, append(leftDiagnostics, rightDiagnostics...)
 			}
+			if value, ok := o.lowerComplexEqualityExpr(ctx, typed, left, right); ok {
+				return value, append(leftDiagnostics, rightDiagnostics...)
+			}
+			if value, ok := o.lowerStringEqualityExpr(ctx, typed, left, right); ok {
+				return value, append(leftDiagnostics, rightDiagnostics...)
+			}
+			if value, ok := o.lowerInterfaceEqualityExpr(ctx, typed, left, right); ok {
+				return value, append(leftDiagnostics, rightDiagnostics...)
+			}
 			left, right = o.lowerEqualityOperands(ctx, typed, left, right)
 		}
+		if value, ok := o.lowerWideIntegerBinaryExpr(ctx, typed, left, right); ok {
+			return value, append(leftDiagnostics, rightDiagnostics...)
+		}
 		if typed.Op == token.QUO && isIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(typed)) {
 			return "Math.trunc(" + left + " / " + right + ")", append(leftDiagnostics, rightDiagnostics...)
 		}
@@ -4561,8 +6050,14 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 					"(" + left + ", " + right + ", " + strconv.Itoa(bits) + ")", append(leftDiagnostics, rightDiagnostics...)
 			}
 		}
-		if value, ok := o.lowerWideIntegerBinaryExpr(ctx, typed, left, right); ok {
-			return value, append(leftDiagnostics, rightDiagnostics...)
+		if value, diagnostics, ok := o.lowerStringOrderExpr(ctx, typed, left, right, leftDiagnostics, rightDiagnostics); ok {
+			return value, diagnostics
+		}
+		if binaryOperandUsesTypeParam(ctx, typed.X) {
+			left = "(" + left + " as any)"
+		}
+		if binaryOperandUsesTypeParam(ctx, typed.Y) {
+			right = "(" + right + " as any)"
 		}
 		return left + " " + typed.Op.String() + " " + right, append(leftDiagnostics, rightDiagnostics...)
 	case *ast.UnaryExpr:
@@ -4575,7 +6070,7 @@ func (o *LoweringOwner) lowerExpr(ctx lowerFileContext, expr ast.Expr) (string,
 		}
 		value, diagnostics := o.lowerExpr(ctx, typed.X)
 		if typed.Op == token.NOT || typed.Op == token.SUB || typed.Op == token.ADD {
-			return typed.Op.String() + value, diagnostics
+			return lowerPrefixUnaryExpr(typed.Op, value), diagnostics
 		}
 		if typed.Op == token.XOR {
 			return "~" + value, diagnostics
@@ -4621,7 +6116,7 @@ func lowerBasicLit(lit *ast.BasicLit) string {
 		if err != nil {
 			return strconv.Quote(lit.Value)
 		}
-		return strconv.Quote(value)
+		return lowerGoStringLiteral(value)
 	}
 	if lit.Kind == token.INT && isLegacyOctalLiteral(lit.Value) {
 		digits := strings.TrimLeft(strings.ReplaceAll(lit.Value, "_", ""), "0")
@@ -4665,8 +6160,17 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	if asyncCompatibleParams || funcLiteralUsesFunctionIdentifierCall(ctx, lit) {
 		bodyCtx = bodyCtx.withAsyncFunction(true)
 	}
+	var params []loweredParam
+	var paramBindings []loweredStmt
+	if signature != nil && signature.Params() != nil {
+		for idx := range signature.Params().Len() {
+			param := signature.Params().At(idx)
+			params, paramBindings = o.appendLoweredParam(ctx, params, paramBindings, param, idx, asyncCompatibleParams)
+		}
+	}
 	body, diagnostics := o.lowerBlock(bodyCtx, lit.Body)
 	var rendered strings.Builder
+	renderStmts(&rendered, paramBindings, 1)
 	renderNamedResults(&rendered, o.lowerNamedResults(ctx, signature), 1)
 	renderDeferStack(&rendered, deferState, 1)
 	renderStmts(&rendered, body, 1)
@@ -4675,21 +6179,28 @@ func (o *LoweringOwner) lowerFuncLit(ctx lowerFileContext, lit *ast.FuncLit) (st
 	if async {
 		prefix = "async "
 	}
-	function := prefix + "(" + o.tsSignatureParamsFor(ctx, signature, asyncCompatibleParams) + "): " +
+	function := prefix + "(" + renderLoweredParams(params) + "): " +
 		asyncResultType(o.tsSignatureResultFor(ctx, signature), async) + " => {\n" +
 		rendered.String() + "}"
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperFunctionValue) +
 		"(" + function + ", " + o.runtimeFunctionTypeInfo(signature, "") + ")", async, diagnostics
 }
 
+func renderLoweredParams(params []loweredParam) string {
+	if len(params) == 0 {
+		return ""
+	}
+	rendered := make([]string, 0, len(params))
+	for _, param := range params {
+		rendered = append(rendered, param.name+": "+param.typ)
+	}
+	return strings.Join(rendered, ", ")
+}
+
 func funcLiteralUsesFunctionIdentifierCall(ctx lowerFileContext, lit *ast.FuncLit) bool {
 	if lit == nil || lit.Body == nil || ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return false
 	}
-	signature, _ := ctx.semPkg.source.TypesInfo.TypeOf(lit).(*types.Signature)
-	if signature == nil || signature.Results() == nil || signature.Results().Len() == 0 {
-		return false
-	}
 	uses := false
 	ast.Inspect(lit.Body, func(node ast.Node) bool {
 		if uses {
@@ -4760,6 +6271,9 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 	}
 	obj := objectForIdent(ctx, ident)
 	if alias := ctx.identAliases[obj]; alias != "" {
+		if !raw && obj != nil && ctx.identAliasRefs[obj] && ctx.model.needsVarRef[obj] {
+			return alias + ".value"
+		}
 		return alias
 	}
 	if constObj, ok := obj.(*types.Const); ok && ctx.localAliases[obj] != "" {
@@ -4770,22 +6284,28 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 	if alias := ctx.localAliases[obj]; alias != "" {
 		if ctx.lazyPackageVars[obj] {
 			lazyValue := alias + "." + packageVarGetterName(value) + "()"
-			if obj != nil && ctx.model.needsVarRef[obj] {
-				return lazyValue + ".value"
+			if (ctx.asyncFunction || ctx.topLevel) && o.packageVarHasAsyncLazyInit(ctx, obj) {
+				lazyValue = "(await " + alias + "." + packageVarInitName(value) + "(), " + lazyValue + ")"
+			}
+			if raw {
+				return lazyValue
 			}
-			return lazyValue
+			return o.lowerPackageVarReadValue(ctx, obj, lazyValue)
 		}
-		return alias + "." + value
+		if raw {
+			return alias + "." + value
+		}
+		return o.lowerPackageVarReadValue(ctx, obj, alias+"."+value)
 	}
 	if raw {
 		return value
 	}
 	if ctx.lazyPackageVars[obj] {
 		lazyValue := packageVarGetterName(value) + "()"
-		if obj != nil && ctx.model.needsVarRef[obj] {
-			return lazyValue + ".value"
+		if (ctx.asyncFunction || ctx.topLevel) && o.packageVarHasAsyncLazyInit(ctx, obj) {
+			lazyValue = "(await " + packageVarInitName(value) + "(), " + lazyValue + ")"
 		}
-		return lazyValue
+		return o.lowerPackageVarReadValue(ctx, obj, lazyValue)
 	}
 	if obj != nil && ctx.model.needsVarRef[obj] {
 		return value + ".value"
@@ -4793,6 +6313,17 @@ func (o *LoweringOwner) lowerIdent(ctx lowerFileContext, ident *ast.Ident, raw b
 	return value
 }
 
+func (o *LoweringOwner) lowerPackageVarReadValue(ctx lowerFileContext, obj types.Object, value string) string {
+	if obj == nil || ctx.model == nil || !ctx.model.needsVarRef[obj] {
+		return value
+	}
+	if varObj, ok := obj.(*types.Var); ok && packageVarReadNeedsPointerValue(varObj.Type()) {
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<" + o.tsNonNilTypeFor(ctx, varObj.Type()) + ">(" + value + ")"
+	}
+	return value + ".value"
+}
+
 func objectForIdent(ctx lowerFileContext, ident *ast.Ident) types.Object {
 	if ctx.semPkg == nil || ctx.semPkg.source == nil {
 		return nil
@@ -4820,6 +6351,28 @@ func objectForValueExpr(ctx lowerFileContext, expr ast.Expr) types.Object {
 	}
 }
 
+func objectNeedsVarRef(ctx lowerFileContext, obj types.Object) bool {
+	if obj == nil || ctx.model == nil {
+		return false
+	}
+	if ctx.model.needsVarRef[obj] {
+		return true
+	}
+	if obj.Pkg() == nil {
+		return false
+	}
+	semPkg := ctx.model.packages[obj.Pkg().Path()]
+	if semPkg == nil {
+		return false
+	}
+	for _, value := range semPkg.values {
+		if value.name == obj.Name() && ctx.model.needsVarRef[value.object] {
+			return true
+		}
+	}
+	return false
+}
+
 func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr) (string, []Diagnostic) {
 	if ident, ok := expr.Fun.(*ast.Ident); ok && isBuiltinCallTarget(ctx, ident) {
 		switch ident.Name {
@@ -4846,6 +6399,22 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 				}
 				return o.runtimeOwner.QualifiedHelper(helper) + "(" + strings.Join(args, ", ") + ")", diagnostics
 			case "append":
+				if len(expr.Args) > 0 {
+					if slice, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr.Args[0])).Underlying().(*types.Slice); ok {
+						for idx := 1; idx < len(args); idx++ {
+							if expr.Ellipsis != token.NoPos && idx == len(args)-1 {
+								continue
+							}
+							args[idx] = o.lowerValueForTargetTypes(
+								ctx,
+								slice.Elem(),
+								ctx.semPkg.source.TypesInfo.TypeOf(expr.Args[idx]),
+								args[idx],
+								false,
+							)
+						}
+					}
+				}
 				if expr.Ellipsis != token.NoPos && len(args) > 1 {
 					last := len(args) - 1
 					spread := args[last]
@@ -4854,7 +6423,13 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 					}
 					args[last] = "...(" + spread + " ?? [])"
 				}
-				return o.runtimeOwner.QualifiedHelper(RuntimeHelperAppend) + "(" + strings.Join(args, ", ") + ")", diagnostics
+				appendHelper := o.runtimeOwner.QualifiedHelper(RuntimeHelperAppend)
+				if len(args) > 0 && args[0] == "null" {
+					if slice, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr)).Underlying().(*types.Slice); ok {
+						appendHelper += "<" + o.tsTypeFor(ctx, slice.Elem()) + ">"
+					}
+				}
+				return appendHelper + "(" + strings.Join(args, ", ") + ")", diagnostics
 			case "cap":
 				if len(expr.Args) == 1 {
 					args[0] = o.lowerArrayPointerTarget(ctx, args[0], ctx.semPkg.source.TypesInfo.TypeOf(expr.Args[0]))
@@ -4906,7 +6481,7 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 			if typeParam := receiverTypeParam(selection.Recv()); typeParam != nil {
 				receiverExpr, receiverDiagnostics := o.lowerExpr(ctx, fun.X)
 				diagnostics = append(diagnostics, receiverDiagnostics...)
-				if !signatureHasTypeParam(ctx.signature, typeParam) {
+				if !typeParamInScope(ctx, typeParam) {
 					call := receiverExpr + "." + fun.Sel.Name + "(" + strings.Join(args, ", ") + ")"
 					return o.awaitCallIfNeeded(ctx, fun, call), diagnostics
 				}
@@ -4914,11 +6489,14 @@ func (o *LoweringOwner) lowerCallExpr(ctx lowerFileContext, expr *ast.CallExpr)
 				call := o.runtimeOwner.QualifiedHelper(RuntimeHelperCallGenericMethod) + "(" + strings.Join(methodArgs, ", ") + ")"
 				return o.awaitCallIfNeeded(ctx, fun, call), diagnostics
 			}
-			receiver := receiverNamedType(selection.Recv())
+			receiver := methodReceiverNamedType(selection.Obj())
+			if receiver == nil {
+				receiver = receiverNamedType(selection.Recv())
+			}
 			if namedNonInterfaceNonStructType(receiver) {
 				return o.lowerNamedReceiverMethodCall(ctx, fun, args, diagnostics)
 			}
-			if call, callDiagnostics, ok := o.lowerNilablePointerReceiverMethodCall(ctx, fun, selection, args); ok {
+			if call, callDiagnostics, ok := o.lowerPointerReceiverMethodCall(ctx, fun, selection, args); ok {
 				return o.awaitCallIfNeeded(ctx, fun, call), append(diagnostics, callDiagnostics...)
 			}
 			receiverExpr, receiverDiagnostics := o.lowerMethodReceiverExpr(ctx, fun.X, selection)
@@ -5024,6 +6602,7 @@ func (o *LoweringOwner) lowerCallArgs(
 				lowered = o.lowerCallArgForTarget(ctx, arg, params.At(idx).Type(), lowered, overrideCall)
 			} else if expr.Ellipsis != token.NoPos && idx == len(expr.Args)-1 {
 				lowered = o.lowerCallArgForTarget(ctx, arg, params.At(fixedCount).Type(), lowered, overrideCall)
+				lowered = "...(" + lowered + " ?? [])"
 			} else {
 				lowered = o.lowerCallArgForTarget(ctx, arg, targetType, lowered, overrideCall)
 			}
@@ -5107,19 +6686,41 @@ func (o *LoweringOwner) lowerTupleCallArgs(
 		parts = append(parts, converted)
 	}
 	if !changed {
-		return []string{"...(" + value + ")"}, diagnostics, true
+		return []string{"...(" + o.parenthesizedTupleCast(ctx, value, params) + ")"}, diagnostics, true
 	}
 	temp := ctx.tempName("TupleArg")
 	for idx, part := range parts {
 		parts[idx] = strings.ReplaceAll(part, "__goscriptTupleArg", temp)
 	}
-	body := "const " + temp + " = " + value + "; return [" + strings.Join(parts, ", ") + "]"
+	body := "const " + temp + " = " + value + "; return " + o.tupleLiteralCast(ctx, params, parts)
 	if strings.Contains(value, "await ") {
 		return []string{"...(await (async () => { " + body + " })())"}, diagnostics, true
 	}
 	return []string{"...(() => { " + body + " })()"}, diagnostics, true
 }
 
+func (o *LoweringOwner) parenthesizedTupleCast(ctx lowerFileContext, value string, params *types.Tuple) string {
+	if strings.HasPrefix(value, "await ") {
+		return "(" + value + ") as " + o.tupleTypeForParams(ctx, params)
+	}
+	return value + " as " + o.tupleTypeForParams(ctx, params)
+}
+
+func (o *LoweringOwner) tupleLiteralCast(ctx lowerFileContext, params *types.Tuple, parts []string) string {
+	return "[" + strings.Join(parts, ", ") + "] as " + o.tupleTypeForParams(ctx, params)
+}
+
+func (o *LoweringOwner) tupleTypeForParams(ctx lowerFileContext, params *types.Tuple) string {
+	if params == nil || params.Len() == 0 {
+		return "[]"
+	}
+	parts := make([]string, 0, params.Len())
+	for v := range params.Variables() {
+		parts = append(parts, o.tsTypeFor(ctx, v.Type()))
+	}
+	return "[" + strings.Join(parts, ", ") + "]"
+}
+
 func (o *LoweringOwner) lowerFixedCallArgs(
 	ctx lowerFileContext,
 	exprs []ast.Expr,
@@ -5153,7 +6754,7 @@ func (o *LoweringOwner) lowerCallArgForTarget(
 	value = o.lowerValueForTarget(ctx, expr, targetType, value)
 	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(expr)
 	if overrideCall && isNonEmptyInterfaceType(targetType) && (isInterfaceType(sourceType) || isNilableType(sourceType)) {
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + "(" + value + ")"
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValueOrNil) + "(" + value + ")!"
 	}
 	return value
 }
@@ -5293,7 +6894,7 @@ func (o *LoweringOwner) lowerMakeExpr(ctx lowerFileContext, expr *ast.CallExpr)
 			args = append(args, "() => "+o.lowerZeroValueExprFor(ctx, typed.Elem()))
 		}
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMakeSlice) +
-			"<" + o.tsTypeFor(ctx, typed.Elem()) + ">(" + strings.Join(args, ", ") + ")", diagnostics
+			"<" + o.tsSliceElemTypeFor(ctx, typed.Elem()) + ">(" + strings.Join(args, ", ") + ")", diagnostics
 	case *types.Map:
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMakeMap) +
 			"<" + o.tsTypeFor(ctx, typed.Key()) + ", " + o.tsTypeFor(ctx, typed.Elem()) + ">()", nil
@@ -5321,7 +6922,8 @@ func (o *LoweringOwner) lowerNewExpr(ctx lowerFileContext, expr *ast.CallExpr) (
 	if named := namedStructType(typ); named != nil {
 		return "new " + o.namedTypeExpr(ctx, named) + "()", nil
 	}
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperVarRef) + "(" + o.lowerZeroValueExprFor(ctx, typ) + ")", nil
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperVarRef) +
+		"<" + o.tsTypeFor(ctx, typ) + ">(" + o.lowerDeclarationZeroValueExpr(ctx, typ) + ")", nil
 }
 
 func (o *LoweringOwner) lowerConversionExpr(
@@ -5339,12 +6941,17 @@ func (o *LoweringOwner) lowerConversionExpr(
 			return value, append(diagnostics, addressDiagnostics...)
 		}
 	}
+	if helper, addressDiagnostics, ok := o.lowerReflectHeaderPointerConversion(ctx, targetType, expr.Args[0]); ok {
+		return helper, append(diagnostics, addressDiagnostics...)
+	}
+	if helper, addressDiagnostics, ok := o.lowerUnsafeArrayPointerConversion(ctx, targetType, expr.Args[0]); ok {
+		return helper, append(diagnostics, addressDiagnostics...)
+	}
 	if isUnsafePointerType(targetType) {
 		return "(" + value + " as any)", diagnostics
 	}
 	if isNilExpr(expr.Args[0]) && isPointerType(targetType) {
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperTypedNil) +
-			"(" + strconv.Quote(goRuntimeTypeString(targetType)) + ")", diagnostics
+		return "null", diagnostics
 	}
 	if isInterfaceType(targetType) {
 		return o.lowerValueForTarget(ctx, expr.Args[0], targetType, value), diagnostics
@@ -5402,6 +7009,13 @@ func (o *LoweringOwner) lowerConversionExpr(
 			return result, diagnostics
 		}
 	}
+	if target := pointerToNamedStructType(targetType); target != nil {
+		source := pointerToNamedStructType(sourceType)
+		if source != nil && !types.Identical(target, source) &&
+			types.IdenticalIgnoreTags(target.Underlying(), source.Underlying()) {
+			return "(" + value + " as unknown as " + o.tsTypeFor(ctx, targetType) + ")", diagnostics
+		}
+	}
 	if conversion, ok := o.lowerNamedStructConversion(ctx, expr.Args[0], targetType, sourceType, value); ok {
 		return renderNamedStructConversion(conversion), diagnostics
 	}
@@ -5421,6 +7035,9 @@ func (o *LoweringOwner) lowerConversionExpr(
 		return value, diagnostics
 	}
 	if isNumericType(targetType) {
+		if isFloatType(targetType) {
+			return value, diagnostics
+		}
 		if bits, ok := unsignedIntegerBits(targetType); ok {
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
 				"(" + value + ", " + strconv.Itoa(bits) + ")", diagnostics
@@ -5440,45 +7057,64 @@ func (o *LoweringOwner) lowerWideIntegerBinaryExpr(ctx lowerFileContext, expr *a
 	if !resultWide && !leftWide {
 		return "", false
 	}
+	signed := isFixedSignedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr)) ||
+		isFixedSignedWideIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
 	switch expr.Op {
 	case token.SHL, token.SHR:
 		helper := RuntimeHelperUint64Shr
 		if expr.Op == token.SHL {
 			helper = RuntimeHelperUint64Shl
 		}
+		if signed {
+			helper = RuntimeHelperInt64Shr
+			if expr.Op == token.SHL {
+				helper = RuntimeHelperInt64Shl
+			}
+		}
 		if _, ok := constantShiftAmount(ctx, expr.Y); !ok {
 			return o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")", true
 		}
 		amount, ok := constantShiftAmount(ctx, expr.Y)
-		if ok && amount >= 32 && expr.Op == token.SHL {
+		if ok && amount >= 32 && expr.Op == token.SHL && !signed {
 			base := o.lowerWideShiftLeftOperand(ctx, expr.X, left)
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Mul) +
 				"(" + base + ", " + shiftMultiplier(amount) + ")", true
 		}
 		return o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")", true
 	case token.MUL:
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Mul) + "(" + left + ", " + right + ")", true
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Mul, RuntimeHelperInt64Mul)) + "(" + left + ", " + right + ")", true
+	case token.QUO:
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Div, RuntimeHelperInt64Div)) + "(" + left + ", " + right + ")", true
+	case token.REM:
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Mod, RuntimeHelperInt64Mod)) + "(" + left + ", " + right + ")", true
 	case token.ADD:
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Add) + "(" + left + ", " + right + ")", true
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Add, RuntimeHelperInt64Add)) + "(" + left + ", " + right + ")", true
 	case token.SUB:
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Sub) + "(" + left + ", " + right + ")", true
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Sub, RuntimeHelperInt64Sub)) + "(" + left + ", " + right + ")", true
 	case token.AND:
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64And) + "(" + left + ", " + right + ")", true
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64And, RuntimeHelperInt64And)) + "(" + left + ", " + right + ")", true
 	case token.XOR:
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Xor) + "(" + left + ", " + right + ")", true
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Xor, RuntimeHelperInt64Xor)) + "(" + left + ", " + right + ")", true
 	case token.OR:
 		shift, ok := wideLeftShiftExpr(ctx, expr.X)
-		if ok {
+		if ok && !signed {
 			if bits, ok := lowIntegerBits(ctx, expr.Y); ok && bits <= shift {
 				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Add) + "(" + left + ", " + right + ")", true
 			}
 		}
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint64Or) + "(" + left + ", " + right + ")", true
+		return o.runtimeOwner.QualifiedHelper(wideIntegerHelper(signed, RuntimeHelperUint64Or, RuntimeHelperInt64Or)) + "(" + left + ", " + right + ")", true
 	default:
 		return "", false
 	}
 }
 
+func wideIntegerHelper(signed bool, unsigned RuntimeHelper, signedHelper RuntimeHelper) RuntimeHelper {
+	if signed {
+		return signedHelper
+	}
+	return unsigned
+}
+
 func (o *LoweringOwner) lowerWideShiftLeftOperand(ctx lowerFileContext, expr ast.Expr, fallback string) string {
 	call, ok := unwrapParenExpr(expr).(*ast.CallExpr)
 	if !ok || len(call.Args) != 1 {
@@ -5647,7 +7283,10 @@ func (o *LoweringOwner) lowerNamedReceiverMethodCall(
 	diagnostics []Diagnostic,
 ) (string, []Diagnostic) {
 	selection := ctx.semPkg.source.TypesInfo.Selections[selector]
-	receiver := receiverNamedType(selection.Recv())
+	receiver := methodReceiverNamedType(selection.Obj())
+	if receiver == nil {
+		receiver = selectedReceiverNamedType(ctx.semPkg.source, selector, selection)
+	}
 	receiverExpr, receiverDiagnostics := o.lowerNamedReceiverForMethod(ctx, selector.X, selection)
 	diagnostics = append(diagnostics, receiverDiagnostics...)
 	allArgs := append([]string{receiverExpr}, args...)
@@ -5655,7 +7294,7 @@ func (o *LoweringOwner) lowerNamedReceiverMethodCall(
 	return o.awaitCallIfNeeded(ctx, selector, call), diagnostics
 }
 
-func (o *LoweringOwner) lowerNilablePointerReceiverMethodCall(
+func (o *LoweringOwner) lowerPointerReceiverMethodCall(
 	ctx lowerFileContext,
 	selector *ast.SelectorExpr,
 	selection *types.Selection,
@@ -5668,9 +7307,6 @@ func (o *LoweringOwner) lowerNilablePointerReceiverMethodCall(
 	if method == nil {
 		return "", nil, false
 	}
-	if !methodAllowsNilReceiver(ctx, method) {
-		return "", nil, false
-	}
 	signature, _ := method.Type().(*types.Signature)
 	if signature == nil || signature.Recv() == nil {
 		return "", nil, false
@@ -5683,6 +7319,16 @@ func (o *LoweringOwner) lowerNilablePointerReceiverMethodCall(
 		return "", nil, false
 	}
 	receiverExpr, diagnostics := o.lowerExpr(ctx, selector.X)
+	if o.receiverUsesOverridePackage(signature.Recv().Type()) {
+		receiverExpr = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<" + o.tsTypeFor(ctx, signature.Recv().Type().(*types.Pointer).Elem()) + ">(" + receiverExpr + ")"
+	}
+	if receiverExpr == o.namedTypeExpr(ctx, receiver) {
+		call := o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+			"<" + o.namedTypeExpr(ctx, receiver) + ">(" + receiverExpr + ")." +
+			methodMemberName(selector.Sel.Name) + "(" + strings.Join(args, ", ") + ")"
+		return call, diagnostics, true
+	}
 	callArgs := append([]string{receiverExpr}, args...)
 	call := o.namedTypeExpr(ctx, receiver) + ".prototype." + selector.Sel.Name + ".call(" + strings.Join(callArgs, ", ") + ")"
 	return call, diagnostics, true
@@ -5783,8 +7429,12 @@ func (o *LoweringOwner) lowerNamedReceiverForMethod(
 		}
 		return o.lowerAddressExpr(ctx, expr)
 	}
-	receiver, diagnostics := o.lowerExpr(ctx, expr)
-	if receiverType != nil && isPointerType(ctx.semPkg.source.TypesInfo.TypeOf(expr)) {
+	receiver, diagnostics := o.lowerMethodReceiverExpr(ctx, expr, selection)
+	selectedType := ctx.semPkg.source.TypesInfo.TypeOf(expr)
+	if index := selection.Index(); len(index) > 1 && !o.receiverUsesOverridePackage(selectedType) {
+		selectedType = promotedMethodReceiverType(selectedType, index[:len(index)-1])
+	}
+	if receiverType != nil && isPointerType(selectedType) {
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + "<" + o.tsTypeFor(ctx, receiverType) + ">(" + receiver + ")", diagnostics
 	}
 	return receiver, diagnostics
@@ -5793,17 +7443,35 @@ func (o *LoweringOwner) lowerNamedReceiverForMethod(
 func (o *LoweringOwner) lowerSelectorExpr(ctx lowerFileContext, expr *ast.SelectorExpr) (string, []Diagnostic) {
 	if ident, ok := expr.X.(*ast.Ident); ok {
 		if pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName); pkgName != nil {
-			if alias := ctx.importNames[pkgName.Name()]; alias != "" {
-				return alias + "." + expr.Sel.Name, nil
+			if alias := importAliasForPkgName(ctx, pkgName); alias != "" {
+				value := alias + "." + expr.Sel.Name
+				obj, _ := ctx.semPkg.source.TypesInfo.Uses[expr.Sel].(*types.Var)
+				if o.packageVarIsLazy(ctx, obj) ||
+					o.packageVarNameIsLazy(ctx, pkgName.Imported().Path(), expr.Sel.Name) {
+					value = alias + "." + packageVarGetterName(expr.Sel.Name) + "()"
+					if (ctx.asyncFunction || ctx.topLevel) &&
+						o.packageVarNameHasAsyncLazyInit(ctx, pkgName.Imported().Path(), expr.Sel.Name) {
+						value = "(await " + alias + "." + packageVarInitName(expr.Sel.Name) + "(), " + value + ")"
+					}
+				}
+				if obj != nil && packageVarReadNeedsPointerValue(obj.Type()) {
+					value = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
+						"<" + o.tsNonNilTypeFor(ctx, obj.Type()) + ">(" + value + ")"
+				}
+				return value, nil
 			}
 		}
 	}
 	if selection := ctx.semPkg.source.TypesInfo.Selections[expr]; selection != nil {
 		switch selection.Kind() {
 		case types.MethodVal:
-			if receiver := receiverNamedType(selection.Recv()); namedNonInterfaceNonStructType(receiver) {
+			namedReceiver := methodReceiverNamedType(selection.Obj())
+			if namedReceiver == nil {
+				namedReceiver = selectedReceiverNamedType(ctx.semPkg.source, expr, selection)
+			}
+			if namedNonInterfaceNonStructType(namedReceiver) {
 				receiverExpr, diagnostics := o.lowerNamedReceiverForMethod(ctx, expr.X, selection)
-				methodExpr := o.methodFunctionExpr(ctx, receiver, selection.Obj(), expr.Sel.Name)
+				methodExpr := o.methodFunctionExpr(ctx, namedReceiver, selection.Obj(), expr.Sel.Name)
 				return o.lowerMethodValueClosure(ctx, selection, receiverExpr, methodExpr, true), diagnostics
 			}
 			receiver, diagnostics := o.lowerMethodReceiverExpr(ctx, expr.X, selection)
@@ -5818,9 +7486,41 @@ func (o *LoweringOwner) lowerSelectorExpr(ctx lowerFileContext, expr *ast.Select
 		}
 	}
 	left, diagnostics := o.lowerExpr(ctx, expr.X)
+	left = parenthesizeAwaitedExpr(left)
 	return left + "." + expr.Sel.Name, diagnostics
 }
 
+func packageVarSelectorNeedsPointerValue(ctx lowerFileContext, expr ast.Expr) bool {
+	selector, ok := ast.Unparen(expr).(*ast.SelectorExpr)
+	if !ok || ctx.semPkg == nil || ctx.semPkg.source == nil {
+		return false
+	}
+	if selection := ctx.semPkg.source.TypesInfo.Selections[selector]; selection != nil {
+		return false
+	}
+	ident, ok := ast.Unparen(selector.X).(*ast.Ident)
+	if !ok {
+		return false
+	}
+	pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+	if importAliasForPkgName(ctx, pkgName) == "" {
+		return false
+	}
+	obj, _ := ctx.semPkg.source.TypesInfo.Uses[selector.Sel].(*types.Var)
+	return obj != nil && packageVarReadNeedsPointerValue(obj.Type())
+}
+
+func packageVarReadNeedsPointerValue(typ types.Type) bool {
+	if typ == nil || isPointerType(typ) {
+		return false
+	}
+	if isStructValueType(typ) {
+		return true
+	}
+	_, ok := types.Unalias(typ).Underlying().(*types.Array)
+	return ok
+}
+
 func (o *LoweringOwner) packageVarSetterForAssignment(ctx lowerFileContext, expr ast.Expr) (string, bool) {
 	if ident, ok := unwrapParenExpr(expr).(*ast.Ident); ok {
 		obj, _ := objectForIdent(ctx, ident).(*types.Var)
@@ -5828,10 +7528,13 @@ func (o *LoweringOwner) packageVarSetterForAssignment(ctx lowerFileContext, expr
 			return "", false
 		}
 		alias := ctx.localAliases[obj]
-		if alias == "" {
-			return "", false
+		if alias != "" {
+			return alias + "." + packageVarSetterName(ident.Name), true
+		}
+		if ctx.lazyPackageVars[obj] {
+			return packageVarSetterName(ident.Name), true
 		}
-		return alias + "." + packageVarSetterName(ident.Name), true
+		return "", false
 	}
 	selector, ok := unwrapParenExpr(expr).(*ast.SelectorExpr)
 	if !ok {
@@ -5845,7 +7548,7 @@ func (o *LoweringOwner) packageVarSetterForAssignment(ctx lowerFileContext, expr
 	if pkgName == nil {
 		return "", false
 	}
-	alias := ctx.importNames[pkgName.Name()]
+	alias := importAliasForPkgName(ctx, pkgName)
 	if alias == "" {
 		return "", false
 	}
@@ -5856,6 +7559,36 @@ func (o *LoweringOwner) packageVarSetterForAssignment(ctx lowerFileContext, expr
 	return alias + "." + packageVarSetterName(selector.Sel.Name), true
 }
 
+func (o *LoweringOwner) packageVarAssignmentValue(
+	ctx lowerFileContext,
+	lhs ast.Expr,
+	targetType types.Type,
+	right string,
+	tok token.Token,
+) (string, bool) {
+	if tok == token.ASSIGN {
+		return right, true
+	}
+	left, diagnostics := o.lowerExpr(ctx, lhs)
+	if len(diagnostics) != 0 {
+		return "", false
+	}
+	if tok == token.AND_NOT_ASSIGN {
+		return left + " & ~(" + right + ")", true
+	}
+	if helper, ok := wideIntegerAssignHelper(targetType, tok); ok {
+		return o.runtimeOwner.QualifiedHelper(helper) + "(" + left + ", " + right + ")", true
+	}
+	if value, ok := integerQuotientAssignValueExpr(targetType, left, right, tok); ok {
+		return value, true
+	}
+	op := tok.String()
+	if before, ok := strings.CutSuffix(op, "="); ok {
+		op = before
+	}
+	return left + " " + op + " " + right, true
+}
+
 func (o *LoweringOwner) tsPackageVarSetterValueTypeFor(ctx lowerFileContext, typ types.Type) string {
 	if signature := unnamedSignatureForType(typ); signature != nil {
 		return o.tsAsyncCompatibleFunctionTypeFor(ctx, signature)
@@ -5870,25 +7603,28 @@ func (o *LoweringOwner) lowerFieldSelectionExpr(
 	address bool,
 ) (string, []Diagnostic) {
 	receiver, diagnostics := o.lowerFieldReceiverExpr(ctx, expr.X)
+	receiver = parenthesizeAwaitedExpr(receiver)
 	index := selection.Index()
 	if len(index) == 0 {
+		fieldName := tsStructFieldName(expr.Sel.Name, 0)
 		if address {
-			return o.lowerFieldAddressExpr(ctx, receiver, ctx.semPkg.source.TypesInfo.TypeOf(expr.X), expr.Sel.Name), diagnostics
+			return o.lowerFieldAddressExpr(ctx, receiver, ctx.semPkg.source.TypesInfo.TypeOf(expr.X), fieldName), diagnostics
 		}
-		return receiver + "." + expr.Sel.Name, diagnostics
+		return receiver + "." + fieldName, diagnostics
 	}
 
 	typ := derefPointerType(ctx.semPkg.source.TypesInfo.TypeOf(expr.X))
 	for idx, fieldIndex := range index {
 		structType := structUnderlyingType(typ)
 		if structType == nil || fieldIndex < 0 || fieldIndex >= structType.NumFields() {
+			fieldName := tsStructFieldName(expr.Sel.Name, 0)
 			if address {
-				return receiver + "._fields." + expr.Sel.Name, diagnostics
+				return receiver + "._fields." + fieldName, diagnostics
 			}
-			return receiver + "." + expr.Sel.Name, diagnostics
+			return receiver + "." + fieldName, diagnostics
 		}
 		field := structType.Field(fieldIndex)
-		name := field.Name()
+		name := tsStructFieldName(field.Name(), fieldIndex)
 		if idx == len(index)-1 {
 			if address {
 				return o.lowerFieldAddressExpr(ctx, receiver, typ, name), diagnostics
@@ -5906,9 +7642,9 @@ func (o *LoweringOwner) lowerFieldSelectionExpr(
 	}
 
 	if address {
-		return o.lowerFieldAddressExpr(ctx, receiver, typ, expr.Sel.Name), diagnostics
+		return o.lowerFieldAddressExpr(ctx, receiver, typ, tsStructFieldName(expr.Sel.Name, 0)), diagnostics
 	}
-	return receiver + "." + expr.Sel.Name, diagnostics
+	return receiver + "." + tsStructFieldName(expr.Sel.Name, 0), diagnostics
 }
 
 func (o *LoweringOwner) lowerFieldAddressExpr(ctx lowerFileContext, receiver string, typ types.Type, fieldName string) string {
@@ -5980,9 +7716,11 @@ func (o *LoweringOwner) lowerFieldReceiverExpr(ctx lowerFileContext, expr ast.Ex
 		return o.lowerPointerValueExpr(ctx, expr)
 	}
 	value, diagnostics := o.lowerExpr(ctx, expr)
+	value = parenthesizeAwaitedExpr(value)
 	if obj := objectForValueExpr(ctx, expr); obj != nil &&
-		ctx.model.needsVarRef[obj] &&
+		objectNeedsVarRef(ctx, obj) &&
 		isStructValueType(obj.Type()) &&
+		!packageVarSelectorNeedsPointerValue(ctx, expr) &&
 		fieldReceiverNeedsVarRefValue(ctx, expr, obj) {
 		return value + ".value", diagnostics
 	}
@@ -5993,7 +7731,16 @@ func fieldReceiverNeedsVarRefValue(ctx lowerFileContext, expr ast.Expr, obj type
 	if _, ok := expr.(*ast.Ident); !ok {
 		return true
 	}
-	return ctx.localAliases[obj] != "" || ctx.identAliases[obj] != ""
+	if ctx.identAliases[obj] != "" {
+		return !ctx.identAliasRefs[obj]
+	}
+	if ctx.localAliases[obj] != "" {
+		if varObj, ok := obj.(*types.Var); ok && packageVarReadNeedsPointerValue(varObj.Type()) {
+			return false
+		}
+		return !ctx.lazyPackageVars[obj]
+	}
+	return false
 }
 
 func (o *LoweringOwner) lowerMethodReceiverExpr(
@@ -6016,14 +7763,24 @@ func (o *LoweringOwner) lowerMethodReceiverExpr(
 		receiver, diagnostics = o.lowerPointerValueExpr(ctx, expr)
 	} else {
 		receiver, diagnostics = o.lowerExpr(ctx, expr)
+		receiver = parenthesizeAwaitedExpr(receiver)
 	}
 	receiverType := ctx.semPkg.source.TypesInfo.TypeOf(expr)
+	if !receiverPointer {
+		if obj := objectForValueExpr(ctx, expr); obj != nil &&
+			objectNeedsVarRef(ctx, obj) &&
+			isStructValueType(obj.Type()) &&
+			!packageVarSelectorNeedsPointerValue(ctx, expr) &&
+			fieldReceiverNeedsVarRefValue(ctx, expr, obj) {
+			receiver += ".value"
+		}
+	}
 	if index := selection.Index(); len(index) > 1 && !o.receiverUsesOverridePackage(receiverType) {
 		receiver, receiverType = o.lowerPromotedMethodReceiver(ctx, receiver, receiverType, index[:len(index)-1])
 	}
 	if receiverPointer {
 		if obj := objectForValueExpr(ctx, expr); obj != nil &&
-			ctx.model.needsVarRef[obj] &&
+			objectNeedsVarRef(ctx, obj) &&
 			isStructValueType(obj.Type()) &&
 			fieldReceiverNeedsVarRefValue(ctx, expr, obj) {
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) +
@@ -6074,16 +7831,38 @@ func (o *LoweringOwner) lowerPromotedMethodReceiver(
 	return receiver, typ
 }
 
+func promotedMethodReceiverType(typ types.Type, index []int) types.Type {
+	typ = derefPointerType(typ)
+	for _, fieldIndex := range index {
+		structType := structUnderlyingType(typ)
+		if structType == nil || fieldIndex < 0 || fieldIndex >= structType.NumFields() {
+			return typ
+		}
+		typ = structType.Field(fieldIndex).Type()
+		if pointer, ok := types.Unalias(typ).Underlying().(*types.Pointer); ok {
+			typ = pointer.Elem()
+		}
+	}
+	return typ
+}
+
 func (o *LoweringOwner) lowerAssignmentTarget(
 	ctx lowerFileContext,
 	expr ast.Expr,
 	declare bool,
 ) (string, []Diagnostic) {
-	switch typed := expr.(type) {
+	switch typed := unwrapParenExpr(expr).(type) {
 	case *ast.Ident:
 		if declare {
 			return o.lowerIdent(ctx, typed, true), nil
 		}
+		if obj := objectForIdent(ctx, typed); obj != nil && ctx.lazyPackageVars[obj] {
+			target := o.lowerIdent(ctx, typed, true)
+			if ctx.model.needsVarRef[obj] {
+				target += ".value"
+			}
+			return target, nil
+		}
 		return o.lowerIdent(ctx, typed, false), nil
 	case *ast.StarExpr:
 		return o.lowerPointerValueExpr(ctx, typed.X)
@@ -6093,7 +7872,10 @@ func (o *LoweringOwner) lowerAssignmentTarget(
 }
 
 func (o *LoweringOwner) lowerAddressExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
-	switch typed := expr.(type) {
+	if value, ok := o.lowerPackageVarAddressExpr(ctx, expr); ok {
+		return value, nil
+	}
+	switch typed := unwrapParenExpr(expr).(type) {
 	case *ast.Ident:
 		return o.lowerIdent(ctx, typed, true), nil
 	case *ast.CompositeLit:
@@ -6115,6 +7897,55 @@ func (o *LoweringOwner) lowerAddressExpr(ctx lowerFileContext, expr ast.Expr) (s
 	}
 }
 
+func (o *LoweringOwner) lowerPackageVarAddressExpr(ctx lowerFileContext, expr ast.Expr) (string, bool) {
+	switch typed := unwrapParenExpr(expr).(type) {
+	case *ast.Ident:
+		obj, _ := objectForIdent(ctx, typed).(*types.Var)
+		if obj == nil || !objectNeedsVarRef(ctx, obj) {
+			return "", false
+		}
+		return o.lowerIdent(ctx, typed, true), true
+	case *ast.SelectorExpr:
+		if selection := ctx.semPkg.source.TypesInfo.Selections[typed]; selection != nil {
+			return "", false
+		}
+		ident, ok := unwrapParenExpr(typed.X).(*ast.Ident)
+		if !ok {
+			return "", false
+		}
+		pkgName, _ := objectForIdent(ctx, ident).(*types.PkgName)
+		if pkgName == nil {
+			return "", false
+		}
+		alias := importAliasForPkgName(ctx, pkgName)
+		if alias == "" {
+			return "", false
+		}
+		obj, _ := ctx.semPkg.source.TypesInfo.Uses[typed.Sel].(*types.Var)
+		if obj == nil || !objectNeedsVarRef(ctx, obj) {
+			return "", false
+		}
+		return alias + "." + typed.Sel.Name, true
+	default:
+		return "", false
+	}
+}
+
+func importAliasForPkgName(ctx lowerFileContext, pkgName *types.PkgName) string {
+	if pkgName == nil {
+		return ""
+	}
+	if alias := ctx.importObjects[pkgName]; alias != "" {
+		return alias
+	}
+	if imported := pkgName.Imported(); imported != nil {
+		if alias := ctx.importPaths[imported.Path()]; alias != "" {
+			return alias
+		}
+	}
+	return ctx.importNames[pkgName.Name()]
+}
+
 func (o *LoweringOwner) lowerIndexAddressExpr(ctx lowerFileContext, expr *ast.IndexExpr) (string, []Diagnostic) {
 	target, targetDiagnostics := o.lowerExpr(ctx, expr.X)
 	index, indexDiagnostics := o.lowerExpr(ctx, expr.Index)
@@ -6171,46 +8002,240 @@ func (o *LoweringOwner) lowerIndexAddressIntegerExpr(
 	if isStringType(targetType) || isMapType(targetType) {
 		return "", diagnostics, false
 	}
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexAddress) +
-		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ")", diagnostics, true
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperIndexAddress) +
+		"(" + o.lowerIndexTarget(ctx, target, targetType) + ", " + index + ")", diagnostics, true
+}
+
+func (o *LoweringOwner) lowerPointerValueExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
+	if value, diagnostics, ok := o.lowerUnsafeStringPointerValue(ctx, expr); ok {
+		return value, diagnostics
+	}
+	if value, diagnostics, ok := o.lowerUnsafeStringByteSlicePointerValue(ctx, expr); ok {
+		return value, diagnostics
+	}
+	base, diagnostics := o.lowerExpr(ctx, expr)
+	typeArg := ""
+	if pointer, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr)).Underlying().(*types.Pointer); ok {
+		typeArg = "<" + o.tsTypeFor(ctx, pointer.Elem()) + ">"
+	}
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + typeArg + "(" + base + ")", diagnostics
+}
+
+func (o *LoweringOwner) lowerUnsafeStringPointerValue(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic, bool) {
+	call, ok := unwrapParenExpr(expr).(*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 || !isStringType(targetPointer.Elem()) {
+		return "", nil, false
+	}
+	unsafeCall, ok := unwrapParenExpr(call.Args[0]).(*ast.CallExpr)
+	unsafeTargetType := typeFromExpr(ctx, unsafeCall.Fun)
+	if !ok || len(unsafeCall.Args) != 1 || unsafeTargetType == nil || !isUnsafePointerType(unsafeTargetType) {
+		return "", nil, false
+	}
+	address, ok := unwrapParenExpr(unsafeCall.Args[0]).(*ast.UnaryExpr)
+	if !ok || address.Op != token.AND || !isByteSliceType(ctx.semPkg.source.TypesInfo.TypeOf(address.X)) {
+		return "", nil, false
+	}
+	value, diagnostics := o.lowerExpr(ctx, address.X)
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperBytesToString) + "(" + value + ")", diagnostics, true
+}
+
+func (o *LoweringOwner) lowerUnsafeStringByteSlicePointerValue(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic, bool) {
+	call, ok := unwrapParenExpr(expr).(*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 || !isByteSliceType(targetPointer.Elem()) {
+		return "", nil, false
+	}
+	unsafeCall, ok := unwrapParenExpr(call.Args[0]).(*ast.CallExpr)
+	unsafeTargetType := typeFromExpr(ctx, unsafeCall.Fun)
+	if !ok || len(unsafeCall.Args) != 1 || unsafeTargetType == nil || !isUnsafePointerType(unsafeTargetType) {
+		return "", nil, false
+	}
+	address, ok := unwrapParenExpr(unsafeCall.Args[0]).(*ast.UnaryExpr)
+	if !ok || address.Op != token.AND {
+		return "", nil, false
+	}
+	source, ok := localStringSliceHeaderSource(ctx, address.X)
+	if !ok {
+		return "", nil, false
+	}
+	value, diagnostics := o.lowerExpr(ctx, source)
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperStringToBytes) + "(" + value + ")", diagnostics, true
+}
+
+func (o *LoweringOwner) lowerReflectHeaderPointerConversion(
+	ctx lowerFileContext,
+	targetType types.Type,
+	expr ast.Expr,
+) (string, []Diagnostic, bool) {
+	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" {
+		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
+	}
+	switch header.Obj().Name() {
+	case "StringHeader":
+		if !isStringType(ctx.semPkg.source.TypesInfo.TypeOf(address.X)) {
+			return "", nil, false
+		}
+		value, diagnostics := o.lowerAddressedValueRef(ctx, address.X)
+		helper := o.runtimeOwner.QualifiedHelper(RuntimeHelperStringHeaderRef) + "(" + value + ")"
+		return "(" + helper + " as unknown as " + o.tsTypeFor(ctx, targetType) + ")", diagnostics, true
+	case "SliceHeader":
+		if !isByteSliceType(ctx.semPkg.source.TypesInfo.TypeOf(address.X)) {
+			return "", nil, false
+		}
+		value, diagnostics := o.lowerAddressedValueRef(ctx, address.X)
+		helper := o.runtimeOwner.QualifiedHelper(RuntimeHelperSliceHeaderRef) + "(" + value + ")"
+		return "(" + helper + " as unknown as " + o.tsTypeFor(ctx, targetType) + ")", diagnostics, true
+	default:
+		return "", nil, false
+	}
+}
+
+func (o *LoweringOwner) lowerUnsafeArrayPointerConversion(
+	ctx lowerFileContext,
+	targetType types.Type,
+	expr ast.Expr,
+) (string, []Diagnostic, bool) {
+	targetPointer, _ := types.Unalias(targetType).Underlying().(*types.Pointer)
+	if targetPointer == nil {
+		return "", nil, false
+	}
+	array, _ := types.Unalias(targetPointer.Elem()).Underlying().(*types.Array)
+	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)
+	if !ok {
+		return "", nil, false
+	}
+	ref, diagnostics := o.lowerAddressExpr(ctx, index)
+	helper := o.runtimeOwner.QualifiedHelper(RuntimeHelperArrayPointerFromIndexRef) +
+		"<" + o.tsTypeFor(ctx, array.Elem()) + ">(" + ref + ", " + strconv.FormatInt(array.Len(), 10) + ")"
+	return "(" + helper + " as unknown as " + o.tsTypeFor(ctx, targetType) + ")", diagnostics, 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] {
+			return o.lowerIdent(ctx, ident, true), nil
+		}
+	}
+	value, diagnostics := o.lowerExpr(ctx, expr)
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperVarRef) + "(" + value + ")", diagnostics
 }
 
-func (o *LoweringOwner) lowerPointerValueExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
-	if value, diagnostics, ok := o.lowerUnsafeStringPointerValue(ctx, expr); ok {
-		return value, diagnostics
+func localStringSliceHeaderSource(ctx lowerFileContext, expr ast.Expr) (ast.Expr, bool) {
+	lit, ok := unwrapParenExpr(expr).(*ast.CompositeLit)
+	if !ok {
+		return nil, false
 	}
-	base, diagnostics := o.lowerExpr(ctx, expr)
-	typeArg := ""
-	if pointer, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(expr)).Underlying().(*types.Pointer); ok {
-		typeArg = "<" + o.tsTypeFor(ctx, pointer.Elem()) + ">"
+	structType, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(lit)).Underlying().(*types.Struct)
+	if !ok || structType.NumFields() != 2 {
+		return nil, false
 	}
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + typeArg + "(" + base + ")", diagnostics
+	if !isStringType(structType.Field(0).Type()) || !isIntegerType(structType.Field(1).Type()) {
+		return nil, false
+	}
+	var source ast.Expr
+	var capacity ast.Expr
+	for idx, elt := range lit.Elts {
+		fieldIndex := idx
+		valueExpr := elt
+		if keyed, ok := elt.(*ast.KeyValueExpr); ok {
+			valueExpr = keyed.Value
+			ident, ok := keyed.Key.(*ast.Ident)
+			if !ok {
+				return nil, false
+			}
+			fieldIndex = -1
+			for index := range structType.NumFields() {
+				if structType.Field(index).Name() == ident.Name {
+					fieldIndex = index
+					break
+				}
+			}
+			if fieldIndex < 0 {
+				return nil, false
+			}
+		}
+		switch fieldIndex {
+		case 0:
+			source = valueExpr
+		case 1:
+			capacity = valueExpr
+		}
+	}
+	if source == nil || capacity == nil {
+		return nil, false
+	}
+	if !isStringType(ctx.semPkg.source.TypesInfo.TypeOf(source)) ||
+		!isIntegerType(ctx.semPkg.source.TypesInfo.TypeOf(capacity)) {
+		return nil, false
+	}
+	if !isLenCallOfExpr(ctx, capacity, source) {
+		return nil, false
+	}
+	return source, true
 }
 
-func (o *LoweringOwner) lowerUnsafeStringPointerValue(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic, bool) {
+func isLenCallOfExpr(ctx lowerFileContext, expr ast.Expr, target ast.Expr) bool {
 	call, ok := unwrapParenExpr(expr).(*ast.CallExpr)
 	if !ok || len(call.Args) != 1 {
-		return "", nil, false
-	}
-	targetType := typeFromExpr(ctx, call.Fun)
-	if targetType == nil {
-		return "", nil, false
+		return false
 	}
-	targetPointer, _ := types.Unalias(targetType).Underlying().(*types.Pointer)
-	if targetPointer == nil || !isStringType(targetPointer.Elem()) {
-		return "", nil, false
+	ident, ok := unwrapParenExpr(call.Fun).(*ast.Ident)
+	if !ok || ident.Name != "len" {
+		return false
 	}
-	unsafeCall, ok := unwrapParenExpr(call.Args[0]).(*ast.CallExpr)
-	unsafeTargetType := typeFromExpr(ctx, unsafeCall.Fun)
-	if !ok || len(unsafeCall.Args) != 1 || unsafeTargetType == nil || !isUnsafePointerType(unsafeTargetType) {
-		return "", nil, false
+	if objectForIdent(ctx, ident) != types.Universe.Lookup("len") {
+		return false
 	}
-	address, ok := unwrapParenExpr(unsafeCall.Args[0]).(*ast.UnaryExpr)
-	if !ok || address.Op != token.AND || !isByteSliceType(ctx.semPkg.source.TypesInfo.TypeOf(address.X)) {
-		return "", nil, false
+	return sameLoweredSourceExpr(ctx, call.Args[0], target)
+}
+
+func sameLoweredSourceExpr(ctx lowerFileContext, left ast.Expr, right ast.Expr) bool {
+	left = unwrapParenExpr(left)
+	right = unwrapParenExpr(right)
+	if leftIdent, ok := left.(*ast.Ident); ok {
+		rightIdent, ok := right.(*ast.Ident)
+		return ok && objectForIdent(ctx, leftIdent) == objectForIdent(ctx, rightIdent)
 	}
-	value, diagnostics := o.lowerExpr(ctx, address.X)
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperBytesToString) + "(" + value + ")", diagnostics, true
+	return false
 }
 
 func (o *LoweringOwner) lowerPointerStorageExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
@@ -6362,6 +8387,13 @@ func (o *LoweringOwner) lowerCompositeLit(
 	lit *ast.CompositeLit,
 	markStruct bool,
 ) (string, []Diagnostic) {
+	if len(lit.Elts) == 0 {
+		if typeParam, ok := types.Unalias(ctx.semPkg.source.TypesInfo.TypeOf(lit)).(*types.TypeParam); ok {
+			if typeParamInScope(ctx, typeParam) {
+				return o.lowerDeclarationZeroValueExpr(ctx, typeParam), nil
+			}
+		}
+	}
 	named := namedStructType(ctx.semPkg.source.TypesInfo.TypeOf(lit))
 	if named != nil {
 		return o.lowerStructCompositeLit(ctx, lit, named, markStruct)
@@ -6402,6 +8434,7 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 ) (string, []Diagnostic) {
 	structType, _ := named.Underlying().(*types.Struct)
 	fields := make([]string, 0, len(lit.Elts))
+	var prelude []string
 	var diagnostics []Diagnostic
 	for idx, elt := range lit.Elts {
 		fieldName := ""
@@ -6410,9 +8443,13 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 		if keyed, ok := elt.(*ast.KeyValueExpr); ok {
 			valueExpr = keyed.Value
 			if ident, ok := keyed.Key.(*ast.Ident); ok {
-				fieldName = ident.Name
-				if field := fieldByName(structType, fieldName); field != nil {
-					fieldType = field.Type()
+				for index := range structType.NumFields() {
+					field := structType.Field(index)
+					if field.Name() == ident.Name {
+						fieldName = tsStructFieldName(field.Name(), index)
+						fieldType = field.Type()
+						break
+					}
 				}
 			}
 		} else if idx < structType.NumFields() {
@@ -6427,6 +8464,11 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 		value, valueDiagnostics := o.lowerExpr(ctx, valueExpr)
 		diagnostics = append(diagnostics, valueDiagnostics...)
 		value = o.lowerValueForTarget(ctx, valueExpr, fieldType, value)
+		if compositeLiteralFieldNeedsPreEval(ctx, valueExpr) {
+			temp := ctx.tempName("LiteralField")
+			prelude = append(prelude, "const "+temp+" = "+value)
+			value = temp
+		}
 		fields = append(fields, fieldName+": "+value)
 	}
 
@@ -6437,9 +8479,30 @@ func (o *LoweringOwner) lowerStructCompositeLit(
 	if markStruct {
 		expr = o.runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue) + "(" + expr + ")"
 	}
+	if len(prelude) != 0 {
+		body := strings.Join(prelude, "; ") + "; return " + expr
+		if strings.Contains(body, "await ") {
+			return "(await (async () => { " + body + " })())", diagnostics
+		}
+		return "(() => { " + body + " })()", diagnostics
+	}
 	return expr, diagnostics
 }
 
+func compositeLiteralFieldNeedsPreEval(ctx lowerFileContext, expr ast.Expr) bool {
+	switch typed := unwrapParenExpr(expr).(type) {
+	case *ast.CallExpr:
+		if ident, ok := typed.Fun.(*ast.Ident); ok && isBuiltinCallTarget(ctx, ident) {
+			return false
+		}
+		return typeFromExpr(ctx, typed.Fun) == nil
+	case *ast.UnaryExpr:
+		return typed.Op == token.ARROW
+	default:
+		return false
+	}
+}
+
 func (o *LoweringOwner) lowerAnonymousStructCompositeLit(
 	ctx lowerFileContext,
 	lit *ast.CompositeLit,
@@ -6460,10 +8523,10 @@ func (o *LoweringOwner) lowerAnonymousStructCompositeLit(
 		if keyed, ok := elt.(*ast.KeyValueExpr); ok {
 			valueExpr = keyed.Value
 			if ident, ok := keyed.Key.(*ast.Ident); ok {
-				fieldName = ident.Name
 				for index := range structType.NumFields() {
 					field := structType.Field(index)
-					if field.Name() == fieldName {
+					if field.Name() == ident.Name {
+						fieldName = tsStructFieldName(field.Name(), index)
 						fieldIndex = index
 						fieldType = field.Type()
 						break
@@ -6571,7 +8634,7 @@ func (o *LoweringOwner) lowerSliceCompositeLit(
 		nextIndex = index + 1
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperArrayToSlice) +
-		"<" + o.tsTypeFor(ctx, slice.Elem()) + ">([" + strings.Join(values, ", ") + "])", diagnostics
+		"<" + o.tsSliceElemTypeFor(ctx, slice.Elem()) + ">([" + strings.Join(values, ", ") + "])", diagnostics
 }
 
 func (o *LoweringOwner) lowerMapCompositeLit(
@@ -6602,7 +8665,7 @@ func (o *LoweringOwner) lowerTypeAssertExpr(ctx lowerFileContext, expr *ast.Type
 	targetType := ctx.semPkg.source.TypesInfo.TypeOf(expr.Type)
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperMustTypeAssert) +
 		"<" + o.tsTypeAssertionTypeFor(ctx, targetType) + ">(" +
-		value + ", " + o.runtimeTypeInfoExpr(targetType) + ")", diagnostics
+		value + ", " + o.runtimeTypeAssertInfoExpr(ctx, targetType) + ")", diagnostics
 }
 
 func (o *LoweringOwner) lowerTupleExpr(ctx lowerFileContext, expr ast.Expr) (string, []Diagnostic) {
@@ -6612,7 +8675,7 @@ func (o *LoweringOwner) lowerTupleExpr(ctx lowerFileContext, expr ast.Expr) (str
 		targetType := ctx.semPkg.source.TypesInfo.TypeOf(typed.Type)
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeAssertTuple) +
 			"<" + o.tsTypeAssertionTypeFor(ctx, targetType) + ">(" +
-			value + ", " + o.runtimeTypeInfoExpr(targetType) + ")", diagnostics
+			value + ", " + o.runtimeTypeAssertInfoExpr(ctx, targetType) + ")", diagnostics
 	case *ast.IndexExpr:
 		if isMapType(ctx.semPkg.source.TypesInfo.TypeOf(typed.X)) {
 			target, targetDiagnostics := o.lowerExpr(ctx, typed.X)
@@ -6644,6 +8707,9 @@ func (o *LoweringOwner) lowerValueForTarget(
 ) string {
 	sourceType := ctx.semPkg.source.TypesInfo.TypeOf(expr)
 	if isComplexType(targetType) {
+		if isComplexType(sourceType) {
+			return value
+		}
 		if isRealNumericConstantExpr(ctx, expr) {
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperComplex) + "(" + value + ", 0)"
 		}
@@ -6697,6 +8763,14 @@ func isRealNumericConstantExpr(ctx lowerFileContext, expr ast.Expr) bool {
 	}
 }
 
+func lowerPrefixUnaryExpr(op token.Token, value string) string {
+	prefix := op.String()
+	if (op == token.SUB && strings.HasPrefix(value, "-")) || (op == token.ADD && strings.HasPrefix(value, "+")) {
+		return prefix + "(" + value + ")"
+	}
+	return prefix + value
+}
+
 func (o *LoweringOwner) lowerValueForTargetTypes(
 	ctx lowerFileContext,
 	targetType types.Type,
@@ -6704,6 +8778,9 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 	value string,
 	cloneStructValue bool,
 ) string {
+	if targetType == nil || sourceType == nil {
+		return value
+	}
 	if isFunctionType(targetType) && isUntypedNilType(sourceType) {
 		return "(" + value + " as " + o.tsTypeFor(ctx, targetType) + ")"
 	}
@@ -6734,6 +8811,15 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 		return o.lowerStructClone(value)
 	}
 	if isIntegerType(targetType) && isIntegerType(sourceType) {
+		if isBasicFixedWideIntegerType(targetType) {
+			if bits, ok := unsignedIntegerBits(targetType); ok {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
+					"(" + value + ", " + strconv.Itoa(bits) + ")"
+			}
+			if _, ok := signedIntegerBits(targetType); ok {
+				return o.runtimeOwner.QualifiedHelper(RuntimeHelperInt) + "(" + value + ")"
+			}
+		}
 		if bits, ok := unsignedIntegerBits(targetType); ok && bits < 64 {
 			return o.runtimeOwner.QualifiedHelper(RuntimeHelperUint) +
 				"(" + value + ", " + strconv.Itoa(bits) + ")"
@@ -6751,12 +8837,28 @@ func (o *LoweringOwner) lowerValueForTargetTypes(
 	return value
 }
 
+func isBasicFixedWideIntegerType(typ types.Type) bool {
+	basic, ok := types.Unalias(typ).(*types.Basic)
+	if !ok {
+		return false
+	}
+	switch basic.Kind() {
+	case types.Int64, types.Uint64, types.Uintptr:
+		return true
+	default:
+		return false
+	}
+}
+
 func (o *LoweringOwner) lowerNamedValueInterfaceWrapper(
 	ctx lowerFileContext,
 	targetType types.Type,
 	sourceType types.Type,
 	value string,
 ) string {
+	if targetType == nil || sourceType == nil {
+		return ""
+	}
 	if !isInterfaceType(targetType) || isInterfaceType(sourceType) {
 		return ""
 	}
@@ -6794,8 +8896,9 @@ func (o *LoweringOwner) lowerPrimitiveErrorWrapper(ctx lowerFileContext, sourceT
 	if fn == nil {
 		return ""
 	}
-	return o.runtimeOwner.QualifiedHelper(RuntimeHelperWrapPrimitiveError) +
-		"(" + value + ", " + o.methodFunctionExpr(ctx, named, fn, "Error") + ")"
+	return o.runtimeOwner.QualifiedHelper(RuntimeHelperNamedValueInterfaceValue) +
+		"<$.GoError>(" + value + ", " + strconv.Quote(goRuntimeTypeString(sourceType)) +
+		", {\"Error\": " + o.methodFunctionExpr(ctx, named, fn, "Error") + "})"
 }
 
 func (o *LoweringOwner) lowerStructClone(value string) string {
@@ -6805,13 +8908,16 @@ func (o *LoweringOwner) lowerStructClone(value string) string {
 
 func (o *LoweringOwner) lowerZeroValueExpr(typ types.Type) string {
 	if named := namedStructType(typ); named != nil && isStructValueType(typ) {
-		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue) + "(new " + named.Obj().Name() + "())"
+		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue) + "(new " + safeIdentifier(named.Obj().Name()) + "())"
 	}
 	return zeroValueExpr(typ)
 }
 
 func (o *LoweringOwner) lowerZeroValueExprFor(ctx lowerFileContext, typ types.Type) string {
 	if named := namedStructType(typ); named != nil && isStructValueType(typ) {
+		if crossPackageUnexportedNamedType(ctx, named) {
+			return "undefined as any"
+		}
 		return o.runtimeOwner.QualifiedHelper(RuntimeHelperMarkAsStructValue) + "(new " + o.namedTypeExpr(ctx, named) + "())"
 	}
 	switch typed := types.Unalias(typ).Underlying().(type) {
@@ -6859,7 +8965,7 @@ func (o *LoweringOwner) lowerDeclarationZeroValueExpr(ctx lowerFileContext, typ
 		}
 		return value
 	}
-	if !signatureHasTypeParam(ctx.signature, typeParam) {
+	if !typeParamInScope(ctx, typeParam) {
 		return zeroValueExpr(typ)
 	}
 	return o.runtimeOwner.QualifiedHelper(RuntimeHelperGenericZero) +
@@ -6870,6 +8976,15 @@ func (o *LoweringOwner) runtimeTypeInfoExpr(typ types.Type) string {
 	return o.runtimeTypeInfoExprWithSeen(typ, make(map[types.Type]bool))
 }
 
+func (o *LoweringOwner) runtimeTypeAssertInfoExpr(ctx lowerFileContext, typ types.Type) string {
+	typeParam, ok := types.Unalias(typ).(*types.TypeParam)
+	if !ok || !typeParamInScope(ctx, typeParam) {
+		return o.runtimeTypeInfoExpr(typ)
+	}
+	return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "]?.type ?? " +
+		o.runtimeTypeInfoExpr(typ)
+}
+
 func (o *LoweringOwner) runtimeTypeInfoExprWithSeen(typ types.Type, seen map[types.Type]bool) string {
 	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
 	if typ == nil {
@@ -6890,20 +9005,14 @@ func (o *LoweringOwner) runtimeTypeInfoExprWithSeen(typ types.Type, seen map[typ
 		return o.runtimeFunctionTypeInfoWithSeen(named.Underlying().(*types.Signature), runtimeNamedTypeName(named), seen)
 	}
 	if named := namedNonStructType(typ); named != nil {
+		if basic, ok := types.Unalias(named.Underlying()).(*types.Basic); ok {
+			return runtimeBasicTypeInfoExpr(typeKind, basic, runtimeNamedTypeName(named))
+		}
 		return strconv.Quote(runtimeNamedTypeName(named))
 	}
 	switch typed := types.Unalias(typ).Underlying().(type) {
 	case *types.Basic:
-		switch {
-		case typed.Info()&types.IsBoolean != 0:
-			return "{ kind: " + typeKind + ".Basic, name: \"bool\" }"
-		case typed.Info()&types.IsString != 0:
-			return "{ kind: " + typeKind + ".Basic, name: \"string\" }"
-		case typed.Info()&types.IsNumeric != 0:
-			return "{ kind: " + typeKind + ".Basic, name: \"" + basicRuntimeName(typed) + "\" }"
-		default:
-			return "{ kind: " + typeKind + ".Basic, name: \"unknown\" }"
-		}
+		return runtimeBasicTypeInfoExpr(typeKind, typed, "")
 	case *types.Pointer:
 		return "{ kind: " + typeKind + ".Pointer, elemType: " + o.runtimeTypeInfoExprWithSeen(typed.Elem(), seen) + " }"
 	case *types.Struct:
@@ -6926,6 +9035,23 @@ func (o *LoweringOwner) runtimeTypeInfoExprWithSeen(typ types.Type, seen map[typ
 	}
 }
 
+func runtimeBasicTypeInfoExpr(typeKind string, basic *types.Basic, typeName string) string {
+	name := "unknown"
+	switch {
+	case basic.Info()&types.IsBoolean != 0:
+		name = "bool"
+	case basic.Info()&types.IsString != 0:
+		name = "string"
+	case basic.Info()&types.IsNumeric != 0:
+		name = basicRuntimeName(basic)
+	}
+	parts := []string{"kind: " + typeKind + ".Basic", "name: " + strconv.Quote(name)}
+	if typeName != "" {
+		parts = append(parts, "typeName: "+strconv.Quote(typeName))
+	}
+	return "{ " + strings.Join(parts, ", ") + " }"
+}
+
 func (o *LoweringOwner) shallowRuntimeTypeInfoExpr(typ types.Type) string {
 	typeKind := o.runtimeOwner.QualifiedHelper(RuntimeHelperTypeKind)
 	switch types.Unalias(typ).Underlying().(type) {
@@ -6998,7 +9124,8 @@ func (o *LoweringOwner) runtimeFunctionTypeInfoWithSeen(signature *types.Signatu
 	if signature.Variadic() {
 		parts = append(parts, "isVariadic: true")
 	}
-	return "{ " + strings.Join(parts, ", ") + " }"
+	runtimePackage := strings.TrimSuffix(typeKind, ".TypeKind")
+	return "({ " + strings.Join(parts, ", ") + " } as " + runtimePackage + ".FunctionTypeInfo)"
 }
 
 func (o *LoweringOwner) runtimeSignatureTypes(tuple *types.Tuple, seen map[types.Type]bool) string {
@@ -7012,20 +9139,11 @@ func (o *LoweringOwner) runtimeSignatureTypes(tuple *types.Tuple, seen map[types
 	return "[" + strings.Join(types, ", ") + "]"
 }
 
-func fieldByName(structType *types.Struct, name string) *types.Var {
-	for field := range structType.Fields() {
-		if field.Name() == name {
-			return field
-		}
-	}
-	return nil
-}
-
 func tsStructFieldName(name string, idx int) string {
 	if name == "_" {
 		return "_blank" + strconv.Itoa(idx)
 	}
-	return name
+	return safeIdentifier(name)
 }
 
 func shouldCloneStructValue(expr ast.Expr) bool {
@@ -7076,6 +9194,11 @@ func (o *LoweringOwner) tsSignatureResultFor(ctx lowerFileContext, signature *ty
 }
 
 func (o *LoweringOwner) tsSignatureResultTypeFor(ctx lowerFileContext, typ types.Type) string {
+	if named, ok := types.Unalias(typ).(*types.Named); ok {
+		if _, ok := types.Unalias(named.Underlying()).(*types.Signature); ok {
+			return o.tsTypeFor(ctx, typ)
+		}
+	}
 	if signature := signatureForType(typ); ctx.functionTypeDepth == 0 && signature != nil {
 		return o.tsAsyncCompatibleFunctionResultTypeFor(ctx, signature)
 	}
@@ -7139,6 +9262,13 @@ func asyncCompatibleResultType(result string) string {
 	return result + " | " + tsPromiseType(result)
 }
 
+func asyncCompatibleMethodResultType(result string, async bool) string {
+	if !async {
+		return result
+	}
+	return asyncCompatibleResultType(result)
+}
+
 func tsPromiseType(result string) string {
 	return "globalThis.Promise<" + result + ">"
 }
@@ -7203,10 +9333,16 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 		if crossPackageUnexportedNamedType(ctx, named) {
 			return "any"
 		}
+		if !ctx.canReferenceNamedType(named) {
+			return "any"
+		}
 		name := o.namedTypeExpr(ctx, named)
 		if _, ok := named.Underlying().(*types.Interface); ok {
 			return name + " | null"
 		}
+		if _, ok := types.Unalias(named.Underlying()).(*types.Signature); ok {
+			return name + " | null"
+		}
 		return name
 	}
 	switch typed := types.Unalias(typ).Underlying().(type) {
@@ -7233,7 +9369,7 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 		}
 		return tsArrayType(o.tsTypeFor(ctx, typed.Elem()))
 	case *types.Slice:
-		return "$.Slice<" + o.tsTypeFor(ctx, typed.Elem()) + ">"
+		return "$.Slice<" + o.tsSliceElemTypeFor(ctx, typed.Elem()) + ">"
 	case *types.Map:
 		return "Map<" + o.tsTypeFor(ctx, typed.Key()) + ", " + o.tsTypeFor(ctx, typed.Elem()) + "> | null"
 	case *types.Chan:
@@ -7251,12 +9387,18 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 			if crossPackageUnexportedNamedType(ctx, named) {
 				return "any"
 			}
+			if !ctx.canReferenceNamedType(named) {
+				return "any"
+			}
 			return "$.VarRef<" + o.namedTypeExpr(ctx, named) + "> | null"
 		}
 		if named := namedStructType(typed.Elem()); named != nil {
 			if crossPackageUnexportedNamedType(ctx, named) {
 				return "any"
 			}
+			if !ctx.canReferenceNamedType(named) {
+				return "any"
+			}
 			name := o.namedTypeExpr(ctx, named)
 			return name + " | $.VarRef<" + name + "> | null"
 		}
@@ -7272,12 +9414,28 @@ func (o *LoweringOwner) tsTypeFor(ctx lowerFileContext, typ types.Type) string {
 	}
 }
 
+func (o *LoweringOwner) tsSliceElemTypeFor(ctx lowerFileContext, typ types.Type) string {
+	if typeParam, ok := types.Unalias(typ).(*types.TypeParam); ok && staticTypeParamInScope(ctx, typeParam) {
+		return safeIdentifier(typeParam.Obj().Name())
+	}
+	if pointer, ok := types.Unalias(typ).(*types.Pointer); ok {
+		if typeParam, ok := types.Unalias(pointer.Elem()).(*types.TypeParam); ok && staticTypeParamInScope(ctx, typeParam) {
+			name := safeIdentifier(typeParam.Obj().Name())
+			return name + " | $.VarRef<" + name + "> | null"
+		}
+	}
+	return o.tsTypeFor(ctx, typ)
+}
+
 func (o *LoweringOwner) tsNonNilTypeFor(ctx lowerFileContext, typ types.Type) string {
 	if isBuiltinErrorType(typ) {
 		return "Exclude<$.GoError, null>"
 	}
 	if named, ok := types.Unalias(typ).(*types.Named); ok {
 		if _, ok := named.Underlying().(*types.Interface); ok {
+			if !ctx.canReferenceNamedType(named) {
+				return "any"
+			}
 			return "Exclude<" + o.namedTypeExpr(ctx, named) + ", null>"
 		}
 	}
@@ -7288,6 +9446,9 @@ func (o *LoweringOwner) aliasTypeExpr(ctx lowerFileContext, alias *types.Alias)
 	if alias == nil || alias.Obj() == nil {
 		return "unknown"
 	}
+	if !ctx.canReferenceObjectPackage(alias.Obj()) {
+		return "any"
+	}
 	if alias.Obj().Pkg() == nil {
 		return o.tsTypeFor(ctx, alias.Rhs())
 	}
@@ -7337,7 +9498,7 @@ func zeroValueExpr(typ types.Type) string {
 		return "undefined"
 	}
 	if named := namedStructType(typ); named != nil && isStructValueType(typ) {
-		return "new " + named.Obj().Name() + "()"
+		return "new " + safeIdentifier(named.Obj().Name()) + "()"
 	}
 	switch typed := types.Unalias(typ).Underlying().(type) {
 	case *types.Basic:
@@ -7397,6 +9558,14 @@ func namedStructType(typ types.Type) *types.Named {
 	return named
 }
 
+func pointerToNamedStructType(typ types.Type) *types.Named {
+	pointer, ok := types.Unalias(typ).Underlying().(*types.Pointer)
+	if !ok {
+		return nil
+	}
+	return namedStructType(pointer.Elem())
+}
+
 func namedNonStructType(typ types.Type) *types.Named {
 	named, _ := types.Unalias(typ).(*types.Named)
 	if named == nil {
@@ -7458,6 +9627,94 @@ func signatureHasTypeParam(signature *types.Signature, target *types.TypeParam)
 	return false
 }
 
+func typeParamInScope(ctx lowerFileContext, target *types.TypeParam) bool {
+	if target == nil {
+		return false
+	}
+	if signatureHasTypeParam(ctx.signature, target) {
+		return true
+	}
+	return ctx.typeParams[target.Obj().Name()]
+}
+
+func staticTypeParamInScope(ctx lowerFileContext, target *types.TypeParam) bool {
+	if target == nil || !typeParamInScope(ctx, target) {
+		return false
+	}
+	return ctx.staticTypeParams[target.Obj().Name()]
+}
+
+func typeParamConstraintIsAny(typeParam *types.TypeParam) bool {
+	if typeParam == nil {
+		return false
+	}
+	iface, ok := typeParam.Constraint().Underlying().(*types.Interface)
+	if !ok {
+		return false
+	}
+	return iface.NumMethods() == 0 && iface.NumEmbeddeds() == 0
+}
+
+func signatureTypeParamNames(signature *types.Signature) []string {
+	if signature == nil || signature.TypeParams() == nil {
+		return nil
+	}
+	typeParams := signature.TypeParams()
+	names := make([]string, 0, typeParams.Len())
+	for typeParam := range typeParams.TypeParams() {
+		if !signatureUsesTypeParamAsSliceElem(signature, typeParam) {
+			continue
+		}
+		names = append(names, safeIdentifier(typeParam.Obj().Name()))
+	}
+	return names
+}
+
+func signatureUsesTypeParamAsSliceElem(signature *types.Signature, target *types.TypeParam) bool {
+	if signature == nil || target == nil {
+		return false
+	}
+	return tupleUsesTypeParamAsSliceElem(signature.Params(), target) ||
+		tupleUsesTypeParamAsSliceElem(signature.Results(), target)
+}
+
+func tupleUsesTypeParamAsSliceElem(tuple *types.Tuple, target *types.TypeParam) bool {
+	if tuple == nil {
+		return false
+	}
+	for variable := range tuple.Variables() {
+		if typeUsesTypeParamAsSliceElem(variable.Type(), target) {
+			return true
+		}
+	}
+	return false
+}
+
+func typeUsesTypeParamAsSliceElem(typ types.Type, target *types.TypeParam) bool {
+	switch typed := types.Unalias(typ).Underlying().(type) {
+	case *types.Slice:
+		if typeParam, ok := types.Unalias(typed.Elem()).(*types.TypeParam); ok &&
+			(typeParam == target || typeParam.Obj() == target.Obj()) {
+			return true
+		}
+		return typeUsesTypeParamAsSliceElem(typed.Elem(), target)
+	case *types.Array:
+		return typeUsesTypeParamAsSliceElem(typed.Elem(), target)
+	case *types.Pointer:
+		return typeUsesTypeParamAsSliceElem(typed.Elem(), target)
+	case *types.Map:
+		return typeUsesTypeParamAsSliceElem(typed.Key(), target) ||
+			typeUsesTypeParamAsSliceElem(typed.Elem(), target)
+	case *types.Chan:
+		return typeUsesTypeParamAsSliceElem(typed.Elem(), target)
+	case *types.Signature:
+		return tupleUsesTypeParamAsSliceElem(typed.Params(), target) ||
+			tupleUsesTypeParamAsSliceElem(typed.Results(), target)
+	default:
+		return false
+	}
+}
+
 func sameNamedTypeOrigin(a *types.Named, b *types.Named) bool {
 	if a == nil || b == nil {
 		return false
@@ -7585,6 +9842,11 @@ func isIntegerType(typ types.Type) bool {
 	return ok && basic.Info()&types.IsInteger != 0
 }
 
+func isFloatType(typ types.Type) bool {
+	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
+	return ok && basic.Info()&types.IsFloat != 0
+}
+
 func unsignedIntegerBits(typ types.Type) (int, bool) {
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	if !ok || basic.Info()&types.IsUnsigned == 0 {
@@ -7632,6 +9894,9 @@ func isWideIntegerType(typ types.Type) bool {
 }
 
 func isFixedWideIntegerType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
 	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
 	if !ok {
 		return false
@@ -7644,6 +9909,14 @@ func isFixedWideIntegerType(typ types.Type) bool {
 	}
 }
 
+func isFixedSignedWideIntegerType(typ types.Type) bool {
+	if typ == nil {
+		return false
+	}
+	basic, ok := types.Unalias(typ).Underlying().(*types.Basic)
+	return ok && basic.Kind() == types.Int64
+}
+
 func isRuneSliceType(typ types.Type) bool {
 	slice, ok := types.Unalias(typ).Underlying().(*types.Slice)
 	return ok && isRuneType(slice.Elem())
@@ -7672,6 +9945,8 @@ func sliceTypeHint(typ types.Type) string {
 		return "string"
 	case isNumericType(typ):
 		return "number"
+	case isBoolType(typ):
+		return "boolean"
 	default:
 		return ""
 	}
@@ -7800,6 +10075,13 @@ func (o *LoweringOwner) awaitCallIfNeeded(ctx lowerFileContext, fun ast.Expr, ca
 	return call
 }
 
+func parenthesizeAwaitedExpr(expr string) string {
+	if strings.HasPrefix(expr, "await ") {
+		return "(" + expr + ")"
+	}
+	return expr
+}
+
 func (o *LoweringOwner) genericTypeArgsExpr(ctx lowerFileContext, callee ast.Expr, typeArgExprs []ast.Expr) string {
 	signature := genericFunctionSignature(ctx, callee)
 	if signature == nil {
@@ -7883,7 +10165,7 @@ func (o *LoweringOwner) inferGenericTypeArg(
 }
 
 func (o *LoweringOwner) genericTypeDescriptorExpr(ctx lowerFileContext, typ types.Type) string {
-	if typeParam, ok := types.Unalias(typ).(*types.TypeParam); ok && signatureHasTypeParam(ctx.signature, typeParam) {
+	if typeParam, ok := types.Unalias(typ).(*types.TypeParam); ok && typeParamInScope(ctx, typeParam) {
 		return "__typeArgs?.[" + strconv.Quote(typeParam.Obj().Name()) + "] ?? { type: " +
 			o.runtimeTypeInfoExpr(typ) + ", zero: () => " + o.lowerZeroValueExprFor(ctx, typ) + " }"
 	}
@@ -7921,7 +10203,21 @@ func (o *LoweringOwner) genericMethodDescriptorsForType(
 			methods = append(methods, method.Name()+": (receiver: any, ...args: any[]) => receiver."+method.Name()+"(...args)")
 			continue
 		}
-		methods = append(methods, method.Name()+": "+o.methodFunctionExpr(ctx, named.Origin(), method, method.Name()))
+		receiver := "receiver"
+		if sig, _ := method.Type().(*types.Signature); sig != nil {
+			if recv := sig.Recv(); recv != nil {
+				if _, ok := types.Unalias(recv.Type()).Underlying().(*types.Pointer); !ok {
+					if _, ok := types.Unalias(methodSetType).Underlying().(*types.Pointer); ok {
+						receiver = o.runtimeOwner.QualifiedHelper(RuntimeHelperPointerValue) + "(receiver)"
+					} else {
+						receiver = "(" + o.runtimeOwner.QualifiedHelper(RuntimeHelperIsVarRef) +
+							"(receiver) ? receiver.value : receiver)"
+					}
+				}
+			}
+		}
+		methods = append(methods, method.Name()+": (receiver: any, ...args: any[]) => "+
+			"("+o.methodFunctionExpr(ctx, named.Origin(), method, method.Name())+" as any)("+receiver+", ...args)")
 	}
 	if len(methods) == 0 {
 		return ""
@@ -7946,9 +10242,21 @@ func namedNonStructMethodSetType(typ types.Type) (*types.Named, types.Type) {
 
 func methodFunctionName(receiver *types.Named, method string) string {
 	if receiver == nil || receiver.Obj() == nil {
-		return method
+		return safeIdentifier(method)
+	}
+	return safeIdentifier(receiver.Obj().Name()) + "_" + safeIdentifier(method)
+}
+
+func methodReceiverNamedType(obj types.Object) *types.Named {
+	fn, _ := obj.(*types.Func)
+	if fn == nil {
+		return nil
+	}
+	signature, _ := fn.Type().(*types.Signature)
+	if signature == nil || signature.Recv() == nil {
+		return nil
 	}
-	return receiver.Obj().Name() + "_" + method
+	return receiverNamedType(signature.Recv().Type())
 }
 
 func (o *LoweringOwner) methodFunctionExpr(
@@ -7973,7 +10281,7 @@ func (o *LoweringOwner) namedTypeExpr(ctx lowerFileContext, named *types.Named)
 	if named == nil || named.Obj() == nil {
 		return "unknown"
 	}
-	baseName := named.Obj().Name()
+	baseName := safeIdentifier(named.Obj().Name())
 	if alias := ctx.localAliases[named.Obj()]; alias != "" {
 		baseName = alias + "." + baseName
 	} else if named.Obj().Pkg() != nil {
@@ -8036,11 +10344,30 @@ func runtimeNamedTypeName(named *types.Named) string {
 }
 
 func goRuntimeTypeString(typ types.Type) string {
-	return types.TypeString(typ, func(pkg *types.Package) string {
+	return types.TypeString(runtimeIdentityType(typ), func(pkg *types.Package) string {
 		return pkg.Name()
 	})
 }
 
+func runtimeIdentityType(typ types.Type) types.Type {
+	switch typed := typ.(type) {
+	case *types.Alias:
+		return runtimeIdentityType(types.Unalias(typed))
+	case *types.Pointer:
+		return types.NewPointer(runtimeIdentityType(typed.Elem()))
+	case *types.Slice:
+		return types.NewSlice(runtimeIdentityType(typed.Elem()))
+	case *types.Array:
+		return types.NewArray(runtimeIdentityType(typed.Elem()), typed.Len())
+	case *types.Map:
+		return types.NewMap(runtimeIdentityType(typed.Key()), runtimeIdentityType(typed.Elem()))
+	case *types.Chan:
+		return types.NewChan(typed.Dir(), runtimeIdentityType(typed.Elem()))
+	default:
+		return typ
+	}
+}
+
 func basicRuntimeName(basic *types.Basic) string {
 	if basic == nil {
 		return "unknown"