goscript 0.2.4 → 0.2.5

package/README.md

@@ -9,13 +9,13 @@
   </p>
 
   <p>
-    <a href="https://godoc.org/github.com/aperturerobotics/goscript">
-      <img src="https://godoc.org/github.com/aperturerobotics/goscript?status.svg" alt="GoDoc" />
+    <a href="https://godoc.org/github.com/s4wave/goscript">
+      <img src="https://godoc.org/github.com/s4wave/goscript?status.svg" alt="GoDoc" />
     </a>
-    <a href="https://goreportcard.com/report/github.com/aperturerobotics/goscript">
-      <img src="https://goreportcard.com/badge/github.com/aperturerobotics/goscript" alt="Go Report Card" />
+    <a href="https://goreportcard.com/report/github.com/s4wave/goscript">
+      <img src="https://goreportcard.com/badge/github.com/s4wave/goscript" alt="Go Report Card" />
     </a>
-    <a href="https://deepwiki.com/aperturerobotics/goscript">
+    <a href="https://deepwiki.com/s4wave/goscript">
       <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki" />
     </a>
   </p>
@@ -120,7 +120,7 @@ curl -fsSL https://bun.sh/install | bash
 Install the CLI:
 
 ```bash
-go install github.com/aperturerobotics/goscript/cmd/goscript@latest
+go install github.com/s4wave/goscript/cmd/goscript@latest
 ```
 
 Compile a Go package from a module directory:
