ttsc 0.3.1 → 0.4.0-dev.20260425

package/cmd/ttsc/main.go

@@ -0,0 +1,222 @@
+// Command ttsc is the Go CLI entrypoint for ttsc.
+//
+// Current responsibilities:
+//   - Report version and platform (`ttsc --version`).
+//   - Exercise a native rewrite backend end-to-end (`ttsc demo --type=string`)
+//     so smoke tests can verify the Go binary really runs.
+//   - Act as a placeholder for the eventual `build` / `dev` / `check` / `setup`
+//     subcommands that will land in Week 3+.
+//
+// Everything below is deliberately dependency-free so that the standalone binary
+// stays small and its behavior is trivial to audit.
+package main
+
+import (
+	"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"
+)
+
+// stdout / stderr are package-level to keep the CLI testable.
+var (
+	stdout io.Writer = os.Stdout
+	stderr io.Writer = os.Stderr
+)
+
+func main() {
+	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 "check":
+		// `ttsc check` runs the analyze pipeline without emitting JS — useful
+		// in CI and pre-commit hooks that only need schema validation.
+		return runBuild(append([]string{"--noEmit"}, args[1:]...))
+	case "transform":
+		// Single-file transform for bundler plugin integration (unplugin,
+		// vite, esbuild, webpack, …). Emits only the requested file's JS to
+		// stdout or a chosen path — no project-wide write.
+		return runTransform(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
+	}
+}
+
+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
+	}
+}
+
+// appendUnique appends `extra` to `args` only when it's not already present.
+func appendUnique(args []string, extra ...string) []string {
+	out := append([]string{}, args...)
+	for _, e := range extra {
+		seen := false
+		for _, a := range out {
+			if a == e {
+				seen = true
+				break
+			}
+		}
+		if !seen {
+			out = append(out, e)
+		}
+	}
+	return out
+}
+
+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(),
+	)
+}
+
+func printHelp(w io.Writer) {
+	fmt.Fprintln(w, strings.TrimSpace(`
+ttsc — standalone typescript-go host.
+
+Usage:
+  ttsc
+  ttsc -p tsconfig.json
+  ttsc --watch
+  ttsc --noEmit
+  ttsc transform --file=src/main.ts
+
+Project build:
+  ttsc compiles the current tsconfig.json, matching the tsc/tsgo shape.
+  build         Compatibility alias for the same project build lane.
+  check         Compatibility alias for --noEmit validation.
+  transform     Emit a single file's rewritten JS (bundler plugin hook).
+  demo          Run a native backend smoke pipeline with synthetic input.
+  version       Print version, build info, and platform.
+  help          Show this help.
+
+Build options:
+  --tsconfig=FILE   Path to tsconfig.json (default: tsconfig.json).
+  --cwd=DIR         Override working directory.
+  --emit            Force emitted .js files even when tsconfig has noEmit.
+  --noEmit          Force analysis-only run even when tsconfig would emit.
+  --quiet           Suppress the per-call summary banner (default).
+  --verbose         Print the per-call summary banner and emitted file list.
+  --rewrite-mode=M  Native rewrite backend id.
+  --manifest=FILE   Write emitted file paths as JSON to FILE after build --emit.
+
+Transform options:
+  --file=PATH       Absolute or cwd-relative path of the .ts file to transform.
+  --tsconfig=FILE   tsconfig.json owning --file (default: tsconfig.json).
+  --out=PATH        Write output JS to PATH. Default: stdout.
+  --rewrite-mode=M  Native rewrite backend id.
+
+Demo options:
+  --type=T          Atomic TypeScript type to simulate. One of:
+                      string, number, boolean, bigint, any (default: string).
+
+Examples:
+  ttsc --version
+  ttsc
+  ttsc -p ./tsconfig.json
+  ttsc --noEmit
+  ttsc transform --file=src/main.ts
+  ttsc demo --type=number
+
+Integration guide (bundlers):
+  - vite / webpack / rollup / esbuild: shell out to "ttsc transform" per file,
+    forward stdout as the bundler transform result. A bundler adapter can wrap
+    this command without depending on the Go internals.
+  - Next.js / Nuxt / Bun: "ttsc" in your pipeline replaces tsc and
+    the rewritten .js feeds the runtime directly.
+  - Monorepo / pnpm workspace: share one ttsc binary via a root script;
+    per-package tsconfig.json references work unchanged.
+`))
+}
+
+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
+}
+
+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)
+	}
+}

