diff --git a/internal/runtime/pkg/builtin/builtin.go b/internal/runtime/pkg/builtin/builtin.go
index fbb54fb..439de41 100644
--- a/internal/runtime/pkg/builtin/builtin.go
+++ b/internal/runtime/pkg/builtin/builtin.go
@@ -13,16 +13,26 @@ type Builtin struct {
 	Name       string
 	Function   func(*goja.Runtime) func(goja.FunctionCall) goja.Value
 	Definition string
+	isPromise  bool
 }
 
 type EmptyArgs struct{}
 
+type RegisterOption func(*Builtin) error
+
+func WithPromise() RegisterOption {
+	return func(b *Builtin) error {
+		b.isPromise = true
+		return nil
+	}
+}
+
 var (
 	builtinRegistry = make(map[string]Builtin)
 	registryMutex   sync.RWMutex
 )
 
-func RegisterBuiltin[T any, R any](name string, fn any) {
+func RegisterBuiltin[T any, R any](name string, fn any, opts ...RegisterOption) {
 	var zeroT T
 	tType := reflect.TypeOf(zeroT)
 
@@ -31,18 +41,35 @@ func RegisterBuiltin[T any, R any](name string, fn any) {
 	}
 
 	fnType := reflect.TypeOf(fn)
-	wrapper := createWrapper[T](fn, fnType)
+
+	isPromise := false
+	for _, opt := range opts {
+		if opt != nil {
+			isPromise = true
+			break
+		}
+	}
+
+	wrapper := createWrapper[T](fn, fnType, isPromise)
 
 	registryMutex.Lock()
-	builtinRegistry[name] = Builtin{
+	b := Builtin{
 		Name:       name,
 		Function:   wrapper,
-		Definition: generateTypeScriptDefinition(name, tType, fnType),
+		Definition: generateTypeScriptDefinition(name, tType, fnType, isPromise),
 	}
+	for _, opt := range opts {
+		if opt != nil {
+			if err := opt(&b); err != nil {
+				panic(fmt.Sprintf("builtin %s: option error: %v", name, err))
+			}
+		}
+	}
+	builtinRegistry[name] = b
 	registryMutex.Unlock()
 }
 
-func createWrapper[T any](fn any, fnType reflect.Type) func(*goja.Runtime) func(goja.FunctionCall) goja.Value {
+func createWrapper[T any](fn any, fnType reflect.Type, isPromise bool) func(*goja.Runtime) func(goja.FunctionCall) goja.Value {
 	return func(vm *goja.Runtime) func(goja.FunctionCall) goja.Value {
 		return func(call goja.FunctionCall) goja.Value {
 			var args T
@@ -83,19 +110,53 @@ func createWrapper[T any](fn any, fnType reflect.Type) func(*goja.Runtime) func(
 
 			if err, isError := results[len(results)-1].Interface().(error); isError {
 				if err != nil {
+					if isPromise {
+						return createRejectedPromise(vm, err)
+					}
 					panic(err)
 				}
 				if len(results) == 1 {
+					if isPromise {
+						return createResolvedPromise(vm)
+					}
 					return goja.Undefined()
 				}
+				if isPromise {
+					return createResolvedPromise(vm, results[0])
+				}
 				return convertGoValueToJS(vm, results[0])
 			}
 
+			if isPromise {
+				return createResolvedPromise(vm, results[0])
+			}
+
 			return convertGoValueToJS(vm, results[0])
 		}
 	}
 }
 
+func createResolvedPromise(vm *goja.Runtime, value ...reflect.Value) goja.Value {
+	promise, resolve, _ := vm.NewPromise()
+	go func() {
+		if len(value) > 0 {
+			jsValue := convertGoValueToJS(vm, value[0])
+			_ = resolve(jsValue)
+		} else {
+			_ = resolve(goja.Undefined())
+		}
+	}()
+	return vm.ToValue(promise)
+}
+
+func createRejectedPromise(vm *goja.Runtime, err error) goja.Value {
+	promise, _, reject := vm.NewPromise()
+	go func() {
+		_ = reject(vm.ToValue(err.Error()))
+	}()
+	return vm.ToValue(promise)
+}
+
 func convertJSValueToGo(vm *goja.Runtime, jsValue goja.Value, targetType reflect.Type) (any, error) {
 	if goja.IsNull(jsValue) {
 		if targetType.Kind() == reflect.Pointer || targetType.Kind() == reflect.Map {
@@ -292,7 +353,7 @@ func getFieldName(field reflect.StructField) string {
 	return field.Name
 }
 
-func generateTypeScriptDefinition(name string, argsType reflect.Type, fnType reflect.Type) string {
+func generateTypeScriptDefinition(name string, argsType reflect.Type, fnType reflect.Type, isPromise bool) string {
 	if argsType.Kind() != reflect.Struct {
 		return ""
 	}
@@ -321,6 +382,10 @@ func generateTypeScriptDefinition(name string, argsType reflect.Type, fnType ref
 		}
 	}
 
+	if isPromise {
+		returnSignature = fmt.Sprintf("Promise<%s>", returnSignature)
+	}
+
 	return fmt.Sprintf("declare function %s(%s): %s;", name, strings.Join(params, ", "), returnSignature)
 }
 
@@ -367,6 +432,11 @@ func goTypeToTSType(t reflect.Type, isPointer bool) string {
 			fields = append(fields, fmt.Sprintf("%s: %s", name, tsType))
 		}
 		return fmt.Sprintf("{ %s }", strings.Join(fields, "; "))
+	case reflect.Pointer:
+		if t.Elem().Kind() == reflect.Struct {
+			return goTypeToTSType(t.Elem(), false)
+		}
+		return "any"
 	default:
 		return "any"
 	}
diff --git a/internal/runtime/standard/fetch.go b/internal/runtime/standard/fetch.go
index 126e946..1150f37 100644
--- a/internal/runtime/standard/fetch.go
+++ b/internal/runtime/standard/fetch.go
@@ -11,13 +11,14 @@ import (
 )
 
 type FetchArgs struct {
-	URL     string        `json:"url"`
-	Options *FetchOptions `json:"options"`
+	Input string        `json:"input"`
+	Init  *FetchOptions `json:"init,omitempty"`
 }
 
 type FetchOptions struct {
-	Method  string             `json:"method"`
-	Headers *map[string]string `json:"headers"`
+	Method  string            `json:"method,omitempty"`
+	Headers map[string]string `json:"headers,omitempty"`
+	Body    *string           `json:"body,omitempty"`
 }
 
 func (o *FetchOptions) Defaults() *FetchOptions {
@@ -47,14 +48,14 @@ func Fetch(args FetchArgs) (*FetchResult, error) {
 	method := "GET"
 	headers := make(map[string]string)
 
-	if args.Options != nil {
-		method = args.Options.Method
-		if args.Options.Headers != nil {
-			maps.Copy(headers, *args.Options.Headers)
+	if args.Init != nil {
+		method = args.Init.Method
+		if args.Init.Headers != nil {
+			maps.Copy(headers, args.Init.Headers)
 		}
 	}
 
-	req, err := http.NewRequest(method, args.URL, nil)
+	req, err := http.NewRequest(method, args.Input, nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
@@ -102,7 +103,7 @@ func greet(args GreetArgs) string {
 }
 
 func init() {
-	builtin.RegisterBuiltin[FetchArgs, *FetchResult]("fetch", Fetch)
+	builtin.RegisterBuiltin[FetchArgs, *FetchResult]("fetch", Fetch, builtin.WithPromise())
 	builtin.RegisterBuiltin[AddArgs, int]("add", add)
 	builtin.RegisterBuiltin[GreetArgs, string]("greet", greet)
 }
diff --git a/internal/runtime/standard/fetch_test.go b/internal/runtime/standard/fetch_test.go
index 9cce52a..d7f7201 100644
--- a/internal/runtime/standard/fetch_test.go
+++ b/internal/runtime/standard/fetch_test.go
@@ -18,7 +18,7 @@ func TestFetch(t *testing.T) {
 	}))
 	defer server.Close()
 
-	result, err := Fetch(FetchArgs{URL: server.URL})
+	result, err := Fetch(FetchArgs{Input: server.URL})
 	require.NoError(t, err)
 
 	assert.True(t, result.OK)
@@ -32,7 +32,7 @@ func TestFetch(t *testing.T) {
 func TestFetchHTTPBin(t *testing.T) {
 	t.Skip("httpbin.org test is flaky")
 
-	result, err := Fetch(FetchArgs{URL: "https://httpbin.org/get"})
+	result, err := Fetch(FetchArgs{Input: "https://httpbin.org/get"})
 	require.NoError(t, err)
 
 	assert.True(t, result.OK)
@@ -42,7 +42,7 @@ func TestFetchHTTPBin(t *testing.T) {
 }
 
 func TestFetchWith404(t *testing.T) {
-	result, err := Fetch(FetchArgs{URL: "https://httpbin.org/status/404"})
+	result, err := Fetch(FetchArgs{Input: "https://httpbin.org/status/404"})
 	require.NoError(t, err)
 
 	assert.False(t, result.OK)
@@ -50,7 +50,7 @@ func TestFetchWith404(t *testing.T) {
 }
 
 func TestFetchWithInvalidURL(t *testing.T) {
-	_, err := Fetch(FetchArgs{URL: "http://this-domain-does-not-exist-12345.com"})
+	_, err := Fetch(FetchArgs{Input: "http://this-domain-does-not-exist-12345.com"})
 	assert.Error(t, err)
 	assert.Contains(t, err.Error(), "failed to fetch")
 }
@@ -69,9 +69,9 @@ func TestFetchWithHeaders(t *testing.T) {
 	}
 	options := &FetchOptions{
 		Method:  "GET",
-		Headers: &headers,
+		Headers: headers,
 	}
-	result, err := Fetch(FetchArgs{URL: server.URL, Options: options})
+	result, err := Fetch(FetchArgs{Input: server.URL, Init: options})
 	require.NoError(t, err)
 	assert.True(t, result.OK)
 }
@@ -85,7 +85,7 @@ func TestFetchDefaults(t *testing.T) {
 	defer server.Close()
 
 	options := &FetchOptions{}
-	result, err := Fetch(FetchArgs{URL: server.URL, Options: options})
+	result, err := Fetch(FetchArgs{Input: server.URL, Init: options})
 	require.NoError(t, err)
 	assert.True(t, result.OK)
 }
diff --git a/test_data/fetch.ts b/test_data/fetch.ts
index 251bbe7..ce60317 100644
--- a/test_data/fetch.ts
+++ b/test_data/fetch.ts
@@ -1,6 +1,10 @@
-const response = fetch("https://httpbin.org/get");
+async function main() {
+	const response = await fetch("https://httpbin.org/get");
 
-console.log("OK:", response.ok);
-console.log("Status:", response.status);
-console.log("Body:", response.body);
-console.log("Content-Type:", response.headers["content-type"]);
+	console.log("OK:", response.ok);
+	console.log("Status:", response.status);
+	console.log("Body:", response.body);
+	console.log("Content-Type:", response.headers["content-type"]);
+}
+
+main();