internal/pkg: move pkg/internal to internal/pkg

This change is required because we need to import the package from
cuelang.org/go/cue/wasm.

Tweak pkg/gen/gen.go to generate code with the new import paths.
Also tweak a couple of manually-written files from pkg/... then run
go generate.

Signed-off-by: Aram Hăvărneanu <[e-mail]>
Change-Id: I87edf4160adc0dbba34f4c1c06fc035e2ca60c41
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/550136
Reviewed-by: Daniel Martí <[e-mail]>
Reviewed-by: Marcel van Lohuizen <[e-mail]>
Unity-Result: CUEcueckoo <[e-mail]>
TryBot-Result: CUEcueckoo <[e-mail]>

pkg/crypto/ed25519/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("crypto/ed25519", pkg)
+	pkg.Register("crypto/ed25519", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "PublicKeySize",
 		Const: "32",
 	}, {
 		Name: "Valid",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			publicKey, message, signature := c.Bytes(0), c.Bytes(1), c.Bytes(2)
 			if c.Do() {
 				c.Ret, c.Err = Valid(publicKey, message, signature)

pkg/crypto/hmac/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("crypto/hmac", pkg)
+	pkg.Register("crypto/hmac", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "MD5",
 		Const: "\"MD5\"",
 	}, {
···
 		Const: "\"SHA512_256\"",
 	}, {
 		Name: "Sign",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			hashName, key, data := c.String(0), c.Bytes(1), c.Bytes(2)
 			if c.Do() {
 				c.Ret, c.Err = Sign(hashName, key, data)

pkg/crypto/md5/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("crypto/md5", pkg)
+	pkg.Register("crypto/md5", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "Size",
 		Const: "16",
 	}, {
···
 		Const: "64",
 	}, {
 		Name: "Sum",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum(data)

pkg/crypto/sha1/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("crypto/sha1", pkg)
+	pkg.Register("crypto/sha1", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "Size",
 		Const: "20",
 	}, {
···
 		Const: "64",
 	}, {
 		Name: "Sum",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum(data)

pkg/crypto/sha256/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("crypto/sha256", pkg)
+	pkg.Register("crypto/sha256", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "Size",
 		Const: "32",
 	}, {
···
 		Const: "64",
 	}, {
 		Name: "Sum256",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum256(data)
···
 		},
 	}, {
 		Name: "Sum224",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum224(data)

pkg/crypto/sha512/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("crypto/sha512", pkg)
+	pkg.Register("crypto/sha512", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "Size",
 		Const: "64",
 	}, {
···
 		Const: "128",
 	}, {
 		Name: "Sum512",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum512(data)
···
 		},
 	}, {
 		Name: "Sum384",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum384(data)
···
 		},
 	}, {
 		Name: "Sum512_224",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum512_224(data)
···
 		},
 	}, {
 		Name: "Sum512_256",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Sum512_256(data)

pkg/encoding/base64/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("encoding/base64", pkg)
+	pkg.Register("encoding/base64", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "EncodedLen",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			encoding, n := c.Value(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = EncodedLen(encoding, n)
···
 		},
 	}, {
 		Name: "DecodedLen",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			encoding, x := c.Value(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = DecodedLen(encoding, x)
···
 		},
 	}, {
 		Name: "Encode",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			encoding, src := c.Value(0), c.Bytes(1)
 			if c.Do() {
 				c.Ret, c.Err = Encode(encoding, src)
···
 		},
 	}, {
 		Name: "Decode",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			encoding, s := c.Value(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = Decode(encoding, s)

pkg/encoding/csv/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("encoding/csv", pkg)
+	pkg.Register("encoding/csv", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Encode",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = Encode(x)
···
 		},
 	}, {
 		Name: "Decode",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			r := c.Reader(0)
 			if c.Do() {
 				c.Ret, c.Err = Decode(r)

pkg/encoding/hex/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("encoding/hex", pkg)
+	pkg.Register("encoding/hex", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "EncodedLen",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			n := c.Int(0)
 			if c.Do() {
 				c.Ret = EncodedLen(n)
···
 		},
 	}, {
 		Name: "DecodedLen",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Int(0)
 			if c.Do() {
 				c.Ret = DecodedLen(x)
···
 		},
 	}, {
 		Name: "Decode",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Decode(s)
···
 		},
 	}, {
 		Name: "Dump",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Dump(data)
···
 		},
 	}, {
 		Name: "Encode",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			src := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Encode(src)

pkg/encoding/json/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("encoding/json", pkg)
+	pkg.Register("encoding/json", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Valid",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret = Valid(data)
···
 		},
 	}, {
 		Name: "Compact",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			src := c.Bytes(0)
 			if c.Do() {
 				c.Ret, c.Err = Compact(src)
···
 		},
 	}, {
 		Name: "Indent",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			src, prefix, indent := c.Bytes(0), c.String(1), c.String(2)
 			if c.Do() {
 				c.Ret, c.Err = Indent(src, prefix, indent)
···
 		},
 	}, {
 		Name: "HTMLEscape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			src := c.Bytes(0)
 			if c.Do() {
 				c.Ret = HTMLEscape(src)
···
 		},
 	}, {
 		Name: "Marshal",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			v := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = Marshal(v)
···
 		},
 	}, {
 		Name: "MarshalStream",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			v := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = MarshalStream(v)
···
 		},
 	}, {
 		Name: "UnmarshalStream",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.TopKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret, c.Err = UnmarshalStream(data)
···
 		},
 	}, {
 		Name: "Unmarshal",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.TopKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b := c.Bytes(0)
 			if c.Do() {
 				c.Ret, c.Err = Unmarshal(b)
···
 		},
 	}, {
 		Name: "Validate",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b, v := c.Bytes(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = Validate(b, v)

pkg/encoding/yaml/manual.go

···
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/errors"
 	cueyaml "cuelang.org/go/internal/encoding/yaml"
+	"cuelang.org/go/internal/pkg"
 	"cuelang.org/go/internal/third_party/yaml"
-	"cuelang.org/go/pkg/internal"
 )
 
 // Marshal returns the YAML encoding of v.
···
 		}
 		if err := x.Validate(cue.Concrete(true)); err != nil {
 			// Strip error codes: incomplete errors are terminal in this case.
-			var b internal.Bottomer
+			var b pkg.Bottomer
 			if errors.As(err, &b) {
 				err = b.Bottom().Err
 			}

pkg/encoding/yaml/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("encoding/yaml", pkg)
+	pkg.Register("encoding/yaml", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Marshal",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			v := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = Marshal(v)
···
 		},
 	}, {
 		Name: "MarshalStream",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			v := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = MarshalStream(v)
···
 		},
 	}, {
 		Name: "Unmarshal",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.TopKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret, c.Err = Unmarshal(data)
···
 		},
 	}, {
 		Name: "UnmarshalStream",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.TopKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Bytes(0)
 			if c.Do() {
 				c.Ret, c.Err = UnmarshalStream(data)
···
 		},
 	}, {
 		Name: "Validate",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b, v := c.Bytes(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = Validate(b, v)
···
 		},
 	}, {
 		Name: "ValidatePartial",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b, v := c.Bytes(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = ValidatePartial(b, v)

pkg/gen.go

···
 {{if .CUEPkg -}}
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register({{printf "%q" .CUEPkg}}, pkg)
+	pkg.Register({{printf "%q" .CUEPkg}}, p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
···
 	}
 
 	if !skipRegister {
-		fmt.Fprintf(g.w, "var pkg = &internal.Package{\nNative: []*internal.Builtin{")
+		fmt.Fprintf(g.w, "var p = &pkg.Package{\nNative: []*pkg.Builtin{")
 		g.first = true
 		for _, filename := range pkg.GoFiles {
 			if filename == genFile {
···
 		}
 	}
 
-	fmt.Fprintf(g.w, "Params: []internal.Param{\n")
+	fmt.Fprintf(g.w, "Params: []pkg.Param{\n")
 	for _, k := range kind {
 		fmt.Fprintf(g.w, "{Kind: %s},\n", k)
 	}
···
 		init = fmt.Sprintf("%s := %s", argList, valList)
 	}
 
-	fmt.Fprintf(g.w, "Func: func(c *internal.CallCtxt) {")
+	fmt.Fprintf(g.w, "Func: func(c *pkg.CallCtxt) {")
 	defer fmt.Fprintln(g.w, "},")
 	fmt.Fprintln(g.w)
 	if init != "" {
···
 		return "error"
 	case "internal.Decimal":
 		return "decimal"
-	case "internal.List":
+	case "pkg.List":
 		return "cueList"
-	case "internal.Struct":
+	case "pkg.Struct":
 		return "struct"
 	case "[]*internal.Decimal":
 		return "decimalList"

pkg/html/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("html", pkg)
+	pkg.Register("html", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Escape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = Escape(s)
···
 		},
 	}, {
 		Name: "Unescape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = Unescape(s)

pkg/internal/builtin.go internal/pkg/builtin.go

···
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package internal
+package pkg
 
 import (
 	"encoding/json"

pkg/internal/context.go internal/pkg/context.go

···
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package internal
+package pkg
 
 import (
 	"io"

pkg/internal/errors.go internal/pkg/errors.go

···
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package internal
+package pkg
 
 import (
 	"fmt"

pkg/internal/register.go internal/pkg/register.go

···
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package internal
+package pkg
 
 import (
 	"cuelang.org/go/cue/errors"

pkg/internal/types.go internal/pkg/types.go

···
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package internal
+package pkg
 
 import (
 	"cuelang.org/go/internal/core/adt"

pkg/list/list.go

···
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 // Drop reports the suffix of list x after the first n elements,
···
 }
 
 // MinItems reports whether a has at least n items.
-func MinItems(list internal.List, n int) (bool, error) {
+func MinItems(list pkg.List, n int) (bool, error) {
 	count := len(list.Elems())
 	if count >= n {
 		return true, nil
···
 	if list.IsOpen() {
 		code = adt.IncompleteError
 	}
-	return false, internal.ValidationError{B: &adt.Bottom{
+	return false, pkg.ValidationError{B: &adt.Bottom{
 		Code: code,
 		Err:  errors.Newf(token.NoPos, "len(list) < MinItems(%[2]d) (%[1]d < %[2]d)", count, n),
 	}}
 }
 
 // MaxItems reports whether a has at most n items.
-func MaxItems(list internal.List, n int) (bool, error) {
+func MaxItems(list pkg.List, n int) (bool, error) {
 	count := len(list.Elems())
 	if count > n {
-		return false, internal.ValidationError{B: &adt.Bottom{
+		return false, pkg.ValidationError{B: &adt.Bottom{
 			Code: adt.EvalError,
 			Err:  errors.Newf(token.NoPos, "len(list) > MaxItems(%[2]d) (%[1]d > %[2]d)", count, n),
 		}}

pkg/list/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("list", pkg)
+	pkg.Register("list", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Drop",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, n := c.List(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = Drop(x, n)
···
 		},
 	}, {
 		Name: "FlattenN",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			xs, depth := c.Value(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = FlattenN(xs, depth)
···
 		},
 	}, {
 		Name: "Repeat",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, count := c.List(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = Repeat(x, count)
···
 		},
 	}, {
 		Name: "Concat",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a := c.List(0)
 			if c.Do() {
 				c.Ret, c.Err = Concat(a)
···
 		},
 	}, {
 		Name: "Take",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, n := c.List(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = Take(x, n)
···
 		},
 	}, {
 		Name: "Slice",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, i, j := c.List(0), c.Int(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = Slice(x, i, j)
···
 		},
 	}, {
 		Name: "MinItems",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			list, n := c.CueList(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = MinItems(list, n)
···
 		},
 	}, {
 		Name: "MaxItems",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			list, n := c.CueList(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = MaxItems(list, n)
···
 		},
 	}, {
 		Name: "UniqueItems",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a := c.List(0)
 			if c.Do() {
 				c.Ret = UniqueItems(a)
···
 		},
 	}, {
 		Name: "Contains",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a, v := c.List(0), c.Value(1)
 			if c.Do() {
 				c.Ret = Contains(a, v)
···
 		},
 	}, {
 		Name: "Avg",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			xs := c.DecimalList(0)
 			if c.Do() {
 				c.Ret, c.Err = Avg(xs)
···
 		},
 	}, {
 		Name: "Max",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			xs := c.DecimalList(0)
 			if c.Do() {
 				c.Ret, c.Err = Max(xs)
···
 		},
 	}, {
 		Name: "Min",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			xs := c.DecimalList(0)
 			if c.Do() {
 				c.Ret, c.Err = Min(xs)
···
 		},
 	}, {
 		Name: "Product",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			xs := c.DecimalList(0)
 			if c.Do() {
 				c.Ret, c.Err = Product(xs)
···
 		},
 	}, {
 		Name: "Range",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			start, limit, step := c.Decimal(0), c.Decimal(1), c.Decimal(2)
 			if c.Do() {
 				c.Ret, c.Err = Range(start, limit, step)
···
 		},
 	}, {
 		Name: "Sum",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			xs := c.DecimalList(0)
 			if c.Do() {
 				c.Ret, c.Err = Sum(xs)
···
 		},
 	}, {
 		Name: "Sort",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			list, cmp := c.List(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = Sort(list, cmp)
···
 		},
 	}, {
 		Name: "SortStable",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			list, cmp := c.List(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = SortStable(list, cmp)
···
 		},
 	}, {
 		Name: "SortStrings",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a := c.StringList(0)
 			if c.Do() {
 				c.Ret = SortStrings(a)
···
 		},
 	}, {
 		Name: "IsSorted",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			list, cmp := c.List(0), c.Value(1)
 			if c.Do() {
 				c.Ret = IsSorted(list, cmp)
···
 		},
 	}, {
 		Name: "IsSortedStrings",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a := c.StringList(0)
 			if c.Do() {
 				c.Ret = IsSortedStrings(a)

pkg/math/bits/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("math/bits", pkg)
+	pkg.Register("math/bits", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Lsh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, n := c.BigInt(0), c.Uint(1)
 			if c.Do() {
 				c.Ret = Lsh(x, n)
···
 		},
 	}, {
 		Name: "Rsh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, n := c.BigInt(0), c.Uint(1)
 			if c.Do() {
 				c.Ret = Rsh(x, n)
···
 		},
 	}, {
 		Name: "At",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, i := c.BigInt(0), c.Uint(1)
 			if c.Do() {
 				c.Ret, c.Err = At(x, i)
···
 		},
 	}, {
 		Name: "Set",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, i, bit := c.BigInt(0), c.Int(1), c.Uint(2)
 			if c.Do() {
 				c.Ret = Set(x, i, bit)
···
 		},
 	}, {
 		Name: "And",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a, b := c.BigInt(0), c.BigInt(1)
 			if c.Do() {
 				c.Ret = And(a, b)
···
 		},
 	}, {
 		Name: "Or",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a, b := c.BigInt(0), c.BigInt(1)
 			if c.Do() {
 				c.Ret = Or(a, b)
···
 		},
 	}, {
 		Name: "Xor",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a, b := c.BigInt(0), c.BigInt(1)
 			if c.Do() {
 				c.Ret = Xor(a, b)
···
 		},
 	}, {
 		Name: "Clear",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a, b := c.BigInt(0), c.BigInt(1)
 			if c.Do() {
 				c.Ret = Clear(a, b)
···
 		},
 	}, {
 		Name: "OnesCount",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.BigInt(0)
 			if c.Do() {
 				c.Ret = OnesCount(x)
···
 		},
 	}, {
 		Name: "Len",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.BigInt(0)
 			if c.Do() {
 				c.Ret = Len(x)

pkg/math/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("math", pkg)
+	pkg.Register("math", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "MaxExp",
 		Const: "2147483647",
 	}, {
···
 		Const: "1",
 	}, {
 		Name: "Jacobi",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.BigInt(0), c.BigInt(1)
 			if c.Do() {
 				c.Ret = Jacobi(x, y)
···
 		Const: "62",
 	}, {
 		Name: "Floor",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Floor(x)
···
 		},
 	}, {
 		Name: "Ceil",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Ceil(x)
···
 		},
 	}, {
 		Name: "Trunc",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Trunc(x)
···
 		},
 	}, {
 		Name: "Round",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Round(x)
···
 		},
 	}, {
 		Name: "RoundToEven",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = RoundToEven(x)
···
 		},
 	}, {
 		Name: "MultipleOf",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.Decimal(0), c.Decimal(1)
 			if c.Do() {
 				c.Ret, c.Err = MultipleOf(x, y)
···
 		},
 	}, {
 		Name: "Abs",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Abs(x)
···
 		},
 	}, {
 		Name: "Acosh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Acosh(x)
···
 		},
 	}, {
 		Name: "Asin",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Asin(x)
···
 		},
 	}, {
 		Name: "Acos",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Acos(x)
···
 		},
 	}, {
 		Name: "Asinh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Asinh(x)
···
 		},
 	}, {
 		Name: "Atan",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Atan(x)
···
 		},
 	}, {
 		Name: "Atan2",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			y, x := c.Float64(0), c.Float64(1)
 			if c.Do() {
 				c.Ret = Atan2(y, x)
···
 		},
 	}, {
 		Name: "Atanh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Atanh(x)
···
 		},
 	}, {
 		Name: "Cbrt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Cbrt(x)
···
 		Const: "0.43429448190325182765112891891660508229439700580366656611445378",
 	}, {
 		Name: "Copysign",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.Decimal(0), c.Decimal(1)
 			if c.Do() {
 				c.Ret = Copysign(x, y)
···
 		},
 	}, {
 		Name: "Dim",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.Decimal(0), c.Decimal(1)
 			if c.Do() {
 				c.Ret, c.Err = Dim(x, y)
···
 		},
 	}, {
 		Name: "Erf",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Erf(x)
···
 		},
 	}, {
 		Name: "Erfc",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Erfc(x)
···
 		},
 	}, {
 		Name: "Erfinv",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Erfinv(x)
···
 		},
 	}, {
 		Name: "Erfcinv",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Erfcinv(x)
···
 		},
 	}, {
 		Name: "Exp",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Exp(x)
···
 		},
 	}, {
 		Name: "Exp2",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Exp2(x)
···
 		},
 	}, {
 		Name: "Expm1",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Expm1(x)
···
 		},
 	}, {
 		Name: "Gamma",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Gamma(x)
···
 		},
 	}, {
 		Name: "Hypot",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			p, q := c.Float64(0), c.Float64(1)
 			if c.Do() {
 				c.Ret = Hypot(p, q)
···
 		},
 	}, {
 		Name: "J0",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = J0(x)
···
 		},
 	}, {
 		Name: "Y0",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Y0(x)
···
 		},
 	}, {
 		Name: "J1",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = J1(x)
···
 		},
 	}, {
 		Name: "Y1",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Y1(x)
···
 		},
 	}, {
 		Name: "Jn",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			n, x := c.Int(0), c.Float64(1)
 			if c.Do() {
 				c.Ret = Jn(n, x)
···
 		},
 	}, {
 		Name: "Yn",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			n, x := c.Int(0), c.Float64(1)
 			if c.Do() {
 				c.Ret = Yn(n, x)
···
 		},
 	}, {
 		Name: "Ldexp",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			frac, exp := c.Float64(0), c.Int(1)
 			if c.Do() {
 				c.Ret = Ldexp(frac, exp)
···
 		},
 	}, {
 		Name: "Log",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Log(x)
···
 		},
 	}, {
 		Name: "Log10",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Log10(x)
···
 		},
 	}, {
 		Name: "Log2",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret, c.Err = Log2(x)
···
 		},
 	}, {
 		Name: "Log1p",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Log1p(x)
···
 		},
 	}, {
 		Name: "Logb",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Logb(x)
···
 		},
 	}, {
 		Name: "Ilogb",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Ilogb(x)
···
 		},
 	}, {
 		Name: "Mod",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.Float64(0), c.Float64(1)
 			if c.Do() {
 				c.Ret = Mod(x, y)
···
 		},
 	}, {
 		Name: "Pow",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.Decimal(0), c.Decimal(1)
 			if c.Do() {
 				c.Ret, c.Err = Pow(x, y)
···
 		},
 	}, {
 		Name: "Pow10",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			n := c.Int32(0)
 			if c.Do() {
 				c.Ret = Pow10(n)
···
 		},
 	}, {
 		Name: "Remainder",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x, y := c.Float64(0), c.Float64(1)
 			if c.Do() {
 				c.Ret = Remainder(x, y)
···
 		},
 	}, {
 		Name: "Signbit",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
 				c.Ret = Signbit(x)
···
 		},
 	}, {
 		Name: "Cos",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Cos(x)
···
 		},
 	}, {
 		Name: "Sin",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Sin(x)
···
 		},
 	}, {
 		Name: "Sinh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Sinh(x)
···
 		},
 	}, {
 		Name: "Cosh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Cosh(x)
···
 		},
 	}, {
 		Name: "Sqrt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Sqrt(x)
···
 		},
 	}, {
 		Name: "Tan",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Tan(x)
···
 		},
 	}, {
 		Name: "Tanh",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.Float64(0)
 			if c.Do() {
 				c.Ret = Tanh(x)

pkg/net/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("net", pkg)
+	pkg.Register("net", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "SplitHostPort",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = SplitHostPort(s)
···
 		},
 	}, {
 		Name: "JoinHostPort",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			host, port := c.Value(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = JoinHostPort(host, port)
···
 		},
 	}, {
 		Name: "FQDN",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = FQDN(s)
···
 		Const: "16",
 	}, {
 		Name: "ParseIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = ParseIP(s)
···
 		},
 	}, {
 		Name: "IPv4",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = IPv4(ip)
···
 		},
 	}, {
 		Name: "IP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = IP(ip)
···
 		},
 	}, {
 		Name: "IPCIDR",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = IPCIDR(ip)
···
 		},
 	}, {
 		Name: "LoopbackIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = LoopbackIP(ip)
···
 		},
 	}, {
 		Name: "MulticastIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = MulticastIP(ip)
···
 		},
 	}, {
 		Name: "InterfaceLocalMulticastIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = InterfaceLocalMulticastIP(ip)
···
 		},
 	}, {
 		Name: "LinkLocalMulticastIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = LinkLocalMulticastIP(ip)
···
 		},
 	}, {
 		Name: "LinkLocalUnicastIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = LinkLocalUnicastIP(ip)
···
 		},
 	}, {
 		Name: "GlobalUnicastIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = GlobalUnicastIP(ip)
···
 		},
 	}, {
 		Name: "UnspecifiedIP",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret = UnspecifiedIP(ip)
···
 		},
 	}, {
 		Name: "ToIP4",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = ToIP4(ip)
···
 		},
 	}, {
 		Name: "ToIP16",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = ToIP16(ip)
···
 		},
 	}, {
 		Name: "IPString",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			ip := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = IPString(ip)
···
 		},
 	}, {
 		Name: "PathEscape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = PathEscape(s)
···
 		},
 	}, {
 		Name: "PathUnescape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = PathUnescape(s)
···
 		},
 	}, {
 		Name: "QueryEscape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = QueryEscape(s)
···
 		},
 	}, {
 		Name: "QueryUnescape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = QueryUnescape(s)

pkg/path/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("path", pkg)
+	pkg.Register("path", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
···
 	return &adt.String{Str: s}
 }
 
-var pkg = &internal.Package{
+var p = &pkg.Package{
 	CUE: `{
 		Unix:    "unix"
 		Windows: "windows"
 		Plan9:   "plan9"
 	}`,
-	Native: []*internal.Builtin{{
+	Native: []*pkg.Builtin{{
 		Name: "Split",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Split(path, OS(os))
···
 		},
 	}, {
 		Name: "SplitList",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: osRequired},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = SplitList(path, OS(os))
···
 		},
 	}, {
 		Name: "Join",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			list, os := c.StringList(0), c.String(1)
 			if c.Do() {
 				c.Ret = Join(list, OS(os))
···
 		},
 	}, {
 		Name: "Match",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, name, os := c.String(0), c.String(1), c.String(2)
 			if c.Do() {
 				c.Ret, c.Err = Match(pattern, name, OS(os))
···
 		},
 	}, {
 		Name: "Clean",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Clean(path, OS(os))
···
 		},
 	}, {
 		Name: "ToSlash",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: osRequired},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = ToSlash(path, OS(os))
···
 		},
 	}, {
 		Name: "FromSlash",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: osRequired},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = FromSlash(path, OS(os))