package/cmd/ttsc/main_test.go

@@ -0,0 +1,288 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// withCapture replaces stdout/stderr with buffers for the duration of fn.
+// Keeps each test hermetic.
+func withCapture(fn func()) (out, errOut string) {
+	var outBuf, errBuf bytes.Buffer
+	prevOut, prevErr := stdout, stderr
+	stdout = &outBuf
+	stderr = &errBuf
+	defer func() {
+		stdout = prevOut
+		stderr = prevErr
+	}()
+	fn()
+	return outBuf.String(), errBuf.String()
+}
+
+func TestRunNoArgsAttemptsProjectBuild(t *testing.T) {
+	out, errOut := withCapture(func() {
+		if code := run(nil); code == 0 {
+			t.Errorf("expected no-args run without a local tsconfig to fail")
+		}
+	})
+	if strings.Contains(out, "Usage:") {
+		t.Errorf("no-args ttsc must build the project, not print help; got %q", out)
+	}
+	if !strings.Contains(errOut, "tsconfig") {
+		t.Errorf("expected no-args build to look for tsconfig, got stderr %q", errOut)
+	}
+}
+
+func TestRunHelpVariants(t *testing.T) {
+	for _, flag := range []string{"-h", "--help", "help"} {
+		t.Run(flag, func(t *testing.T) {
+			out, _ := withCapture(func() {
+				if code := run([]string{flag}); code != 0 {
+					t.Errorf("expected exit 0, got %d", code)
+				}
+			})
+			if !strings.Contains(out, "demo") {
+				t.Errorf("help text should list demo subcommand, got %q", out)
+			}
+		})
+	}
+}
+
+func TestRunVersion(t *testing.T) {
+	for _, flag := range []string{"-v", "--version", "version"} {
+		t.Run(flag, func(t *testing.T) {
+			out, _ := withCapture(func() {
+				if code := run([]string{flag}); code != 0 {
+					t.Errorf("expected exit 0, got %d", code)
+				}
+			})
+			if !strings.Contains(out, "ttsc ") {
+				t.Errorf("expected version banner, got %q", out)
+			}
+			// Include useful debug bits
+			for _, tag := range []string{"commit", "go"} {
+				if !strings.Contains(out, tag) {
+					t.Errorf("expected %q substring in version output, got %q", tag, out)
+				}
+			}
+		})
+	}
+}
+
+func TestRunUnknownCommandExits2(t *testing.T) {
+	_, errOut := withCapture(func() {
+		if code := run([]string{"fly-to-mars"}); code != 2 {
+			t.Errorf("expected exit 2, got %d", code)
+		}
+	})
+	if !strings.Contains(errOut, "unknown command") {
+		t.Errorf("expected error text, got %q", errOut)
+	}
+}
+
+func TestRunBuildBlocksSemanticDiagnosticsBeforeEmit(t *testing.T) {
+	root := t.TempDir()
+	writeProjectFile(t, root, "tsconfig.json", `{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "bin",
+    "strict": true
+  }
+}
+`)
+	writeProjectFile(t, root, "index.ts", `const value: string = 123;
+console.log(value);
+`)
+
+	_, errOut := withCapture(func() {
+		if code := runBuild([]string{"--cwd", root, "--emit"}); code != 2 {
+			t.Errorf("expected exit 2, got %d", code)
+		}
+	})
+	if !strings.Contains(errOut, "Type 'number' is not assignable to type 'string'") {
+		t.Errorf("expected semantic diagnostic, got %q", errOut)
+	}
+	if !strings.Contains(errOut, "\x1b[91merror\x1b[0m") || !strings.Contains(errOut, "TS2322") {
+		t.Errorf("expected colored TypeScript-style diagnostic header, got %q", errOut)
+	}
+	if !strings.Contains(errOut, "\x1b[7m1\x1b[0m") || !strings.Contains(errOut, "~~~~~") {
+		t.Errorf("expected source context with highlighted span, got %q", errOut)
+	}
+	if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); !os.IsNotExist(err) {
+		t.Errorf("expected no emitted JS, stat err=%v", err)
+	}
+}
+
+func TestRunBuildAllowsUnusedTypeParametersOnOverloadSignatures(t *testing.T) {
+	root := t.TempDir()
+	writeProjectFile(t, root, "tsconfig.json", `{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "bin",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true
+  }
+}
+`)
+	writeProjectFile(t, root, "index.ts", `export function marker<T>(input: unknown): string;
+export function marker(input: unknown): string {
+  return String(input);
+}
+`)
+
+	_, errOut := withCapture(func() {
+		if code := runBuild([]string{"--cwd", root, "--emit", "--quiet"}); code != 0 {
+			t.Errorf("expected exit 0, got %d", code)
+		}
+	})
+	if strings.Contains(errOut, "declared but never used") || strings.Contains(errOut, "All type parameters are unused") {
+		t.Errorf("overload signature type parameters must not fail noUnused checks, got %q", errOut)
+	}
+	if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); err != nil {
+		t.Errorf("expected emitted JS, stat err=%v", err)
+	}
+}
+
+func TestRunBuildBlocksUnusedParametersBeforeEmit(t *testing.T) {
+	root := t.TempDir()
+	writeProjectFile(t, root, "tsconfig.json", `{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "bin",
+    "strict": true,
+    "noUnusedParameters": true
+  }
+}
+`)
+	writeProjectFile(t, root, "index.ts", `export function run(unused: string): number {
+  return 1;
+}
+`)
+
+	_, errOut := withCapture(func() {
+		if code := runBuild([]string{"--cwd", root, "--emit"}); code != 2 {
+			t.Errorf("expected exit 2, got %d", code)
+		}
+	})
+	if !strings.Contains(errOut, "'unused' is declared but its value is never read") &&
+		!strings.Contains(errOut, "'unused' is declared but never used") {
+		t.Errorf("expected unused parameter diagnostic, got %q", errOut)
+	}
+	if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); !os.IsNotExist(err) {
+		t.Errorf("expected no emitted JS, stat err=%v", err)
+	}
+}
+
+func TestRunBuildBlocksSyntacticDiagnosticsBeforeEmit(t *testing.T) {
+	root := t.TempDir()
+	writeProjectFile(t, root, "tsconfig.json", `{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "es2020",
+    "outDir": "bin"
+  }
+}
+`)
+	writeProjectFile(t, root, "index.ts", `console.log("before");
+const = ;
+`)
+
+	_, errOut := withCapture(func() {
+		if code := runBuild([]string{"--cwd", root, "--emit"}); code != 2 {
+			t.Errorf("expected exit 2, got %d", code)
+		}
+	})
+	if !strings.Contains(errOut, "Variable declaration expected") {
+		t.Errorf("expected syntactic diagnostic, got %q", errOut)
+	}
+	if _, err := os.Stat(filepath.Join(root, "bin", "index.js")); !os.IsNotExist(err) {
+		t.Errorf("expected no emitted JS, stat err=%v", err)
+	}
+}
+
+func writeProjectFile(t *testing.T, root string, name string, contents string) {
+	t.Helper()
+	file := filepath.Join(root, 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)
+	}
+}
+
+func TestRunDemoString(t *testing.T) {
+	out, _ := withCapture(func() {
+		if code := run([]string{"demo", "--type=string"}); code != 0 {
+			t.Errorf("expected exit 0, got %d", code)
+		}
+	})
+	want := `(input) => "string" === typeof input`
+	if !strings.Contains(out, want) {
+		t.Errorf("expected demo output to contain %q, got:\n%s", want, out)
+	}
+	if !strings.Contains(out, "demo<string>") {
+		t.Errorf("expected comment prefix in demo output, got:\n%s", out)
+	}
+}
+
+func TestRunDemoEveryAtomic(t *testing.T) {
+	cases := map[string]string{
+		"boolean": `"boolean" === typeof input`,
+		"number":  `"number" === typeof input`,
+		"bigint":  `"bigint" === typeof input`,
+		"any":     `(input) => true`,
+	}
+	for typ, expected := range cases {
+		t.Run(typ, func(t *testing.T) {
+			out, _ := withCapture(func() {
+				if code := run([]string{"demo", "--type=" + typ}); code != 0 {
+					t.Errorf("expected exit 0 for %s, got %d", typ, code)
+				}
+			})
+			if !strings.Contains(out, expected) {
+				t.Errorf("for --type=%s, want %q in output:\n%s", typ, expected, out)
+			}
+		})
+	}
+}
+
+func TestRunDemoUnknownTypeExits2(t *testing.T) {
+	_, errOut := withCapture(func() {
+		if code := run([]string{"demo", "--type=object"}); code != 2 {
+			t.Errorf("expected exit 2 for unknown type, got %d", code)
+		}
+	})
+	if !strings.Contains(errOut, "unknown --type") {
+		t.Errorf("expected diagnostic text, got %q", errOut)
+	}
+}
+
+func TestDemoArrowEveryAtomic(t *testing.T) {
+	cases := map[string]string{
+		"string":  `"string" === typeof input`,
+		"number":  `"number" === typeof input`,
+		"boolean": `"boolean" === typeof input`,
+		"bigint":  `"bigint" === typeof input`,
+		"any":     `(input) => true`,
+	}
+	for name, want := range cases {
+		t.Run(name, func(t *testing.T) {
+			arrow, err := demoArrow(name)
+			if err != nil {
+				t.Fatalf("unexpected err: %v", err)
+			}
+			if !strings.Contains(arrow, want) {
+				t.Errorf("for %s want %q, got %q", name, want, arrow)
+			}
+		})
+	}
+}