@@ -231,7 +231,7 @@ package main
 import (
 	"context"
 
-	"github.com/aperturerobotics/goscript/compiler"
+	"github.com/s4wave/goscript/compiler"
 )
 
 func main() {
@@ -265,7 +265,7 @@ WASM adapter package:
 ```go
 package main
 
-import "github.com/aperturerobotics/goscript/compiler/wasm"
+import "github.com/s4wave/goscript/compiler/wasm"
 
 func main() {
 	ts, err := wasm.CompileSource(`

package/cmd/go_js_wasm_exec/main.go

@@ -9,8 +9,8 @@ import (
 	"strings"
 	"time"
 
-	"github.com/aperturerobotics/goscript/compiler/gotest"
 	"github.com/pkg/errors"
+	"github.com/s4wave/goscript/compiler/gotest"
 )
 
 func main() {

package/cmd/go_js_wasm_exec/main_test.go

@@ -6,7 +6,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aperturerobotics/goscript/compiler/gotest"
+	"github.com/s4wave/goscript/compiler/gotest"
 )
 
 func TestRequestFromGoToolArgsMapsSupportedFlags(t *testing.T) {

package/cmd/goscript/cmd-compile.go

@@ -5,8 +5,8 @@ import (
 	"slices"
 
 	"github.com/aperturerobotics/cli"
-	"github.com/aperturerobotics/goscript/compiler"
 	"github.com/pkg/errors"
+	"github.com/s4wave/goscript/compiler"
 	"github.com/sirupsen/logrus"
 )
 
@@ -19,6 +19,7 @@ func newCompileCommand() *cli.Command {
 	var packages cli.StringSlice
 	var buildFlags rawStringSlice
 	var overrideDirs cli.StringSlice
+	var packageBlocklist cli.StringSlice
 
 	return &cli.Command{
 		Name:     "compile",
@@ -27,6 +28,7 @@ func newCompileCommand() *cli.Command {
 		Action: func(c *cli.Context) error {
 			config.BuildFlags = buildFlags.Value()
 			config.OverrideDirs = slices.Clone(overrideDirs.Value())
+			config.PackageBlocklist = slices.Clone(packageBlocklist.Value())
 			return compilePackage(c.Context, &config, packages.Value())
 		},
 		Flags: []cli.Flag{
@@ -65,6 +67,12 @@ func newCompileCommand() *cli.Command {
 				Destination: &overrideDirs,
 				EnvVars:     []string{"GOSCRIPT_GS_PATH"},
 			},
+			&cli.StringSliceFlag{
+				Name:        "package-blocklist",
+				Usage:       "comma-separated Go import paths to reject from the compiled package graph",
+				Destination: &packageBlocklist,
+				EnvVars:     []string{"GOSCRIPT_PACKAGE_BLOCKLIST"},
+			},
 			&cli.BoolFlag{
 				Name:        "disable-emit-builtin",
 				Usage:       "disable emitting built-in packages that have handwritten equivalents",

package/cmd/goscript/cmd-test.go

@@ -11,8 +11,8 @@ import (
 	"time"
 
 	"github.com/aperturerobotics/cli"
-	"github.com/aperturerobotics/goscript/compiler/gotest"
 	"github.com/pkg/errors"
+	"github.com/s4wave/goscript/compiler/gotest"
 )
 
 func testCommands() []*cli.Command {

package/cmd/goscript/cmd_compile_test.go

@@ -170,8 +170,52 @@ func TestCompileCommandPreservesCommaSeparatedBuildFlagEnvValue(t *testing.T) {
 	}
 }
 
+func TestCompileCommandForwardsPackageBlocklist(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, "main.go"), strings.Join([]string{
+		"package cli",
+		`import "example.test/cli/dep"`,
+		"func Selected() int { return dep.Value() }",
+		"",
+	}, "\n"))
+	writeFile(t, filepath.Join(dir, "dep", "dep.go"), strings.Join([]string{
+		"package dep",
+		"func Value() int { return 1 }",
+		"",
+	}, "\n"))
+
+	app := newApp()
+	err := app.Run([]string{
+		"goscript",
+		"compile",
+		"--package",
+		".",
+		"--output",
+		outputDir,
+		"--dir",
+		dir,
+		"--all-dependencies",
+		"--package-blocklist=example.test/cli/dep,example.test/unused",
+	})
+	if err == nil {
+		t.Fatal("expected package blocklist error")
+	}
+	text := err.Error()
+	if !strings.Contains(text, "goscript/package-graph:blocklisted-package") {
+		t.Fatalf("expected blocklist diagnostic, got %q", text)
+	}
+	if !strings.Contains(text, "example.test/cli -> example.test/cli/dep") {
+		t.Fatalf("expected CLI diagnostic to include import chain, got %q", text)
+	}
+}
+
 func writeFile(t *testing.T, path string, content string) {
 	t.Helper()
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatalf("create parent for %s: %v", path, err)
+	}
 	if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
 		t.Fatalf("write %s: %v", path, err)
 	}

package/cmd/goscript/deps.go

@@ -4,5 +4,5 @@ package main
 
 import (
 	// _ ensure we include the root package
-	_ "github.com/aperturerobotics/goscript"
+	_ "github.com/s4wave/goscript"
 )

package/cmd/goscript-wasm/main.go

@@ -6,8 +6,8 @@ import (
 	"errors"
 	"syscall/js"
 
-	"github.com/aperturerobotics/goscript/compiler"
-	"github.com/aperturerobotics/goscript/compiler/wasm"
+	"github.com/s4wave/goscript/compiler"
+	"github.com/s4wave/goscript/compiler/wasm"
 )
 
 func main() {

package/compiler/compile-request.go

@@ -38,6 +38,8 @@ type CompileRequest struct {
 	BuildFlags []string
 	// OverrideDirs are additional GoScript override roots.
 	OverrideDirs []string
+	// PackageBlocklist rejects package paths in the loaded dependency closure.
+	PackageBlocklist []string
 	// DependencyMode controls whether dependencies are included in the graph.
 	DependencyMode DependencyMode
 	// RuntimeEmissionMode controls runtime package emission policy.
@@ -82,6 +84,7 @@ func (o *CompileRequestOwner) NewRequest(conf Config, patterns []string) *Compil
 		OutputPath:                strings.TrimSpace(conf.OutputPath),
 		BuildFlags:                append([]string(nil), conf.BuildFlags...),
 		OverrideDirs:              append([]string(nil), conf.OverrideDirs...),
+		PackageBlocklist:          normalizePackageBlocklist(conf.PackageBlocklist),
 		DependencyMode:            dependencyMode,
 		RuntimeEmissionMode:       runtimeEmissionMode,
 		ProtobufTypeScriptBinding: conf.ProtobufTypeScriptBinding,
@@ -235,6 +238,22 @@ func normalizePatterns(patterns []string) []string {
 	return normalized
 }
 
+func normalizePackageBlocklist(paths []string) []string {
+	var normalized []string
+	seen := make(map[string]bool)
+	for _, path := range paths {
+		for part := range strings.SplitSeq(path, ",") {
+			part = strings.TrimSpace(part)
+			if part == "" || seen[part] {
+				continue
+			}
+			seen[part] = true
+			normalized = append(normalized, part)
+		}
+	}
+	return normalized
+}
+
 func hasGoMod(dir string) bool {
 	abs, err := filepath.Abs(dir)
 	if err != nil {

package/compiler/compile_bench_test.go

@@ -0,0 +1,121 @@
+package compiler
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+// benchDependencyPatterns is a representative existing GoScript dependency
+// package graph: real util packages whose closure pulls in generics, channels,
+// sync primitives, and context wiring, so the per-stage attribution reflects a
+// realistic compile rather than a toy fixture.
+var benchDependencyPatterns = []string{
+	"github.com/aperturerobotics/util/broadcast",
+	"github.com/aperturerobotics/util/keyed",
+	"github.com/aperturerobotics/util/ccontainer",
+	"github.com/aperturerobotics/util/refcount",
+	"github.com/aperturerobotics/util/routine",
+}
+
+// BenchmarkCompilePipelineStages runs the full CompileService pipeline over a
+// representative existing dependency package graph and attributes wall time to
+// each stage owner: package-graph load, semantic-model build, lowering, and
+// TypeScript emit. It reports per-stage milliseconds-per-op metrics so a single
+// run names the dominant compile-time stage. Service construction (which builds
+// the runtime contract owner) is measured once as serviceinit-ms because the
+// runtime contract is static setup, not a per-package stage. Emit is measured
+// via EmitToMemory to isolate code-generation cost from output disk writes.
+func BenchmarkCompilePipelineStages(b *testing.B) {
+	moduleRoot := benchModuleRoot(b)
+	outputPath := b.TempDir()
+	req := &CompileRequest{
+		Dir:            moduleRoot,
+		OutputPath:     outputPath,
+		Patterns:       benchDependencyPatterns,
+		DependencyMode: DependencyModeAll,
+	}
+
+	// Resolve the dependency graph once outside the timer to confirm the
+	// patterns load cleanly and fail fast before measuring.
+	if _, diagnostics := NewCompileService().PackageGraphOwner().Load(context.Background(), req); diagnosticsHaveErrors(diagnostics) {
+		b.Fatalf("load representative dependency graph: %v", diagnostics)
+	}
+
+	var serviceInit, graphLoad, semantic, lowering, emit time.Duration
+	loweringOpts := LoweringOptions{
+		SourceRoot:  protobufTypeScriptBindingRoot(req.Dir),
+		DisplayRoot: req.Dir,
+		OutputPath:  req.OutputPath,
+	}
+
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		start := time.Now()
+		service := NewCompileService()
+		serviceInit += time.Since(start)
+
+		start = time.Now()
+		graph, graphDiagnostics := service.PackageGraphOwner().Load(context.Background(), req)
+		graphLoad += time.Since(start)
+		if diagnosticsHaveErrors(graphDiagnostics) {
+			b.Fatalf("graph load: %v", graphDiagnostics)
+		}
+
+		start = time.Now()
+		model, semanticDiagnostics := service.SemanticModelOwner().Build(context.Background(), graph)
+		semantic += time.Since(start)
+		if diagnosticsHaveErrors(semanticDiagnostics) {
+			b.Fatalf("semantic build: %v", semanticDiagnostics)
+		}
+
+		start = time.Now()
+		program, loweringDiagnostics := service.LoweringOwner().Build(context.Background(), model, loweringOpts)
+		lowering += time.Since(start)
+		if diagnosticsHaveErrors(loweringDiagnostics) {
+			b.Fatalf("lowering: %v", loweringDiagnostics)
+		}
+
+		start = time.Now()
+		_, emitDiagnostics := service.TypeScriptEmitOwner().EmitToMemory(context.Background(), program)
+		emit += time.Since(start)
+		if diagnosticsHaveErrors(emitDiagnostics) {
+			b.Fatalf("emit: %v", emitDiagnostics)
+		}
+	}
+	b.StopTimer()
+
+	perOpMs := func(total time.Duration) float64 {
+		return float64(total.Nanoseconds()) / float64(b.N) / 1e6
+	}
+	b.ReportMetric(perOpMs(serviceInit), "serviceinit-ms/op")
+	b.ReportMetric(perOpMs(graphLoad), "graphload-ms/op")
+	b.ReportMetric(perOpMs(semantic), "semantic-ms/op")
+	b.ReportMetric(perOpMs(lowering), "lowering-ms/op")
+	b.ReportMetric(perOpMs(emit), "emit-ms/op")
+}
+
+// benchModuleRoot walks up from the test working directory to the module root
+// that owns go.mod, so the bench loads util packages in the GoScript module's
+// own dependency context (resolved go.sum and module cache) rather than a
+// synthetic temp module.
+func benchModuleRoot(tb testing.TB) string {
+	tb.Helper()
+	dir, err := os.Getwd()
+	if err != nil {
+		tb.Fatalf("getwd: %v", err)
+	}
+	for {
+		if _, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil {
+			return dir
+		}
+		parent := filepath.Dir(dir)
+		if parent == dir {
+			tb.Fatal("module root with go.mod not found above test working directory")
+		}
+		dir = parent
+	}
+}

package/compiler/compliance_test.go

@@ -7,7 +7,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/aperturerobotics/goscript/tests"
+	"github.com/s4wave/goscript/tests"
 )
 
 // TestCompliance runs the inherited GoScript compliance fixtures through the
@@ -59,6 +59,9 @@ func TestCompliance(t *testing.T) {
 					if expectedV2ComplianceGaps[name] {
 						t.Skip("expected v2 compliance gap")
 					}
+					if complianceHarnessExcluded[name] {
+						t.Skip("validated by a dedicated oracle test, not stdout comparison")
+					}
 
 					ranTests++
 					tests.RunGoScriptTestDir(t, workspaceDir, testPath)
@@ -120,6 +123,19 @@ func complianceCategory(name string) string {
 	}
 }
 
+// complianceHarnessExcluded lists fixture directories that the shared stdout
+// comparison harness must skip because a dedicated test validates them another
+// way. runtime_trace_proof, runtime_trace_empty, and runtime_trace_multibatch
+// emit Go execution-trace bytes whose GoScript subset is intentionally not
+// byte-identical to the native runtime trace, so TestRuntimeTraceProof,
+// TestRuntimeTraceEmptyCapture, and TestRuntimeTraceMultiBatch validate them
+// through the upstream Go trace reader.
+var complianceHarnessExcluded = map[string]bool{
+	"runtime_trace_proof":      true,
+	"runtime_trace_empty":      true,
+	"runtime_trace_multibatch": true,
+}
+
 var expectedV2ComplianceGaps = map[string]bool{
 	"bitwise_and_not_assignment":        true,
 	"buffer_value_field_error":          true,

package/compiler/config.go

@@ -18,6 +18,8 @@ type Config struct {
 	BuildFlags []string
 	// OverrideDirs are additional GoScript override roots.
 	OverrideDirs []string
+	// PackageBlocklist rejects package paths in the loaded dependency closure.
+	PackageBlocklist []string
 	// AllDependencies controls whether dependencies are included in the graph.
 	AllDependencies bool
 	// DisableEmitBuiltin controls whether runtime packages are emitted.

package/compiler/gotest/result.go

@@ -1,6 +1,6 @@
 package gotest
 
-import "github.com/aperturerobotics/goscript/compiler"
+import "github.com/s4wave/goscript/compiler"
 
 // Result describes one GoScript package-test run.
 type Result struct {

package/compiler/gotest/runner.go

@@ -12,9 +12,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/aperturerobotics/goscript/compiler"
-	"github.com/aperturerobotics/goscript/compiler/tsworkspace"
 	"github.com/pkg/errors"
+	"github.com/s4wave/goscript/compiler"
+	"github.com/s4wave/goscript/compiler/tsworkspace"
 )
 
 const combinedRuntimeResultPrefix = "__GOSCRIPT_PACKAGE_RESULT__"

package/compiler/gotest/runner_test.go

@@ -11,7 +11,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/aperturerobotics/goscript/compiler"
+	"github.com/s4wave/goscript/compiler"
 )
 
 func TestDiagnosticsSummaryUsesCompilerFormatter(t *testing.T) {
@@ -604,7 +604,7 @@ func TestRunnerScopesPackageLoadErrors(t *testing.T) {
 	}
 }
 
-func TestRunnerScopesPackageCompileErrors(t *testing.T) {
+func TestRunnerCompilesAddressOfDereferencePackage(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod": "module example.test/mixedcompile\n\ngo 1.25.3\n",
 		"clean/value.go": strings.Join([]string{
@@ -664,11 +664,8 @@ func TestRunnerScopesPackageCompileErrors(t *testing.T) {
 		t.Fatalf("clean package should pass independently: %#v", clean)
 	}
 	broken := requirePackageResult(t, result, "example.test/mixedcompile/broken")
-	if broken.Action != ActionFail || broken.Owner != OwnerLowering {
-		t.Fatalf("broken package should carry lowering failure: %#v", broken)
-	}
-	if !strings.Contains(broken.Error, "unsupported address expression") {
-		t.Fatalf("broken package error should preserve compile diagnostic: %#v", broken)
+	if broken.Action != ActionPass {
+		t.Fatalf("address-of-dereference package should pass: %#v", broken)
 	}
 }
 

package/compiler/index.test.ts

@@ -51,4 +51,32 @@ describe('GoScript Compiler API', () => {
       stderr: expect.stringContaining('main.go:4:'),
     })
   }, 30000)
+
+  it('forwards the package blocklist to closure compiles', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'goscript-api-blocklist-'))
+    const output = join(dir, 'output')
+    await mkdir(join(dir, 'dep'), { recursive: true })
+    await writeFile(join(dir, 'go.mod'), 'module example.test/apiblock\n\ngo 1.25.3\n')
+    await writeFile(join(dir, 'main.go'), [
+      'package apiblock',
+      'import "example.test/apiblock/dep"',
+      'func Value() int { return dep.Value() }',
+      '',
+    ].join('\n'))
+    await writeFile(join(dir, 'dep', 'dep.go'), [
+      'package dep',
+      'func Value() int { return 1 }',
+      '',
+    ].join('\n'))
+
+    await expect(compile({
+      pkg: '.',
+      output,
+      dir,
+      allDependencies: true,
+      packageBlocklist: ['example.test/apiblock/dep'],
+    })).rejects.toMatchObject({
+      stderr: expect.stringContaining('example.test/apiblock -> example.test/apiblock/dep'),
+    })
+  }, 30000)
 })

package/compiler/index.ts

@@ -19,6 +19,10 @@ export interface CompileConfig {
   output?: string
   /** The working directory for the compiler. Defaults to the current working directory. */
   dir?: string
+  /** Compile all transitive dependencies of the requested package. */
+  allDependencies?: boolean
+  /** Go import paths to reject from the compiled package graph. */
+  packageBlocklist?: string[] | string
   /** The path to the goscript executable. Defaults to `go run ./cmd/goscript`. */
   goscriptPath?: string
 }
@@ -33,33 +37,45 @@ export async function compile(config: CompileConfig): Promise<void> {
 
   const cwd = config.dir ? path.resolve(config.dir) : process.cwd()
   const output = config.output ? path.resolve(config.output) : './output'
+  const args = [
+    'compile',
+    '--package',
+    config.pkg,
+    '--output',
+    output,
+    '--dir',
+    cwd,
+  ]
+  if (config.allDependencies) {
+    args.push('--all-dependencies')
+  }
+  const packageBlocklist = normalizePackageBlocklist(config.packageBlocklist)
+  if (packageBlocklist) {
+    args.push('--package-blocklist', packageBlocklist)
+  }
 
   if (config.goscriptPath) {
-    await execFileAsync(config.goscriptPath, [
-      'compile',
-      '--package',
-      config.pkg,
-      '--output',
-      output,
-      '--dir',
-      cwd,
-    ])
+    await execFileAsync(config.goscriptPath, args)
     return
   }
 
   await execFileAsync('go', [
     'run',
     path.join(projectRoot, 'cmd/goscript'),
-    'compile',
-    '--package',
-    config.pkg,
-    '--output',
-    output,
-    '--dir',
-    cwd,
+    ...args,
   ])
 }
 
+function normalizePackageBlocklist(value: string[] | string | undefined): string {
+  if (!value) {
+    return ''
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => item.trim()).filter(Boolean).join(',')
+  }
+  return value.trim()
+}
+
 /**
  * Default export for convenience.
  */