···
 		},
 	}, {
 		Name: "Ext",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Ext(path, OS(os))
···
 		},
 	}, {
 		Name: "Resolve",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			dir, sub, os := c.String(0), c.String(1), c.String(2)
 			if c.Do() {
 				c.Ret = Resolve(dir, sub, OS(os))
···
 		},
 	}, {
 		Name: "Rel",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			base, target, os := c.String(0), c.String(1), c.String(2)
 			if c.Do() {
 				c.Ret, c.Err = Rel(base, target, OS(os))
···
 		},
 	}, {
 		Name: "Base",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Base(path, OS(os))
···
 		},
 	}, {
 		Name: "Dir",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Dir(path, OS(os))
···
 		},
 	}, {
 		Name: "IsAbs",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: unixDefault},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = IsAbs(path, OS(os))
···
 		},
 	}, {
 		Name: "VolumeName",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind, Value: windowsDefault},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			path, os := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = VolumeName(path, OS(os))

pkg/regexp/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("regexp", pkg)
+	pkg.Register("regexp", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Find",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = Find(pattern, s)
···
 		},
 	}, {
 		Name: "FindAll",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s, n := c.String(0), c.String(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = FindAll(pattern, s, n)
···
 		},
 	}, {
 		Name: "FindAllNamedSubmatch",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s, n := c.String(0), c.String(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = FindAllNamedSubmatch(pattern, s, n)
···
 		},
 	}, {
 		Name: "FindAllSubmatch",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s, n := c.String(0), c.String(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = FindAllSubmatch(pattern, s, n)
···
 		},
 	}, {
 		Name: "FindNamedSubmatch",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StructKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = FindNamedSubmatch(pattern, s)
···
 		},
 	}, {
 		Name: "FindSubmatch",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = FindSubmatch(pattern, s)
···
 		},
 	}, {
 		Name: "ReplaceAll",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, src, repl := c.String(0), c.String(1), c.String(2)
 			if c.Do() {
 				c.Ret, c.Err = ReplaceAll(pattern, src, repl)
···
 		},
 	}, {
 		Name: "ReplaceAllLiteral",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, src, repl := c.String(0), c.String(1), c.String(2)
 			if c.Do() {
 				c.Ret, c.Err = ReplaceAllLiteral(pattern, src, repl)
···
 		},
 	}, {
 		Name: "Valid",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Valid(pattern)
···
 		},
 	}, {
 		Name: "Match",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			pattern, s := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = Match(pattern, s)
···
 		},
 	}, {
 		Name: "QuoteMeta",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = QuoteMeta(s)

pkg/strconv/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("strconv", pkg)
+	pkg.Register("strconv", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Unquote",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Unquote(s)
···
 		},
 	}, {
 		Name: "ParseBool",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			str := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = ParseBool(str)
···
 		},
 	}, {
 		Name: "FormatBool",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BoolKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b := c.Bool(0)
 			if c.Do() {
 				c.Ret = FormatBool(b)
···
 		},
 	}, {
 		Name: "ParseComplex",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.TopKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, bitSize := c.String(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = ParseComplex(s, bitSize)
···
 		},
 	}, {
 		Name: "ParseFloat",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.NumKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, bitSize := c.String(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = ParseFloat(s, bitSize)
···
 		Const: "64",
 	}, {
 		Name: "ParseUint",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, base, bitSize := c.String(0), c.Int(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = ParseUint(s, base, bitSize)
···
 		},
 	}, {
 		Name: "ParseInt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, base, bitSize := c.String(0), c.Int(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = ParseInt(s, base, bitSize)
···
 		},
 	}, {
 		Name: "Atoi",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Atoi(s)
···
 		},
 	}, {
 		Name: "FormatFloat",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.NumKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			f, fmt, prec, bitSize := c.Float64(0), c.Byte(1), c.Int(2), c.Int(3)
 			if c.Do() {
 				c.Ret = FormatFloat(f, fmt, prec, bitSize)
···
 		},
 	}, {
 		Name: "FormatUint",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			i, base := c.BigInt(0), c.Int(1)
 			if c.Do() {
 				c.Ret = FormatUint(i, base)
···
 		},
 	}, {
 		Name: "FormatInt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			i, base := c.BigInt(0), c.Int(1)
 			if c.Do() {
 				c.Ret = FormatInt(i, base)
···
 		},
 	}, {
 		Name: "Quote",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = Quote(s)
···
 		},
 	}, {
 		Name: "QuoteToASCII",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = QuoteToASCII(s)
···
 		},
 	}, {
 		Name: "QuoteToGraphic",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = QuoteToGraphic(s)
···
 		},
 	}, {
 		Name: "QuoteRune",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			r := c.Rune(0)
 			if c.Do() {
 				c.Ret = QuoteRune(r)
···
 		},
 	}, {
 		Name: "QuoteRuneToASCII",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			r := c.Rune(0)
 			if c.Do() {
 				c.Ret = QuoteRuneToASCII(r)
···
 		},
 	}, {
 		Name: "QuoteRuneToGraphic",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			r := c.Rune(0)
 			if c.Do() {
 				c.Ret = QuoteRuneToGraphic(r)
···
 		},
 	}, {
 		Name: "IsPrint",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			r := c.Rune(0)
 			if c.Do() {
 				c.Ret = IsPrint(r)
···
 		},
 	}, {
 		Name: "IsGraphic",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			r := c.Rune(0)
 			if c.Do() {
 				c.Ret = IsGraphic(r)

pkg/strings/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("strings", pkg)
+	pkg.Register("strings", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "ByteAt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b, i := c.Bytes(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = ByteAt(b, i)
···
 		},
 	}, {
 		Name: "ByteSlice",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.BytesKind | adt.StringKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BytesKind | adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			b, start, end := c.Bytes(0), c.Int(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = ByteSlice(b, start, end)
···
 		},
 	}, {
 		Name: "Runes",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = Runes(s)
···
 		},
 	}, {
 		Name: "MinRunes",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, min := c.String(0), c.Int(1)
 			if c.Do() {
 				c.Ret = MinRunes(s, min)
···
 		},
 	}, {
 		Name: "MaxRunes",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, max := c.String(0), c.Int(1)
 			if c.Do() {
 				c.Ret = MaxRunes(s, max)
···
 		},
 	}, {
 		Name: "ToTitle",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = ToTitle(s)
···
 		},
 	}, {
 		Name: "ToCamel",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = ToCamel(s)
···
 		},
 	}, {
 		Name: "SliceRunes",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, start, end := c.String(0), c.Int(1), c.Int(2)
 			if c.Do() {
 				c.Ret, c.Err = SliceRunes(s, start, end)
···
 		},
 	}, {
 		Name: "Compare",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			a, b := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Compare(a, b)
···
 		},
 	}, {
 		Name: "Count",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, substr := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Count(s, substr)
···
 		},
 	}, {
 		Name: "Contains",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, substr := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Contains(s, substr)
···
 		},
 	}, {
 		Name: "ContainsAny",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, chars := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = ContainsAny(s, chars)
···
 		},
 	}, {
 		Name: "LastIndex",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, substr := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = LastIndex(s, substr)
···
 		},
 	}, {
 		Name: "IndexAny",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, chars := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = IndexAny(s, chars)
···
 		},
 	}, {
 		Name: "LastIndexAny",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, chars := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = LastIndexAny(s, chars)
···
 		},
 	}, {
 		Name: "SplitN",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, sep, n := c.String(0), c.String(1), c.Int(2)
 			if c.Do() {
 				c.Ret = SplitN(s, sep, n)
···
 		},
 	}, {
 		Name: "SplitAfterN",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, sep, n := c.String(0), c.String(1), c.Int(2)
 			if c.Do() {
 				c.Ret = SplitAfterN(s, sep, n)
···
 		},
 	}, {
 		Name: "Split",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, sep := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Split(s, sep)
···
 		},
 	}, {
 		Name: "SplitAfter",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, sep := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = SplitAfter(s, sep)
···
 		},
 	}, {
 		Name: "Fields",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.ListKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = Fields(s)
···
 		},
 	}, {
 		Name: "Join",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.ListKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			elems, sep := c.StringList(0), c.String(1)
 			if c.Do() {
 				c.Ret = Join(elems, sep)
···
 		},
 	}, {
 		Name: "HasPrefix",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, prefix := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = HasPrefix(s, prefix)
···
 		},
 	}, {
 		Name: "HasSuffix",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, suffix := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = HasSuffix(s, suffix)
···
 		},
 	}, {
 		Name: "Repeat",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, count := c.String(0), c.Int(1)
 			if c.Do() {
 				c.Ret = Repeat(s, count)
···
 		},
 	}, {
 		Name: "ToUpper",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = ToUpper(s)
···
 		},
 	}, {
 		Name: "ToLower",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = ToLower(s)
···
 		},
 	}, {
 		Name: "Trim",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, cutset := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Trim(s, cutset)
···
 		},
 	}, {
 		Name: "TrimLeft",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, cutset := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = TrimLeft(s, cutset)
···
 		},
 	}, {
 		Name: "TrimRight",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, cutset := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = TrimRight(s, cutset)
···
 		},
 	}, {
 		Name: "TrimSpace",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = TrimSpace(s)
···
 		},
 	}, {
 		Name: "TrimPrefix",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, prefix := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = TrimPrefix(s, prefix)
···
 		},
 	}, {
 		Name: "TrimSuffix",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, suffix := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = TrimSuffix(s, suffix)
···
 		},
 	}, {
 		Name: "Replace",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, old, new, n := c.String(0), c.String(1), c.String(2), c.Int(3)
 			if c.Do() {
 				c.Ret = Replace(s, old, new, n)
···
 		},
 	}, {
 		Name: "Index",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s, substr := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret = Index(s, substr)

pkg/struct/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("struct", pkg)
+	pkg.Register("struct", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "MinFields",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StructKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			object, n := c.Struct(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = MinFields(object, n)
···
 		},
 	}, {
 		Name: "MaxFields",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StructKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			object, n := c.Struct(0), c.Int(1)
 			if c.Do() {
 				c.Ret, c.Err = MaxFields(object, n)

pkg/struct/struct.go

···
 	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/cue/token"
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 // MinFields validates the minimum number of fields that are part of a struct.
···
 //
 // Only fields that are part of the data model count. This excludes hidden
 // fields, optional fields, and definitions.
-func MinFields(object internal.Struct, n int) (bool, error) {
+func MinFields(object pkg.Struct, n int) (bool, error) {
 	count := object.Len()
 	code := adt.EvalError
 	if object.IsOpen() {
 		code = adt.IncompleteError
 	}
 	if count < n {
-		return false, internal.ValidationError{B: &adt.Bottom{
+		return false, pkg.ValidationError{B: &adt.Bottom{
 			Code: code,
 			Err:  errors.Newf(token.NoPos, "len(fields) < MinFields(%[2]d) (%[1]d < %[2]d)", count, n),
 		}}
···
 //
 // Only fields that are part of the data model count. This excludes hidden
 // fields, optional fields, and definitions.
-func MaxFields(object internal.Struct, n int) (bool, error) {
+func MaxFields(object pkg.Struct, n int) (bool, error) {
 	count := object.Len()
 	if count > n {
-		return false, internal.ValidationError{B: &adt.Bottom{
+		return false, pkg.ValidationError{B: &adt.Bottom{
 			Code: adt.EvalError,
 			Err:  errors.Newf(token.NoPos, "len(fields) > MaxFields(%[2]d) (%[1]d > %[2]d)", count, n),
 		}}

pkg/text/tabwriter/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("text/tabwriter", pkg)
+	pkg.Register("text/tabwriter", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Write",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			data := c.Value(0)
 			if c.Do() {
 				c.Ret, c.Err = Write(data)

pkg/text/template/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("text/template", pkg)
+	pkg.Register("text/template", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Execute",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.TopKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			templ, data := c.String(0), c.Value(1)
 			if c.Do() {
 				c.Ret, c.Err = Execute(templ, data)
···
 		},
 	}, {
 		Name: "HTMLEscape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = HTMLEscape(s)
···
 		},
 	}, {
 		Name: "JSEscape",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = JSEscape(s)

pkg/time/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("time", pkg)
+	pkg.Register("time", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name:  "Nanosecond",
 		Const: "1",
 	}, {
···
 		Const: "3600000000000",
 	}, {
 		Name: "Duration",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Duration(s)
···
 		},
 	}, {
 		Name: "FormatDuration",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			d := c.Int64(0)
 			if c.Do() {
 				c.Ret = FormatDuration(d)
···
 		},
 	}, {
 		Name: "ParseDuration",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = ParseDuration(s)
···
 		Const: "6",
 	}, {
 		Name: "Time",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Time(s)
···
 		},
 	}, {
 		Name: "Format",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BoolKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			value, layout := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = Format(value, layout)
···
 		},
 	}, {
 		Name: "FormatString",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			layout, value := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = FormatString(layout, value)
···
 		},
 	}, {
 		Name: "Parse",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			layout, value := c.String(0), c.String(1)
 			if c.Do() {
 				c.Ret, c.Err = Parse(layout, value)
···
 		},
 	}, {
 		Name: "Unix",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			sec, nsec := c.Int64(0), c.Int64(1)
 			if c.Do() {
 				c.Ret = Unix(sec, nsec)
···
 		},
 	}, {
 		Name: "Split",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.TopKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			t := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Split(t)

pkg/tool/cli/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("tool/cli", pkg)
+	pkg.Register("tool/cli", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{},
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{},
 	CUE: `{
 	Print: {
 		$id:  *"tool/cli.Print" | "print"

pkg/tool/exec/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("tool/exec", pkg)
+	pkg.Register("tool/exec", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{},
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{},
 	CUE: `{
 	Run: {
 		$id:  *"tool/exec.Run" | "exec"

pkg/tool/file/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("tool/file", pkg)
+	pkg.Register("tool/file", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{},
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{},
 	CUE: `{
 	Read: {
 		$id:      "tool/file.Read"

pkg/tool/http/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("tool/http", pkg)
+	pkg.Register("tool/http", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{},
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{},
 	CUE: `{
 	Get: Do & {
 		method: "GET"

pkg/tool/os/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("tool/os", pkg)
+	pkg.Register("tool/os", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{},
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{},
 	CUE: `{
 	Value: bool | number | *string | null
 	Name:  !="" & !~"^[$]"

pkg/uuid/pkg.go

···
 
 import (
 	"cuelang.org/go/internal/core/adt"
-	"cuelang.org/go/pkg/internal"
+	"cuelang.org/go/internal/pkg"
 )
 
 func init() {
-	internal.Register("uuid", pkg)
+	pkg.Register("uuid", p)
 }
 
 var _ = adt.TopKind // in case the adt package isn't used
 
-var pkg = &internal.Package{
-	Native: []*internal.Builtin{{
+var p = &pkg.Package{
+	Native: []*pkg.Builtin{{
 		Name: "Valid",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.BottomKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret = Valid(s)
···
 		},
 	}, {
 		Name: "Parse",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			s := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Parse(s)
···
 		},
 	}, {
 		Name: "ToString",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.String(0)
 			if c.Do() {
 				c.Ret = ToString(x)
···
 		},
 	}, {
 		Name: "URN",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = URN(x)
···
 		},
 	}, {
 		Name: "FromInt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.IntKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			i := c.BigInt(0)
 			if c.Do() {
 				c.Ret, c.Err = FromInt(i)
···
 		},
 	}, {
 		Name: "ToInt",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.String(0)
 			if c.Do() {
 				c.Ret = ToInt(x)
···
 		},
 	}, {
 		Name: "Variant",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Variant(x)
···
 		},
 	}, {
 		Name: "Version",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 		},
 		Result: adt.IntKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			x := c.String(0)
 			if c.Do() {
 				c.Ret, c.Err = Version(x)
···
 		},
 	}, {
 		Name: "SHA1",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			space, data := c.String(0), c.Bytes(1)
 			if c.Do() {
 				c.Ret, c.Err = SHA1(space, data)
···
 		},
 	}, {
 		Name: "MD5",
-		Params: []internal.Param{
+		Params: []pkg.Param{
 			{Kind: adt.StringKind},
 			{Kind: adt.BytesKind | adt.StringKind},
 		},
 		Result: adt.StringKind,
-		Func: func(c *internal.CallCtxt) {
+		Func: func(c *pkg.CallCtxt) {
 			space, data := c.String(0), c.Bytes(1)
 			if c.Do() {
 				c.Ret, c.Err = MD5(space, data)