goscript 0.1.1 → 0.1.2

package/compiler/gotest/runner_test.go

@@ -4,6 +4,9 @@ import (
 	"context"
 	"os"
 	"path/filepath"
+	"runtime"
+	"slices"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
@@ -158,6 +161,55 @@ func TestRunnerAwaitsAsyncDependencyCallsInTests(t *testing.T) {
 	}
 }
 
+func TestRunnerEvaluatesStructLiteralCallsBeforeFieldCopies(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/literalorder\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package literalorder",
+			"",
+			"import \"testing\"",
+			"",
+			"type result struct {",
+			"\tvalue int",
+			"\terr error",
+			"}",
+			"",
+			"func fill(value *int) error {",
+			"\t*value = 7",
+			"\treturn nil",
+			"}",
+			"",
+			"func recv() result {",
+			"\tvar value int",
+			"\treturn result{value: value, err: fill(&value)}",
+			"}",
+			"",
+			"func TestLiteralOrder(t *testing.T) {",
+			"\tres := recv()",
+			"\tif res.err != nil {",
+			"\t\tt.Fatalf(\"unexpected error: %v\", res.err)",
+			"\t}",
+			"\tif res.value != 7 {",
+			"\t\tt.Fatalf(\"unexpected value: %d\", res.value)",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run literal order package: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected literal order package to pass: %#v", result.Packages)
+	}
+}
+
 func TestRunnerRunsExternalPackageTest(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod": "module example.test/external\n\ngo 1.25.3\n",
@@ -206,6 +258,63 @@ func TestRunnerRunsExternalPackageTest(t *testing.T) {
 	}
 }
 
