ttsc 0.3.1 → 0.4.0-dev.20260425

package/driver/program.go

@@ -0,0 +1,298 @@
+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"path/filepath"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	shimchecker "github.com/microsoft/typescript-go/shim/checker"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+	"github.com/microsoft/typescript-go/shim/core"
+	shimdiagnosticwriter "github.com/microsoft/typescript-go/shim/diagnosticwriter"
+	shimscanner "github.com/microsoft/typescript-go/shim/scanner"
+	"github.com/microsoft/typescript-go/shim/tsoptions"
+	"github.com/microsoft/typescript-go/shim/tspath"
+	"github.com/microsoft/typescript-go/shim/vfs"
+)
+
+// Diagnostic is the compilation diagnostic shape ttsc passes around. Kept
+// dependency-free (no shim types) so callers can render or inspect freely.
+type Diagnostic struct {
+	File    string
+	Line    int
+	Column  int
+	Message string
+	raw     *ast.Diagnostic
+}
+
+// SourceFile returns the program source file matching filename.
+func (p *Program) SourceFile(filename string) *ast.SourceFile {
+	if p == nil || p.TSProgram == nil {
+		return nil
+	}
+	normalized := filepath.ToSlash(filename)
+	for _, file := range p.TSProgram.SourceFiles() {
+		if filepath.ToSlash(file.FileName()) == normalized {
+			return file
+		}
+	}
+	return nil
+}
+
+// String returns a `path:line:col: message` formatted string.
+func (d Diagnostic) String() string {
+	if d.File == "" {
+		return d.Message
+	}
+	if d.Line > 0 {
+		return fmt.Sprintf("%s:%d:%d: %s", d.File, d.Line, d.Column, d.Message)
+	}
+	return fmt.Sprintf("%s: %s", d.File, d.Message)
+}
+
+// WritePrettyDiagnostics renders diagnostics with TypeScript-style colors,
+// source snippets and the trailing error summary when raw tsgo diagnostic
+// objects are available. It falls back to the legacy one-line form for
+// diagnostics assembled outside tsgo.
+func WritePrettyDiagnostics(w io.Writer, diagnostics []Diagnostic, cwd string) {
+	raw := make([]*ast.Diagnostic, 0, len(diagnostics))
+	for _, d := range diagnostics {
+		if d.raw == nil {
+			for _, d := range diagnostics {
+				fmt.Fprintln(w, "  -", d.String())
+			}
+			return
+		}
+		raw = append(raw, d.raw)
+	}
+	shimdiagnosticwriter.FormatASTDiagnosticsWithColorAndContext(w, raw, cwd)
+}
+
+// Program is the shim-agnostic facade the rest of the engine sees.
+type Program struct {
+	TSProgram      *shimcompiler.Program
+	ParsedConfig   *tsoptions.ParsedCommandLine
+	Checker        *shimchecker.Checker
+	checkerRelease func()
+	Host           shimcompiler.CompilerHost
+	FS             vfs.FS
+}
+
+// LoadProgramOptions controls tsconfig overrides applied before tsgo creates
+// the program. `ForceEmit` is used by `ttsc --emit` and `ttsc transform`
+// so runtime compilation still works when the project defaults to `noEmit`.
+type LoadProgramOptions struct {
+	ForceEmit   bool
+	ForceNoEmit bool
+	OutDir      string
+}
+
+// Close releases the checker pool lease acquired by LoadProgram.
+func (p *Program) Close() error {
+	if p.checkerRelease != nil {
+		p.checkerRelease()
+		p.checkerRelease = nil
+	}
+	return nil
+}
+
+// ParseTSConfig parses a tsconfig.json file via tsgo's native JSONC parser.
+// Comments, trailing commas, and `extends` chains are handled automatically.
+//
+// The absolute path is resolved against cwd before any VFS lookups because
+// tsgo's filesystem APIs require absolute paths — mirrors what tsc does when
+// you pass a relative `--project` flag.
+func ParseTSConfig(fs vfs.FS, cwd, tsconfigPath string, host shimcompiler.CompilerHost) (*tsoptions.ParsedCommandLine, []Diagnostic, error) {
+	resolved := tspath.ResolvePath(cwd, tsconfigPath)
+	if !fs.FileExists(resolved) {
+		return nil, nil, fmt.Errorf("tsconfig not found: %s", resolved)
+	}
+	parsed, diags := tsoptions.GetParsedCommandLineOfConfigFile(resolved, &core.CompilerOptions{}, nil, host, nil)
+	if len(diags) > 0 {
+		return nil, convertDiagnostics(diags), nil
+	}
+	if parsed == nil {
+		return nil, nil, errors.New("tsoptions: parsed command line was nil")
+	}
+	if len(parsed.Errors) > 0 {
+		return nil, convertDiagnostics(parsed.Errors), nil
+	}
+	return parsed, nil, nil
+}
+
+// CreateProgramFromConfig builds a tsgo Program from the parsed config.
+func CreateProgramFromConfig(parsed *tsoptions.ParsedCommandLine, host shimcompiler.CompilerHost) (*shimcompiler.Program, []Diagnostic, error) {
+	opts := shimcompiler.ProgramOptions{
+		Config:                      parsed,
+		SingleThreaded:              core.TSTrue,
+		Host:                        host,
+		UseSourceOfProjectReference: true,
+	}
+	p := shimcompiler.NewProgram(opts)
+	if p == nil {
+		return nil, nil, errors.New("shimcompiler.NewProgram returned nil")
+	}
+	return p, nil, nil
+}
+
+// LoadProgram is the one-shot convenience used by `ttsc`.
+// It parses the tsconfig, creates a program and a type-checker, and returns
+// the wrapped facade.
+//
+// cwd must be absolute; tsconfigPath may be relative to cwd.
+func LoadProgram(cwd, tsconfigPath string, options LoadProgramOptions) (*Program, []Diagnostic, error) {
+	if !filepath.IsAbs(cwd) {
+		if abs, err := filepath.Abs(cwd); err == nil {
+			cwd = abs
+		}
+	}
+	cwd = tspath.ResolvePath(cwd)
+	fs := DefaultFS()
+	host := DefaultHost(cwd, fs)
+
+	parsed, diags, err := ParseTSConfig(fs, cwd, tsconfigPath, host)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(diags) > 0 {
+		return nil, diags, nil
+	}
+	if options.ForceNoEmit {
+		forceNoEmit(parsed)
+	}
+	if options.ForceEmit {
+		forceEmit(parsed)
+	}
+	if options.OutDir != "" {
+		overrideOutDir(cwd, parsed, options.OutDir)
+	}
+
+	tsProgram, progDiags, err := CreateProgramFromConfig(parsed, host)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(progDiags) > 0 {
+		return nil, progDiags, nil
+	}
+
+	checker, done := tsProgram.GetTypeChecker(context.Background())
+	return &Program{
+		TSProgram:      tsProgram,
+		ParsedConfig:   parsed,
+		Checker:        checker,
+		checkerRelease: done,
+		Host:           host,
+		FS:             fs,
+	}, nil, nil
+}
+
+func forceEmit(parsed *tsoptions.ParsedCommandLine) {
+	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+		return
+	}
+	options := parsed.ParsedConfig.CompilerOptions
+	options.NoEmit = core.TSFalse
+	options.EmitDeclarationOnly = core.TSFalse
+}
+
+func forceNoEmit(parsed *tsoptions.ParsedCommandLine) {
+	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+		return
+	}
+	parsed.ParsedConfig.CompilerOptions.NoEmit = core.TSTrue
+}
+
+func overrideOutDir(cwd string, parsed *tsoptions.ParsedCommandLine, outDir string) {
+	if parsed == nil || parsed.ParsedConfig == nil || parsed.ParsedConfig.CompilerOptions == nil {
+		return
+	}
+	parsed.ParsedConfig.CompilerOptions.OutDir = tspath.ResolvePath(cwd, outDir)
+}
+
+// SourceFiles exposes the program's user-authored source files (declaration
+// files filtered out).
+func (p *Program) SourceFiles() []*ast.SourceFile {
+	out := make([]*ast.SourceFile, 0)
+	for _, f := range p.TSProgram.SourceFiles() {
+		if f.IsDeclarationFile {
+			continue
+		}
+		out = append(out, f)
+	}
+	return out
+}
+
+// Diagnostics returns project diagnostics that must block compilation or
+// runtime execution before any JavaScript is emitted or evaluated.
+func (p *Program) Diagnostics() []Diagnostic {
+	if p == nil || p.TSProgram == nil {
+		return []Diagnostic{{Message: "driver: nil program"}}
+	}
+	ctx := context.Background()
+	raw := shimcompiler.GetDiagnosticsOfAnyProgram(
+		ctx,
+		p.TSProgram,
+		nil,
+		false,
+		p.TSProgram.GetBindDiagnostics,
+		p.TSProgram.GetSemanticDiagnostics,
+	)
+	raw = filterDiagnostics(raw)
+	return convertDiagnostics(shimcompiler.SortAndDeduplicateDiagnostics(raw))
+}
+
+func filterDiagnostics(in []*ast.Diagnostic) []*ast.Diagnostic {
+	out := in[:0]
+	for _, d := range in {
+		if isUnusedOverloadSignatureTypeParameterDiagnostic(d) {
+			continue
+		}
+		out = append(out, d)
+	}
+	return out
+}
+
+func isUnusedOverloadSignatureTypeParameterDiagnostic(d *ast.Diagnostic) bool {
+	if d == nil || d.File() == nil {
+		return false
+	}
+	switch d.Code() {
+	case 6196, 6205: // unused declaration / all type parameters are unused
+	default:
+		return false
+	}
+	node := ast.GetNodeAtPosition(d.File(), d.Pos(), false)
+	for node != nil {
+		if node.Kind == ast.KindFunctionDeclaration {
+			return node.Body() == nil
+		}
+		node = node.Parent
+	}
+	return false
+}
+
+// convertDiagnostics translates shim-specific diagnostics into the plain
+// Diagnostic struct with line/column populated via tsgo's ECMALineMap (the
+// same helper tsc uses for its "file:line:col: message" banner).
+func convertDiagnostics(in []*ast.Diagnostic) []Diagnostic {
+	out := make([]Diagnostic, 0, len(in))
+	for _, d := range in {
+		if d == nil {
+			continue
+		}
+		diag := Diagnostic{Message: d.String(), raw: d}
+		if file := d.File(); file != nil {
+			diag.File = file.FileName()
+			if pos := d.Pos(); pos >= 0 {
+				line, col := shimscanner.GetECMALineAndByteOffsetOfPosition(file, pos)
+				diag.Line = line + 1
+				diag.Column = col + 1
+			}
+		}
+		out = append(out, diag)
+	}
+	return out
+}

