ttsc 0.12.3 → 0.13.0

package/cmd/ttsc/build.go

@@ -8,15 +8,15 @@
 package main
 
 import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"os"
-	"path/filepath"
+  "encoding/json"
+  "flag"
+  "fmt"
+  "os"
+  "path/filepath"
 
-	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+  shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
 
-	"github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
 // runBuild implements the `ttsc` project-build lane. Two modes:
@@ -25,110 +25,143 @@ import (
 //   - --emit: also run tsgo's emit pipeline, patching every recognized native
 //     consumer call in the resulting .js files.
 func runBuild(args []string) int {
-	fs := flag.NewFlagSet("build", flag.ContinueOnError)
-	fs.SetOutput(stderr)
-	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
-	cwdOverride := fs.String("cwd", "", "override the working directory (defaults to process cwd)")
-	quiet := fs.Bool("quiet", true, "suppress the per-call diagnostic summary")
-	verbose := fs.Bool("verbose", false, "print the per-call diagnostic summary")
-	emit := fs.Bool("emit", false, "force emitted .js files (runs tsgo + ttsc rewrite)")
-	noEmit := fs.Bool("noEmit", false, "force analysis-only run with no file writes")
-	outDir := fs.String("outDir", "", "override compilerOptions.outDir for this build")
-	manifestPath := fs.String("manifest", "", "write emitted file list as JSON to this path")
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-	if *emit && *noEmit {
-		fmt.Fprintln(stderr, "ttsc: --emit and --noEmit are mutually exclusive")
-		return 2
-	}
-	if *verbose {
-		*quiet = false
-	}
+  fs := flag.NewFlagSet("build", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  tsconfigPath := fs.String("tsconfig", "tsconfig.json", "path to tsconfig.json")
+  cwdOverride := fs.String("cwd", "", "override the working directory (defaults to process cwd)")
+  quiet := fs.Bool("quiet", true, "suppress the per-call diagnostic summary")
+  verbose := fs.Bool("verbose", false, "print the per-call diagnostic summary")
+  emit := fs.Bool("emit", false, "force emitted .js files (runs tsgo + ttsc rewrite)")
+  noEmit := fs.Bool("noEmit", false, "force analysis-only run with no file writes")
+  outDir := fs.String("outDir", "", "override compilerOptions.outDir for this build")
+  manifestPath := fs.String("manifest", "", "write emitted file list as JSON to this path")
+  singleThreaded := fs.Bool("singleThreaded", false, "run TypeScript-Go single-threaded")
+  checkers := fs.Int("checkers", 0, "type-checker pool size (0 = TypeScript-Go default)")
+  tsgoArgsRaw := fs.String("tsgo-args", "", "JSON array of forwarded tsgo CLI flags")
+  // Strip unknown forwarded tsgo options before fs.Parse so a flag like
+  // `--strict` (which tsgo accepts but cmd/ttsc's FlagSet does not declare)
+  // does not exit 2 before reaching the tsgo lane via `--tsgo-args=<JSON>`.
+  // See packages/ttsc/cmd/ttsc/filter.go for the allow-list source.
+  if err := fs.Parse(filterHostArgs(args)); err != nil {
+    return 2
+  }
+  tsgoArgs, err := decodeTsgoArgs(*tsgoArgsRaw)
+  if err != nil {
+    fmt.Fprintf(stderr, "ttsc: %v\n", err)
+    return 2
+  }
+  if *emit && *noEmit {
+    fmt.Fprintln(stderr, "ttsc: --emit and --noEmit are mutually exclusive")
+    return 2
+  }
+  if *verbose {
+    *quiet = false
+  }
 
-	cwd := *cwdOverride
-	if cwd == "" {
-		var err error
-		cwd, err = getwd()
-		if err != nil {
-			fmt.Fprintf(stderr, "ttsc: could not get working directory: %v\n", err)
-			return 2
-		}
-	}
+  cwd := *cwdOverride
+  if cwd == "" {
+    var err error
+    cwd, err = getwd()
+    if err != nil {
+      fmt.Fprintf(stderr, "ttsc: could not get working directory: %v\n", err)
+      return 2
+    }
+  }
 
-	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
-		ForceEmit:   *emit,
-		ForceNoEmit: *noEmit,
-		OutDir:      *outDir,
-	})
-	if err != nil {
-		fmt.Fprintf(stderr, "ttsc: %v\n", err)
-		return 2
-	}
-	if len(diags) > 0 {
-		driver.WritePrettyDiagnostics(stderr, diags, cwd)
-		return 2
-	}
-	defer prog.Close()
-	if diags := prog.Diagnostics(); len(diags) > 0 {
-		driver.WritePrettyDiagnostics(stderr, diags, cwd)
-		return 2
-	}
+  prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+    ForceEmit:      *emit,
+    ForceNoEmit:    *noEmit,
+    OutDir:         *outDir,
+    SingleThreaded: *singleThreaded,
+    Checkers:       *checkers,
+    TsgoArgs:       tsgoArgs,
+  })
+  if err != nil {
+    fmt.Fprintf(stderr, "ttsc: %v\n", err)
+    return 2
+  }
+  if len(diags) > 0 {
+    driver.WritePrettyDiagnostics(stderr, diags, cwd)
+    return 2
+  }
+  defer prog.Close()
+  if diags := prog.Diagnostics(); len(diags) > 0 {
+    driver.WritePrettyDiagnostics(stderr, diags, cwd)
+    return 2
+  }
 