+func TestRunnerAppliesOverridesToTestImports(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/testoverride\n\ngo 1.25.3\n",
+		"dep/value.go": strings.Join([]string{
+			"package dep",
+			"",
+			"func Value() int {",
+			"\tx := 41",
+			"\t_ = &x",
+			"\treturn x + 1",
+			"}",
+			"",
+		}, "\n"),
+		"app/value.go": "package app\n",
+		"app/value_test.go": strings.Join([]string{
+			"package app",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\t\"example.test/testoverride/dep\"",
+			")",
+			"",
+			"func TestOverrideImport(t *testing.T) {",
+			"\tif dep.Value() != 42 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	overrideDir := filepath.Join(moduleDir, "gs")
+	if err := os.MkdirAll(filepath.Join(overrideDir, "example.test", "testoverride", "dep"), 0o755); err != nil {
+		t.Fatal(err.Error())
+	}
+	if err := os.WriteFile(
+		filepath.Join(overrideDir, "example.test", "testoverride", "dep", "index.ts"),
+		[]byte("export function Value(): number { return 42 }\n"),
+		0o644,
+	); err != nil {
+		t.Fatal(err.Error())
+	}
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:          moduleDir,
+		Patterns:     []string{"./app"},
+		OverrideDirs: []string{overrideDir},
+		Timeout:      30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run override import package: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected package test to pass with override import: %#v", result.Packages)
+	}
+}
+
 func TestRunnerRejectsInvalidRunPattern(t *testing.T) {
 	moduleDir := writeFixture(t, map[string]string{
 		"go.mod":   "module example.test/badrun\n\ngo 1.25.3\n",
@@ -374,7 +483,8 @@ func TestRunnerScopesPackageCompileErrors(t *testing.T) {
 			"",
 			"func Value() int {",
 			"\tx := 1",
-			"\t_ = &(x)",
+			"\tp := &x",
+			"\t_ = &(*p)",
 			"\treturn x",
 			"}",
 			"",
@@ -524,6 +634,13 @@ func TestRunnerScopesPackageTypecheckErrors(t *testing.T) {
 		"\tfi",
 		"\tshift || break",
 		"done",
+		"if [ \"$project\" = \"tsconfig.json\" ]; then",
+		"\tif grep -q 'example.test/mixedtypecheck/bad' runner-*.ts; then",
+		"\t\techo 'TypeScript TS9000: bad package'",
+		"\t\texit 1",
+		"\tfi",
+		"\texit 0",
+		"fi",
 		"runner=$(sed -n 's/.*\"\\(runner-[0-9][0-9]*\\.ts\\)\".*/\\1/p' \"$project\" | head -n 1)",
 		"if grep -q 'example.test/mixedtypecheck/bad' \"$runner\"; then",
 		"\techo 'TypeScript TS9000: bad package'",
@@ -560,18 +677,503 @@ func TestRunnerScopesPackageTypecheckErrors(t *testing.T) {
 	}
 }
 
+func TestRunnerDoesNotRepeatSharedOverrideTypecheckFailure(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/sharedoverride\n\ngo 1.25.3\n",
+		"one/value.go": strings.Join([]string{
+			"package one",
+			"",
+			"func Value() int { return 1 }",
+			"",
+		}, "\n"),
+		"one/value_test.go": strings.Join([]string{
+			"package one",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestOne(t *testing.T) {",
+			"\tif Value() != 1 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"two/value.go": strings.Join([]string{
+			"package two",
+			"",
+			"func Value() int { return 2 }",
+			"",
+		}, "\n"),
+		"two/value_test.go": strings.Join([]string{
+			"package two",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestTwo(t *testing.T) {",
+			"\tif Value() != 2 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	workDir := filepath.Join(moduleDir, "work")
+	projectLog := filepath.Join(moduleDir, "projects.log")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), strings.Join([]string{
+		"#!/bin/sh",
+		"project=",
+		"while [ \"$#\" -gt 0 ]; do",
+		"\tif [ \"$1\" = \"--project\" ]; then",
+		"\t\tshift",
+		"\t\tproject=\"$1\"",
+		"\tfi",
+		"\tshift || break",
+		"done",
+		"printf '%s\\n' \"$project\" >> " + strconv.Quote(projectLog),
+		"echo 'output/@goscript/example.test/override/index.ts(1,1): error TS2305: Module has no exported member Thing'",
+		"exit 1",
+		"",
+	}, "\n"))
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "bun"), strings.Join([]string{
+		"#!/bin/sh",
+		"exit 0",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./..."},
+		Timeout:  30 * time.Second,
+		WorkDir:  workDir,
+	})
+	if err != nil {
+		t.Fatalf("run shared override typecheck fixture: %v", err)
+	}
+
+	one := requirePackageResult(t, result, "example.test/sharedoverride/one")
+	two := requirePackageResult(t, result, "example.test/sharedoverride/two")
+	for _, pkg := range []PackageResult{one, two} {
+		if pkg.Action != ActionFail || pkg.Owner != OwnerOverridePackage {
+			t.Fatalf("package should carry aggregate override failure: %#v", pkg)
+		}
+		if pkg.Phases.TypeCheck != PhaseStatusFail || pkg.Phases.Runtime != PhaseStatusSkip {
+			t.Fatalf("package should fail at aggregate typecheck without runtime: %#v", pkg)
+		}
+	}
+	data, err := os.ReadFile(projectLog)
+	if err != nil {
+		t.Fatalf("read project log: %v", err)
+	}
+	projects := strings.Fields(string(data))
+	if len(projects) != 1 || projects[0] != "tsconfig.json" {
+		t.Fatalf("expected only aggregate typecheck, got:\n%s", data)
+	}
+}
+
+func TestRunnerUsesBatchTypeScriptProject(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/packageprojects\n\ngo 1.25.3\n",
+		"one/value.go": strings.Join([]string{
+			"package one",
+			"",
+			"func Value() int { return 1 }",
+			"",
+		}, "\n"),
+		"one/value_test.go": strings.Join([]string{
+			"package one",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestOne(t *testing.T) {",
+			"\tif Value() != 1 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"two/value.go": strings.Join([]string{
+			"package two",
+			"",
+			"func Value() int { return 2 }",
+			"",
+		}, "\n"),
+		"two/value_test.go": strings.Join([]string{
+			"package two",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestTwo(t *testing.T) {",
+			"\tif Value() != 2 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	workDir := filepath.Join(moduleDir, ".tmp", "package-projects")
+	projectLog := filepath.Join(moduleDir, "projects.log")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), strings.Join([]string{
+		"#!/bin/sh",
+		"project=",
+		"while [ \"$#\" -gt 0 ]; do",
+		"\tif [ \"$1\" = \"--project\" ]; then",
+		"\t\tshift",
+		"\t\tproject=\"$1\"",
+		"\tfi",
+		"\tshift || break",
+		"done",
+		"printf '%s\\n' \"$project\" >> " + strconv.Quote(projectLog),
+		"exit 0",
+		"",
+	}, "\n"))
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "bun"), strings.Join([]string{
+		"#!/bin/sh",
+		"exit 0",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:         moduleDir,
+		Patterns:    []string{"./..."},
+		Timeout:     30 * time.Second,
+		WorkDir:     workDir,
+		Parallelism: 2,
+	})
+	if err != nil {
+		t.Fatalf("run package projects fixture: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected package projects fixture to pass: %#v", result.Packages)
+	}
+	data, err := os.ReadFile(projectLog)
+	if err != nil {
+		t.Fatalf("read project log: %v", err)
+	}
+	projects := string(data)
+	if strings.TrimSpace(projects) != "tsconfig.json" {
+		t.Fatalf("expected aggregate tsconfig project, got:\n%s", projects)
+	}
+}
+
+func TestRunnerRunsCombinedRuntimeChunks(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/runtimechunks\n\ngo 1.25.3\n",
+		"one/value.go": strings.Join([]string{
+			"package one",
+			"",
+			"func Value() int { return 1 }",
+			"",
+		}, "\n"),
+		"one/value_test.go": strings.Join([]string{
+			"package one",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestOne(t *testing.T) {",
+			"\tif Value() != 1 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"two/value.go": strings.Join([]string{
+			"package two",
+			"",
+			"func Value() int { return 2 }",
+			"",
+		}, "\n"),
+		"two/value_test.go": strings.Join([]string{
+			"package two",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestTwo(t *testing.T) {",
+			"\tif Value() != 2 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	workDir := filepath.Join(moduleDir, ".tmp", "runtime-chunks")
+	runtimeLog := filepath.Join(moduleDir, "runtime.log")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), strings.Join([]string{
+		"#!/bin/sh",
+		"exit 0",
+		"",
+	}, "\n"))
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "bun"), strings.Join([]string{
+		"#!/bin/sh",
+		"runner=\"$1\"",
+		"printf '%s\\n' \"$runner\" >> " + strconv.Quote(runtimeLog),
+		"case \"$runner\" in",
+		"runner-all-*)",
+		"\tsed -n 's/.*await __goscriptRunPackage(\"\\([^\"]*\\)\".*/\\1/p' \"$runner\" | while IFS= read -r pkg; do",
+		"\t\tprintf '" + combinedRuntimeResultPrefix + "{\"packagePath\":\"%s\",\"ok\":true,\"elapsedMs\":1,\"output\":\"\"}\\n' \"$pkg\"",
+		"\tdone",
+		"\texit 0",
+		"\t;;",
+		"*)",
+		"\texit 1",
+		"\t;;",
+		"esac",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:           moduleDir,
+		Patterns:      []string{"./..."},
+		Timeout:       30 * time.Second,
+		WorkDir:       workDir,
+		Parallelism:   2,
+		RuntimeGroups: true,
+	})
+	if err != nil {
+		t.Fatalf("run runtime chunks fixture: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected runtime chunks fixture to pass: %#v", result.Packages)
+	}
+	data, err := os.ReadFile(runtimeLog)
+	if err != nil {
+		t.Fatalf("read runtime log: %v", err)
+	}
+	runners := strings.Fields(string(data))
+	slices.Sort(runners)
+	if strings.Join(runners, "\n") != "runner-all-0.ts\nrunner-all-1.ts" {
+		t.Fatalf("expected chunked combined runners, got:\n%s", data)
+	}
+}
+
+func TestRunnerFallsBackToPackageScopedTypeScriptProjects(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/packageprojects\n\ngo 1.25.3\n",
+		"one/value.go": strings.Join([]string{
+			"package one",
+			"",
+			"func Value() int { return 1 }",
+			"",
+		}, "\n"),
+		"one/value_test.go": strings.Join([]string{
+			"package one",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestOne(t *testing.T) {",
+			"\tif Value() != 1 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"two/value.go": strings.Join([]string{
+			"package two",
+			"",
+			"func Value() int { return 2 }",
+			"",
+		}, "\n"),
+		"two/value_test.go": strings.Join([]string{
+			"package two",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestTwo(t *testing.T) {",
+			"\tif Value() != 2 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	workDir := filepath.Join(moduleDir, ".tmp", "package-projects")
+	projectLog := filepath.Join(moduleDir, "projects.log")
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), strings.Join([]string{
+		"#!/bin/sh",
+		"project=",
+		"while [ \"$#\" -gt 0 ]; do",
+		"\tif [ \"$1\" = \"--project\" ]; then",
+		"\t\tshift",
+		"\t\tproject=\"$1\"",
+		"\tfi",
+		"\tshift || break",
+		"done",
+		"printf '%s\\n' \"$project\" >> " + strconv.Quote(projectLog),
+		"if [ \"$project\" = \"tsconfig.json\" ]; then",
+		"\texit 1",
+		"fi",
+		"exit 0",
+		"",
+	}, "\n"))
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "bun"), strings.Join([]string{
+		"#!/bin/sh",
+		"exit 0",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:         moduleDir,
+		Patterns:    []string{"./..."},
+		Timeout:     30 * time.Second,
+		WorkDir:     workDir,
+		Parallelism: 2,
+	})
+	if err != nil {
+		t.Fatalf("run package projects fixture: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected package projects fixture to pass: %#v", result.Packages)
+	}
+	data, err := os.ReadFile(projectLog)
+	if err != nil {
+		t.Fatalf("read project log: %v", err)
+	}
+	projects := string(data)
+	if !strings.Contains(projects, "tsconfig.json") ||
+		!strings.Contains(projects, "tsconfig-0.json") ||
+		!strings.Contains(projects, "tsconfig-1.json") {
+		t.Fatalf("expected aggregate project and package-scoped fallback, got:\n%s", projects)
+	}
+}
+
+func TestDefaultParallelismCapsAtEight(t *testing.T) {
+	previous := runtime.GOMAXPROCS(16)
+	t.Cleanup(func() { runtime.GOMAXPROCS(previous) })
+
+	if got := DefaultParallelism(); got != 8 {
+		t.Fatalf("expected default parallelism cap 8, got %d", got)
+	}
+}
+
+func TestNormalizeKeepsIncrementalTypeCheckExplicit(t *testing.T) {
+	norm, err := (&Request{
+		Patterns: []string{"./..."},
+		WorkDir:  t.TempDir(),
+	}).normalize()
+	if err != nil {
+		t.Fatalf("normalize request: %v", err)
+	}
+	if norm.IncrementalTypeCheck {
+		t.Fatalf("expected explicit workdir alone to skip incremental typecheck cache")
+	}
+
+	norm, err = (&Request{
+		Patterns:             []string{"./..."},
+		IncrementalTypeCheck: true,
+	}).normalize()
+	if err != nil {
+		t.Fatalf("normalize incremental request: %v", err)
+	}
+	if !norm.IncrementalTypeCheck {
+		t.Fatalf("expected incremental flag to enable typecheck cache")
+	}
+}
+
+func TestPackageExecutionIndexesPrioritizesLargerTestPackages(t *testing.T) {
+	result := &Result{Packages: []PackageResult{
+		{
+			PackagePath: "example.test/small",
+			Tests:       []Test{{Name: "TestSmall"}},
+		},
+		{
+			PackagePath: "example.test/large",
+			Tests: []Test{
+				{Name: "TestLargeA"},
+				{Name: "TestLargeB"},
+				{Name: "TestLargeC"},
+			},
+		},
+		{
+			PackagePath: "example.test/medium-b",
+			Tests: []Test{
+				{Name: "TestMediumB1"},
+				{Name: "TestMediumB2"},
+			},
+		},
+		{
+			PackagePath: "example.test/medium-a",
+			Tests: []Test{
+				{Name: "TestMediumA1"},
+				{Name: "TestMediumA2"},
+			},
+		},
+	}}
+
+	got := packageExecutionIndexes(result, []int{0, 1, 2, 3})
+	want := []int{1, 3, 2, 0}
+	if !slices.Equal(got, want) {
+		t.Fatalf("expected execution indexes %v, got %v", want, got)
+	}
+}
+
+func TestRenderRunnerChangesToPackageSourceDir(t *testing.T) {
+	req := &normalizedRequest{}
+	runner := renderRunner(PackageResult{
+		PackagePath: "example.test/pkg",
+		SourceDir:   "/workspace/pkg",
+		Tests: []Test{{
+			Name:        "TestCwd",
+			PackagePath: "example.test/pkg",
+		}},
+	}, req)
+
+	if !strings.Contains(runner, "process.chdir(\"/workspace/pkg\")") {
+		t.Fatalf("expected runner to chdir to package source dir: %s", runner)
+	}
+	if !strings.Contains(runner, "await runTests(\"example.test/pkg\"") {
+		t.Fatalf("expected runner to execute package tests: %s", runner)
+	}
+}
+
+func TestRenderCombinedRunnerChangesToEachPackageSourceDir(t *testing.T) {
+	req := &normalizedRequest{}
+	runner := renderCombinedRunner(&Result{Packages: []PackageResult{
+		{
+			PackagePath: "example.test/one",
+			SourceDir:   "/workspace/one",
+			Tests: []Test{{
+				Name:        "TestOne",
+				PackagePath: "example.test/one",
+			}},
+		},
+		{
+			PackagePath: "example.test/two",
+			SourceDir:   "/workspace/two",
+			Tests: []Test{{
+				Name:        "TestTwo",
+				PackagePath: "example.test/two",
+			}},
+		},
+	}}, []int{0, 1}, req)
+
+	if !strings.Contains(runner, "await __goscriptRunPackage(\"example.test/one\", \"/workspace/one\"") {
+		t.Fatalf("expected combined runner to pass first package source dir: %s", runner)
+	}
+	if !strings.Contains(runner, "await __goscriptRunPackage(\"example.test/two\", \"/workspace/two\"") {
+		t.Fatalf("expected combined runner to pass second package source dir: %s", runner)
+	}
+	if !strings.Contains(runner, "process.chdir(packageDir)") {
+		t.Fatalf("expected combined runner to chdir before each package: %s", runner)
+	}
+}
+
 func TestRenderTypeScriptProjectDisablesAmbientTypePackages(t *testing.T) {
 	req := &normalizedRequest{
 		WorkDir: "/work",
 	}
 
-	tsconfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", false)
+	tsconfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", "tsconfig-0.json", false)
 	if !strings.Contains(tsconfig, "\"types\": []") {
 		t.Fatalf("expected generated tsconfig to disable ambient @types packages: %s", tsconfig)
 	}
 	if !strings.Contains(tsconfig, "\"goscript-node.d.ts\"") {
 		t.Fatalf("expected generated tsconfig to include GoScript node ambient declarations: %s", tsconfig)
 	}
+	if strings.Contains(tsconfig, "\"incremental\": true") || strings.Contains(tsconfig, "\"tsBuildInfoFile\"") {
+		t.Fatalf("expected generated tsconfig to keep one-shot typecheck by default: %s", tsconfig)
+	}
+	if strings.Contains(tsconfig, "output/package-0/**/*.ts") {
+		t.Fatalf("expected generated tsconfig to typecheck from runner roots, not output globs: %s", tsconfig)
+	}
 }
 
 func TestRenderTypeScriptProjectUsesNodeTypesWhenAvailable(t *testing.T) {
@@ -579,12 +1181,54 @@ func TestRenderTypeScriptProjectUsesNodeTypesWhenAvailable(t *testing.T) {
 		WorkDir: "/work",
 	}
 
-	tsconfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", true)
+	tsconfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", "tsconfig-0.json", true)
 	if !strings.Contains(tsconfig, "\"types\": [\"node\"]") {
 		t.Fatalf("expected generated tsconfig to opt into node types: %s", tsconfig)
 	}
 }
 
+func TestRenderRuntimeTypeScriptProjectDisablesEmit(t *testing.T) {
+	req := &normalizedRequest{
+		WorkDir: "/work",
+	}
+
+	tsconfig := renderRuntimeTypeScriptProject(req, []string{"/work/output"}, false)
+	if !strings.Contains(tsconfig, "\"noEmit\": true") {
+		t.Fatalf("expected aggregate tsconfig to disable emit: %s", tsconfig)
+	}
+	if strings.Contains(tsconfig, "\"incremental\": true") || strings.Contains(tsconfig, "\"tsBuildInfoFile\"") {
+		t.Fatalf("expected aggregate tsconfig to keep one-shot typecheck by default: %s", tsconfig)
+	}
+	if !strings.Contains(tsconfig, "\"runner-*.ts\"") {
+		t.Fatalf("expected aggregate tsconfig to typecheck generated runner roots: %s", tsconfig)
+	}
+	if !strings.Contains(tsconfig, "./output/@goscript/*") {
+		t.Fatalf("expected aggregate tsconfig path aliases to reference output root: %s", tsconfig)
+	}
+	if strings.Contains(tsconfig, "output/**/*.ts") {
+		t.Fatalf("expected aggregate tsconfig to typecheck from runner roots, not output globs: %s", tsconfig)
+	}
+}
+
+func TestRenderTypeScriptProjectsCanUseIncrementalBuildInfo(t *testing.T) {
+	req := &normalizedRequest{
+		WorkDir:              "/work",
+		IncrementalTypeCheck: true,
+	}
+
+	packageTSConfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", "tsconfig-0.json", false)
+	if !strings.Contains(packageTSConfig, "\"incremental\": true") ||
+		!strings.Contains(packageTSConfig, "\"tsBuildInfoFile\": \".goscript/tsconfig-0.tsbuildinfo\"") {
+		t.Fatalf("expected package tsconfig to cache package typecheck state: %s", packageTSConfig)
+	}
+
+	aggregateTSConfig := renderRuntimeTypeScriptProject(req, []string{"/work/output"}, false)
+	if !strings.Contains(aggregateTSConfig, "\"incremental\": true") ||
+		!strings.Contains(aggregateTSConfig, "\"tsBuildInfoFile\": \".goscript/tsconfig.tsbuildinfo\"") {
+		t.Fatalf("expected aggregate tsconfig to cache typecheck state: %s", aggregateTSConfig)
+	}
+}
+
 func requirePackageResult(t *testing.T, result *Result, packagePath string) PackageResult {
 	t.Helper()