package/driver/rewrite.go

@@ -0,0 +1,315 @@
+// Package driver: post-emit rewriter.
+//
+// tsgo emits `.js` with plugin-owned call expressions preserved as-is because
+// the compile-time transformer stage is now hosted outside the native
+// compiler. This file implements the emit-time rewrite pattern pioneered by
+// tsgonest: we hook tsgo's Emit() via its WriteFile callback, locate each
+// previously-recognized plugin call in the emitted JS, and replace the call
+// expression with the JS the native consumer produced.
+//
+// The rewriter operates on the output text only — it relies on the caller
+// having already produced an ordered list of (file, call, emittedJS) triples.
+// Today we match by textual pattern (`<alias>.<method>(...)`), which is safe
+// because the compiler-stripped call site is distinctive.
+package driver
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"unicode"
+
+	"github.com/microsoft/typescript-go/shim/ast"
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+)
+
+// Rewrite describes one emit-time patch. Produced by CollectCallSites after
+// the engine has generated a replacement JS fragment for the call.
+type Rewrite struct {
+	File          *ast.SourceFile
+	RootName      string
+	Namespaces    []string
+	Method        string
+	Replacement   string
+	ConsumeParens bool
+}
+
+// RewriteSet groups rewrites by file, preserving source order.
+type RewriteSet struct {
+	byPath map[string][]Rewrite
+}
+
+// NewRewriteSet returns an empty set.
+func NewRewriteSet() *RewriteSet { return &RewriteSet{byPath: map[string][]Rewrite{}} }
+
+// Add registers a rewrite under the absolute path of its source file.
+func (rs *RewriteSet) Add(r Rewrite) {
+	if r.File == nil {
+		return
+	}
+	path := filepath.ToSlash(r.File.FileName())
+	rs.byPath[path] = append(rs.byPath[path], r)
+}
+
+// Len returns the total number of rewrites across every file.
+func (rs *RewriteSet) Len() int {
+	n := 0
+	for _, rws := range rs.byPath {
+		n += len(rws)
+	}
+	return n
+}
+
+// RewriteSentinel is the marker inserted at the top of a patched file so
+// re-running the emit on an already-rewritten file is a no-op.
+const RewriteSentinel = "/* @ttsc-rewritten */"
+
+// EmitAll runs tsgo's emitter, patching every registered plugin-owned call in
+// the output. Returns the tsgo diagnostics and any patch-time error. When
+// `writeFile` is nil, the patched JS is written to disk via the standard
+// tsgo WriteFile.
+func (p *Program) EmitAll(rs *RewriteSet, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
+	return p.emit(rs, nil, writeFile)
+}
+
+// EmitFile runs tsgo's emitter for one source file, applying the same rewrite
+// pipeline as EmitAll.
+func (p *Program) EmitFile(rs *RewriteSet, target *ast.SourceFile, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
+	return p.emit(rs, target, writeFile)
+}
+
+func (p *Program) emit(rs *RewriteSet, target *ast.SourceFile, writeFile shimcompiler.WriteFile) (*shimcompiler.EmitResult, []Diagnostic, error) {
+	if p == nil || p.TSProgram == nil {
+		return nil, nil, errors.New("driver: nil program")
+	}
+	if rs == nil {
+		rs = NewRewriteSet()
+	}
+	cursors := map[string]int{}
+	wf := func(fileName, text string, data *shimcompiler.WriteFileData) error {
+		if strings.Contains(text, RewriteSentinel) {
+			if writeFile != nil {
+				return writeFile(fileName, text, data)
+			}
+			return DefaultWriteFile(fileName, text)
+		}
+		patched, err := applyRewrites(fileName, text, rs, cursors)
+		if err != nil {
+			return err
+		}
+		if patched != text {
+			patched = insertSentinel(patched)
+		}
+		if writeFile != nil {
+			return writeFile(fileName, patched, data)
+		}
+		return DefaultWriteFile(fileName, patched)
+	}
+
+	result := p.TSProgram.Emit(context.Background(), shimcompiler.EmitOptions{
+		TargetSourceFile: target,
+		WriteFile:        wf,
+	})
+	if result == nil {
+		return nil, nil, errors.New("driver: Emit returned nil")
+	}
+	return result, convertDiagnostics(result.Diagnostics), nil
+}
+
+// DefaultWriteFile is the default disk writer used when EmitAll's caller does not
+// supply a custom WriteFile hook.
+func DefaultWriteFile(fileName, text string) error {
+	if dir := filepath.Dir(fileName); dir != "" {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return err
+		}
+	}
+	return os.WriteFile(fileName, []byte(text), 0o644)
+}
+
+func insertSentinel(text string) string {
+	for _, prefix := range []string{"\"use strict\";\n", "'use strict';\n"} {
+		if strings.HasPrefix(text, prefix) {
+			return prefix + RewriteSentinel + "\n" + text[len(prefix):]
+		}
+	}
+	return RewriteSentinel + "\n" + text
+}
+
+func applyRewrites(outputName, text string, rs *RewriteSet, cursors map[string]int) (string, error) {
+	srcPath, ok := findSourceForOutput(outputName, rs)
+	if !ok || len(rs.byPath[srcPath]) == 0 {
+		return text, nil
+	}
+	rewrites := rs.byPath[srcPath]
+	pos := cursors[srcPath]
+	out := text
+	searchFrom := 0
+	for pos < len(rewrites) {
+		r := rewrites[pos]
+		replaced, nextSearchFrom, ok, err := spliceCall(out, r, searchFrom)
+		if err != nil {
+			return "", err
+		}
+		if !ok {
+			preview := out
+			if len(preview) > 400 {
+				preview = preview[:400] + "…"
+			}
+			return "", fmt.Errorf("driver: could not locate %s.%s(…) call in %s (tried roots %v; preview: %q)", joinRootAndNamespaces(r), r.Method, outputName, candidateRoots(r.RootName), preview)
+		}
+		out = replaced
+		searchFrom = nextSearchFrom
+		pos++
+	}
+	cursors[srcPath] = pos
+	return out, nil
+}
+
+func findSourceForOutput(outputName string, rs *RewriteSet) (string, bool) {
+	outSlash := strings.TrimSuffix(filepath.ToSlash(outputName), filepath.Ext(outputName))
+	var best string
+	bestScore := 0
+	for path := range rs.byPath {
+		srcStem := strings.TrimSuffix(filepath.ToSlash(path), filepath.Ext(path))
+		score := commonSuffixSegments(srcStem, outSlash)
+		if score > bestScore {
+			best = path
+			bestScore = score
+		}
+	}
+	return best, bestScore > 0
+}
+
+func commonSuffixSegments(a, b string) int {
+	as := strings.Split(a, "/")
+	bs := strings.Split(b, "/")
+	n := len(as)
+	if len(bs) < n {
+		n = len(bs)
+	}
+	shared := 0
+	for i := 1; i <= n; i++ {
+		if as[len(as)-i] != bs[len(bs)-i] {
+			break
+		}
+		shared++
+	}
+	return shared
+}
+
+func spliceCall(text string, r Rewrite, searchFrom int) (string, int, bool, error) {
+	aliases := candidateRoots(r.RootName)
+	tail := needleTail(r)
+	idx := -1
+	needleLen := 0
+	for _, cand := range aliases {
+		candNeedle := cand + tail
+		if i := indexAtCallStart(text, candNeedle, searchFrom); i >= 0 {
+			idx = i
+			needleLen = len(candNeedle) - 1
+			break
+		}
+	}
+	if idx < 0 {
+		return text, searchFrom, false, nil
+	}
+	parenPos := idx + needleLen
+	if parenPos >= len(text) || text[parenPos] != '(' {
+		return text, searchFrom, false, errors.New("driver: expected '(' after method name")
+	}
+	closePos, ok := matchParen(text, parenPos)
+	if !ok {
+		return text, searchFrom, false, errors.New("driver: unbalanced parens while locating plugin call")
+	}
+	if r.ConsumeParens {
+		replaced := text[:idx] + r.Replacement + text[closePos+1:]
+		return replaced, idx + len(r.Replacement), true, nil
+	}
+	replaced := text[:idx] + r.Replacement + text[idx+needleLen:]
+	return replaced, idx + len(r.Replacement), true, nil
+}
+
+func candidateRoots(root string) []string {
+	return []string{
+		root,
+		root + "_1.default",
+		root + "_2.default",
+		root + ".default",
+		root + "_1",
+		root + "_2",
+	}
+}
+
+func joinRootAndNamespaces(r Rewrite) string {
+	if len(r.Namespaces) == 0 {
+		return r.RootName
+	}
+	return r.RootName + "." + strings.Join(r.Namespaces, ".")
+}
+
+func needleTail(r Rewrite) string {
+	if len(r.Namespaces) == 0 {
+		return "." + r.Method + "("
+	}
+	return "." + strings.Join(r.Namespaces, ".") + "." + r.Method + "("
+}
+
+func indexAtCallStart(text, needle string, searchFrom int) int {
+	start := searchFrom
+	if start < 0 {
+		start = 0
+	}
+	for {
+		hit := strings.Index(text[start:], needle)
+		if hit < 0 {
+			return -1
+		}
+		pos := start + hit
+		if pos == 0 {
+			return pos
+		}
+		prev := rune(text[pos-1])
+		if isIdentifierPart(prev) {
+			start = pos + 1
+			continue
+		}
+		return pos
+	}
+}
+
+func isIdentifierPart(r rune) bool {
+	return r == '_' || r == '$' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
+
+func matchParen(text string, pos int) (int, bool) {
+	if pos >= len(text) || text[pos] != '(' {
+		return 0, false
+	}
+	depth := 1
+	for i := pos + 1; i < len(text); i++ {
+		switch text[i] {
+		case '(':
+			depth++
+		case ')':
+			depth--
+			if depth == 0 {
+				return i, true
+			}
+		case '"', '\'', '`':
+			q := text[i]
+			j := i + 1
+			for j < len(text) && text[j] != q {
+				if text[j] == '\\' {
+					j++
+				}
+				j++
+			}
+			i = j
+		}
+	}
+	return 0, false
+}

package/go.mod

@@ -0,0 +1,48 @@
+module github.com/samchon/ttsc/packages/ttsc
+
+go 1.26
+
+// Every shim sub-module is wired up via the sibling go.work file together
+// with the local typescript-go checkout under ../../third_party/typescript-go.
+// Tagged upstream versions can replace these local wires when the shim API
+// stabilizes.
+replace (
+	github.com/microsoft/typescript-go/shim/ast => ./shim/ast
+	github.com/microsoft/typescript-go/shim/bundled => ./shim/bundled
+	github.com/microsoft/typescript-go/shim/checker => ./shim/checker
+	github.com/microsoft/typescript-go/shim/compiler => ./shim/compiler
+	github.com/microsoft/typescript-go/shim/core => ./shim/core
+	github.com/microsoft/typescript-go/shim/diagnosticwriter => ./shim/diagnosticwriter
+	github.com/microsoft/typescript-go/shim/parser => ./shim/parser
+	github.com/microsoft/typescript-go/shim/scanner => ./shim/scanner
+	github.com/microsoft/typescript-go/shim/tsoptions => ./shim/tsoptions
+	github.com/microsoft/typescript-go/shim/tspath => ./shim/tspath
+	github.com/microsoft/typescript-go/shim/vfs => ./shim/vfs
+	github.com/microsoft/typescript-go/shim/vfs/cachedvfs => ./shim/vfs/cachedvfs
+	github.com/microsoft/typescript-go/shim/vfs/osvfs => ./shim/vfs/osvfs
+)
+
+require (
+	github.com/microsoft/typescript-go/shim/ast v0.0.0
+	github.com/microsoft/typescript-go/shim/bundled v0.0.0
+	github.com/microsoft/typescript-go/shim/checker v0.0.0
+	github.com/microsoft/typescript-go/shim/compiler v0.0.0
+	github.com/microsoft/typescript-go/shim/core v0.0.0
+	github.com/microsoft/typescript-go/shim/diagnosticwriter v0.0.0
+	github.com/microsoft/typescript-go/shim/scanner v0.0.0
+	github.com/microsoft/typescript-go/shim/tsoptions v0.0.0
+	github.com/microsoft/typescript-go/shim/tspath v0.0.0
+	github.com/microsoft/typescript-go/shim/vfs v0.0.0
+	github.com/microsoft/typescript-go/shim/vfs/cachedvfs v0.0.0
+	github.com/microsoft/typescript-go/shim/vfs/osvfs v0.0.0
+)
+
+require (
+	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.42.0 // indirect
+	golang.org/x/text v0.35.0 // indirect
+)

package/go.sum

@@ -0,0 +1,22 @@
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 h1:vymEbVwYFP/L05h5TKQxvkXoKxNvTpjxYKdF1Nlwuao=
+github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433/go.mod h1:tphK2c80bpPhMOI4v6bIc2xWywPfbqi1Z06+RcrMkDg=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
+github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
+github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22 h1:iH0TuqCh+yQ95Ea0f9lVM5B1xkTqlmxQhzOEj8QWR6o=
+github.com/microsoft/typescript-go v0.0.0-20260408193441-2a5e1cf9fe22/go.mod h1:eE2mO7PBRpeR8gWgxwsZq1LOW4tsgIF6zd0iQ5TbsJU=
+github.com/peter-evans/patience v0.3.0 h1:rX0JdJeepqdQl1Sk9c9uvorjYYzL2TfgLX1adqYm9cA=
+github.com/peter-evans/patience v0.3.0/go.mod h1:Kmxu5sY1NmBLFSStvXjX1wS9mIv7wMcP/ubucyMOAu0=
+github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=
+github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=
+github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs=
+github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s=
+golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
+golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
+golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
+golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+gotest.tools/v3 v3.5.2 h1:7koQfIKdy+I8UTetycgUqXWSDwpgv193Ka+qRsmBY8Q=
+gotest.tools/v3 v3.5.2/go.mod h1:LtdLGcnqToBH83WByAAi/wiwSFCArdFIUV/xxN4pcjA=