ttsc 0.12.3 → 0.13.0

package/cmd/ttsc/flags_gen.go

@@ -0,0 +1,30 @@
+// Code generated by packages/ttsc/scripts/gen-flags.mts. DO NOT EDIT.
+//
+// Source of truth: packages/ttsc/src/flags/schema.ts.
+// Regenerate with:    pnpm format
+// Verify in CI with:  node packages/ttsc/scripts/check-flags.cjs
+
+package main
+
+// HostFlagAllowList is the allow-list of CLI flags this Go layer accepts. The map's
+// value is true when the flag carries a separate value token (--flag VALUE
+// or --flag=VALUE) and false when the flag is boolean (--flag).
+//
+// Generated from packages/ttsc/src/flags/schema.ts. Edit the schema, not
+// this file.
+var HostFlagAllowList = map[string]bool{
+  "checkers":       true,
+  "cwd":            true,
+  "emit":           false,
+  "manifest":       true,
+  "noEmit":         false,
+  "outDir":         true,
+  "p":              true,
+  "plugins-json":   true,
+  "project":        true,
+  "quiet":          false,
+  "singleThreaded": false,
+  "tsconfig":       true,
+  "tsgo-args":      true,
+  "verbose":        false,
+}

package/cmd/ttsc/helpers_test.go

@@ -1,47 +1,58 @@
 package main
 
 import (
-	"bytes"
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-	_ "unsafe"
+  "bytes"
+  "errors"
+  "os"
+  "path/filepath"
+  "testing"
+  _ "unsafe"
 )
 
+// driverPluginRegistry is a linkname alias for the unexported plugin slice in
+// the driver package, allowing tests to reset registered plugins between cases.
+//
 //go:linkname driverPluginRegistry github.com/samchon/ttsc/packages/ttsc/driver.pluginRegistry
 var driverPluginRegistry []any
 
+// captureCommand redirects the package-level stdout/stderr/getwd seams around
+// fn, then returns the exit code and the captured output strings.
 func captureCommand(t *testing.T, fn func() int) (int, string, string) {
-	t.Helper()
-	prevOut, prevErr, prevGetwd := stdout, stderr, getwd
-	var out, err bytes.Buffer
-	stdout = &out
-	stderr = &err
-	defer func() {
-		stdout = prevOut
-		stderr = prevErr
-		getwd = prevGetwd
-	}()
-	code := fn()
-	return code, out.String(), err.String()
+  t.Helper()
+  prevOut, prevErr, prevGetwd := stdout, stderr, getwd
+  var out, err bytes.Buffer
+  stdout = &out
+  stderr = &err
+  defer func() {
+    stdout = prevOut
+    stderr = prevErr
+    getwd = prevGetwd
+  }()
+  code := fn()
+  return code, out.String(), err.String()
 }
 
+// failGetwd is a getwd stub that always returns an error, used to exercise the
+// cwd-resolution failure path in command entrypoints.
 func failGetwd() (string, error) {
-	return "", errors.New("cwd boom")
+  return "", errors.New("cwd boom")
 }
 
+// writeCommandProjectFile writes contents to root/name, creating intermediate
+// directories as needed. Slashes in name are normalised to the OS separator.
 func writeCommandProjectFile(t *testing.T, root, name, contents string) {
-	t.Helper()
-	file := filepath.Join(root, filepath.FromSlash(name))
-	if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(file, []byte(contents), 0o644); err != nil {
-		t.Fatal(err)
-	}
+  t.Helper()
+  file := filepath.Join(root, filepath.FromSlash(name))
+  if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(file, []byte(contents), 0o644); err != nil {
+    t.Fatal(err)
+  }
 }
 
+// resetCommandLinkedPluginRegistry clears the driver plugin registry so that
+// tests that register plugins do not pollute subsequent test cases.
 func resetCommandLinkedPluginRegistry() {
-	driverPluginRegistry = nil
+  driverPluginRegistry = nil
 }

package/cmd/ttsc/main.go

