goscript 0.0.22 → 0.0.23

package/compiler/expr.go

@@ -11,10 +11,35 @@ import (
 
 // WriteIndexExpr translates a Go index expression (a[b]) to its TypeScript equivalent.
 func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
+	// Check if this might be a generic function instantiation with a single type argument
+	// In this case, the Index should be a type expression, not a value expression
+	if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
+		// If X is a function type, this might be generic instantiation
+		if _, isFuncType := tv.Type.Underlying().(*types.Signature); isFuncType {
+			// Check if the index is a type expression (identifier that refers to a type)
+			if indexIdent, isIdent := exp.Index.(*ast.Ident); isIdent {
+				// Check if this identifier refers to a type
+				if obj := c.pkg.TypesInfo.Uses[indexIdent]; obj != nil {
+					if _, isTypeName := obj.(*types.TypeName); isTypeName {
+						// This is a generic function instantiation: f[T] -> f<T>
+						if err := c.WriteValueExpr(exp.X); err != nil {
+							return err
+						}
+						c.tsw.WriteLiterally("<")
+						c.WriteTypeExpr(exp.Index)
+						c.tsw.WriteLiterally(">")
+						return nil
+					}
+				}
+			}
+		}
+	}
+
 	// Handle map access: use Map.get() instead of brackets for reading values
 	if tv, ok := c.pkg.TypesInfo.Types[exp.X]; ok {
+		underlyingType := tv.Type.Underlying()
 		// Check if it's a map type
-		if mapType, isMap := tv.Type.Underlying().(*types.Map); isMap {
+		if mapType, isMap := underlyingType.(*types.Map); isMap {
 			c.tsw.WriteLiterally("$.mapGet(")
 			if err := c.WriteValueExpr(exp.X); err != nil {
 				return err
@@ -30,6 +55,36 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 			c.tsw.WriteLiterally(")")
 			return nil
 		}
+
+		// Check if it's a string type
+		if basicType, isBasic := underlyingType.(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+			c.tsw.WriteLiterally("$.indexString(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(")")
+			return nil
+		}
+
+		// Check if it's a type parameter with a union constraint (e.g., string | []byte)
+		if _, isTypeParam := tv.Type.(*types.TypeParam); isTypeParam {
+			// For type parameters with string | []byte constraint, use specialized function
+			// that returns number (byte value) for better TypeScript typing
+			c.tsw.WriteLiterally("$.indexStringOrBytes(")
+			if err := c.WriteValueExpr(exp.X); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.Index); err != nil {
+				return err
+			}
+			c.tsw.WriteLiterally(")")
+			return nil
+		}
 	}
 
 	// Regular array/slice access: use brackets
@@ -44,6 +99,26 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 	return nil
 }
 
+// WriteIndexListExpr translates a Go generic function instantiation (f[T1, T2]) to its TypeScript equivalent (f<T1, T2>).
+func (c *GoToTSCompiler) WriteIndexListExpr(exp *ast.IndexListExpr) error {
+	// Write the function expression
+	if err := c.WriteValueExpr(exp.X); err != nil {
+		return err
+	}
+
+	// Write the type arguments using TypeScript syntax
+	c.tsw.WriteLiterally("<")
+	for i, typeArg := range exp.Indices {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		c.WriteTypeExpr(typeArg)
+	}
+	c.tsw.WriteLiterally(">")
+
+	return nil
+}
+
 // WriteTypeAssertExpr translates a Go type assertion expression (e.g., `x.(T)`)
 // into a TypeScript call to `$.typeAssert<T_ts>(x_ts, 'TypeName').value`.
 // The `$.typeAssert` runtime function handles the actual type check and panic
