goscript 0.0.22 → 0.0.24

package/compiler/type.go

@@ -4,17 +4,34 @@ import (
 	"fmt"
 	"go/ast"
 	"go/types"
-	"sort"
 	"strings"
 )
 
+// GoTypeContext specifies the context in which a Go type is being translated to TypeScript.
+// This affects how certain types (especially pointers) are handled.
+type GoTypeContext int
+
+const (
+	// GoTypeContextGeneral is used for general type translation
+	GoTypeContextGeneral GoTypeContext = iota
+	// GoTypeContextFunctionReturn is used when translating types for function return values.
+	// In this context, pointer-to-struct types become `ClassName | null` instead of
+	// `$.VarRef<ClassName> | null` because function return values cannot be addressed.
+	GoTypeContextFunctionReturn
+)
+
 // WriteGoType is the main dispatcher for translating Go types to their TypeScript
 // equivalents. It examines the type and delegates to more specialized type writer
 // functions based on the specific Go type encountered.
 //
+// The context parameter controls how certain types (especially pointers) are handled:
+//   - GoTypeContextGeneral: Standard type translation
+//   - GoTypeContextFunctionReturn: Special handling for function return types where
+//     pointer-to-struct types become `ClassName | null` instead of `$.VarRef<ClassName> | null`
+//
 // It handles nil types as 'any' with a comment, and dispatches to appropriate
 // type-specific writers for all other recognized Go types.
-func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
+func (c *GoToTSCompiler) WriteGoType(typ types.Type, context GoTypeContext) {
 	if typ == nil {
 		c.tsw.WriteLiterally("any")
 		c.tsw.WriteCommentInline("nil type")
@@ -27,7 +44,11 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	case *types.Named:
 		c.WriteNamedType(t)
 	case *types.Pointer:
-		c.WritePointerType(t)
+		if context == GoTypeContextFunctionReturn {
+			c.writePointerTypeForFunctionReturn(t)
+		} else {
+			c.WritePointerType(t, context)
+		}
 	case *types.Slice:
 		c.WriteSliceType(t)
 	case *types.Array:
@@ -43,7 +64,10 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	case *types.Struct:
 		c.WriteStructType(t)
 	case *types.Alias:
-		c.WriteGoType(t.Underlying())
+		c.WriteGoType(t.Underlying(), context)
+	case *types.TypeParam:
+		// For type parameters, write the type parameter name (e.g., "T", "K", etc.)
+		c.tsw.WriteLiterally(t.Obj().Name())
 	default:
 		// For other types, just write "any" and add a comment
 		c.tsw.WriteLiterally("any")
@@ -51,12 +75,38 @@ func (c *GoToTSCompiler) WriteGoType(typ types.Type) {
 	}
 }
 
+// writePointerTypeForFunctionReturn translates a Go pointer type (*T) to its TypeScript
+// equivalent for function return types. Unlike WritePointerType, this function
+// handles pointer-to-struct types specially: they become `ClassName | null` instead
+// of `$.VarRef<ClassName> | null` because function return values cannot be addressed.
+func (c *GoToTSCompiler) writePointerTypeForFunctionReturn(t *types.Pointer) {
+	elemType := t.Elem()
+
+	// Check if the element type is a struct (directly or via a named type)
+	isStructType := false
+	if _, ok := elemType.Underlying().(*types.Struct); ok {
+		isStructType = true
+	}
+
+	if isStructType {
+		// For pointer-to-struct in function returns, generate ClassName | null
+		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
+		c.tsw.WriteLiterally(" | null")
+	} else {
+		// For pointer-to-primitive in function returns, still use varRefing
+		c.tsw.WriteLiterally("$.VarRef<")
+		c.WriteGoType(elemType, GoTypeContextFunctionReturn)
+		c.tsw.WriteLiterally("> | null")
+	}
+}
+
 // WriteZeroValueForType writes the TypeScript representation of the zero value
 // for a given Go type.
 // It handles `types.Array` by recursively writing zero values for each element
 // to form a TypeScript array literal (e.g., `[0, 0, 0]`).
 // For `types.Basic` (like `bool`, `string`, numeric types), it writes the
 // corresponding TypeScript zero value (`false`, `""`, `0`).
+// For `[]byte`, it writes `new Uint8Array(0)`.
 // Other types default to `null`. This function is primarily used for initializing
 // arrays and variables where an explicit initializer is absent.
 func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
@@ -97,9 +147,21 @@ func (c *GoToTSCompiler) WriteZeroValueForType(typ any) {
 		}
 		// For other named types, use the zero value of the underlying type
 		c.WriteZeroValueForType(t.Underlying())
+	case *types.Slice:
+		// Check if it's a []byte slice
+		if elem, ok := t.Elem().(*types.Basic); ok && elem.Kind() == types.Uint8 {
+			c.tsw.WriteLiterally("new Uint8Array(0)")
+			return
+		}
+		// For other slice types, default to null
+		c.tsw.WriteLiterally("null")
 	case *types.Struct:
 		// For anonymous struct types, initialize with {}
 		c.tsw.WriteLiterally("{}")
+	case *types.TypeParam:
+		// For type parameters, use null! (non-null assertion) to avoid TypeScript
+		// casting errors with union types like string | Uint8Array
+		c.tsw.WriteLiterally("null!")
 	default:
 		c.tsw.WriteLiterally("null")
 	}