-	rewrites := driver.NewRewriteSet()
-	shouldEmit := !prog.ParsedConfig.ParsedConfig.CompilerOptions.NoEmit.IsTrue()
-	if !*quiet {
-		fmt.Fprintf(stdout, "// ttsc: tsconfig=%s cwd=%s sites=%d emit=%v\n", *tsconfigPath, cwd, 0, shouldEmit)
-	}
+  rewrites := driver.NewRewriteSet()
+  // shouldEmit reflects the resolved tsconfig noEmit flag. The flag lives
+  // three levels deep in the parsed config because TypeScript-Go mirrors the
+  // tsconfig object structure verbatim, with a tri-state bool per option.
+  shouldEmit := !prog.ParsedConfig.ParsedConfig.CompilerOptions.NoEmit.IsTrue()
+  if !*quiet {
+    fmt.Fprintf(stdout, "// ttsc: tsconfig=%s cwd=%s sites=%d emit=%v\n", *tsconfigPath, cwd, 0, shouldEmit)
+  }
 
-	if shouldEmit {
-		// Emit is callback-driven in TypeScript-Go. ttsc keeps that shape and
-		// wraps only the final WriteFile step so native rewrites and custom output
-		// capture share the same path.
-		writeFile := shimcompiler.WriteFile(
-			func(fileName, text string, _ *shimcompiler.WriteFileData) error {
-				return driver.DefaultWriteFile(fileName, text)
-			},
-		)
-		res, eDiags, err := prog.EmitAll(rewrites, writeFile)
-		if err != nil {
-			fmt.Fprintf(stderr, "ttsc: emit failed: %v\n", err)
-			return 3
-		}
-		for _, d := range eDiags {
-			fmt.Fprintln(stderr, "  -", d.String())
-		}
-		if driver.CountErrors(eDiags) > 0 {
-			return 2
-		}
-		if !*quiet {
-			fmt.Fprintf(stdout, "// ttsc: emitted=%d files\n", len(res.EmittedFiles))
-			for _, f := range res.EmittedFiles {
-				rel := f
-				if abs, err := filepath.Rel(cwd, f); err == nil {
-					rel = abs
-				}
-				fmt.Fprintln(stdout, "  +", rel)
-			}
-		}
-		if *manifestPath != "" {
-			// The manifest is intentionally just the emitted file list. Higher
-			// layers already know the project and tsconfig, and tests compare this
-			// array as the build contract.
-			data, _ := json.Marshal(res.EmittedFiles)
-			if err := os.MkdirAll(filepath.Dir(*manifestPath), 0o755); err != nil {
-				fmt.Fprintf(stderr, "ttsc: manifest mkdir failed: %v\n", err)
-				return 3
-			}
-			if err := os.WriteFile(*manifestPath, data, 0o644); err != nil {
-				fmt.Fprintf(stderr, "ttsc: manifest write failed: %v\n", err)
-				return 3
-			}
-		}
-	}
+  if shouldEmit {
+    // Emit is callback-driven in TypeScript-Go. ttsc keeps that shape and
+    // wraps only the final WriteFile step so native rewrites and custom output
+    // capture share the same path.
+    writeFile := shimcompiler.WriteFile(
+      func(fileName, text string, _ *shimcompiler.WriteFileData) error {
+        return driver.DefaultWriteFile(fileName, text)
+      },
+    )
+    res, eDiags, err := prog.EmitAll(rewrites, writeFile)
+    if err != nil {
+      fmt.Fprintf(stderr, "ttsc: emit failed: %v\n", err)
+      return 3
+    }
+    for _, d := range eDiags {
+      fmt.Fprintln(stderr, "  -", d.String())
+    }
+    if driver.CountErrors(eDiags) > 0 {
+      return 2
+    }
+    if !*quiet {
+      fmt.Fprintf(stdout, "// ttsc: emitted=%d files\n", len(res.EmittedFiles))
+      for _, f := range res.EmittedFiles {
+        rel := f
+        if abs, err := filepath.Rel(cwd, f); err == nil {
+          rel = abs
+        }
+        fmt.Fprintln(stdout, "  +", rel)
+      }
+    }
+    if *manifestPath != "" {
+      // The manifest is intentionally just the emitted file list. Higher
+      // layers already know the project and tsconfig, and tests compare this
+      // array as the build contract.
+      data, _ := json.Marshal(res.EmittedFiles)
+      if err := os.MkdirAll(filepath.Dir(*manifestPath), 0o755); err != nil {
+        fmt.Fprintf(stderr, "ttsc: manifest mkdir failed: %v\n", err)
+        return 3
+      }
+      if err := os.WriteFile(*manifestPath, data, 0o644); err != nil {
+        fmt.Fprintf(stderr, "ttsc: manifest write failed: %v\n", err)
+        return 3
+      }
+    }
+  }
 