package/cmd/ttsc/transform.go

@@ -0,0 +1,166 @@
+package main
+
+import (
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// runTransform implements `ttsc transform` — a single-file transform used by
+// bundler plugin adapters (unplugin, vite, webpack, rollup, esbuild, rspack,
+// farm). Behavior:
+//
+//   - Loads the enclosing tsconfig so tsgo resolves imports and types.
+//   - Runs tsgo Emit, filtering WriteFile so only the requested source
+//     file's JS leaves the binary.
+//   - Applies the ttsc rewrite + import cleanup just like `build --emit`.
+//   - Writes the result to stdout (or `--out` when provided).
+//
+// The contract matches a per-file bundler transform hook: bundlers
+// hand the plugin a source file path, the plugin shells out here, and the
+// returned text replaces the file in the bundle graph.
+func runTransform(args []string) int {
+	fs := flag.NewFlagSet("transform", flag.ContinueOnError)
+	fs.SetOutput(stderr)
+	file := fs.String("file", "", "absolute or cwd-relative path of the .ts file to transform")
+	tsconfigPath := fs.String("tsconfig", "tsconfig.json", "tsconfig.json owning --file")
+	cwdOverride := fs.String("cwd", "", "override the working directory")
+	out := fs.String("out", "", "write output JS to PATH (default: stdout)")
+	rewriteMode := fs.String("rewrite-mode", "none", "native rewrite backend id")
+	if err := fs.Parse(args); err != nil {
+		return 2
+	}
+	if *file == "" {
+		fmt.Fprintln(stderr, "ttsc transform: --file is required")
+		return 2
+	}
+
+	cwd := *cwdOverride
+	if cwd == "" {
+		var err error
+		cwd, err = os.Getwd()
+		if err != nil {
+			fmt.Fprintf(stderr, "ttsc transform: cwd: %v\n", err)
+			return 2
+		}
+	}
+
+	prog, diags, err := driver.LoadProgram(cwd, *tsconfigPath, driver.LoadProgramOptions{
+		ForceEmit: true,
+	})
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc transform: %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
+	}
+
+	absFile := *file
+	if !filepath.IsAbs(absFile) {
+		absFile = filepath.Join(cwd, absFile)
+	}
+	absFile = filepath.ToSlash(absFile)
+
+	rewrites := driver.NewRewriteSet()
+	if *rewriteMode != "none" {
+		fmt.Fprintf(stderr, "ttsc transform: rewrite backend %q is not built into the standalone ttsc binary\n", *rewriteMode)
+		fmt.Fprintln(stderr, "ttsc transform: run through the JS host with the matching compiler plugin so it can select the consumer-provided native binary")
+		return 2
+	}
+
+	target := prog.SourceFile(absFile)
+	if target == nil {
+		fmt.Fprintf(stderr, "ttsc transform: source file is not in program: %s\n", absFile)
+		return 2
+	}
+
+	// Capture the requested source file's JS output.
+	var captured []byte
+	capture := func(name, text string, _ *shimcompiler.WriteFileData) error {
+		rel := filepath.ToSlash(name)
+		if !isJavaScriptOutput(rel) {
+			return nil
+		}
+		captured = []byte(text)
+		return nil
+	}
+	_, eDiags, err := prog.EmitFile(rewrites, target, capture)
+	if err != nil {
+		fmt.Fprintf(stderr, "ttsc transform: emit: %v\n", err)
+		return 3
+	}
+	for _, d := range eDiags {
+		fmt.Fprintln(stderr, "  -", d.String())
+	}
+	if captured == nil {
+		fmt.Fprintf(stderr, "ttsc transform: no output produced for %s\n", absFile)
+		return 3
+	}
+	if *out == "" {
+		if _, werr := bytes.NewReader(captured).WriteTo(stdout); werr != nil {
+			fmt.Fprintf(stderr, "ttsc transform: write stdout: %v\n", werr)
+			return 3
+		}
+		return 0
+	}
+	if dir := filepath.Dir(*out); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			fmt.Fprintf(stderr, "ttsc transform: mkdir: %v\n", err)
+			return 3
+		}
+	}
+	if err := os.WriteFile(*out, captured, 0o644); err != nil {
+		fmt.Fprintf(stderr, "ttsc transform: write %s: %v\n", *out, err)
+		return 3
+	}
+	return 0
+}
+
+// sharedSourceStemSegments counts the shared trailing path segments between the
+// emitted output path and the original source path after stripping extensions.
+// `src/foo/bar.ts` ↔ `dist/foo/bar.js` returns 2, while unrelated paths return
+// 0. `ttsc transform` uses the highest score to pick the emitted JS that
+// belongs to the requested source file even when a project contains multiple
+// `index.ts` files.
+func sharedSourceStemSegments(outPath, srcPath string) int {
+	trim := func(p string) []string {
+		p = strings.TrimSuffix(p, filepath.Ext(p))
+		return strings.Split(p, "/")
+	}
+	a, b := trim(outPath), trim(srcPath)
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	shared := 0
+	for i := 1; i <= n; i++ {
+		if a[len(a)-i] != b[len(b)-i] {
+			break
+		}
+		shared++
+	}
+	return shared
+}
+
+func isJavaScriptOutput(name string) bool {
+	switch strings.ToLower(filepath.Ext(name)) {
+	case ".js", ".mjs", ".cjs":
+		return true
+	default:
+		return false
+	}
+}