@@ -12,104 +12,108 @@
 package main
 
 import (
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"runtime"
-	"strings"
+  "flag"
+  "fmt"
+  "io"
+  "os"
+  "runtime"
+  "strings"
 )
 
 // These are overridden via `-ldflags "-X main.version=... -X main.commit=..."`
 // in CI. Sensible defaults keep local `go run ./cmd/ttsc` usable.
 var (
-	version = "0.0.0-dev"
-	commit  = "dev"
-	date    = "unknown"
+  version = "0.0.0-dev"
+  commit  = "dev"
+  date    = "unknown"
 )
 
 // stdout / stderr are package-level to keep the CLI testable.
 var (
-	stdout io.Writer = os.Stdout
-	stderr io.Writer = os.Stderr
-	getwd            = os.Getwd
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+  getwd            = os.Getwd
 )
 
 func main() {
-	os.Exit(run(os.Args[1:]))
+  os.Exit(run(os.Args[1:]))
 }
 
 func run(args []string) int {
-	if len(args) == 0 {
-		return runBuild(nil)
-	}
-
-	switch args[0] {
-	case "-h", "--help", "help":
-		printHelp(stdout)
-		return 0
-	case "-v", "--version", "version":
-		printVersion(stdout)
-		return 0
-	case "demo":
-		return runDemo(args[1:])
-	case "build":
-		return runBuild(args[1:])
-	case "api-compile":
-		return runAPICompile(args[1:])
-	case "api-transform":
-		return runAPITransform(args[1:])
-	case "check":
-		// `ttsc check` runs the analyze pipeline without emitting JS — useful
-		// in CI and pre-commit checks that only need schema validation.
-		return runBuild(append([]string{"--noEmit"}, args[1:]...))
-	case "-p", "--project":
-		if len(args) < 2 {
-			fmt.Fprintln(stderr, "ttsc: -p/--project requires a path argument")
-			return 2
-		}
-		return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
-	default:
-		if isBuildAlias(args[0]) {
-			return runBuild(args)
-		}
-		fmt.Fprintf(stderr, "ttsc: unknown command %q\n", args[0])
-		fmt.Fprintln(stderr, `ttsc: run "ttsc --help" to see supported commands`)
-		return 2
-	}
+  if len(args) == 0 {
+    return runBuild(nil)
+  }
+
+  switch args[0] {
+  case "-h", "--help", "help":
+    printHelp(stdout)
+    return 0
+  case "-v", "--version", "version":
+    printVersion(stdout)
+    return 0
+  case "demo":
+    return runDemo(args[1:])
+  case "build":
+    return runBuild(args[1:])
+  case "api-compile":
+    return runAPICompile(args[1:])
+  case "api-transform":
+    return runAPITransform(args[1:])
+  case "check":
+    // `ttsc check` runs the analyze pipeline without emitting JS — useful
+    // in CI and pre-commit checks that only need schema validation.
+    return runBuild(append([]string{"--noEmit"}, args[1:]...))
+  case "-p", "--project":
+    if len(args) < 2 {
+      fmt.Fprintln(stderr, "ttsc: -p/--project requires a path argument")
+      return 2
+    }
+    return runBuild(append([]string{"--tsconfig=" + args[1]}, args[2:]...))
+  default:
+    if isBuildAlias(args[0]) {
+      return runBuild(args)
+    }
+    fmt.Fprintf(stderr, "ttsc: unknown command %q\n", args[0])
+    fmt.Fprintln(stderr, `ttsc: run "ttsc --help" to see supported commands`)
+    return 2
+  }
 }
 