-	if !*quiet {
-		fmt.Fprintf(stdout, "// ttsc: recognized=%d total=%d rewrites=%d\n", 0, 0, rewrites.Len())
-	}
-	return 0
+  if !*quiet {
+    fmt.Fprintf(stdout, "// ttsc: recognized=%d total=%d rewrites=%d\n", 0, 0, rewrites.Len())
+  }
+  return 0
+}
+
+// decodeTsgoArgs decodes the JSON-array value of the `--tsgo-args` flag — the
+// tsgo CLI flags the `ttsc` launcher forwarded — into a string slice. An empty
+// flag yields a nil slice. Shared by the build / api-compile / api-transform
+// subcommands, which all hand the result to driver.LoadProgram.
+func decodeTsgoArgs(raw string) ([]string, error) {
+  if raw == "" {
+    return nil, nil
+  }
+  var args []string
+  if err := json.Unmarshal([]byte(raw), &args); err != nil {
+    return nil, fmt.Errorf("invalid --tsgo-args: %w", err)
+  }
+  return args, nil
 }

package/cmd/ttsc/build_branches_test.go

@@ -1,130 +1,128 @@
 package main
 
 import (
-	"errors"
-	"path/filepath"
-	"strings"
-	"testing"
+  "errors"
+  "path/filepath"
+  "strings"
+  "testing"
 
-	"github.com/samchon/ttsc/packages/ttsc/driver"
+  "github.com/samchon/ttsc/packages/ttsc/driver"
 )
 
 type buildApplyErrorPlugin struct{}
 
 func (buildApplyErrorPlugin) ApplyProgram(*driver.Program, driver.PluginContext) error {
-	return errors.New("build apply boom")
+  return errors.New("build apply boom")
 }
 