@@ -140,37 +202,81 @@ func (c *GoToTSCompiler) WriteBasicType(t *types.Basic) {
 
 // WriteNamedType translates a Go named type to its TypeScript equivalent.
 // It specially handles the error interface as $.GoError, and uses the original
-// type name for other named types.
+// type name for other named types. For generic types, it includes type arguments.
 func (c *GoToTSCompiler) WriteNamedType(t *types.Named) {
 	// Check if the named type is the error interface
 	if iface, ok := t.Underlying().(*types.Interface); ok && iface.String() == "interface{Error() string}" {
 		c.tsw.WriteLiterally("$.GoError")
-	} else {
-		// Use Obj().Name() for the original defined name
-		c.tsw.WriteLiterally(t.Obj().Name())
+		return
+	}
+
+	// Use Obj().Name() for the original defined name
+	c.tsw.WriteLiterally(t.Obj().Name())
+
+	// For generic types, include type arguments
+	if t.TypeArgs() != nil && t.TypeArgs().Len() > 0 {
+		c.tsw.WriteLiterally("<")
+		for i := 0; i < t.TypeArgs().Len(); i++ {
+			if i > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.WriteGoType(t.TypeArgs().At(i), GoTypeContextGeneral)
+		}
+		c.tsw.WriteLiterally(">")
 	}
 }
 
 // WritePointerType translates a Go pointer type (*T) to its TypeScript equivalent.
-// It generates $.Box<T_ts> | null, where T_ts is the translated element type.
-func (c *GoToTSCompiler) WritePointerType(t *types.Pointer) {
-	c.tsw.WriteLiterally("$.Box<")
-	c.WriteGoType(t.Elem())
-	c.tsw.WriteLiterally("> | null") // Pointers are always nullable
+func (c *GoToTSCompiler) WritePointerType(t *types.Pointer, context GoTypeContext) {
+	elemGoType := t.Elem()
+	underlyingElemGoType := elemGoType.Underlying()
+
+	// Handle pointers to functions: *func(...) -> func(...) | null
+	if _, isSignature := underlyingElemGoType.(*types.Signature); isSignature {
+		c.WriteGoType(elemGoType, context) // Write the function signature itself, pass context
+		c.tsw.WriteLiterally(" | null")    // Function pointers are nullable
+		return
+	}
+
+	// Handle pointers to structs or interfaces: *MyStruct -> MyStruct | null
+	_, isStruct := underlyingElemGoType.(*types.Struct)
+	_, isInterface := underlyingElemGoType.(*types.Interface)
+
+	if isStruct || isInterface {
+		// For pointers to structs or interfaces, the TS type is StructName | null or InterfaceName | null.
+		// This aligns with VAR_REFS.md and JS/TS object reference semantics.
+		// TODO If the target variable is boxed, we have to wrap with VarRef as well?
+		c.WriteGoType(elemGoType, context) // Write the struct/interface type directly, pass context
+		c.tsw.WriteLiterally(" | null")
+	} else {
+		// For pointers to other types (primitives, slices, maps, other pointers like **MyStruct),
+		// they are generally represented as $.VarRef<T_ts> | null.
+		// Example: *int -> $.VarRef<number> | null
+		// Example: **MyStruct -> $.VarRef<MyStruct | null> | null (recursive call handles inner part)
+		c.tsw.WriteLiterally("$.VarRef<")
+		c.WriteGoType(elemGoType, context) // Translate element type, pass context
+		c.tsw.WriteLiterally("> | null")   // Pointers are always nullable
+	}
 }
 
 // WriteSliceType translates a Go slice type ([]T) to its TypeScript equivalent.
 // It generates $.Slice<T_ts>, where T_ts is the translated element type.
+// For []byte, it generates Uint8Array.
 func (c *GoToTSCompiler) WriteSliceType(t *types.Slice) {
+	// Check if it's a []byte slice
+	if elem, ok := t.Elem().(*types.Basic); ok && elem.Kind() == types.Uint8 {
+		c.tsw.WriteLiterally("Uint8Array")
+		return
+	}
 	c.tsw.WriteLiterally("$.Slice<")
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(">")
 }
 
 // WriteArrayType translates a Go array type ([N]T) to its TypeScript equivalent.
 // It generates T_ts[], where T_ts is the translated element type.
 func (c *GoToTSCompiler) WriteArrayType(t *types.Array) {
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally("[]") // Arrays cannot be nil
 }
 
@@ -179,18 +285,19 @@ func (c *GoToTSCompiler) WriteArrayType(t *types.Array) {
 // and element types respectively.
 func (c *GoToTSCompiler) WriteMapType(t *types.Map) {
 	c.tsw.WriteLiterally("Map<")
-	c.WriteGoType(t.Key())
+	c.WriteGoType(t.Key(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(", ")
-	c.WriteGoType(t.Elem())
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
 	c.tsw.WriteLiterally(">")
 }
 
 // WriteChannelType translates a Go channel type (chan T) to its TypeScript equivalent.
-// It generates $.Channel<T_ts>, where T_ts is the translated element type.
+// It generates $.Channel<T_ts> | null, where T_ts is the translated element type.
+// Channels are nilable in Go, so they are represented as nullable types in TypeScript.
 func (c *GoToTSCompiler) WriteChannelType(t *types.Chan) {
 	c.tsw.WriteLiterally("$.Channel<")
-	c.WriteGoType(t.Elem())
-	c.tsw.WriteLiterally(">")
+	c.WriteGoType(t.Elem(), GoTypeContextGeneral)
+	c.tsw.WriteLiterally("> | null")
 }
 
 // WriteFuncType translates a Go function type (`ast.FuncType`) into a TypeScript
@@ -217,7 +324,7 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 		if len(exp.Results.List) == 1 && len(exp.Results.List[0].Names) == 0 {
 			// Single unnamed return type
 			typ := c.pkg.TypesInfo.TypeOf(exp.Results.List[0].Type)
-			c.WriteGoType(typ)
+			c.WriteGoType(typ, GoTypeContextFunctionReturn)
 		} else {
 			// Multiple or named return types -> tuple
 			c.tsw.WriteLiterally("[")
@@ -226,7 +333,7 @@ func (c *GoToTSCompiler) WriteFuncType(exp *ast.FuncType, isAsync bool) {
 					c.tsw.WriteLiterally(", ")
 				}
 				typ := c.pkg.TypesInfo.TypeOf(field.Type)
-				c.WriteGoType(typ)
+				c.WriteGoType(typ, GoTypeContextFunctionReturn)
 			}
 			c.tsw.WriteLiterally("]")
 		}
@@ -288,10 +395,10 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 		c.tsw.WriteLiterally(": ")
 
 		if paramVariadic && paramIsSlice {
-			c.WriteGoType(paramSlice.Elem())
+			c.WriteGoType(paramSlice.Elem(), GoTypeContextGeneral)
 			c.tsw.WriteLiterally("[]")
 		} else {
-			c.WriteGoType(param.Type())
+			c.WriteGoType(param.Type(), GoTypeContextGeneral)
 		}
 	}
 	c.tsw.WriteLiterally(")")
@@ -302,7 +409,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 	if results.Len() == 0 {
 		c.tsw.WriteLiterally("void")
 	} else if results.Len() == 1 {
-		c.WriteGoType(results.At(0).Type())
+		c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn)
 	} else {
 		// Multiple return values -> tuple
 		c.tsw.WriteLiterally("[")
@@ -310,7 +417,7 @@ func (c *GoToTSCompiler) WriteSignatureType(t *types.Signature) {
 			if i > 0 {
 				c.tsw.WriteLiterally(", ")
 			}
-			c.WriteGoType(results.At(i).Type())
+			c.WriteGoType(results.At(i).Type(), GoTypeContextFunctionReturn)
 		}
 		c.tsw.WriteLiterally("]")
 	}
@@ -378,7 +485,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 				}
 				c.tsw.WriteLiterally(paramName)
 				c.tsw.WriteLiterally(": ")
-				c.WriteGoType(paramVar.Type()) // Recursive call for param type
+				c.WriteGoType(paramVar.Type(), GoTypeContextGeneral) // Recursive call for param type
 			}
 			c.tsw.WriteLiterally(")") // End params
 
