goscript 0.1.4 → 0.2.0

package/README.md

@@ -5,7 +5,7 @@
 
   <p>
     Compile Go packages into TypeScript modules for shared application logic.<br/>
-    Built for Bun, modern bundlers, browser demos, and package-level workflows.<br/>
+    Performance-optimized for fast package builds, Bun, modern bundlers, and browser demos.<br/>
   </p>
 
   <p>
@@ -29,7 +29,10 @@ GoScript compiles Go packages from inside a Go module and writes deterministic
 TypeScript packages under `@goscript/<go-package>/`. The compiler keeps package
 loading, semantic modeling, lowering, TypeScript emission, runtime helpers, and
 handwritten override packages as explicit pipeline stages so generated output is
-readable and semantic decisions have one owner.
+readable and semantic decisions have one owner. The compiler is also
+performance-tuned through real package dogfooding, so large package sets can be
+rebuilt quickly instead of treating Go-to-TypeScript generation as an offline
+batch step.
 
 > "Right now goscript looks pretty cool if [your] problem is 'I want this
 > self-sufficient algorithm [to] be available in Go and JS runtimes.'"

package/cmd/go_js_wasm_exec/main.go

@@ -0,0 +1,201 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/aperturerobotics/goscript/compiler/gotest"
+	"github.com/pkg/errors"
+)
+
+func main() {
+	if err := run(context.Background(), os.Args[1:], os.Stdout); err != nil {
+		_, _ = fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func run(ctx context.Context, args []string, stdout io.Writer) error {
+	req, err := requestFromGoToolArgs(args)
+	if err != nil {
+		return err
+	}
+	result, err := gotest.NewRunner().Run(ctx, req)
+	if err != nil {
+		return err
+	}
+	if err := printResult(stdout, result); err != nil {
+		return err
+	}
+	if !result.Passed() {
+		return errors.New("goscript browser test failed")
+	}
+	return nil
+}
+
+func requestFromGoToolArgs(args []string) (*gotest.Request, error) {
+	if len(args) != 0 && !strings.HasPrefix(args[0], "-") {
+		args = args[1:]
+	}
+	cwd, err := os.Getwd()
+	if err != nil {
+		return nil, errors.Wrap(err, "get package working directory")
+	}
+	req := &gotest.Request{
+		Dir:            cwd,
+		Patterns:       []string{"."},
+		Count:          1,
+		Timeout:        10 * time.Minute,
+		RuntimeBackend: gotest.RuntimeBackendBrowser,
+	}
+	for idx := 0; idx < len(args); idx++ {
+		name, value, hasValue := splitFlag(args[idx])
+		switch name {
+		case "-test.v":
+			if !hasValue {
+				req.Verbose = true
+				continue
+			}
+			verbose, err := parseTestBool(value)
+			if err != nil {
+				return nil, errors.Wrapf(err, "parse %s", name)
+			}
+			req.Verbose = verbose
+		case "-test.run":
+			if !hasValue {
+				idx++
+				if idx >= len(args) {
+					return nil, errors.New("-test.run requires a value")
+				}
+				value = args[idx]
+			}
+			req.Run = value
+		case "-test.count":
+			if !hasValue {
+				idx++
+				if idx >= len(args) {
+					return nil, errors.New("-test.count requires a value")
+				}
+				value = args[idx]
+			}
+			count, err := strconv.Atoi(value)
+			if err != nil {
+				return nil, errors.Wrap(err, "parse -test.count")
+			}
+			req.Count = count
+		case "-test.short":
+			if !hasValue {
+				req.Short = true
+				continue
+			}
+			short, err := parseTestBool(value)
+			if err != nil {
+				return nil, errors.Wrap(err, "parse -test.short")
+			}
+			req.Short = short
+		case "-test.timeout":
+			if !hasValue {
+				idx++
+				if idx >= len(args) {
+					return nil, errors.New("-test.timeout requires a value")
+				}
+				value = args[idx]
+			}
+			timeout, err := time.ParseDuration(value)
+			if err != nil {
+				return nil, errors.Wrap(err, "parse -test.timeout")
+			}
+			req.Timeout = timeout
+		case "-test.paniconexit0":
+			if !hasValue {
+				req.PanicOnExit0 = true
+				continue
+			}
+			panicOnExit0, err := parseTestBool(value)
+			if err != nil {
+				return nil, errors.Wrap(err, "parse -test.paniconexit0")
+			}
+			req.PanicOnExit0 = panicOnExit0
+		case "-test.parallel":
+			if !hasValue {
+				idx++
+				if idx >= len(args) {
+					return nil, errors.New("-test.parallel requires a value")
+				}
+			}
+		case "-test.testlogfile":
+			if !hasValue {
+				idx++
+				if idx >= len(args) {
+					return nil, errors.New("-test.testlogfile requires a value")
+				}
+			}
+		default:
+			return nil, errors.Errorf("unsupported go_js_wasm_exec flag %s", name)
+		}
+	}
+	return req, nil
+}
+
+func splitFlag(arg string) (string, string, bool) {
+	name, value, ok := strings.Cut(arg, "=")
+	return name, value, ok
+}
+
+func parseTestBool(value string) (bool, error) {
+	switch strings.ToLower(strings.TrimSpace(value)) {
+	case "", "1", "t", "true", "test2json":
+		return true, nil
+	case "0", "f", "false":
+		return false, nil
+	default:
+		return false, errors.Errorf("invalid boolean value %q", value)
+	}
+}
+
+func printResult(w io.Writer, result *gotest.Result) error {
+	if result == nil {
+		return errors.New("goscript browser test result is nil")
+	}
+	for _, pkg := range result.Packages {
+		if strings.TrimSpace(pkg.Output) != "" {
+			if _, err := io.WriteString(w, strings.TrimSpace(pkg.Output)+"\n"); err != nil {
+				return err
+			}
+		}
+		switch pkg.Action {
+		case gotest.ActionPass:
+			if _, err := io.WriteString(w, "ok  \t"+pkg.PackagePath+"\n"); err != nil {
+				return err
+			}
+		case gotest.ActionSkip:
+			if _, err := io.WriteString(w, "?   \t"+pkg.PackagePath+"\t[no test files]\n"); err != nil {
+				return err
+			}
+		case gotest.ActionFail:
+			line := "FAIL\t" + pkg.PackagePath
+			if pkg.Owner != "" {
+				line += "\towner=" + string(pkg.Owner)
+			}
+			if _, err := io.WriteString(w, line+"\n"); err != nil {
+				return err
+			}
+			if strings.TrimSpace(pkg.Error) != "" {
+				if _, err := io.WriteString(w, strings.TrimSpace(pkg.Error)+"\n"); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	if result.WorkDir != "" {
+		if _, err := io.WriteString(w, "goscript browser test workdir: "+result.WorkDir+"\n"); err != nil {
+			return err
+		}
+	}
+	return nil
+}

package/cmd/go_js_wasm_exec/main_test.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/aperturerobotics/goscript/compiler/gotest"
+)
+
+func TestRequestFromGoToolArgsMapsSupportedFlags(t *testing.T) {
+	dir := t.TempDir()
+	t.Chdir(dir)
+
+	req, err := requestFromGoToolArgs([]string{
+		"/tmp/pkg.test.wasm",
+		"-test.v=test2json",
+		"-test.run", "TestBrowser",
+		"-test.count=2",
+		"-test.short",
+		"-test.timeout=3s",
+		"-test.paniconexit0",
+		"-test.parallel", "8",
+		"-test.testlogfile=ignored",
+	})
+	if err != nil {
+		t.Fatalf("parse go tool args: %v", err)
+	}
+	if req.Dir != dir {
+		t.Fatalf("Dir = %q, want %q", req.Dir, dir)
+	}
+	if len(req.Patterns) != 1 || req.Patterns[0] != "." {
+		t.Fatalf("Patterns = %#v, want .", req.Patterns)
+	}
+	if req.RuntimeBackend != gotest.RuntimeBackendBrowser {
+		t.Fatalf("RuntimeBackend = %q, want browser", req.RuntimeBackend)
+	}
+	if !req.Verbose || req.Run != "TestBrowser" || req.Count != 2 || !req.Short || req.Timeout != 3*time.Second || !req.PanicOnExit0 {
+		t.Fatalf("unexpected mapped request: %#v", req)
+	}
+}
+
+func TestRequestFromGoToolArgsMapsPanicOnExitZeroFalse(t *testing.T) {
+	t.Chdir(t.TempDir())
+
+	req, err := requestFromGoToolArgs([]string{"/tmp/pkg.test.wasm", "-test.paniconexit0=false"})
+	if err != nil {
+		t.Fatalf("parse go tool args: %v", err)
+	}
+	if req.PanicOnExit0 {
+		t.Fatal("expected explicit -test.paniconexit0=false to disable panic-on-exit-zero")
+	}
+}
+
+func TestRequestFromGoToolArgsRejectsUnsupportedFlags(t *testing.T) {
+	t.Chdir(t.TempDir())
+
+	if _, err := requestFromGoToolArgs([]string{"/tmp/pkg.test.wasm", "-test.coverprofile=cover.out"}); err == nil {
+		t.Fatal("expected unsupported flag to fail")
+	} else if !strings.Contains(err.Error(), "unsupported go_js_wasm_exec flag -test.coverprofile") {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}
+
+func TestPrintResult(t *testing.T) {
+	var out bytes.Buffer
+	err := printResult(&out, &gotest.Result{
+		WorkDir: "/work",
+		Packages: []gotest.PackageResult{{
+			PackagePath: "example.test/browser",
+			Action:      gotest.ActionPass,
+			Output:      "browser ok",
+		}},
+	})
+	if err != nil {
+		t.Fatalf("print result: %v", err)
+	}
+	got := out.String()
+	if !strings.Contains(got, "browser ok") || !strings.Contains(got, "ok  \texample.test/browser") {
+		t.Fatalf("unexpected output:\n%s", got)
+	}
+}

package/cmd/goscript/{cmd_compile.go → cmd-compile.go}

@@ -80,6 +80,13 @@ func newCompileCommand() *cli.Command {
 				Value:       false,
 				EnvVars:     []string{"GOSCRIPT_ALL_DEPENDENCIES"},
 			},
+			&cli.BoolFlag{
+				Name:        "protobuf-ts-binding",
+				Usage:       "bind .pb.go files to sibling .pb.ts files instead of emitting .pb.gs.ts",
+				Destination: &config.ProtobufTypeScriptBinding,
+				Value:       false,
+				EnvVars:     []string{"GOSCRIPT_PROTOBUF_TS_BINDING"},
+			},
 		},
 	}
 }

package/cmd/goscript/cmd-test.go

@@ -32,6 +32,7 @@ func newTestCommand() *cli.Command {
 	var dir string
 	var parallelism int
 	var runtimeGroups bool
+	var browser bool
 	var cpuProfile string
 	var memProfile string
 	var incrementalTypeCheck bool
@@ -54,6 +55,7 @@ func newTestCommand() *cli.Command {
 				WorkDir:              workDir,
 				OutputRoot:           outputRoot,
 				Parallelism:          parallelism,
+				RuntimeBackend:       testRuntimeBackend(browser),
 				RuntimeGroups:        runtimeGroups,
 				IncrementalTypeCheck: incrementalTypeCheck,
 			}
@@ -147,6 +149,11 @@ func newTestCommand() *cli.Command {
 				Usage:       "run package runtimes in grouped Bun worker processes",
 				Destination: &runtimeGroups,
 			},
+			&cli.BoolFlag{
+				Name:        "browser",
+				Usage:       "run package runtimes in a Chromium browser",
+				Destination: &browser,
+			},
 			&cli.BoolFlag{
 				Name:        "incremental-typecheck",
 				Usage:       "reuse TypeScript build-info files in the test workdir",
@@ -166,6 +173,13 @@ func newTestCommand() *cli.Command {
 	}
 }
 
+func testRuntimeBackend(browser bool) gotest.RuntimeBackend {
+	if browser {
+		return gotest.RuntimeBackendBrowser
+	}
+	return gotest.RuntimeBackendBun
+}
+
 func startCPUProfile(path string) (func(), error) {
 	path = strings.TrimSpace(path)
 	if path == "" {

package/cmd/goscript/cmd-test_test.go

@@ -17,7 +17,7 @@ func TestTestCommandHelp(t *testing.T) {
 		t.Fatalf("test help failed: %v", err)
 	}
 	help := out.String()
-	for _, expected := range []string{"compile and run Go package tests through GoScript", "--tags", "--run", "--count", "--short", "--timeout", "-p", "--runtime-groups", "--cpuprofile", "--memprofile"} {
+	for _, expected := range []string{"compile and run Go package tests through GoScript", "--tags", "--run", "--count", "--short", "--timeout", "-p", "--runtime-groups", "--browser", "--cpuprofile", "--memprofile"} {
 		if !strings.Contains(help, expected) {
 			t.Fatalf("help output missing %q:\n%s", expected, help)
 		}

package/compiler/compile-request.go

@@ -42,6 +42,8 @@ type CompileRequest struct {
 	DependencyMode DependencyMode
 	// RuntimeEmissionMode controls runtime package emission policy.
 	RuntimeEmissionMode RuntimeEmissionMode
+	// ProtobufTypeScriptBinding binds .pb.go files to sibling .pb.ts files.
+	ProtobufTypeScriptBinding bool
 	// Tests controls whether package loading includes Go package-test variants.
 	Tests bool
 	// AllDependencies controls whether the package graph should include deps.
@@ -75,15 +77,16 @@ func (o *CompileRequestOwner) NewRequest(conf Config, patterns []string) *Compil
 	}
 
 	return &CompileRequest{
-		Patterns:            normalizePatterns(patterns),
-		Dir:                 strings.TrimSpace(dir),
-		OutputPath:          strings.TrimSpace(conf.OutputPath),
-		BuildFlags:          append([]string(nil), conf.BuildFlags...),
-		OverrideDirs:        append([]string(nil), conf.OverrideDirs...),
-		DependencyMode:      dependencyMode,
-		RuntimeEmissionMode: runtimeEmissionMode,
-		AllDependencies:     conf.AllDependencies,
-		DisableEmitBuiltin:  conf.DisableEmitBuiltin,
+		Patterns:                  normalizePatterns(patterns),
+		Dir:                       strings.TrimSpace(dir),
+		OutputPath:                strings.TrimSpace(conf.OutputPath),
+		BuildFlags:                append([]string(nil), conf.BuildFlags...),
+		OverrideDirs:              append([]string(nil), conf.OverrideDirs...),
+		DependencyMode:            dependencyMode,
+		RuntimeEmissionMode:       runtimeEmissionMode,
+		ProtobufTypeScriptBinding: conf.ProtobufTypeScriptBinding,
+		AllDependencies:           conf.AllDependencies,
+		DisableEmitBuiltin:        conf.DisableEmitBuiltin,
 	}
 }
 

package/compiler/compliance_test.go

@@ -172,7 +172,6 @@ var expectedV2ComplianceGaps = map[string]bool{
 	"promise_return_type":               true,
 	"protobuf_lite_ts":                  true,
 	"receiver_variable":                 true,
-	"reflect_implements":                true,
 	"reflect_numfield":                  true,
 	"reserved_words":                    true,
 	"star_expr_destructuring":           true,

package/compiler/config.go

@@ -22,6 +22,8 @@ type Config struct {
 	AllDependencies bool
 	// DisableEmitBuiltin controls whether runtime packages are emitted.
 	DisableEmitBuiltin bool
+	// ProtobufTypeScriptBinding binds .pb.go files to sibling .pb.ts files.
+	ProtobufTypeScriptBinding bool
 }
 
 // Validate checks the config and initializes owned defaults.

package/compiler/gotest/request.go

@@ -30,12 +30,16 @@ type Request struct {
 	Timeout time.Duration
 	// Verbose emits test-level output.
 	Verbose bool
+	// PanicOnExit0 makes os.Exit(0) fail like go test's -test.paniconexit0.
+	PanicOnExit0 bool
 	// WorkDir stores generated runner files and logs.
 	WorkDir string
 	// OutputRoot stores generated TypeScript packages.
 	OutputRoot string
 	// Parallelism limits concurrent package typecheck/runtime subprocesses.
 	Parallelism int
+	// RuntimeBackend selects the JavaScript host used for package runtime tests.
+	RuntimeBackend RuntimeBackend
 	// RuntimeGroups allows package runtimes to share worker Bun processes.
 	RuntimeGroups bool
 	// IncrementalTypeCheck reuses TypeScript build-info files inside WorkDir.
@@ -52,13 +56,25 @@ type normalizedRequest struct {
 	Short                bool
 	Timeout              time.Duration
 	Verbose              bool
+	PanicOnExit0         bool
 	WorkDir              string
 	OutputRoot           string
 	Parallelism          int
+	RuntimeBackend       RuntimeBackend
 	RuntimeGroups        bool
 	IncrementalTypeCheck bool
 }
 
+// RuntimeBackend selects the JavaScript host used for package runtime tests.
+type RuntimeBackend string
+
+const (
+	// RuntimeBackendBun runs generated package-test modules directly in Bun.
+	RuntimeBackendBun RuntimeBackend = "bun"
+	// RuntimeBackendBrowser runs generated package-test modules in Chromium.
+	RuntimeBackendBrowser RuntimeBackend = "browser"
+)
+
 // DefaultParallelism returns the default package subprocess concurrency.
 func DefaultParallelism() int {
 	parallelism := runtime.GOMAXPROCS(0)
@@ -134,6 +150,16 @@ func (r *Request) normalize() (*normalizedRequest, error) {
 		return nil, errors.New("test parallelism must be positive")
 	}
 
+	runtimeBackend := r.RuntimeBackend
+	if runtimeBackend == "" {
+		runtimeBackend = RuntimeBackendBun
+	}
+	switch runtimeBackend {
+	case RuntimeBackendBun, RuntimeBackendBrowser:
+	default:
+		return nil, errors.Errorf("unsupported runtime backend %q", runtimeBackend)
+	}
+
 	return &normalizedRequest{
 		Dir:                  absDir,
 		Patterns:             patterns,
@@ -144,9 +170,11 @@ func (r *Request) normalize() (*normalizedRequest, error) {
 		Short:                r.Short,
 		Timeout:              r.Timeout,
 		Verbose:              r.Verbose,
+		PanicOnExit0:         r.PanicOnExit0,
 		WorkDir:              workDir,
 		OutputRoot:           outputRoot,
 		Parallelism:          parallelism,
+		RuntimeBackend:       runtimeBackend,
 		RuntimeGroups:        r.RuntimeGroups,
 		IncrementalTypeCheck: r.IncrementalTypeCheck,
 	}, nil