goscript 0.1.3 → 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}

@@ -17,7 +17,7 @@ func compileCommands() []*cli.Command {
 func newCompileCommand() *cli.Command {
 	var config compiler.Config
 	var packages cli.StringSlice
-	var buildFlags cli.StringSlice
+	var buildFlags rawStringSlice
 	var overrideDirs cli.StringSlice
 
 	return &cli.Command{
@@ -25,7 +25,7 @@ func newCompileCommand() *cli.Command {
 		Category: "compile",
 		Usage:    "compile a Go package to TypeScript",
 		Action: func(c *cli.Context) error {
-			config.BuildFlags = slices.Clone(buildFlags.Value())
+			config.BuildFlags = buildFlags.Value()
 			config.OverrideDirs = slices.Clone(overrideDirs.Value())
 			return compilePackage(c.Context, &config, packages.Value())
 		},
@@ -51,12 +51,12 @@ func newCompileCommand() *cli.Command {
 				Value:       "",
 				EnvVars:     []string{"GOSCRIPT_DIR"},
 			},
-			&cli.StringSliceFlag{
-				Name:        "build-flags",
-				Aliases:     []string{"b", "buildflags", "build-flag", "buildflag"},
-				Usage:       "Go build flags (tags) to use during analysis",
-				Destination: &buildFlags,
-				EnvVars:     []string{"GOSCRIPT_BUILD_FLAGS"},
+			&cli.GenericFlag{
+				Name:    "build-flags",
+				Aliases: []string{"b", "buildflags", "build-flag", "buildflag"},
+				Usage:   "Go build flags (tags) to use during analysis",
+				Value:   &buildFlags,
+				EnvVars: []string{"GOSCRIPT_BUILD_FLAGS"},
 			},
 			&cli.StringSliceFlag{
 				Name:        "gs-path",
@@ -80,10 +80,37 @@ 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"},
+			},
 		},
 	}
 }
 
+type rawStringSlice []string
+
+func (s *rawStringSlice) Set(value string) error {
+	if value == "" {
+		return nil
+	}
+	*s = append(*s, value)
+	return nil
+}
+
+func (s *rawStringSlice) String() string {
+	// Keep the flag default empty. The CLI package registers aliases against
+	// the same flag value, and echoing accumulated values here re-parses them.
+	return ""
+}
+
+func (s *rawStringSlice) Value() []string {
+	return slices.Clone(*s)
+}
+
 // compilePackage tries to compile the package.
 func compilePackage(ctx context.Context, config *compiler.Config, pkgs []string) error {
 	if len(pkgs) == 0 {

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/cmd/goscript/cmd_compile_test.go

@@ -14,22 +14,20 @@ func TestCompileCommandForwardsBuildFlags(t *testing.T) {
 	writeFile(t, filepath.Join(dir, "default.go"), strings.Join([]string{
 		"//go:build !customtag",
 		"",
-		"package main",
+		"package cli",
 		`const selected = "default"`,
 		"",
 	}, "\n"))
 	writeFile(t, filepath.Join(dir, "tagged.go"), strings.Join([]string{
 		"//go:build customtag",
 		"",
-		"package main",
+		"package cli",
 		`const selected = "custom"`,
 		"",
 	}, "\n"))
 	writeFile(t, filepath.Join(dir, "main.go"), strings.Join([]string{
-		"package main",
-		"func main() {",
-		"  println(selected)",
-		"}",
+		"package cli",
+		"func Selected() string { return selected }",
 		"",
 	}, "\n"))
 
@@ -71,6 +69,107 @@ func TestCompileCommandForwardsBuildFlags(t *testing.T) {
 	}
 }
 
+func TestCompileCommandPreservesCommaSeparatedBuildFlagValues(t *testing.T) {
+	dir := t.TempDir()
+	outputDir := filepath.Join(dir, "output")
+	writeFile(t, filepath.Join(dir, "go.mod"), "module example.test/cli\n\ngo 1.25.3\n")
+	writeFile(t, filepath.Join(dir, "default.go"), strings.Join([]string{
+		"//go:build !(customtag && othertag)",
+		"",
+		"package cli",
+		`const selected = "default"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "tagged.go"), strings.Join([]string{
+		"//go:build customtag && othertag",
+		"",
+		"package cli",
+		`const selected = "custom"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "main.go"), strings.Join([]string{
+		"package cli",
+		"func Selected() string { return selected }",
+		"",
+	}, "\n"))
+
+	app := newApp()
+	err := app.Run([]string{
+		"goscript",
+		"compile",
+		"--package",
+		".",
+		"--output",
+		outputDir,
+		"--dir",
+		dir,
+		"--build-flags=-tags=customtag,othertag",
+	})
+	if err != nil {
+		t.Fatalf("compile command failed: %v", err)
+	}
+
+	taggedPath := filepath.Join(outputDir, "@goscript", "example.test", "cli", "tagged.gs.ts")
+	tagged, err := os.ReadFile(taggedPath)
+	if err != nil {
+		t.Fatalf("read tagged generated file: %v", err)
+	}
+	if !strings.Contains(string(tagged), `"custom"`) {
+		t.Fatalf("expected tagged generated file to use tagged source, got:\n%s", tagged)
+	}
+}
+
+func TestCompileCommandPreservesCommaSeparatedBuildFlagEnvValue(t *testing.T) {
+	dir := t.TempDir()
+	outputDir := filepath.Join(dir, "output")
+	writeFile(t, filepath.Join(dir, "go.mod"), "module example.test/cli\n\ngo 1.25.3\n")
+	writeFile(t, filepath.Join(dir, "default.go"), strings.Join([]string{
+		"//go:build !(customtag && othertag)",
+		"",
+		"package cli",
+		`const selected = "default"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "tagged.go"), strings.Join([]string{
+		"//go:build customtag && othertag",
+		"",
+		"package cli",
+		`const selected = "custom"`,
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "main.go"), strings.Join([]string{
+		"package cli",
+		"func Selected() string { return selected }",
+		"",
+	}, "\n"))
+
+	t.Setenv("GOSCRIPT_BUILD_FLAGS", "-tags=customtag,othertag")
+
+	app := newApp()
+	err := app.Run([]string{
+		"goscript",
+		"compile",
+		"--package",
+		".",
+		"--output",
+		outputDir,
+		"--dir",
+		dir,
+	})
+	if err != nil {
+		t.Fatalf("compile command failed: %v", err)
+	}
+
+	taggedPath := filepath.Join(outputDir, "@goscript", "example.test", "cli", "tagged.gs.ts")
+	tagged, err := os.ReadFile(taggedPath)
+	if err != nil {
+		t.Fatalf("read tagged generated file: %v", err)
+	}
+	if !strings.Contains(string(tagged), `"custom"`) {
+		t.Fatalf("expected tagged generated file to use tagged source, got:\n%s", tagged)
+	}
+}
+
 func writeFile(t *testing.T, path string, content string) {
 	t.Helper()
 	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {

package/compiler/build-flags.go

@@ -1,8 +1,9 @@
 package compiler
 
-import "slices"
-
-import "strings"
+import (
+	"slices"
+	"strings"
+)
 
 const goScriptBuildTag = "goscript"
 
@@ -26,13 +27,11 @@ func appendBuildTag(value string, tag string) string {
 		return r == ',' || r == ' ' || r == '\t' || r == '\n'
 	})
 	if slices.Contains(tags, tag) {
-		return value
-	}
-	if strings.TrimSpace(value) == "" {
-		return tag
+		return strings.Join(tags, " ")
 	}
-	if strings.ContainsAny(value, " \t\n") {
-		return value + " " + tag
+	tags = append(tags, tag)
+	if len(tags) == 0 {
+		return ""
 	}
-	return value + "," + tag
+	return strings.Join(tags, " ")
 }

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.