@@ -388,14 +495,14 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			if results.Len() == 0 {
 				c.tsw.WriteLiterally("void")
 			} else if results.Len() == 1 {
-				c.WriteGoType(results.At(0).Type()) // Recursive call for result type
+				c.WriteGoType(results.At(0).Type(), GoTypeContextFunctionReturn) // Recursive call for result type
 			} else {
 				c.tsw.WriteLiterally("[")
 				for j := 0; j < results.Len(); j++ {
 					if j > 0 {
 						c.tsw.WriteLiterally(", ")
 					}
-					c.WriteGoType(results.At(j).Type()) // Recursive call for result type
+					c.WriteGoType(results.At(j).Type(), GoTypeContextFunctionReturn) // Recursive call for result type
 				}
 				c.tsw.WriteLiterally("]")
 			}
@@ -419,7 +526,7 @@ func (c *GoToTSCompiler) writeInterfaceStructure(iface *types.Interface, astNode
 			// When WriteGoType encounters an interface, it will call WriteInterfaceType
 			// which will pass nil for astNode, so comments for deeply embedded interface literals
 			// might not be available unless they are named types.
-			c.WriteGoType(embeddedType)
+			c.WriteGoType(embeddedType, GoTypeContextGeneral)
 		}
 	}
 }
@@ -433,107 +540,10 @@ func (c *GoToTSCompiler) getTypeString(goType types.Type) string {
 	var typeStr strings.Builder
 	writer := NewTSCodeWriter(&typeStr)
 	tempCompiler := NewGoToTSCompiler(writer, c.pkg, c.analysis)
-	tempCompiler.WriteGoType(goType)
+	tempCompiler.WriteGoType(goType, GoTypeContextGeneral)
 	return typeStr.String()
 }
 