package/driver/host.go

@@ -0,0 +1,31 @@
+// Package driver wraps the typescript-go compiler so the rest of ttsc doesn't
+// need to know about shim packages directly. It is the only part of the engine
+// that imports `shim/*` by design — everything downstream consumes a small,
+// shim-agnostic interface (`*Program`).
+//
+// Structural note: this file is deliberately adapted from tsgonest's
+// `internal/compiler/host.go` (MIT, github.com/tsgonest/tsgonest).
+// The helper surface is the same; we keep names in sync to make future
+// upstream changes easy to compare.
+package driver
+
+import (
+	"github.com/microsoft/typescript-go/shim/bundled"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	"github.com/microsoft/typescript-go/shim/vfs"
+	"github.com/microsoft/typescript-go/shim/vfs/cachedvfs"
+	"github.com/microsoft/typescript-go/shim/vfs/osvfs"
+)
+
+// DefaultFS returns an OS-backed filesystem wrapped with tsgo's bundled libs so
+// built-in definitions (lib.es*.d.ts, dom, etc.) resolve without a network
+// fetch. Mirrors tsgonest/tsgolint behavior.
+func DefaultFS() vfs.FS {
+	return bundled.WrapFS(cachedvfs.From(osvfs.FS()))
+}
+
+// DefaultHost returns a CompilerHost anchored at cwd that can find tsgo's
+// bundled library files via `bundled.LibPath()`.
+func DefaultHost(cwd string, fs vfs.FS) shimcompiler.CompilerHost {
+	return shimcompiler.NewCompilerHost(cwd, fs, bundled.LibPath(), nil, nil)
+}