all: replace module "share" with "pakakeh.go"

The module "share" has been moved to new repository at SourceHut and
we rename it to make it more unique instead of common English words
"share".

15 files changed, 346 insertions, 300 deletions

diff --git a/blockd_test.go b/blockd_test.go
index f1d6abf..b231b90 100644
--- a/blockd_test.go
+++ b/blockd_test.go
@@ -8,7 +8,7 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/shuLhan/share/lib/test"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/test"
 )
 
 func TestBlockd_init(t *testing.T) {
diff --git a/client.go b/client.go
index e7a6946..2cc8b2c 100644
--- a/client.go
+++ b/client.go
@@ -10,8 +10,8 @@ import (
 	"net/http"
 	"net/url"
 
-	"github.com/shuLhan/share/lib/dns"
-	libhttp "github.com/shuLhan/share/lib/http"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
+	libhttp "git.sr.ht/~shulhan/pakakeh.go/lib/http"
 )
 
 // Client for rescached.
@@ -23,12 +23,12 @@ type Client struct {
 func NewClient(serverURL string, insecure bool) (cl *Client) {
 	var (
 		httpcOpts = libhttp.ClientOptions{
-			ServerUrl:     serverURL,
+			ServerURL:     serverURL,
 			AllowInsecure: insecure,
 		}
 	)
 	cl = &Client{
-		Client: libhttp.NewClient(&httpcOpts),
+		Client: libhttp.NewClient(httpcOpts),
 	}
 	return cl
 }
@@ -36,20 +36,23 @@ func NewClient(serverURL string, insecure bool) (cl *Client) {
 // Blockd return list of all block.d files on the server.
 func (cl *Client) Blockd() (hostBlockd map[string]*Blockd, err error) {
 	var (
-		logp = "Blockd"
-		res  = libhttp.EndpointResponse{}
-
-		resb []byte
+		logp      = `Blockd`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPIBlockd,
+		}
+		clientResp *libhttp.ClientResponse
 	)
 
-	_, resb, err = cl.Get(httpAPIBlockd, nil, nil)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	res.Data = &hostBlockd
+	var res = libhttp.EndpointResponse{
+		Data: &hostBlockd,
+	}
 
-	err = json.Unmarshal(resb, &res)
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -63,22 +66,26 @@ func (cl *Client) Blockd() (hostBlockd map[string]*Blockd, err error) {
 // BlockdDisable disable specific hosts on block.d.
 func (cl *Client) BlockdDisable(blockdName string) (blockd *Blockd, err error) {
 	var (
-		logp   = "BlockdDisable"
-		res    = libhttp.EndpointResponse{}
-		params = url.Values{}
-
-		resb []byte
+		logp      = `BlockdDisable`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPIBlockdDisable,
+			Params: url.Values{
+				paramNameName: []string{blockdName},
+			},
+		}
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, blockdName)
-
-	_, resb, err = cl.PostForm(httpAPIBlockdDisable, nil, params)
+	clientResp, err = cl.PostForm(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	res.Data = &blockd
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &blockd,
+	}
+
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -92,22 +99,25 @@ func (cl *Client) BlockdDisable(blockdName string) (blockd *Blockd, err error) {
 // BlockdEnable enable specific hosts on block.d.
 func (cl *Client) BlockdEnable(blockdName string) (blockd *Blockd, err error) {
 	var (
-		logp   = "BlockdEnable"
-		res    = libhttp.EndpointResponse{}
-		params = url.Values{}
-
-		resb []byte
+		logp      = `BlockdEnable`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPIBlockdEnable,
+			Params: url.Values{
+				paramNameName: []string{blockdName},
+			},
+		}
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, blockdName)
-
-	_, resb, err = cl.PostForm(httpAPIBlockdEnable, nil, params)
+	clientResp, err = cl.PostForm(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	res.Data = &blockd
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &blockd,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -122,22 +132,25 @@ func (cl *Client) BlockdEnable(blockdName string) (blockd *Blockd, err error) {
 // provider based on registered URL.
 func (cl *Client) BlockdFetch(blockdName string) (blockd *Blockd, err error) {
 	var (
-		logp   = "BlockdFetch"
-		params = url.Values{}
-		res    = libhttp.EndpointResponse{}
-
-		resb []byte
+		logp = `BlockdFetch`
+		req  = libhttp.ClientRequest{
+			Path: httpAPIBlockdFetch,
+			Params: url.Values{
+				paramNameName: []string{blockdName},
+			},
+		}
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, blockdName)
-
-	_, resb, err = cl.PostForm(httpAPIBlockdFetch, nil, params)
+	clientResp, err = cl.PostForm(req)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	res.Data = &blockd
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &blockd,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -151,20 +164,22 @@ func (cl *Client) BlockdFetch(blockdName string) (blockd *Blockd, err error) {
 // Caches fetch all of non-local caches from server.
 func (cl *Client) Caches() (answers []*dns.Answer, err error) {
 	var (
-		logp = "Caches"
-		res  = libhttp.EndpointResponse{
-			Data: &answers,
+		logp      = `Caches`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPICaches,
 		}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	_, resb, err = cl.Get(httpAPICaches, nil, nil)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &answers,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -179,23 +194,26 @@ func (cl *Client) Caches() (answers []*dns.Answer, err error) {
 // CachesRemove request to remove caches by its domain name.
 func (cl *Client) CachesRemove(q string) (listAnswer []*dns.Answer, err error) {
 	var (
-		logp   = "CachesRemove"
-		params = url.Values{}
-		res    = libhttp.EndpointResponse{
-			Data: &listAnswer,
+		logp      = `CachesRemove`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPICaches,
+			Params: url.Values{
+				paramNameName: []string{q},
+			},
 		}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, q)
-
-	_, resb, err = cl.Delete(httpAPICaches, nil, params)
+	clientResp, err = cl.Delete(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &listAnswer,
+	}
+
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -211,23 +229,25 @@ func (cl *Client) CachesRemove(q string) (listAnswer []*dns.Answer, err error) {
 // as DNS message.
 func (cl *Client) CachesSearch(q string) (listMsg []*dns.Message, err error) {
 	var (
-		logp   = "CachesSearch"
-		params = url.Values{}
-		res    = libhttp.EndpointResponse{
-			Data: &listMsg,
+		logp      = `CachesSearch`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPICachesSearch,
+			Params: url.Values{
+				paramNameQuery: []string{q},
+			},
 		}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameQuery, q)
-
-	_, resb, err = cl.Get(httpAPICachesSearch, nil, params)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &listMsg,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -241,18 +261,22 @@ func (cl *Client) CachesSearch(q string) (listMsg []*dns.Message, err error) {
 // Env get the server environment.
 func (cl *Client) Env() (env *Environment, err error) {
 	var (
-		logp = "Env"
-		res  = libhttp.EndpointResponse{
-			Data: &env,
+		logp      = `Env`
+		clientReq = libhttp.ClientRequest{
+			Path: httpAPIEnvironment,
 		}
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	_, resb, err = cl.Get(httpAPIEnvironment, nil, nil)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
-	err = json.Unmarshal(resb, &res)
+
+	var res = libhttp.EndpointResponse{
+		Data: &env,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -265,20 +289,23 @@ func (cl *Client) Env() (env *Environment, err error) {
 // EnvUpdate update the server environment using new Environment.
 func (cl *Client) EnvUpdate(envIn *Environment) (envOut *Environment, err error) {
 	var (
-		logp = "EnvUpdate"
-		res  = libhttp.EndpointResponse{
-			Data: &envOut,
+		logp      = `EnvUpdate`
+		clientReq = libhttp.ClientRequest{
+			Path:   httpAPIEnvironment,
+			Params: envIn,
 		}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	_, resb, err = cl.PostJSON(httpAPIEnvironment, nil, envIn)
+	clientResp, err = cl.PostJSON(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &envOut,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -291,23 +318,25 @@ func (cl *Client) EnvUpdate(envIn *Environment) (envOut *Environment, err error)
 // HostsdCreate create new hosts file inside the hosts.d with requested name.
 func (cl *Client) HostsdCreate(name string) (hostsFile *dns.HostsFile, err error) {
 	var (
-		logp = "HostsdCreate"
-		res  = libhttp.EndpointResponse{
-			Data: &hostsFile,
+		logp      = `HostsdCreate`
+		clientReq = libhttp.ClientRequest{
+			Path: apiHostsd,
+			Params: url.Values{
+				paramNameName: []string{name},
+			},
 		}
-		params = url.Values{}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, name)
-
-	_, resb, err = cl.PostForm(apiHostsd, nil, params)
+	clientResp, err = cl.PostForm(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &hostsFile,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -320,23 +349,25 @@ func (cl *Client) HostsdCreate(name string) (hostsFile *dns.HostsFile, err error
 // HostsdDelete delete hosts file inside the hosts.d by file name.
 func (cl *Client) HostsdDelete(name string) (hostsFile *dns.HostsFile, err error) {
 	var (
-		logp = "HostsdDelete"
-		res  = libhttp.EndpointResponse{
-			Data: &hostsFile,
+		logp      = `HostsdDelete`
+		clientReq = libhttp.ClientRequest{
+			Path: apiHostsd,
+			Params: url.Values{
+				paramNameName: []string{name},
+			},
 		}
-		params = url.Values{}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, name)
-
-	_, resb, err = cl.Delete(apiHostsd, nil, params)
+	clientResp, err = cl.Delete(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &hostsFile,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -349,23 +380,25 @@ func (cl *Client) HostsdDelete(name string) (hostsFile *dns.HostsFile, err error
 // HostsdGet get the content of hosts file inside the hosts.d by file name.
 func (cl *Client) HostsdGet(name string) (listrr []*dns.ResourceRecord, err error) {
 	var (
-		logp = "HostsdGet"
-		res  = libhttp.EndpointResponse{
-			Data: &listrr,
+		logp      = `HostsdGet`
+		clientReq = libhttp.ClientRequest{
+			Path: apiHostsd,
+			Params: url.Values{
+				paramNameName: []string{name},
+			},
 		}
-		params = url.Values{}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, name)
-
-	_, resb, err = cl.Get(apiHostsd, nil, params)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &listrr,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -378,25 +411,27 @@ func (cl *Client) HostsdGet(name string) (listrr []*dns.ResourceRecord, err erro
 // HostsdRecordAdd add new resource record to the hosts file.
 func (cl *Client) HostsdRecordAdd(hostsName, domain, value string) (record *dns.ResourceRecord, err error) {
 	var (
-		logp = "HostsdRecordAdd"
-		res  = libhttp.EndpointResponse{
-			Data: &record,
+		logp      = `HostsdRecordAdd`
+		clientReq = libhttp.ClientRequest{
+			Path: apiHostsdRR,
+			Params: url.Values{
+				paramNameName:   []string{hostsName},
+				paramNameDomain: []string{domain},
+				paramNameValue:  []string{value},
+			},
 		}
-		params = url.Values{}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, hostsName)
-	params.Set(paramNameDomain, domain)
-	params.Set(paramNameValue, value)
-
-	_, resb, err = cl.PostForm(apiHostsdRR, nil, params)
+	clientResp, err = cl.PostForm(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &record,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -410,24 +445,26 @@ func (cl *Client) HostsdRecordAdd(hostsName, domain, value string) (record *dns.
 // HostsdRecordDelete delete a record from hosts file by domain name.
 func (cl *Client) HostsdRecordDelete(hostsName, domain string) (record *dns.ResourceRecord, err error) {
 	var (
-		logp = "HostsdRecordDelete"
-		res  = libhttp.EndpointResponse{
-			Data: &record,
+		logp      = `HostsdRecordDelete`
+		clientReq = libhttp.ClientRequest{
+			Path: apiHostsdRR,
+			Params: url.Values{
+				paramNameName:   []string{hostsName},
+				paramNameDomain: []string{domain},
+			},
 		}
-		params = url.Values{}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, hostsName)
-	params.Set(paramNameDomain, domain)
-
-	_, resb, err = cl.Delete(apiHostsdRR, nil, params)
+	clientResp, err = cl.Delete(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &record,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -441,20 +478,22 @@ func (cl *Client) HostsdRecordDelete(hostsName, domain string) (record *dns.Reso
 // Zoned fetch and return list of zone managed on server.
 func (cl *Client) Zoned() (zones map[string]*dns.Zone, err error) {
 	var (
-		logp = "Zoned"
-		res  = libhttp.EndpointResponse{}
-
-		resBody []byte
+		logp      = `Zoned`
+		clientReq = libhttp.ClientRequest{
+			Path: apiZoned,
+		}
+		clientResp *libhttp.ClientResponse
 	)
 
-	res.Data = &zones
-
-	_, resBody, err = cl.Get(apiZoned, nil, nil)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resBody, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &zones,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -465,23 +504,25 @@ func (cl *Client) Zoned() (zones map[string]*dns.Zone, err error) {
 // ZonedCreate create new zone file.
 func (cl *Client) ZonedCreate(name string) (zone *dns.Zone, err error) {
 	var (
-		logp = "ZonedCreate"
-		res  = libhttp.EndpointResponse{
-			Data: &zone,
+		logp      = `ZonedCreate`
+		clientReq = libhttp.ClientRequest{
+			Path: apiZoned,
+			Params: url.Values{
+				paramNameName: []string{name},
+			},
 		}
-		params = url.Values{}
-
-		resb []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, name)
-
-	_, resb, err = cl.PostForm(apiZoned, nil, params)
+	clientResp, err = cl.PostForm(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &zone,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -494,27 +535,28 @@ func (cl *Client) ZonedCreate(name string) (zone *dns.Zone, err error) {
 // ZonedDelete delete zone file by name.
 func (cl *Client) ZonedDelete(name string) (zone *dns.Zone, err error) {
 	var (
-		logp = "ZonedDelete"
-		res  = libhttp.EndpointResponse{
-			Data: &zone,
+		logp      = `ZonedDelete`
+		clientReq = libhttp.ClientRequest{
+			Path: apiZoned,
+			Params: url.Values{
+				paramNameName: []string{name},
+			},
 		}
-		params = url.Values{}
-
-		httpRes *http.Response
-		resb    []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, name)
-
-	httpRes, resb, err = cl.Delete(apiZoned, nil, params)
+	clientResp, err = cl.Delete(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
-	if httpRes.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("%s: %s", logp, httpRes.Status)
+	if clientResp.HTTPResponse.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("%s: %s", logp, clientResp.HTTPResponse.Status)
 	}
 
-	err = json.Unmarshal(resb, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &zone,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -527,23 +569,25 @@ func (cl *Client) ZonedDelete(name string) (zone *dns.Zone, err error) {
 // ZonedRecords fetch the zone records by its name.
 func (cl *Client) ZonedRecords(zone string) (zoneRecords map[string][]*dns.ResourceRecord, err error) {
 	var (
-		logp   = "ZonedRecords"
-		params = url.Values{}
-		res    = libhttp.EndpointResponse{
-			Data: &zoneRecords,
+		logp      = `ZonedRecords`
+		clientReq = libhttp.ClientRequest{
+			Path: apiZonedRR,
+			Params: url.Values{
+				paramNameName: []string{zone},
+			},
 		}
-
-		resBody []byte
+		clientResp *libhttp.ClientResponse
 	)
 
-	params.Set(paramNameName, zone)
-
-	_, resBody, err = cl.Get(apiZonedRR, nil, params)
+	clientResp, err = cl.Get(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	err = json.Unmarshal(resBody, &res)
+	var res = libhttp.EndpointResponse{
+		Data: &zoneRecords,
+	}
+	err = json.Unmarshal(clientResp.Body, &res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -554,14 +598,11 @@ func (cl *Client) ZonedRecords(zone string) (zoneRecords map[string][]*dns.Resou
 // ZonedRecordAdd add new record to zone file.
 func (cl *Client) ZonedRecordAdd(name string, rreq dns.ResourceRecord) (rres *dns.ResourceRecord, err error) {
 	var (
-		logp = "ZonedRecordAdd"
+		logp = `ZonedRecordAdd`
 		zrr  = zoneRecordRequest{
 			Name: name,
 		}
-
-		res  *libhttp.EndpointResponse
-		rawb []byte
-		ok   bool
+		ok bool
 	)
 
 	zrr.Type, ok = dns.RecordTypeNames[rreq.Type]
@@ -569,6 +610,8 @@ func (cl *Client) ZonedRecordAdd(name string, rreq dns.ResourceRecord) (rres *dn
 		return nil, fmt.Errorf("%s: unknown record type: %d", logp, rreq.Type)
 	}
 
+	var rawb []byte
+
 	rawb, err = json.Marshal(rreq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
@@ -576,16 +619,22 @@ func (cl *Client) ZonedRecordAdd(name string, rreq dns.ResourceRecord) (rres *dn
 
 	zrr.Record = base64.StdEncoding.EncodeToString(rawb)
 
-	_, rawb, err = cl.PostJSON(apiZonedRR, nil, zrr)
+	var clientReq = libhttp.ClientRequest{
+		Path:   apiZonedRR,
+		Params: zrr,
+	}
+	var clientResp *libhttp.ClientResponse
+
+	clientResp, err = cl.PostJSON(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
 	rres = &dns.ResourceRecord{}
-	res = &libhttp.EndpointResponse{
+	var res = &libhttp.EndpointResponse{
 		Data: rres,
 	}
-	err = json.Unmarshal(rawb, res)
+	err = json.Unmarshal(clientResp.Body, res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
@@ -599,23 +648,23 @@ func (cl *Client) ZonedRecordAdd(name string, rreq dns.ResourceRecord) (rres *dn
 // ZonedRecordDelete delete record from zone file.
 func (cl *Client) ZonedRecordDelete(name string, rreq dns.ResourceRecord) (zoneRecords map[string][]*dns.ResourceRecord, err error) {
 	var (
-		logp   = "ZonedRecordDelete"
-		params = url.Values{}
+		logp   = `ZonedRecordDelete`
+		params = url.Values{
+			paramNameName: []string{name},
+		}
 
-		res  *libhttp.EndpointResponse
 		vstr string
-		rawb []byte
 		ok   bool
 	)
 
-	params.Set(paramNameName, name)
-
 	vstr, ok = dns.RecordTypeNames[rreq.Type]
 	if !ok {
 		return nil, fmt.Errorf("%s: unknown record type: %d", logp, rreq.Type)
 	}
 	params.Set(paramNameType, vstr)
 
+	var rawb []byte
+
 	rawb, err = json.Marshal(rreq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
@@ -623,15 +672,21 @@ func (cl *Client) ZonedRecordDelete(name string, rreq dns.ResourceRecord) (zoneR
 	vstr = base64.StdEncoding.EncodeToString(rawb)
 	params.Set(paramNameRecord, vstr)
 
-	_, rawb, err = cl.Delete(apiZonedRR, nil, params)
+	var clientReq = libhttp.ClientRequest{
+		Path:   apiZonedRR,
+		Params: params,
+	}
+	var clientResp *libhttp.ClientResponse
+
+	clientResp, err = cl.Delete(clientReq)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
 
-	res = &libhttp.EndpointResponse{
+	var res = &libhttp.EndpointResponse{
 		Data: &zoneRecords,
 	}
-	err = json.Unmarshal(rawb, res)
+	err = json.Unmarshal(clientResp.Body, res)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", logp, err)
 	}
diff --git a/client_test.go b/client_test.go
index 349b917..8398004 100644
--- a/client_test.go
+++ b/client_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/shuLhan/share/lib/test"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/test"
 )
 
 func TestClient_BlockdEnable(t *testing.T) {
diff --git a/cmd/rescached/main.go b/cmd/rescached/main.go
index 3123936..58bcf57 100644
--- a/cmd/rescached/main.go
+++ b/cmd/rescached/main.go
@@ -20,8 +20,8 @@ import (
 	"time"
 
 	"git.sr.ht/~shulhan/ciigo"
-	"github.com/shuLhan/share/lib/debug"
-	"github.com/shuLhan/share/lib/memfs"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/debug"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/memfs"
 
 	"github.com/shuLhan/rescached-go/v4"
 )
diff --git a/cmd/resolver/resolver.go b/cmd/resolver/resolver.go
index 4b5e59a..6e1c956 100644
--- a/cmd/resolver/resolver.go
+++ b/cmd/resolver/resolver.go
@@ -16,9 +16,9 @@ import (
 	"strings"
 	"time"
 
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
+	libnet "git.sr.ht/~shulhan/pakakeh.go/lib/net"
 	"github.com/shuLhan/rescached-go/v4"
-	"github.com/shuLhan/share/lib/dns"
-	libnet "github.com/shuLhan/share/lib/net"
 )
 
 const (
diff --git a/cmd/resolverbench/main.go b/cmd/resolverbench/main.go
index 0821d29..653573b 100644
--- a/cmd/resolverbench/main.go
+++ b/cmd/resolverbench/main.go
@@ -10,7 +10,7 @@ import (
 	"os"
 	"time"
 
-	"github.com/shuLhan/share/lib/dns"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
 )
 
 func usage() {
diff --git a/environment.go b/environment.go
index 1a0aef5..be46b94 100644
--- a/environment.go
+++ b/environment.go
@@ -10,13 +10,13 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/shuLhan/share/lib/debug"
-	"github.com/shuLhan/share/lib/dns"
-	libhttp "github.com/shuLhan/share/lib/http"
-	"github.com/shuLhan/share/lib/ini"
-	"github.com/shuLhan/share/lib/memfs"
-	libnet "github.com/shuLhan/share/lib/net"
-	libstrings "github.com/shuLhan/share/lib/strings"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/debug"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
+	libhttp "git.sr.ht/~shulhan/pakakeh.go/lib/http"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/ini"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/memfs"
+	libnet "git.sr.ht/~shulhan/pakakeh.go/lib/net"
+	libstrings "git.sr.ht/~shulhan/pakakeh.go/lib/strings"
 )
 
 const (
@@ -79,7 +79,7 @@ type Environment struct {
 	zoned          map[string]*dns.Zone
 
 	// The options for WUI HTTP server.
-	HttpdOptions *libhttp.ServerOptions `json:"-"`
+	HttpdOptions libhttp.ServerOptions `json:"-"`
 
 	dns.ServerOptions
 
@@ -127,13 +127,6 @@ func newEnvironment(dirBase, fileConfig string) *Environment {
 
 		fileConfig:     filepath.Join(dirBase, fileConfig),
 		hostBlockdFile: make(map[string]*dns.HostsFile),
-		HttpdOptions: &libhttp.ServerOptions{
-			Memfs:   mfsWww,
-			Address: defWuiAddress,
-		},
-		ServerOptions: dns.ServerOptions{
-			ListenAddress: defListenAddress,
-		},
 	}
 }
 
@@ -151,12 +144,10 @@ func (env *Environment) init() (err error) {
 
 	debug.Value = env.Debug
 
-	if env.HttpdOptions == nil {
-		env.HttpdOptions = &libhttp.ServerOptions{
-			Memfs:   mfsWww,
-			Address: env.WUIListen,
-		}
-	} else {
+	if env.HttpdOptions.Memfs == nil {
+		env.HttpdOptions.Memfs = mfsWww
+	}
+	if len(env.HttpdOptions.Address) == 0 {
 		env.HttpdOptions.Address = env.WUIListen
 	}
 
diff --git a/environment_test.go b/environment_test.go
index 467bd5b..a3235d3 100644
--- a/environment_test.go
+++ b/environment_test.go
@@ -9,10 +9,10 @@ import (
 	"path/filepath"
 	"testing"
 
-	"github.com/shuLhan/share/lib/dns"
-	libhttp "github.com/shuLhan/share/lib/http"
-	"github.com/shuLhan/share/lib/ini"
-	"github.com/shuLhan/share/lib/test"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
+	libhttp "git.sr.ht/~shulhan/pakakeh.go/lib/http"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/ini"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/test"
 )
 
 func TestEnvironment(t *testing.T) {
@@ -87,7 +87,7 @@ func TestLoadEnvironment(t *testing.T) {
 					URL:  "http://127.0.0.1:11180/hosts/c",
 				},
 			},
-			HttpdOptions: &libhttp.ServerOptions{
+			HttpdOptions: libhttp.ServerOptions{
 				Address: "127.0.0.1:5381",
 			},
 			ServerOptions: dns.ServerOptions{
diff --git a/go.mod b/go.mod
index 9cc79cf..94695b4 100644
--- a/go.mod
+++ b/go.mod
@@ -3,20 +3,20 @@
 
 module github.com/shuLhan/rescached-go/v4
 
-go 1.20
+go 1.22
 
 require (
-	git.sr.ht/~shulhan/ciigo v0.11.0
-	github.com/shuLhan/share v0.53.1-0.20240204074700-48e6dced72d4
+	git.sr.ht/~shulhan/ciigo v0.11.1-0.20240321082653-aed750e52cec
+	git.sr.ht/~shulhan/pakakeh.go v0.53.2-0.20240321083144-547c4b598110
 )
 
 require (
-	git.sr.ht/~shulhan/asciidoctor-go v0.5.1 // indirect
-	github.com/yuin/goldmark v1.6.0 // indirect
+	git.sr.ht/~shulhan/asciidoctor-go v0.5.2-0.20240305110034-dc67158aeeb6 // indirect
+	github.com/yuin/goldmark v1.7.0 // indirect
 	github.com/yuin/goldmark-meta v1.1.0 // indirect
-	golang.org/x/net v0.20.0 // indirect
-	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/net v0.22.0 // indirect
+	golang.org/x/sys v0.18.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
 
-//replace github.com/shuLhan/share => ../share
+//replace git.sr.ht/~shulhan/pakakeh.go => ../pakakeh.go
diff --git a/go.sum b/go.sum
index 2887d24..9d37589 100644
--- a/go.sum
+++ b/go.sum
@@ -1,17 +1,17 @@
-git.sr.ht/~shulhan/asciidoctor-go v0.5.1 h1:TuuLo+N61+qsXkiFgtiW5W1q7xHzeSID4zH+ci5J8ic=
-git.sr.ht/~shulhan/asciidoctor-go v0.5.1/go.mod h1:5audSCN6jDr2+/cMvx1MdZxkCurjl/k6A5OGYWRtB0o=
-git.sr.ht/~shulhan/ciigo v0.11.0 h1:t8/PqVQVOsG025WLjNjJSI4S37jN5CkY+LyC+zd1snI=
-git.sr.ht/~shulhan/ciigo v0.11.0/go.mod h1:pyt2kxKvipCAO+jrjHuEXOWJ2h0ss/hnO9j7Xot3JHc=
-github.com/shuLhan/share v0.53.1-0.20240204074700-48e6dced72d4 h1:v96XSlpT+F3Ium5WP2Fi428TRNjuW7HRLqzY+LIAdo4=
-github.com/shuLhan/share v0.53.1-0.20240204074700-48e6dced72d4/go.mod h1:97/BcWdLau8i+xeFvPHdyqph1HgxVBSVhQEUIyCmgRc=
-github.com/yuin/goldmark v1.6.0 h1:boZcn2GTjpsynOsC0iJHnBWa4Bi0qzfJjthwauItG68=
-github.com/yuin/goldmark v1.6.0/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+git.sr.ht/~shulhan/asciidoctor-go v0.5.2-0.20240305110034-dc67158aeeb6 h1:/0I9F83ZgfDjVDRTSNGxYaZroOxGg3o5m9GlqnWmYXs=
+git.sr.ht/~shulhan/asciidoctor-go v0.5.2-0.20240305110034-dc67158aeeb6/go.mod h1:ht3glgf7w0J2HxyKoy/ZMg//okyw3F6GrwH4/KlwhxA=
+git.sr.ht/~shulhan/ciigo v0.11.1-0.20240321082653-aed750e52cec h1:BydPiP72IvvnnV5OD5kwwTOv2jIgkgC6pQ9NhyZqeM8=
+git.sr.ht/~shulhan/ciigo v0.11.1-0.20240321082653-aed750e52cec/go.mod h1:8V5f4C/y34ndK9MGpYM2rq70f22kraeX0xLt96ZULuY=
+git.sr.ht/~shulhan/pakakeh.go v0.53.2-0.20240321083144-547c4b598110 h1:80kgGp5dJh53fU2g8HdZX6ya+5kNcKAPxbUf7blsUpk=
+git.sr.ht/~shulhan/pakakeh.go v0.53.2-0.20240321083144-547c4b598110/go.mod h1:ys7WNtXm03x0M59oqrqBjXnc+wRCX8JBXyE/W8+KVbw=
+github.com/yuin/goldmark v1.7.0 h1:EfOIvIMZIzHdB/R/zVrikYLPPwJlfMcNczJFMs1m6sA=
+github.com/yuin/goldmark v1.7.0/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 github.com/yuin/goldmark-meta v1.1.0 h1:pWw+JLHGZe8Rk0EGsMVssiNb/AaPMHfSRszZeUeiOUc=
 github.com/yuin/goldmark-meta v1.1.0/go.mod h1:U4spWENafuA7Zyg+Lj5RqK/MF+ovMYtBvXi1lBb2VP0=
-golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
-golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/net v0.22.0 h1:9sGLhx7iRIHEiX0oAJ3MRZMUCElJgy7Br1nO+AMN3Tc=
+golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
diff --git a/httpd.go b/httpd.go
index 7a9781c..b872f30 100644
--- a/httpd.go
+++ b/httpd.go
@@ -13,9 +13,9 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/shuLhan/share/lib/dns"
-	libhttp "github.com/shuLhan/share/lib/http"
-	libnet "github.com/shuLhan/share/lib/net"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
+	libhttp "git.sr.ht/~shulhan/pakakeh.go/lib/http"
+	libnet "git.sr.ht/~shulhan/pakakeh.go/lib/net"
 )
 
 const (
@@ -61,7 +61,7 @@ func (srv *Server) httpdInit() (err error) {
 func (srv *Server) httpdRegisterEndpoints() (err error) {
 	// Register HTTP APIs to manage block.d.
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         httpAPIBlockd,
 		RequestType:  libhttp.RequestTypeNone,
@@ -72,7 +72,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPut,
 		Path:         httpAPIBlockd,
 		RequestType:  libhttp.RequestTypeJSON,
@@ -83,7 +83,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         httpAPIBlockdDisable,
 		RequestType:  libhttp.RequestTypeForm,
@@ -94,7 +94,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         httpAPIBlockdEnable,
 		RequestType:  libhttp.RequestTypeForm,
@@ -105,7 +105,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         httpAPIBlockdFetch,
 		RequestType:  libhttp.RequestTypeForm,
@@ -118,7 +118,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 
 	// Register HTTP APIs to manage caches.
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         httpAPICaches,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -129,7 +129,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodDelete,
 		Path:         httpAPICaches,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -140,7 +140,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         httpAPICachesSearch,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -153,7 +153,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 
 	// Register HTTP APIs to manage environment.
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         httpAPIEnvironment,
 		RequestType:  libhttp.RequestTypeJSON,
@@ -164,7 +164,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         httpAPIEnvironment,
 		RequestType:  libhttp.RequestTypeJSON,
@@ -177,7 +177,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 
 	// Register HTTP APIs to manage hosts.d.
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         apiHostsd,
 		RequestType:  libhttp.RequestTypeForm,
@@ -188,7 +188,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 	// Register API to delete hosts file.
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodDelete,
 		Path:         apiHostsd,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -199,7 +199,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 	// Register API to get content of hosts file.
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         apiHostsd,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -211,7 +211,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 	}
 
 	// Register API to create one record in hosts file.
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         apiHostsdRR,
 		RequestType:  libhttp.RequestTypeForm,
@@ -223,7 +223,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 	}
 
 	// Register API to delete a record from hosts file.
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodDelete,
 		Path:         apiHostsdRR,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -234,7 +234,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         apiZoned,
 		RequestType:  libhttp.RequestTypeNone,
@@ -245,7 +245,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         apiZoned,
 		RequestType:  libhttp.RequestTypeForm,
@@ -255,7 +255,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 	if err != nil {
 		return err
 	}
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodDelete,
 		Path:         apiZoned,
 		RequestType:  libhttp.RequestTypeNone,
@@ -266,7 +266,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 		return err
 	}
 
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodGet,
 		Path:         apiZonedRR,
 		RequestType:  libhttp.RequestTypeQuery,
@@ -276,7 +276,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 	if err != nil {
 		return err
 	}
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodPost,
 		Path:         apiZonedRR,
 		RequestType:  libhttp.RequestTypeJSON,
@@ -286,7 +286,7 @@ func (srv *Server) httpdRegisterEndpoints() (err error) {
 	if err != nil {
 		return err
 	}
-	err = srv.httpd.RegisterEndpoint(&libhttp.Endpoint{
+	err = srv.httpd.RegisterEndpoint(libhttp.Endpoint{
 		Method:       libhttp.RequestMethodDelete,
 		Path:         apiZonedRR,
 		RequestType:  libhttp.RequestTypeForm,
@@ -365,7 +365,7 @@ func (srv *Server) httpAPIBlockdDisable(epr *libhttp.EndpointRequest) (resBody [
 		hbName string
 	)
 
-	hbName = strings.ToLower(epr.HttpRequest.Form.Get(paramNameName))
+	hbName = strings.ToLower(epr.HTTPRequest.Form.Get(paramNameName))
 
 	hb = srv.env.HostBlockd[hbName]
 	if hb == nil {
@@ -414,7 +414,7 @@ func (srv *Server) httpAPIBlockdEnable(epr *libhttp.EndpointRequest) (resBody []
 		hbName string
 	)
 
-	hbName = strings.ToLower(epr.HttpRequest.Form.Get(paramNameName))
+	hbName = strings.ToLower(epr.HTTPRequest.Form.Get(paramNameName))
 
 	hb = srv.env.HostBlockd[hbName]
 	if hb == nil {
@@ -462,7 +462,7 @@ func (srv *Server) httpAPIBlockdFetch(epr *libhttp.EndpointRequest) (resBody []b
 		hbName string
 	)
 
-	hbName = strings.ToLower(epr.HttpRequest.Form.Get(paramNameName))
+	hbName = strings.ToLower(epr.HTTPRequest.Form.Get(paramNameName))
 
 	hb = srv.env.HostBlockd[hbName]
 	if hb == nil {
@@ -510,7 +510,7 @@ func (srv *Server) httpAPICaches(_ *libhttp.EndpointRequest) (resBody []byte, er
 func (srv *Server) httpAPICachesSearch(epr *libhttp.EndpointRequest) (resBody []byte, err error) {
 	var (
 		res = libhttp.EndpointResponse{}
-		q   = epr.HttpRequest.Form.Get(paramNameQuery)
+		q   = epr.HTTPRequest.Form.Get(paramNameQuery)
 
 		re      *regexp.Regexp
 		listMsg []*dns.Message
@@ -543,7 +543,7 @@ func (srv *Server) httpAPICachesSearch(epr *libhttp.EndpointRequest) (resBody []
 func (srv *Server) httpAPICachesDelete(epr *libhttp.EndpointRequest) (resBody []byte, err error) {
 	var (
 		res = libhttp.EndpointResponse{}
-		q   = epr.HttpRequest.Form.Get(paramNameName)
+		q   = epr.HTTPRequest.Form.Get(paramNameName)
 
 		answers []*dns.Answer
 	)
@@ -827,7 +827,7 @@ func (srv *Server) blockdDisable(hb *Blockd) (err error) {
 func (srv *Server) apiHostsdCreate(epr *libhttp.EndpointRequest) (resbody []byte, err error) {
 	var (
 		res  = libhttp.EndpointResponse{}
-		name = epr.HttpRequest.Form.Get(paramNameName)
+		name = epr.HTTPRequest.Form.Get(paramNameName)
 
 		hfile *dns.HostsFile
 		path  string
@@ -881,7 +881,7 @@ func (srv *Server) apiHostsdCreate(epr *libhttp.EndpointRequest) (resbody []byte
 func (srv *Server) apiHostsdDelete(epr *libhttp.EndpointRequest) (resbody []byte, err error) {
 	var (
 		res  = libhttp.EndpointResponse{}
-		name = epr.HttpRequest.Form.Get(paramNameName)
+		name = epr.HTTPRequest.Form.Get(paramNameName)
 
 		hfile *dns.HostsFile
 		found bool
@@ -939,7 +939,7 @@ func (srv *Server) apiHostsdDelete(epr *libhttp.EndpointRequest) (resbody []byte
 func (srv *Server) apiHostsdGet(epr *libhttp.EndpointRequest) (resbody []byte, err error) {
 	var (
 		res  = libhttp.EndpointResponse{}
-		name = epr.HttpRequest.Form.Get(paramNameName)
+		name = epr.HTTPRequest.Form.Get(paramNameName)
 
 		hf    *dns.HostsFile
 		found bool
@@ -995,7 +995,7 @@ func (srv *Server) apiHostsdGet(epr *libhttp.EndpointRequest) (resbody []byte, e
 func (srv *Server) apiHostsdRecordAdd(epr *libhttp.EndpointRequest) (resbody []byte, err error) {
 	var (
 		res           = libhttp.EndpointResponse{}
-		hostsFileName = epr.HttpRequest.Form.Get(paramNameName)
+		hostsFileName = epr.HTTPRequest.Form.Get(paramNameName)
 
 		hfile *dns.HostsFile
 		rr    *dns.ResourceRecord
@@ -1020,12 +1020,12 @@ func (srv *Server) apiHostsdRecordAdd(epr *libhttp.EndpointRequest) (resbody []b
 		Class: dns.RecordClassIN,
 	}
 
-	rr.Name = epr.HttpRequest.Form.Get(paramNameDomain)
+	rr.Name = epr.HTTPRequest.Form.Get(paramNameDomain)
 	if len(rr.Name) == 0 {
 		res.Message = "empty 'domain' query parameter"
 		return nil, &res
 	}
-	v = epr.HttpRequest.Form.Get(paramNameValue)
+	v = epr.HTTPRequest.Form.Get(paramNameValue)
 	if len(v) == 0 {
 		res.Message = "empty 'value' query parameter"
 		return nil, &res
@@ -1070,8 +1070,8 @@ func (srv *Server) apiHostsdRecordAdd(epr *libhttp.EndpointRequest) (resbody []b
 func (srv *Server) apiHostsdRecordDelete(epr *libhttp.EndpointRequest) (resbody []byte, err error) {
 	var (
 		res           = libhttp.EndpointResponse{}
-		hostsFileName = epr.HttpRequest.Form.Get(paramNameName)
-		domainName    = epr.HttpRequest.Form.Get(paramNameDomain)
+		hostsFileName = epr.HTTPRequest.Form.Get(paramNameName)
+		domainName    = epr.HTTPRequest.Form.Get(paramNameDomain)
 
 		hfile *dns.HostsFile
 		rr    *dns.ResourceRecord
@@ -1150,7 +1150,7 @@ func (srv *Server) apiZoned(_ *libhttp.EndpointRequest) (resb []byte, err error)
 func (srv *Server) apiZonedCreate(epr *libhttp.EndpointRequest) (resb []byte, err error) {
 	var (
 		res      = libhttp.EndpointResponse{}
-		zoneName = epr.HttpRequest.Form.Get(paramNameName)
+		zoneName = epr.HTTPRequest.Form.Get(paramNameName)
 
 		zone     *dns.Zone
 		zoneFile string
@@ -1196,7 +1196,7 @@ func (srv *Server) apiZonedCreate(epr *libhttp.EndpointRequest) (resb []byte, er
 func (srv *Server) apiZonedDelete(epr *libhttp.EndpointRequest) (resb []byte, err error) {
 	var (
 		res      = libhttp.EndpointResponse{}
-		zoneName = epr.HttpRequest.Form.Get(paramNameName)
+		zoneName = epr.HTTPRequest.Form.Get(paramNameName)
 
 		zone  *dns.Zone
 		names []string
@@ -1261,7 +1261,7 @@ func (srv *Server) apiZonedDelete(epr *libhttp.EndpointRequest) (resb []byte, er
 //	}
 func (srv *Server) apiZonedRR(epr *libhttp.EndpointRequest) (resb []byte, err error) {
 	var (
-		zoneName = epr.HttpRequest.Form.Get(paramNameName)
+		zoneName = epr.HTTPRequest.Form.Get(paramNameName)
 		res      = libhttp.EndpointResponse{}
 
 		zone *dns.Zone
@@ -1455,7 +1455,7 @@ func (srv *Server) apiZonedRRDelete(epr *libhttp.EndpointRequest) (resbody []byt
 
 	res.Code = http.StatusBadRequest
 
-	req.Name = epr.HttpRequest.Form.Get(paramNameName)
+	req.Name = epr.HTTPRequest.Form.Get(paramNameName)
 	if len(req.Name) == 0 {
 		res.Message = "empty zone file name"
 		return nil, &res
@@ -1467,14 +1467,14 @@ func (srv *Server) apiZonedRRDelete(epr *libhttp.EndpointRequest) (resbody []byt
 		return nil, &res
 	}
 
-	req.Type = epr.HttpRequest.Form.Get(paramNameType)
+	req.Type = epr.HTTPRequest.Form.Get(paramNameType)
 	req.rtype, ok = dns.RecordTypes[req.Type]
 	if !ok {
 		res.Message = fmt.Sprintf("invalid or empty param type %s: %s", paramNameType, err)
 		return nil, &res
 	}
 
-	req.Record = epr.HttpRequest.Form.Get(paramNameRecord)
+	req.Record = epr.HTTPRequest.Form.Get(paramNameRecord)
 	req.recordRaw, err = base64.StdEncoding.DecodeString(req.Record)
 	if err != nil {
 		res.Message = fmt.Sprintf("invalid record value: %s", err.Error())
diff --git a/memfs_generate.go b/memfs_generate.go
index d2645bd..eb846eb 100644
--- a/memfs_generate.go
+++ b/memfs_generate.go
@@ -1,11 +1,11 @@
 // SPDX-FileCopyrightText: 2021 M. Shulhan <ms@kilabit.info>
 // SPDX-License-Identifier: GPL-3.0-or-later
-// Code generated by github.com/shuLhan/share/lib/memfs DO NOT EDIT.
+// Code generated by git.sr.ht/~shulhan/pakakeh.go/lib/memfs DO NOT EDIT.
 
 package rescached
 
 import (
-	"github.com/shuLhan/share/lib/memfs"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/memfs"
 )
 
 func generate__www() *memfs.Node {
@@ -448,7 +448,7 @@ func init() {
 		Opts: &memfs.Options{
 			Root:        "_www",
 			MaxFileSize: 5242880,
-			Includes: []string{
+			Includes:    []string{
 				`.*\.css$`,
 				`.*\.html$`,
 				`.*\.js$`,
@@ -457,7 +457,7 @@ func init() {
 			Excludes: []string{
 			},
 			Embed: memfs.EmbedOptions{
-				CommentHeader: `// SPDX-FileCopyrightText: 2021 M. Shulhan <ms@kilabit.info>
+				CommentHeader:  `// SPDX-FileCopyrightText: 2021 M. Shulhan <ms@kilabit.info>
 // SPDX-License-Identifier: GPL-3.0-or-later
 `,
 				PackageName:    "rescached",
diff --git a/rescached.go b/rescached.go
index 9cb6bc3..437f89f 100644
--- a/rescached.go
+++ b/rescached.go
@@ -11,10 +11,10 @@ import (
 	"os"
 	"sync"
 
-	"github.com/shuLhan/share/lib/debug"
-	"github.com/shuLhan/share/lib/dns"
-	"github.com/shuLhan/share/lib/http"
-	"github.com/shuLhan/share/lib/memfs"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/debug"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/http"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/memfs"
 )
 
 // Version of program, overwritten by build.
diff --git a/rescached_test.go b/rescached_test.go
index 6ec38e8..d312c2a 100644
--- a/rescached_test.go
+++ b/rescached_test.go
@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"
 
-	libhttp "github.com/shuLhan/share/lib/http"
+	libhttp "git.sr.ht/~shulhan/pakakeh.go/lib/http"
 )
 
 const (
@@ -84,12 +84,12 @@ func mockBlockdServer() {
 		err        error
 	)
 
-	mockServer, err = libhttp.NewServer(&serverOpts)
+	mockServer, err = libhttp.NewServer(serverOpts)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	err = mockServer.RegisterEndpoint(&epHostsA)
+	err = mockServer.RegisterEndpoint(epHostsA)
 	if err != nil {
 		log.Fatal(err)
 	}
diff --git a/zone_record_request.go b/zone_record_request.go
index 2206b83..806586f 100644
--- a/zone_record_request.go
+++ b/zone_record_request.go
@@ -4,7 +4,7 @@
 package rescached
 
 import (
-	"github.com/shuLhan/share/lib/dns"
+	"git.sr.ht/~shulhan/pakakeh.go/lib/dns"
 )
 
 // zoneRecordRequest contains the request parameters for adding or deleting