-// 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, ", ") + "}"
-}
-
 // WriteStructType translates a Go struct type definition (`ast.StructType`)
 // into a TypeScript anonymous object type (e.g., `{ Field1: Type1; Field2: Type2 }`).
 // If the struct has no fields, it writes `{}`. Otherwise, it delegates to
@@ -550,7 +560,84 @@ func (c *GoToTSCompiler) WriteStructType(t *types.Struct) {
 			c.tsw.WriteLiterally("; ")
 		}
 		c.tsw.WriteLiterally(field.Name() + "?: ")
-		c.WriteGoType(field.Type())
+		c.WriteGoType(field.Type(), GoTypeContextGeneral)
 	}
 	c.tsw.WriteLiterally(" }")
 }
+
+// WriteTypeParameters translates Go type parameters to TypeScript generic parameters.
+// It handles the TypeParams field of ast.FuncDecl and ast.TypeSpec to generate
+// TypeScript generic parameter lists like <T extends SomeConstraint, U extends OtherConstraint>.
+func (c *GoToTSCompiler) WriteTypeParameters(typeParams *ast.FieldList) {
+	if typeParams == nil || len(typeParams.List) == 0 {
+		return
+	}
+
+	c.tsw.WriteLiterally("<")
+	for i, field := range typeParams.List {
+		if i > 0 {
+			c.tsw.WriteLiterally(", ")
+		}
+		// Write each type parameter name and constraint
+		for j, name := range field.Names {
+			if j > 0 {
+				c.tsw.WriteLiterally(", ")
+			}
+			c.tsw.WriteLiterally(name.Name)
+
+			// Write constraint if present
+			if field.Type != nil {
+				c.tsw.WriteLiterally(" extends ")
+				c.WriteTypeConstraint(field.Type)
+			}
+		}
+	}
+	c.tsw.WriteLiterally(">")
+}
+
+// WriteTypeConstraint translates Go type constraints to TypeScript constraint expressions.
+// It handles different constraint types including:
+// - Union types: []byte | string -> string | Uint8Array
+// - Interface types: interface{Method()} -> {Method(): void}
+// - Basic types: any -> any, comparable -> $.Comparable
+func (c *GoToTSCompiler) WriteTypeConstraint(constraint ast.Expr) {
+	switch t := constraint.(type) {
+	case *ast.Ident:
+		// Handle predeclared constraints
+		switch t.Name {
+		case "any":
+			c.tsw.WriteLiterally("any")
+		case "comparable":
+			c.tsw.WriteLiterally("$.Comparable")
+		default:
+			// Use the type directly
+			c.WriteTypeExpr(t)
+		}
+	case *ast.BinaryExpr:
+		// Handle union types like []byte | string
+		if t.Op.String() == "|" {
+			c.WriteTypeConstraint(t.X)
+			c.tsw.WriteLiterally(" | ")
+			c.WriteTypeConstraint(t.Y)
+		} else {
+			// Fallback for other binary expressions
+			c.WriteTypeExpr(constraint)
+		}
+	case *ast.InterfaceType:
+		// Handle interface constraints
+		c.WriteTypeExpr(constraint)
+	case *ast.ArrayType:
+		// Handle []byte specifically
+		if ident, ok := t.Elt.(*ast.Ident); ok && ident.Name == "byte" {
+			c.tsw.WriteLiterally("Uint8Array")
+		} else {
+			c.WriteTypeExpr(constraint)
+		}
+	case *ast.SliceExpr:
+		// Handle slice types in constraints
+		c.WriteTypeExpr(constraint)
+	default:
+		// Fallback: use the standard type expression writer
+		c.WriteTypeExpr(constraint)
+	}
+}