+// isBuildAlias reports whether arg should be forwarded to runBuild without
+// requiring an explicit "build" verb. Any flag-shaped argument (leading "-")
+// or a TypeScript-project file extension is treated as a build alias, matching
+// the tsc/tsgo invocation convention.
 func isBuildAlias(arg string) bool {
-	if strings.HasPrefix(arg, "-") {
-		return true
-	}
-	switch {
-	case strings.HasSuffix(arg, ".json"),
-		strings.HasSuffix(arg, ".ts"),
-		strings.HasSuffix(arg, ".tsx"),
-		strings.HasSuffix(arg, ".mts"),
-		strings.HasSuffix(arg, ".cts"):
-		return true
-	default:
-		return false
-	}
+  if strings.HasPrefix(arg, "-") {
+    return true
+  }
+  switch {
+  case strings.HasSuffix(arg, ".json"),
+    strings.HasSuffix(arg, ".ts"),
+    strings.HasSuffix(arg, ".tsx"),
+    strings.HasSuffix(arg, ".mts"),
+    strings.HasSuffix(arg, ".cts"):
+    return true
+  default:
+    return false
+  }
 }
 
 func printVersion(w io.Writer) {
-	fmt.Fprintf(
-		w,
-		"ttsc %s (commit %s, built %s, %s/%s, go %s)\n",
-		version,
-		commit,
-		date,
-		runtime.GOOS,
-		runtime.GOARCH,
-		runtime.Version(),
-	)
+  fmt.Fprintf(
+    w,
+    "ttsc %s (commit %s, built %s, %s/%s, go %s)\n",
+    version,
+    commit,
+    date,
+    runtime.GOOS,
+    runtime.GOARCH,
+    runtime.Version(),
+  )
 }
 
 func printHelp(w io.Writer) {
-	fmt.Fprintln(w, strings.TrimSpace(`
+  fmt.Fprintln(w, strings.TrimSpace(`
 ttsc — standalone typescript-go host.
 
 Usage:
@@ -155,37 +159,40 @@ Integration guide (bundlers):
 }
 
 func runDemo(args []string) int {
-	fs := flag.NewFlagSet("demo", flag.ContinueOnError)
-	fs.SetOutput(stderr)
-	typ := fs.String("type", "string", "atomic type to simulate")
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-
-	arrow, err := demoArrow(*typ)
-	if err != nil {
-		fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
-		return 2
-	}
-
-	fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
-	fmt.Fprintln(stdout, arrow)
-	return 0
+  fs := flag.NewFlagSet("demo", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  typ := fs.String("type", "string", "atomic type to simulate")
+  if err := fs.Parse(args); err != nil {
+    return 2
+  }
+
+  arrow, err := demoArrow(*typ)
+  if err != nil {
+    fmt.Fprintf(stderr, "ttsc demo: %v\n", err)
+    return 2
+  }
+
+  fmt.Fprintf(stdout, "// demo<%s> -> emitted by ttsc %s\n", *typ, version)
+  fmt.Fprintln(stdout, arrow)
+  return 0
 }
 
+// demoArrow returns a JavaScript arrow-function expression that validates the
+// named atomic TypeScript type at runtime. Used by the demo sub-command to
+// produce a small synthetic emit that smoke tests can assert on.
 func demoArrow(name string) (string, error) {
-	switch strings.ToLower(name) {
-	case "any":
-		return "(input) => true", nil
-	case "boolean":
-		return `(input) => "boolean" === typeof input`, nil
-	case "number":
-		return `(input) => "number" === typeof input`, nil
-	case "bigint":
-		return `(input) => "bigint" === typeof input`, nil
-	case "string", "":
-		return `(input) => "string" === typeof input`, nil
-	default:
-		return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
-	}
+  switch strings.ToLower(name) {
+  case "any":
+    return "(input) => true", nil
+  case "boolean":
+    return `(input) => "boolean" === typeof input`, nil
+  case "number":
+    return `(input) => "number" === typeof input`, nil
+  case "bigint":
+    return `(input) => "bigint" === typeof input`, nil
+  case "string", "":
+    return `(input) => "string" === typeof input`, nil
+  default:
+    return "", fmt.Errorf("unknown --type value %q (want: string|number|boolean|bigint|any)", name)
+  }
 }

package/cmd/ttsc/main_alias_branches_test.go

@@ -2,28 +2,26 @@ package main
 
 import "testing"
 
-/**
- * Verifies main command aliases cover flag-shaped demo and cts project inputs.
- *
- * The top-level dispatcher treats extension-shaped arguments as build aliases
- * while demo owns its own flag parser. These small branches keep compatibility
- * with `ttsc ./tsconfig.cts`-style invocations and malformed demo flags.
- *
- * 1. Run demo with a missing flag value.
- * 2. Dispatch a `.cts` argument through the build alias path.
- * 3. Assert both routes fail through their intended parser.
- */
+// TestMainAliasBranches verifies main command aliases cover flag-shaped demo and cts project inputs.
+//
+// The top-level dispatcher treats extension-shaped arguments as build aliases
+// while demo owns its own flag parser. These small branches keep compatibility
+// with `ttsc ./tsconfig.cts`-style invocations and malformed demo flags.
+//
+// 1. Run demo with a missing flag value.
+// 2. Dispatch a `.cts` argument through the build alias path.
+// 3. Assert both routes fail through their intended parser.
 func TestMainAliasBranches(t *testing.T) {
-	code, _, _ := captureCommand(t, func() int {
-		return run([]string{"demo", "--type"})
-	})
-	if code != 2 {
-		t.Fatalf("demo flag status mismatch: %d", code)
-	}
-	code, _, _ = captureCommand(t, func() int {
-		return run([]string{"project.cts"})
-	})
-	if code != 2 {
-		t.Fatalf("cts build alias status mismatch: %d", code)
-	}
+  code, _, _ := captureCommand(t, func() int {
+    return run([]string{"demo", "--type"})
+  })
+  if code != 2 {
+    t.Fatalf("demo flag status mismatch: %d", code)
+  }
+  code, _, _ = captureCommand(t, func() int {
+    return run([]string{"project.cts"})
+  })
+  if code != 2 {
+    t.Fatalf("cts build alias status mismatch: %d", code)
+  }
 }

package/cmd/ttscserver/main.go

@@ -12,34 +12,34 @@
 package main
 
 import (
-	"context"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"os"
-	"os/signal"
-	"runtime"
-	"strings"
-	"syscall"
-	"time"
-
-	"github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+  "context"
+  "errors"
+  "flag"
+  "fmt"
+  "io"
+  "os"
+  "os/signal"
+  "runtime"
+  "strings"
+  "syscall"
+  "time"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
 )
 
 // Build metadata; overwritten via -ldflags in release builds.
 var (
-	version = "0.0.0-dev"
-	commit  = "dev"
-	date    = "unknown"
+  version = "0.0.0-dev"
+  commit  = "dev"
+  date    = "unknown"
 )
 
 // Package-level writers so command tests can capture output without
 // patching os.Stdout / os.Stderr globally.
 var (
-	stdout io.Writer = os.Stdout
-	stderr io.Writer = os.Stderr
-	stdin  io.Reader = os.Stdin
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+  stdin  io.Reader = os.Stdin
 )
 
 // runLSPServer is the seam command tests use to substitute a fake LSP
@@ -56,89 +56,95 @@ var notifyContext = signal.NotifyContext
 var getwd = os.Getwd
 
 func main() {
-	os.Exit(run(os.Args[1:]))
+  os.Exit(run(os.Args[1:]))
 }
 
+// run dispatches top-level subcommands/flags and returns an exit code.
+// Called by main with os.Args[1:] and overridden in tests with a synthetic
+// argument slice to avoid spawning a real tsgo process.
 func run(args []string) int {
-	if len(args) == 0 {
-		printHelp(stdout)
-		return 0
-	}
-	switch args[0] {
-	case "-h", "--help", "help":
-		printHelp(stdout)
-		return 0
-	case "-v", "--version", "version":
-		printVersion(stdout)
-		return 0
-	}
-	return runLSP(args)
+  if len(args) == 0 {
+    printHelp(stdout)
+    return 0
+  }
+  switch args[0] {
+  case "-h", "--help", "help":
+    printHelp(stdout)
+    return 0
+  case "-v", "--version", "version":
+    printVersion(stdout)
+    return 0
+  }
+  return runLSP(args)
 }
 
+// runLSP parses LSP-mode flags and starts the proxy. It returns 0 on clean
+// shutdown, 1 on a runtime error from the LSP host, and 2 on invalid
+// invocation (missing --stdio, unresolvable cwd, unknown flags).
 func runLSP(args []string) int {
-	fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
-	fs.SetOutput(stderr)
-	stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
-	cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
-	tsgoFlag := fs.String("tsgo", "", "absolute tsgo binary path (defaults to TTSC_TSGO_BINARY)")
-	progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
-	if err := fs.Parse(args); err != nil {
-		return 2
-	}
-	if !*stdioFlag {
-		fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
-		return 2
-	}
-
-	cwd := strings.TrimSpace(*cwdFlag)
-	if cwd == "" {
-		resolved, err := getwd()
-		if err != nil {
-			fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
-			return 2
-		}
-		cwd = resolved
-	}
-
-	ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
-	defer stop()
-
-	tsgoBinary := strings.TrimSpace(*tsgoFlag)
-	if tsgoBinary == "" {
-		tsgoBinary = strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY"))
-	}
-
-	err := runLSPServer(ctx, lspserver.LSPServerOptions{
-		In:            stdin,
-		Out:           stdout,
-		Err:           stderr,
-		Cwd:           cwd,
-		TsgoBinary:    tsgoBinary,
-		Source:        lspserver.NullPluginSource{},
-		ProgressDelay: *progressDelayFlag,
-	})
-	if err != nil && !errors.Is(err, context.Canceled) {
-		fmt.Fprintf(stderr, "ttscserver: %v\n", err)
-		return 1
-	}
-	return 0
+  fs := flag.NewFlagSet("ttscserver", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  stdioFlag := fs.Bool("stdio", false, "communicate with the editor over stdin/stdout")
+  cwdFlag := fs.String("cwd", "", "project root (defaults to process cwd)")
+  tsgoFlag := fs.String("tsgo", "", "absolute tsgo binary path (defaults to TTSC_TSGO_BINARY)")
+  progressDelayFlag := fs.Duration("progress-delay", 250*time.Millisecond, "delay before showing tsgo's progress UI")
+  if err := fs.Parse(args); err != nil {
+    return 2
+  }
+  if !*stdioFlag {
+    fmt.Fprintln(stderr, "ttscserver: only --stdio transport is supported")
+    return 2
+  }
+
+  cwd := strings.TrimSpace(*cwdFlag)
+  if cwd == "" {
+    resolved, err := getwd()
+    if err != nil {
+      fmt.Fprintf(stderr, "ttscserver: could not resolve working directory: %v\n", err)
+      return 2
+    }
+    cwd = resolved
+  }
+
+  ctx, stop := notifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+  defer stop()
+
+  tsgoBinary := strings.TrimSpace(*tsgoFlag)
+  if tsgoBinary == "" {
+    tsgoBinary = strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY"))
+  }
+
+  err := runLSPServer(ctx, lspserver.LSPServerOptions{
+    In:            stdin,
+    Out:           stdout,
+    Err:           stderr,
+    Cwd:           cwd,
+    TsgoBinary:    tsgoBinary,
+    Source:        lspserver.NullPluginSource{},
+    ProgressDelay: *progressDelayFlag,
+  })
+  if err != nil && !errors.Is(err, context.Canceled) {
+    fmt.Fprintf(stderr, "ttscserver: %v\n", err)
+    return 1
+  }
+  return 0
 }
 
 func printVersion(w io.Writer) {
-	fmt.Fprintf(
-		w,
-		"ttscserver %s (commit %s, built %s, %s/%s, go %s)\n",
-		version,
-		commit,
-		date,
-		runtime.GOOS,
-		runtime.GOARCH,
-		runtime.Version(),
-	)
+  fmt.Fprintf(
+    w,
+    "ttscserver %s (commit %s, built %s, %s/%s, go %s)\n",
+    version,
+    commit,
+    date,
+    runtime.GOOS,
+    runtime.GOARCH,
+    runtime.Version(),
+  )
 }
 
 func printHelp(w io.Writer) {
-	fmt.Fprintln(w, strings.TrimSpace(`
+  fmt.Fprintln(w, strings.TrimSpace(`
 ttscserver — Language Server Protocol host for ttsc.
 
 Usage: