goscript 0.1.4 → 0.2.1

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

@@ -3,8 +3,10 @@
 package main
 
 import (
+	"errors"
 	"syscall/js"
 
+	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/aperturerobotics/goscript/compiler/wasm"
 )
 
@@ -20,8 +22,9 @@ func main() {
 func compileWrapper(this js.Value, args []js.Value) interface{} {
 	if len(args) < 1 {
 		return map[string]interface{}{
-			"error":  "missing source code argument",
-			"output": "",
+			"error":       "missing source code argument",
+			"output":      "",
+			"diagnostics": []interface{}{},
 		}
 	}
 
@@ -33,14 +36,43 @@ func compileWrapper(this js.Value, args []js.Value) interface{} {
 
 	output, err := wasm.CompileSource(source, packageName)
 	if err != nil {
+		diagnostics := []interface{}{}
+		var compileErr *compiler.CompileError
+		if errors.As(err, &compileErr) {
+			diagnostics = encodeDiagnostics(compileErr.Diagnostics)
+		}
 		return map[string]interface{}{
-			"error":  err.Error(),
-			"output": "",
+			"error":       err.Error(),
+			"output":      "",
+			"diagnostics": diagnostics,
 		}
 	}
 
 	return map[string]interface{}{
-		"error":  "",
-		"output": output,
+		"error":       "",
+		"output":      output,
+		"diagnostics": []interface{}{},
+	}
+}
+
+func encodeDiagnostics(diagnostics []compiler.Diagnostic) []interface{} {
+	encoded := make([]interface{}, 0, len(diagnostics))
+	for _, diagnostic := range diagnostics {
+		item := map[string]interface{}{
+			"severity": string(diagnostic.Severity),
+			"code":     diagnostic.Code,
+			"message":  diagnostic.Message,
+			"detail":   diagnostic.Detail,
+		}
+		if diagnostic.Position != nil {
+			item["position"] = map[string]interface{}{
+				"file":        diagnostic.Position.File,
+				"displayFile": diagnostic.Position.DisplayFile,
+				"line":        diagnostic.Position.Line,
+				"column":      diagnostic.Position.Column,
+			}
+		}
+		encoded = append(encoded, item)
 	}
+	return encoded
 }

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/diagnostic.go

@@ -1,6 +1,10 @@
 package compiler
 
-import "strings"
+import (
+	"path/filepath"
+	"strconv"
+	"strings"
+)
 
 // DiagnosticSeverity is the severity of a compiler diagnostic.
 type DiagnosticSeverity string
@@ -22,6 +26,20 @@ type Diagnostic struct {
 	Message string
 	// Detail carries optional longer guidance.
 	Detail string
+	// Position is the optional source point that caused the diagnostic.
+	Position *DiagnosticPosition
+}
+
+// DiagnosticPosition identifies the source point that caused a diagnostic.
+type DiagnosticPosition struct {
+	// File is the raw file identity from the compiler source owner.
+	File string
+	// DisplayFile is the request-relative file identity for human output.
+	DisplayFile string
+	// Line is the 1-based source line.
+	Line int
+	// Column is the 1-based source column.
+	Column int
 }
 
 // CompileError wraps structured diagnostics for ordinary Go error paths.
@@ -41,25 +59,99 @@ func (e *CompileError) Error() string {
 		return "goscript: compile failed"
 	}
 
+	return FormatDiagnostics(e.Diagnostics)
+}
+
+// FormatDiagnostics returns the canonical human-readable diagnostic summary.
+func FormatDiagnostics(diagnostics []Diagnostic) string {
 	var b strings.Builder
-	for i, diag := range e.Diagnostics {
+	for i, diag := range diagnostics {
 		if i != 0 {
 			b.WriteString("; ")
 		}
-		if diag.Code != "" {
-			b.WriteString(diag.Code)
-			b.WriteString(": ")
-		}
-		b.WriteString(diag.Message)
-		if diag.Detail != "" {
-			b.WriteString(" (")
-			b.WriteString(diag.Detail)
-			b.WriteString(")")
-		}
+		b.WriteString(FormatDiagnostic(diag))
 	}
 	return b.String()
 }
 
+// FormatDiagnostic returns the canonical human-readable form of one diagnostic.
+func FormatDiagnostic(diag Diagnostic) string {
+	var b strings.Builder
+	if pos := formatDiagnosticPosition(diag.Position); pos != "" {
+		b.WriteString(pos)
+		b.WriteString(": ")
+	}
+	if diag.Code != "" {
+		b.WriteString(diag.Code)
+		b.WriteString(": ")
+	}
+	b.WriteString(diag.Message)
+	if diag.Detail != "" {
+		b.WriteString(" (")
+		b.WriteString(diag.Detail)
+		b.WriteString(")")
+	}
+	return b.String()
+}
+
+func formatDiagnosticPosition(pos *DiagnosticPosition) string {
+	if pos == nil || pos.Line <= 0 {
+		return ""
+	}
+	file := strings.TrimSpace(pos.DisplayFile)
+	if file == "" {
+		file = strings.TrimSpace(pos.File)
+	}
+	if file == "" {
+		return ""
+	}
+	var b strings.Builder
+	b.WriteString(filepath.ToSlash(file))
+	b.WriteString(":")
+	b.WriteString(strconv.Itoa(pos.Line))
+	if pos.Column > 0 {
+		b.WriteString(":")
+		b.WriteString(strconv.Itoa(pos.Column))
+	}
+	return b.String()
+}
+
+func diagnosticPositionFromSource(pos sourcePosition, displayRoot string) *DiagnosticPosition {
+	if pos.line <= 0 {
+		return nil
+	}
+	file := strings.TrimSpace(pos.file)
+	return &DiagnosticPosition{
+		File:        file,
+		DisplayFile: diagnosticDisplayFile(file, displayRoot),
+		Line:        pos.line,
+		Column:      pos.column,
+	}
+}
+
+func diagnosticDisplayFile(file string, displayRoot string) string {
+	file = strings.TrimSpace(file)
+	if file == "" {
+		return ""
+	}
+	displayRoot = strings.TrimSpace(displayRoot)
+	if displayRoot == "" {
+		return filepath.ToSlash(file)
+	}
+	root := displayRoot
+	if absRoot, err := filepath.Abs(root); err == nil {
+		root = absRoot
+	}
+	candidate := file
+	if !filepath.IsAbs(candidate) {
+		candidate = filepath.Join(root, candidate)
+	}
+	if rel, err := filepath.Rel(root, candidate); err == nil && rel != "." && rel != ".." && !strings.HasPrefix(rel, ".."+string(filepath.Separator)) {
+		return filepath.ToSlash(rel)
+	}
+	return filepath.ToSlash(file)
+}
+
 func diagnosticsHaveErrors(diagnostics []Diagnostic) bool {
 	for _, diag := range diagnostics {
 		if diag.Severity == DiagnosticSeverityError {