package/dist/gs/builtin/builtin.js

@@ -0,0 +1,37 @@
+export * from './varRef.js';
+export * from './channel.js';
+export * from './defer.js';
+export * from './io.js';
+export * from './map.js';
+export * from './slice.js';
+export * from './type.js';
+// Duration multiplication helper for time package operations
+// Handles expressions like time.Hour * 24
+export function multiplyDuration(duration, multiplier) {
+    // Check if duration has a multiply method (like our Duration class)
+    if (duration && typeof duration.multiply === 'function') {
+        return duration.multiply(multiplier);
+    }
+    // Check if duration has a valueOf method for numeric operations
+    if (duration && typeof duration.valueOf === 'function') {
+        const numValue = duration.valueOf();
+        // Return an object with the same structure but multiplied value
+        if (typeof numValue === 'number') {
+            // Try to create a new instance of the same type
+            if (duration.constructor) {
+                return new duration.constructor(numValue * multiplier);
+            }
+            // Fallback: return a simple object with valueOf
+            return {
+                valueOf: () => numValue * multiplier,
+                toString: () => (numValue * multiplier).toString() + "ns"
+            };
+        }
+    }
+    // Fallback for simple numeric values
+    if (typeof duration === 'number') {
+        return duration * multiplier;
+    }
+    throw new Error(`Cannot multiply duration of type ${typeof duration}`);
+}
+//# sourceMappingURL=builtin.js.map

package/dist/gs/builtin/builtin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.js","sourceRoot":"","sources":["../../../gs/builtin/builtin.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,YAAY,CAAA;AAC1B,cAAc,SAAS,CAAA;AACvB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA;AAC1B,cAAc,WAAW,CAAA;AAEzB,6DAA6D;AAC7D,0CAA0C;AAC1C,MAAM,UAAU,gBAAgB,CAAC,QAAa,EAAE,UAAkB,EAAO;IACvE,oEAAoE;IACpE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;QACxD,OAAO,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACvC,CAAC;IAED,gEAAgE;IAChE,IAAI,QAAQ,IAAI,OAAO,QAAQ,CAAC,OAAO,KAAK,UAAU,EAAE,CAAC;QACvD,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC;QACpC,gEAAgE;QAChE,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;YACjC,gDAAgD;YAChD,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;gBACzB,OAAO,IAAI,QAAQ,CAAC,WAAW,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC;YACzD,CAAC;YACD,gDAAgD;YAChD,OAAO;gBACL,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,GAAG,UAAU;gBACpC,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC,QAAQ,GAAG,UAAU,CAAC,CAAC,QAAQ,EAAE,GAAG,IAAI;aAC1D,CAAC;QACJ,CAAC;IACH,CAAC;IAED,qCAAqC;IACrC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,OAAO,QAAQ,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,oCAAoC,OAAO,QAAQ,EAAE,CAAC,CAAC;AAAA,CACxE"}