-/**
- * Verifies build command branches report setup, emit, and manifest failures.
- *
- * The native build command is the fallback compiler host behind ttsc. It must
- * fail before writing partial output when flags, cwd, tsconfig, disk emit, or
- * manifest paths are invalid.
- *
- * 1. Exercise bad flags, cwd failure, and project-load failures.
- * 2. Force emit through an invalid outDir.
- * 3. Force manifest mkdir and write failures after a valid emit.
- */
+// TestBuildBranches verifies build command branches report setup, emit, and manifest failures.
+//
+// The native build command is the fallback compiler host behind ttsc. It must
+// fail before writing partial output when flags, cwd, tsconfig, disk emit, or
+// manifest paths are invalid.
+//
+// 1. Exercise bad flags, cwd failure, and project-load failures.
+// 2. Force emit through an invalid outDir.
+// 3. Force manifest mkdir and write failures after a valid emit.
 func TestBuildBranches(t *testing.T) {
-	code, _, _ := captureCommand(t, func() int {
-		return runBuild([]string{"--cwd"})
-	})
-	if code != 2 {
-		t.Fatalf("bad flag status mismatch: %d", code)
-	}
-	code, _, errText := captureCommand(t, func() int {
-		getwd = failGetwd
-		return runBuild(nil)
-	})
-	if code != 2 || !strings.Contains(errText, "cwd boom") {
-		t.Fatalf("cwd error mismatch: code=%d stderr=%q", code, errText)
-	}
-	root := t.TempDir()
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "missing.json"})
-	})
-	if code != 2 || !strings.Contains(errText, "tsconfig not found") {
-		t.Fatalf("missing config mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, _ := captureCommand(t, func() int {
+    return runBuild([]string{"--cwd"})
+  })
+  if code != 2 {
+    t.Fatalf("bad flag status mismatch: %d", code)
+  }
+  code, _, errText := captureCommand(t, func() int {
+    getwd = failGetwd
+    return runBuild(nil)
+  })
+  if code != 2 || !strings.Contains(errText, "cwd boom") {
+    t.Fatalf("cwd error mismatch: code=%d stderr=%q", code, errText)
+  }
+  root := t.TempDir()
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "missing.json"})
+  })
+  if code != 2 || !strings.Contains(errText, "tsconfig not found") {
+    t.Fatalf("missing config mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  writeCommandProjectFile(t, root, "tsconfig.json", `{
   "compilerOptions": { "module": "commonjs", "target": "es2020", "strict": true },
   "files": ["index.ts"]
 }
 `)
-	writeCommandProjectFile(t, root, "index.ts", `const value: number = "text";
+  writeCommandProjectFile(t, root, "index.ts", `const value: number = "text";
 export { value };
 `)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
-	})
-	if code != 2 || !strings.Contains(errText, "number") {
-		t.Fatalf("semantic diagnostics mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 2 || !strings.Contains(errText, "number") {
+    t.Fatalf("semantic diagnostics mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  writeCommandProjectFile(t, root, "tsconfig.json", `{
   "compilerOptions": { "module": "not-a-module-kind", "target": "es2020" },
   "files": ["index.ts"]
 }
 `)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
-	})
-	if code != 2 || !strings.Contains(errText, "not-a-module-kind") {
-		t.Fatalf("invalid config mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json"})
+  })
+  if code != 2 || !strings.Contains(errText, "not-a-module-kind") {
+    t.Fatalf("invalid config mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	writeCommandProjectFile(t, root, "tsconfig.json", `{
+  writeCommandProjectFile(t, root, "tsconfig.json", `{
   "compilerOptions": { "module": "commonjs", "target": "es2020", "strict": true },
   "files": ["index.ts"]
 }
 `)
-	writeCommandProjectFile(t, root, "index.ts", `export const value = 1;
+  writeCommandProjectFile(t, root, "index.ts", `export const value = 1;
 `)
-	writeCommandProjectFile(t, root, "blocked", `not a directory`)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "blocked"})
-	})
-	if code != 2 || !strings.Contains(errText, "not a directory") {
-		t.Fatalf("emit failure mismatch: code=%d stderr=%q", code, errText)
-	}
+  writeCommandProjectFile(t, root, "blocked", `not a directory`)
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "blocked"})
+  })
+  if code != 2 || !strings.Contains(errText, "not a directory") {
+    t.Fatalf("emit failure mismatch: code=%d stderr=%q", code, errText)
+  }
 
-	resetCommandLinkedPluginRegistry()
-	driver.RegisterPlugin(buildApplyErrorPlugin{})
-	t.Cleanup(resetCommandLinkedPluginRegistry)
-	t.Setenv(driver.LinkedPluginsEnv, `[{"name":"error","stage":"transform","config":{}}]`)
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "dist"})
-	})
-	if code != 3 || !strings.Contains(errText, "build apply boom") {
-		t.Fatalf("linked apply failure mismatch: code=%d stderr=%q", code, errText)
-	}
-	resetCommandLinkedPluginRegistry()
-	t.Setenv(driver.LinkedPluginsEnv, "")
+  resetCommandLinkedPluginRegistry()
+  driver.RegisterPlugin(buildApplyErrorPlugin{})
+  t.Cleanup(resetCommandLinkedPluginRegistry)
+  t.Setenv(driver.LinkedPluginsEnv, `[{"name":"error","stage":"transform","config":{}}]`)
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{"--cwd", root, "--tsconfig", "tsconfig.json", "--emit", "--outDir", "dist"})
+  })
+  if code != 3 || !strings.Contains(errText, "build apply boom") {
+    t.Fatalf("linked apply failure mismatch: code=%d stderr=%q", code, errText)
+  }
+  resetCommandLinkedPluginRegistry()
+  t.Setenv(driver.LinkedPluginsEnv, "")
 
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{
-			"--cwd", root,
-			"--tsconfig", "tsconfig.json",
-			"--emit",
-			"--outDir", "dist",
-			"--manifest", filepath.Join(root, "index.ts", "manifest.json"),
-		})
-	})
-	if code != 3 || !strings.Contains(errText, "manifest mkdir failed") {
-		t.Fatalf("manifest mkdir mismatch: code=%d stderr=%q", code, errText)
-	}
-	code, _, errText = captureCommand(t, func() int {
-		return runBuild([]string{
-			"--cwd", root,
-			"--tsconfig", "tsconfig.json",
-			"--emit",
-			"--outDir", "dist",
-			"--manifest", root,
-		})
-	})
-	if code != 3 || !strings.Contains(errText, "manifest write failed") {
-		t.Fatalf("manifest write mismatch: code=%d stderr=%q", code, errText)
-	}
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{
+      "--cwd", root,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", "dist",
+      "--manifest", filepath.Join(root, "index.ts", "manifest.json"),
+    })
+  })
+  if code != 3 || !strings.Contains(errText, "manifest mkdir failed") {
+    t.Fatalf("manifest mkdir mismatch: code=%d stderr=%q", code, errText)
+  }
+  code, _, errText = captureCommand(t, func() int {
+    return runBuild([]string{
+      "--cwd", root,
+      "--tsconfig", "tsconfig.json",
+      "--emit",
+      "--outDir", "dist",
+      "--manifest", root,
+    })
+  })
+  if code != 3 || !strings.Contains(errText, "manifest write failed") {
+    t.Fatalf("manifest write mismatch: code=%d stderr=%q", code, errText)
+  }
 }

package/cmd/ttsc/filter.go

@@ -0,0 +1,70 @@
+// Argument filtering for cmd/ttsc subcommand parsers.
+//
+// `flag.NewFlagSet(..., flag.ContinueOnError).Parse` exits with non-zero on
+// the first unknown flag it sees, which is exactly the failure mode RCA
+// #4 in `.discussions/cli-parser-rca/report.md` flagged: a forwarded tsgo
+// option from the JS launcher would crash the build before tsgo's own
+// option table got a chance to consume it. Mirror the strategy that
+// `packages/ttsc/utility/host.go` already uses for the utility host —
+// strip flags that the local FlagSet does not declare, swallowing the
+// next token when the unknown flag clearly takes one. The allow-list is
+// the same generated `HostFlagAllowList` shared by both consumers
+// (`packages/ttsc/cmd/ttsc/flags_gen.go` and
+// `packages/ttsc/utility/flags_gen.go`).
+
+package main
+
+import "strings"
+
+// filterHostArgs strips flags that the cmd/ttsc FlagSet does not declare,
+// so a forwarded tsgo option from the JS launcher (e.g. `--strict`) does
+// not make `fs.Parse` exit 2 before the build can hand it to tsgo via
+// `--tsgo-args=<JSON>`. Flags absent from `HostFlagAllowList` are
+// dropped together with their value token when they clearly take one
+// (no inline `=` and the next token does not start with `-`).
+//
+// The allow-list itself is generated from
+// `packages/ttsc/src/flags/schema.ts` (see `flags_gen.go`); editing it
+// means editing the schema and re-running `pnpm format`, not patching
+// this file.
+func filterHostArgs(args []string) []string {
+  filtered := make([]string, 0, len(args))
+  for i := 0; i < len(args); i++ {
+    current := args[i]
+    if current == "--" {
+      // Forward `--` and everything after verbatim. The Go flag parser
+      // treats `--` as "end of options" and stops there; mirroring that
+      // behavior here keeps trailing positional tokens intact.
+      filtered = append(filtered, args[i:]...)
+      break
+    }
+    if !strings.HasPrefix(current, "--") {
+      filtered = append(filtered, current)
+      continue
+    }
+    name, hasInlineValue := splitFlagName(current)
+    takesValue, ok := HostFlagAllowList[name]
+    if ok {
+      filtered = append(filtered, current)
+      if takesValue && !hasInlineValue && i+1 < len(args) {
+        i++
+        filtered = append(filtered, args[i])
+      }
+      continue
+    }
+    if !hasInlineValue && i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
+      i++
+    }
+  }
+  return filtered
+}
+
+// splitFlagName strips the leading `--` from a flag argument and reports
+// whether the argument carries an inline value (`--foo=value`).
+func splitFlagName(arg string) (string, bool) {
+  name := strings.TrimPrefix(arg, "--")
+  if i := strings.IndexByte(name, '='); i != -1 {
+    return name[:i], true
+  }
+  return name, false
+}

package/cmd/ttsc/filter_strips_unknown_forwarded_flag_test.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+  "reflect"
+  "testing"
+)
+
+// TestFilterHostArgsStripsUnknownForwardedFlag verifies cmd/ttsc's
+// filterHostArgs drops forwarded tsgo options before fs.Parse so the
+// FlagSet does not exit 2.
+//
+// `cmd/ttsc/{build,api_compile,api_transform}.go` use
+// `flag.NewFlagSet(..., flag.ContinueOnError)` which exits non-zero on
+// the first unknown flag it sees. The schema-generated allow-list in
+// `flags_gen.go` (`HostFlagAllowList`) feeds this filter so a forwarded
+// `--strict` from the JS launcher reaches the tsgo lane via
+// `--tsgo-args=<JSON>` instead of crashing the build. This pins the
+// behavior RCA #4 flagged as "next likely bug — `cmd/ttsc/build.go:42`
+// uses bare `flag.FlagSet` with no filter and will exit".
+//
+//  1. Known flags + values survive (long form and `=` form).
+//  2. Unknown flag with separate value (`--strict true`) is dropped
+//     together with its value.
+//  3. Unknown flag with inline value (`--target=ES2022`) is dropped.
+//  4. `--` separator and everything after survives verbatim.
+func TestFilterHostArgsStripsUnknownForwardedFlag(t *testing.T) {
+  cases := []struct {
+    name string
+    in   []string
+    want []string
+  }{
+    {
+      name: "keeps known flags including values",
+      in:   []string{"--tsconfig", "tsconfig.json", "--cwd=.", "--emit"},
+      want: []string{"--tsconfig", "tsconfig.json", "--cwd=.", "--emit"},
+    },
+    {
+      name: "drops unknown flag with separate value",
+      in:   []string{"--tsconfig", "tsconfig.json", "--strict", "true", "--emit"},
+      want: []string{"--tsconfig", "tsconfig.json", "--emit"},
+    },
+    {
+      name: "drops unknown flag with inline value",
+      in:   []string{"--tsconfig=tsconfig.json", "--target=ES2022"},
+      want: []string{"--tsconfig=tsconfig.json"},
+    },
+    {
+      name: "double dash preserves trailing tokens",
+      in:   []string{"--tsconfig=tsconfig.json", "--", "--anything", "src/main.ts"},
+      want: []string{"--tsconfig=tsconfig.json", "--", "--anything", "src/main.ts"},
+    },
+  }
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      got := filterHostArgs(tc.in)
+      if !reflect.DeepEqual(got, tc.want) {
+        t.Fatalf("filterHostArgs(%v):\n  want %v\n  got  %v", tc.in, tc.want, got)
+      }
+    })
+  }
+}