@@ -52,7 +127,7 @@ func (c *GoToTSCompiler) WriteIndexExpr(exp *ast.IndexExpr) error {
 // by the runtime for error messages.
 func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 	// Generate a call to $.typeAssert
-	c.tsw.WriteLiterally("$.typeAssert<")
+	c.tsw.WriteLiterally("$.mustTypeAssert<")
 	c.WriteTypeExpr(exp.Type) // Write the asserted type for the generic
 	c.tsw.WriteLiterally(">(")
 	if err := c.WriteValueExpr(exp.X); err != nil { // The interface expression
@@ -60,9 +135,6 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 	}
 	c.tsw.WriteLiterally(", ")
 
-	// Write the type description instead of just the type name
-	// This ensures we generate proper type info objects for all types
-
 	// Unwrap parenthesized expressions to handle cases like r.((<-chan T))
 	typeExpr := exp.Type
 	for {
@@ -75,7 +147,8 @@ func (c *GoToTSCompiler) WriteTypeAssertExpr(exp *ast.TypeAssertExpr) error {
 
 	c.writeTypeDescription(typeExpr)
 
-	c.tsw.WriteLiterally(")") // Just close the parenthesis, don't access .value directly
+	c.tsw.WriteLiterally(")")
+
 	return nil
 }
 
@@ -137,12 +210,12 @@ func (c *GoToTSCompiler) getTypeNameString(typeExpr ast.Expr) string {
 func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 	// Handle special cases like channel send
 	if exp.Op == token.ARROW {
-		// Channel send: ch <- val becomes await ch.send(val)
-		c.tsw.WriteLiterally("await ")
+		// Channel send: ch <- val becomes await $.chanSend(ch, val)
+		c.tsw.WriteLiterally("await $.chanSend(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write channel send target: %w", err)
 		}
-		c.tsw.WriteLiterally(".send(")
+		c.tsw.WriteLiterally(", ")
 		if err := c.WriteValueExpr(exp.Y); err != nil {
 			return fmt.Errorf("failed to write channel send value: %w", err)
 		}
@@ -218,6 +291,19 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 		isBitwise = true
 	}
 
+	// Special handling for large bit shift expressions that would overflow in JavaScript
+	if exp.Op == token.SHL {
+		// Check if this is 1 << 63 pattern
+		if leftLit, leftIsLit := exp.X.(*ast.BasicLit); leftIsLit && leftLit.Value == "1" {
+			if rightLit, rightIsLit := exp.Y.(*ast.BasicLit); rightIsLit && rightLit.Value == "63" {
+				// Replace 1 << 63 with Number.MAX_SAFE_INTEGER (9007199254740991)
+				// This is the largest integer that can be exactly represented in JavaScript
+				c.tsw.WriteLiterally("Number.MAX_SAFE_INTEGER")
+				return nil
+			}
+		}
+	}
+
 	if isBitwise {
 		c.tsw.WriteLiterally("(") // Add opening parenthesis for bitwise operations
 	}
@@ -263,12 +349,12 @@ func (c *GoToTSCompiler) WriteBinaryExpr(exp *ast.BinaryExpr) error {
 // their statement contexts (e.g., `IncDecStmt`).
 func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	if exp.Op == token.ARROW {
-		// Channel receive: <-ch becomes await ch.receive()
-		c.tsw.WriteLiterally("await ")
+		// Channel receive: <-ch becomes await $.chanRecv(ch)
+		c.tsw.WriteLiterally("await $.chanRecv(")
 		if err := c.WriteValueExpr(exp.X); err != nil {
 			return fmt.Errorf("failed to write channel receive operand: %w", err)
 		}
-		c.tsw.WriteLiterally(".receive()")
+		c.tsw.WriteLiterally(")")
 		return nil
 	}
 
@@ -337,6 +423,155 @@ func (c *GoToTSCompiler) WriteUnaryExpr(exp *ast.UnaryExpr) error {
 	return nil
 }
 
+// WriteSliceExpr translates a Go slice expression (e.g., `s[low:high:max]`) to its TypeScript equivalent.
+// If `s` is a string and it's not a 3-index slice, it uses `s.substring(low, high)`.
+// If `s` is `[]byte` (Uint8Array) and it's not a 3-index slice, it uses `s.subarray(low, high)`.
+// Otherwise, it falls back to the `$.goSlice(s, low, high, max)` runtime helper.
+func (c *GoToTSCompiler) WriteSliceExpr(exp *ast.SliceExpr) error {
+	// Check if the expression being sliced is a string
+	tv := c.pkg.TypesInfo.TypeOf(exp.X)
+	isString := false
+	isByteSlice := false
+	isTypeParam := false
+	if tv != nil {
+		if basicType, isBasic := tv.Underlying().(*types.Basic); isBasic && (basicType.Info()&types.IsString) != 0 {
+			isString = true
+		}
+		if sliceType, isSlice := tv.Underlying().(*types.Slice); isSlice {
+			if basicElem, isBasic := sliceType.Elem().(*types.Basic); isBasic && basicElem.Kind() == types.Uint8 {
+				isByteSlice = true
+			}
+		}
+		if _, isTP := tv.(*types.TypeParam); isTP {
+			isTypeParam = true
+		}
+	}
+
+	// Handle type parameters with union constraints (e.g., string | []byte)
+	if isTypeParam {
+		// For type parameters, we need to create a runtime helper that handles both string and []byte
+		c.tsw.WriteLiterally("$.sliceStringOrBytes(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		if exp.Slice3 {
+			c.tsw.WriteLiterally(", ")
+			if exp.Max != nil {
+				if err := c.WriteValueExpr(exp.Max); err != nil {
+					return err
+				}
+			} else {
+				c.tsw.WriteLiterally("undefined")
+			}
+		}
+		c.tsw.WriteLiterally(")")
+		return nil
+	}
+
+	if isString && !exp.Slice3 {
+		// Use $.sliceString for byte-correct string slicing
+		c.tsw.WriteLiterally("$.sliceString(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			// Go's default low for string[:high] is 0.
+			// $.sliceString can handle undefined for low as 0.
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			// Go's default high for string[low:] means to the end.
+			// $.sliceString can handle undefined for high as end of string.
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(")")
+	} else if isByteSlice && !exp.Slice3 {
+		// Use s.subarray(low, high) for []byte slices
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(".subarray(")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("0") // Default low for subarray is 0
+		}
+		if exp.High != nil {
+			c.tsw.WriteLiterally(", ")
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			// If high is omitted, subarray goes to the end of the array.
+			// No need to write undefined or length, just close the parenthesis if low was the last arg.
+		}
+		c.tsw.WriteLiterally(")")
+	} else {
+		// Fallback to $.goSlice for actual slices (arrays) or 3-index string slices (which are rare and might need $.goSlice's complexity)
+		// Or if it's a string but has Slice3, it's not handled by simple substring.
+		c.tsw.WriteLiterally("$.goSlice(")
+		if err := c.WriteValueExpr(exp.X); err != nil {
+			return err
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.Low != nil {
+			if err := c.WriteValueExpr(exp.Low); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		c.tsw.WriteLiterally(", ")
+		if exp.High != nil {
+			if err := c.WriteValueExpr(exp.High); err != nil {
+				return err
+			}
+		} else {
+			c.tsw.WriteLiterally("undefined")
+		}
+		if exp.Slice3 {
+			c.tsw.WriteLiterally(", ")
+			if exp.Max != nil {
+				if err := c.WriteValueExpr(exp.Max); err != nil {
+					return err
+				}
+			} else {
+				c.tsw.WriteLiterally("undefined")
+			}
+		}
+		c.tsw.WriteLiterally(")")
+	}
+	return nil
+}
+
 // WriteKeyValueExpr translates a Go key-value pair expression (`ast.KeyValueExpr`),
 // typically found within composite literals (for structs, maps, or arrays with
 // indexed elements), into its TypeScript object property equivalent: `key: value`.

package/compiler/field.go

@@ -50,7 +50,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 				c.tsw.WriteLiterally(name.Name)
 				c.tsw.WriteLiterally(": ")
 				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ)
+				c.WriteGoType(typ, GoTypeContextGeneral)
 			}
 		}
 
@@ -89,7 +89,7 @@ func (c *GoToTSCompiler) WriteFieldList(a *ast.FieldList, isArguments bool) {
 					c.tsw.WriteLiterally(name.Name)
 					c.tsw.WriteLiterally(": ")
 					typ := c.pkg.TypesInfo.TypeOf(field.Type)
-					c.WriteGoType(typ) // Use WriteGoType for parameter type
+					c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for parameter type
 				}
 			} else {
 				// For struct fields and other non-argument fields
@@ -155,7 +155,7 @@ func (c *GoToTSCompiler) WriteField(field *ast.Field, isArguments bool) {
 		// write type for struct fields (not arguments)
 		c.tsw.WriteLiterally(": ")
 		typ := c.pkg.TypesInfo.TypeOf(field.Type)
-		c.WriteGoType(typ) // Use WriteGoType for field type
+		c.WriteGoType(typ, GoTypeContextGeneral) // Use WriteGoType for field type
 
 		if !isArguments {
 			// write tag comment if any for struct fields

package/compiler/lit.go

@@ -1,6 +1,7 @@
 package compiler
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 	"strconv"
@@ -90,9 +91,40 @@ func (c *GoToTSCompiler) WriteFuncLitValue(exp *ast.FuncLit) error {
 
 	c.tsw.WriteLiterally(" => ")
 
+	hasNamedReturns := false
+	if exp.Type.Results != nil {
+		for _, field := range exp.Type.Results.List {
+			if len(field.Names) > 0 {
+				hasNamedReturns = true
+				break
+			}
+		}
+	}
+
+	if hasNamedReturns {
+		c.tsw.WriteLine("{")
+		c.tsw.Indent(1)
+
+		// Declare named return variables and initialize them to their zero values
+		for _, field := range exp.Type.Results.List {
+			for _, name := range field.Names {
+				c.tsw.WriteLiterallyf("let %s: ", name.Name)
+				c.WriteTypeExpr(field.Type)
+				c.tsw.WriteLiterally(" = ")
+				c.WriteZeroValueForType(c.pkg.TypesInfo.TypeOf(field.Type))
+				c.tsw.WriteLine("")
+			}
+		}
+	}
+
 	// Write function body
-	if err := c.WriteStmt(exp.Body); err != nil {
-		return err
+	if err := c.WriteStmtBlock(exp.Body, false); err != nil {
+		return fmt.Errorf("failed to write block statement: %w", err)
+	}
+
+	if hasNamedReturns {
+		c.tsw.Indent(-1)
+		c.tsw.WriteLiterally("}")
 	}
 
 	return nil

package/compiler/primitive.go

@@ -29,7 +29,10 @@ var goToTypescriptPrimitives = map[string]string{
 	"int16": "number",
 	"int32": "number",
 	"rune":  "number", // alias for int32
-	"int64": "bigint", // Requires TypeScript target >= ES2020
+
+	// TODO: add bigint support
+	// "int64": "bigint", // Requires TypeScript target >= ES2020
+	"int64": "number",
 
 	// Unsigned Integers
 	"uint":   "number",
@@ -37,7 +40,10 @@ var goToTypescriptPrimitives = map[string]string{
 	"byte":   "number",
 	"uint16": "number",
 	"uint32": "number",
-	"uint64": "bigint", // Requires TypeScript target >= ES2020
+
+	// TODO: add bigint support
+	// "uint64": "bigint", // Requires TypeScript target >= ES2020
+	"uint64": "number",
 
 	// Floating Point Numbers
 	"float32": "number",

package/compiler/spec-struct.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
+	"sort"
 	"strings"
 )
 
@@ -23,6 +24,12 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	if err := c.WriteValueExpr(a.Name); err != nil {
 		return err
 	}
+
+	// Write type parameters if present (for generics)
+	if a.TypeParams != nil {
+		c.WriteTypeParameters(a.TypeParams)
+	}
+
 	c.tsw.WriteLiterally(" ")
 	c.tsw.WriteLine("{")
 	c.tsw.Indent(1)
@@ -121,9 +128,25 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("")
 
 	// Generate the clone method
-	c.tsw.WriteLinef("public clone(): %s {", className)
+	cloneReturnType := className
+	if a.TypeParams != nil && len(a.TypeParams.List) > 0 {
+		cloneReturnType += "<"
+		first := true
+		for _, field := range a.TypeParams.List {
+			for _, name := range field.Names {
+				if !first {
+					cloneReturnType += ", "
+				}
+				first = false
+				cloneReturnType += name.Name
+			}
+		}
+		cloneReturnType += ">"
+	}
+
+	c.tsw.WriteLinef("public clone(): %s {", cloneReturnType)
 	c.tsw.Indent(1)
-	c.tsw.WriteLinef("const cloned = new %s()", className)
+	c.tsw.WriteLinef("const cloned = new %s()", cloneReturnType)
 	c.tsw.WriteLine("cloned._fields = {")
 	c.tsw.Indent(1)
 
@@ -164,7 +187,18 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 			if starExpr, ok := recvType.(*ast.StarExpr); ok {
 				recvType = starExpr.X
 			}
-			if ident, ok := recvType.(*ast.Ident); ok && ident.Name == className {
+
+			// Check for both simple identifiers (Pair) and generic types (Pair[T])
+			var recvTypeName string
+			if ident, ok := recvType.(*ast.Ident); ok {
+				recvTypeName = ident.Name
+			} else if indexExpr, ok := recvType.(*ast.IndexExpr); ok {
+				if ident, ok := indexExpr.X.(*ast.Ident); ok {
+					recvTypeName = ident.Name
+				}
+			}
+
+			if recvTypeName == className {
 				c.tsw.WriteLine("")
 				if err := c.WriteFuncDeclAsMethod(funcDecl); err != nil {
 					return err
@@ -292,21 +326,21 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 					}
 					c.tsw.WriteLiterally(paramName)
 					c.tsw.WriteLiterally(": ")
-					c.WriteGoType(param.Type())
+					c.WriteGoType(param.Type(), GoTypeContextGeneral)
 				}
 				c.tsw.WriteLiterally(")")
 				results := sig.Results()
 				if results.Len() > 0 {
 					c.tsw.WriteLiterally(": ")
 					if results.Len() == 1 {
-						c.WriteGoType(results.At(0).Type())
+						c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
 					} else {
 						c.tsw.WriteLiterally("[")
 						for j := 0; j < results.Len(); j++ {
 							if j > 0 {
 								c.tsw.WriteLiterally(", ")
 							}
-							c.WriteGoType(results.At(j).Type())
+							c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn)
 						}
 						c.tsw.WriteLiterally("]")
 					}
@@ -380,3 +414,100 @@ func (c *GoToTSCompiler) WriteStructTypeSpec(a *ast.TypeSpec, t *ast.StructType)
 	c.tsw.WriteLine("}")
 	return nil
 }
+
+// generateFlattenedInitTypeString generates a TypeScript type string for the
+// initialization object passed to a Go struct's constructor (`_init` method in TypeScript).
+// The generated type is a `Partial`-like structure, `"{ Field1?: Type1, Field2?: Type2, ... }"`,
+// including all direct and promoted fields of the `structType`.
+//   - It iterates through the direct fields of the `structType`. Exported fields
+//     are included with their TypeScript types (obtained via `WriteGoType`).
+//   - For anonymous (embedded) fields, it generates a type like `EmbeddedName?: ConstructorParameters<typeof EmbeddedName>[0]`,
+//     allowing initialization of the embedded struct's fields directly within the outer struct's initializer.
+//   - It then uses `types.NewMethodSet` and checks for `types.Var` objects that are fields
+//     to find promoted fields from embedded structs, adding them to the type string if not already present.
+//
+// The resulting string is sorted by field name for deterministic output and represents
+// the shape of the object expected by the struct's TypeScript constructor.
+func (c *GoToTSCompiler) generateFlattenedInitTypeString(structType *types.Named) string {
+	if structType == nil {
+		return "{}"
+	}
+
+	// Use a map to collect unique field names and their types
+	fieldMap := make(map[string]string)
+	embeddedTypeMap := make(map[string]string) // Stores TS type string for embedded struct initializers
+
+	underlying, ok := structType.Underlying().(*types.Struct)
+	if !ok {
+		return "{}"
+	}
+
+	// First add the direct fields and track embedded types
+	for i := 0; i < underlying.NumFields(); i++ {
+		field := underlying.Field(i)
+		fieldName := field.Name()
+
+		if !field.Exported() && field.Pkg() != c.pkg.Types {
+			continue
+		}
+
+		if field.Anonymous() {
+			fieldType := field.Type()
+			isPtr := false
+			if ptr, ok := fieldType.(*types.Pointer); ok {
+				fieldType = ptr.Elem()
+				isPtr = true
+			}
+
+			if named, ok := fieldType.(*types.Named); ok {
+				embeddedName := named.Obj().Name()
+				// For embedded structs, the init type should allow providing fields of the embedded struct,
+				// or the embedded struct itself.
+				// We generate Partial<EmbeddedStructFields> | EmbeddedStructType
+				// This is complex. For now, let's use ConstructorParameters as before for simplicity,
+				// or allow the embedded struct type itself.
+				// The example `Person?: ConstructorParameters<typeof Person>[0]` is for the fields.
+				// Let's try to generate a type that allows either the embedded struct instance or its fields.
+				// This might be: `Partial<FlattenedInitType<EmbeddedName>> | EmbeddedName`
+				// For now, stick to the simpler `ConstructorParameters<typeof %s>[0]` which implies field-based init.
+				// Or, more simply, the type of the embedded struct itself if it's a pointer.
+				if isPtr {
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type()) // MyEmbeddedType | null
+				} else {
+					// For value-type embedded structs, allow initializing with its fields.
+					// This requires getting the flattened init type for the embedded struct.
+					// This could lead to recursion if not handled carefully.
+					// A simpler approach for now: use the embedded struct's own type.
+					// embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = c.getTypeString(field.Type())
+					// Or, using ConstructorParameters to allow field-based initialization:
+					embeddedTypeMap[c.getEmbeddedFieldKeyName(field.Type())] = fmt.Sprintf("Partial<ConstructorParameters<typeof %s>[0]>", embeddedName)
+				}
+			}
+			continue
+		}
+		fieldMap[fieldName] = c.getTypeString(field.Type())
+	}
+
+	// Promoted fields (handled by Go's embedding, init should use direct/embedded names)
+	// The current logic for `generateFlattenedInitTypeString` seems to focus on top-level
+	// settable properties in the constructor. Promoted fields are accessed via `this.promotedField`,
+	// not typically set directly in `init?` unless the embedded struct itself is named in `init?`.
+
+	// Add embedded types to the field map (these are the names of the embedded structs themselves)
+	for embeddedName, embeddedTSType := range embeddedTypeMap {
+		fieldMap[embeddedName] = embeddedTSType
+	}
+
+	var fieldNames []string
+	for name := range fieldMap {
+		fieldNames = append(fieldNames, name)
+	}
+	sort.Strings(fieldNames)
+
+	var fieldDefs []string
+	for _, fieldName := range fieldNames {
+		fieldDefs = append(fieldDefs, fmt.Sprintf("%s?: %s", fieldName, fieldMap[fieldName]))
+	}
+
+	return "{" + strings.Join(fieldDefs, ", ") + "}"
+}