ttsc 0.18.4 → 0.19.0

package/tools/shim_audit/main_test.go

@@ -5,6 +5,8 @@ import (
   "go/types"
   "reflect"
   "testing"
+
+  "golang.org/x/tools/go/packages"
 )
 
 // TestLinknameRe pins the two //go:linkname target shapes the reachability scan
@@ -65,7 +67,7 @@ func TestDedupe(t *testing.T) {
 
 // TestTierOf pins the kind→tier mapping the gate and report depend on.
 func TestTierOf(t *testing.T) {
-  cases := map[string]int{"ENUM": 1, "FUNC": 2, "ESCAPE": 3, "ENUM?": 4, "UNEXPORTED": 4}
+  cases := map[string]int{"ENUM": 1, "FUNC": 2, "PRODUCER": 2, "ESCAPE": 3, "ENUM?": 4, "UNEXPORTED": 4}
   for kind, want := range cases {
     if got := tierOf(kind); got != want {
       t.Errorf("tierOf(%q) = %d, want %d", kind, got, want)
@@ -73,6 +75,31 @@ func TestTierOf(t *testing.T) {
   }
 }
 
+// TestIndexInternalPackages proves dependency-only internal type packages stay
+// available to the named producer-contract scanner and load failures stay fatal.
+func TestIndexInternalPackages(t *testing.T) {
+  dependencyTypes := types.NewPackage(internalPrefix+"lsp/lsproto", "lsproto")
+  dependency := &packages.Package{
+    PkgPath: internalPrefix + "lsp/lsproto",
+    Types:   dependencyTypes,
+  }
+  root := &packages.Package{
+    PkgPath: internalPrefix + "lsp",
+    Types:   types.NewPackage(internalPrefix+"lsp", "lsp"),
+    Imports: map[string]*packages.Package{dependency.PkgPath: dependency},
+  }
+  indexed, errored := indexInternalPackages([]*packages.Package{root})
+  if indexed["lsp"] != root || indexed["lsp/lsproto"] != dependency || len(errored) != 0 {
+    t.Fatalf("indexed=%+v errored=%+v, want root and dependency", indexed, errored)
+  }
+
+  dependency.Types = nil
+  indexed, errored = indexInternalPackages([]*packages.Package{root})
+  if indexed["lsp/lsproto"] != nil || errored["lsp/lsproto"] == "" {
+    t.Fatalf("failed dependency indexed=%+v errored=%+v, want closed failure", indexed, errored)
+  }
+}
+
 // TestCommonPrefix covers the helper feeding the abbreviation fallback.
 func TestCommonPrefix(t *testing.T) {
   cases := []struct {

package/tools/shim_audit/producer_exemptions_require_rationale_test.go

@@ -0,0 +1,42 @@
+package main
+
+import "testing"
+
+// Verifies producer exemptions require a non-empty rationale.
+//
+// Producer gaps use a separate zero-tolerance path so an ordinary accepted gap
+// or an empty placeholder cannot silently classify compiler state as a root.
+//
+//  1. Evaluate the same producer gap with no exemption and an empty exemption.
+//  2. Supply a reasoned public-root exemption and accept the unrelated function gap.
+//  3. Confirm only the deliberate classification passes both gate classes.
+func TestProducerExemptionsRequireRationale(t *testing.T) {
+  surface := newProducerSurface()
+  surface.add(flowConsume, flowType{pkg: "fixture", name: "Root"}, "fixture.UseRoot")
+  functionGap := finding{kind: "FUNC", pkg: "fixture", symbol: "Reachable"}
+
+  absentProducer := evaluateProducerSurface(surface, nil)
+  absent := evaluateBaseline(append(absentProducer.gaps, functionGap), baselineFile{}, absentProducer.usedRoots)
+  if len(absent.producerGaps) != 1 || len(absent.newGaps) != 1 {
+    t.Fatalf("absent exemption evaluation = %+v", absent)
+  }
+
+  emptyBaseline := baselineFile{
+    ProducerExemptions: map[string]string{"fixture.Root": "  "},
+  }
+  emptyProducer := evaluateProducerSurface(surface, emptyBaseline.ProducerExemptions)
+  empty := evaluateBaseline(append(emptyProducer.gaps, functionGap), emptyBaseline, emptyProducer.usedRoots)
+  if len(empty.producerGaps) != 1 || len(empty.invalidReasons) != 1 {
+    t.Fatalf("empty exemption evaluation = %+v", empty)
+  }
+
+  reasonedBaseline := baselineFile{
+    Accepted:           []string{"FUNC|fixture|Reachable"},
+    ProducerExemptions: map[string]string{"fixture.Root": "Caller-owned configuration object."},
+  }
+  reasonedProducer := evaluateProducerSurface(surface, reasonedBaseline.ProducerExemptions)
+  reasoned := evaluateBaseline(append(reasonedProducer.gaps, functionGap), reasonedBaseline, reasonedProducer.usedRoots)
+  if len(reasoned.producerGaps) != 0 || len(reasoned.newGaps) != 0 || len(reasoned.invalidReasons) != 0 {
+    t.Fatalf("reasoned exemption evaluation = %+v", reasoned)
+  }
+}

package/tools/shim_audit/producer_surface_includes_exposed_methods_test.go

@@ -0,0 +1,154 @@
+package main
+
+import (
+  "go/token"
+  "go/types"
+  "testing"
+
+  "golang.org/x/tools/go/packages"
+)
+
+// Verifies producer closure includes exported methods and canonical type aliases.
+//
+// Shim aliases publish upstream method sets without source declarations, while
+// aliases such as Expression and Node can spell the same compiler object twice.
+//
+//  1. Build a rooted exposed owner with consumer and producer methods.
+//  2. Remove the producer and confirm direct and named-callback inputs become a gap.
+//  3. Confirm an alias and canonical producer close the same object edge.
+//  4. Remove the receiver root and confirm its result no longer counts.
+//  5. Restore it explicitly, then prove a rootless self-cycle still fails.
+//  6. Prove reachable receivers do not legitimize argument/result cycles.
+func TestProducerSurfaceIncludesExposedMethods(t *testing.T) {
+  build := func(includeProducer bool) (reachable, map[string]*packages.Package) {
+    pkg := types.NewPackage(internalPrefix+"fixture", "fixture")
+    tokenName := types.NewTypeName(token.NoPos, pkg, "Token", nil)
+    tokenType := types.NewNamed(tokenName, types.NewStruct(nil, nil), nil)
+    pkg.Scope().Insert(tokenName)
+    ownerName := types.NewTypeName(token.NoPos, pkg, "Owner", nil)
+    ownerType := types.NewNamed(ownerName, types.NewStruct(nil, nil), nil)
+    pkg.Scope().Insert(ownerName)
+    receiver := types.NewVar(token.NoPos, pkg, "owner", types.NewPointer(ownerType))
+    consume := types.NewSignatureType(
+      receiver,
+      nil,
+      nil,
+      types.NewTuple(types.NewVar(token.NoPos, pkg, "value", types.NewPointer(tokenType))),
+      types.NewTuple(),
+      false,
+    )
+    ownerType.AddMethod(types.NewFunc(token.NoPos, pkg, "Consume", consume))
+    factoryName := types.NewTypeName(token.NoPos, pkg, "TokenFactory", nil)
+    factorySignature := types.NewSignatureType(
+      nil,
+      nil,
+      nil,
+      types.NewTuple(),
+      types.NewTuple(types.NewVar(token.NoPos, pkg, "value", types.NewPointer(tokenType))),
+      false,
+    )
+    factoryType := types.NewNamed(factoryName, factorySignature, nil)
+    pkg.Scope().Insert(factoryName)
+    register := types.NewSignatureType(
+      receiver,
+      nil,
+      nil,
+      types.NewTuple(types.NewVar(token.NoPos, pkg, "factory", factoryType)),
+      types.NewTuple(),
+      false,
+    )
+    ownerType.AddMethod(types.NewFunc(token.NoPos, pkg, "Register", register))
+    if includeProducer {
+      produce := types.NewSignatureType(
+        receiver,
+        nil,
+        nil,
+        types.NewTuple(),
+        types.NewTuple(types.NewVar(token.NoPos, pkg, "value", types.NewPointer(tokenType))),
+        false,
+      )
+      ownerType.AddMethod(types.NewFunc(token.NoPos, pkg, "Produce", produce))
+    }
+    exposed := reachable{}
+    exposed.add("fixture", "Owner")
+    return exposed, map[string]*packages.Package{"fixture": {Types: pkg}}
+  }
+
+  completeReachable, completeInner := build(true)
+  complete := newProducerSurface()
+  complete.add(flowProduce, flowType{pkg: "fixture", name: "Owner"}, "fixture.NewOwner")
+  addExposedMethodFlow(completeReachable, completeInner, &complete)
+  if findings := evaluateProducerSurface(canonicalizeProducerSurface(complete, completeInner), nil).gaps; len(findings) != 0 {
+    t.Fatalf("complete method surface findings = %+v", findings)
+  }
+
+  missingReachable, missingInner := build(false)
+  missing := newProducerSurface()
+  missing.add(flowProduce, flowType{pkg: "fixture", name: "Owner"}, "fixture.NewOwner")
+  addExposedMethodFlow(missingReachable, missingInner, &missing)
+  canonicalMissing := canonicalizeProducerSurface(missing, missingInner)
+  findings := evaluateProducerSurface(canonicalMissing, nil).gaps
+  if len(findings) != 1 || findings[0].pkg != "fixture" || findings[0].symbol != "Token" {
+    t.Fatalf("missing method producer findings = %+v, want fixture.Token", findings)
+  }
+
+  aliasPkg := missingInner["fixture"].Types
+  aliasName := types.NewTypeName(token.NoPos, aliasPkg, "TokenAlias", nil)
+  types.NewAlias(aliasName, aliasPkg.Scope().Lookup("Token").Type())
+  aliasPkg.Scope().Insert(aliasName)
+  aliases := newProducerSurface()
+  aliases.add(flowConsume, flowType{pkg: "fixture", name: "TokenAlias"}, "fixture.ConsumeAlias")
+  aliases.add(flowProduce, flowType{pkg: "fixture", name: "Token"}, "fixture.ProduceToken")
+  if findings := evaluateProducerSurface(canonicalizeProducerSurface(aliases, missingInner), nil).gaps; len(findings) != 0 {
+    t.Fatalf("canonical alias surface findings = %+v", findings)
+  }
+
+  rootless := newProducerSurface()
+  token := flowType{pkg: "fixture", name: "Token"}
+  owner := flowType{pkg: "fixture", name: "Owner"}
+  rootless.add(flowConsume, token, "fixture.UseToken")
+  rootless.operations = append(rootless.operations, operationFlow{
+    receiver: &owner,
+    consumed: map[flowType]map[string]bool{},
+    produced: map[flowType]map[string]bool{token: {"fixture.Owner.Produce": true}},
+  })
+  if findings := evaluateProducerSurface(rootless, nil).gaps; len(findings) != 1 || findings[0].symbol != "Token" {
+    t.Fatalf("rootless receiver findings = %+v, want fixture.Token", findings)
+  }
+  rooted := evaluateProducerSurface(rootless, map[string]string{"fixture.Owner": "Caller-owned root."})
+  if len(rooted.gaps) != 0 || !rooted.usedRoots["fixture.Owner"] {
+    t.Fatalf("rooted receiver evaluation = %+v, want no gaps and used Owner root", rooted)
+  }
+
+  cycle := newProducerSurface()
+  cycle.add(flowConsume, owner, "fixture.UseOwner")
+  cycle.operations = append(cycle.operations, operationFlow{
+    receiver: &owner,
+    consumed: map[flowType]map[string]bool{},
+    produced: map[flowType]map[string]bool{owner: {"fixture.Owner.Clone": true}},
+  })
+  if findings := evaluateProducerSurface(cycle, nil).gaps; len(findings) != 1 || findings[0].symbol != "Owner" {
+    t.Fatalf("rootless self-cycle findings = %+v, want fixture.Owner", findings)
+  }
+
+  methodCycle := newProducerSurface()
+  methodCycle.add(flowProduce, owner, "fixture.NewOwner")
+  left := flowType{pkg: "fixture", name: "Left"}
+  right := flowType{pkg: "fixture", name: "Right"}
+  methodCycle.operations = append(methodCycle.operations,
+    operationFlow{
+      receiver: &owner,
+      consumed: map[flowType]map[string]bool{left: {"fixture.Owner.RightFromLeft": true}},
+      produced: map[flowType]map[string]bool{right: {"fixture.Owner.RightFromLeft": true}},
+    },
+    operationFlow{
+      receiver: &owner,
+      consumed: map[flowType]map[string]bool{right: {"fixture.Owner.LeftFromRight": true}},
+      produced: map[flowType]map[string]bool{left: {"fixture.Owner.LeftFromRight": true}},
+    },
+  )
+  methodFindings := evaluateProducerSurface(methodCycle, nil).gaps
+  if len(methodFindings) != 2 || methodFindings[0].symbol != "Left" || methodFindings[1].symbol != "Right" {
+    t.Fatalf("rootless method argument cycle findings = %+v, want Left and Right", methodFindings)
+  }
+}

package/tools/shim_audit/producer_surface_rejects_unproducible_reference_test.go

@@ -0,0 +1,142 @@
+package main
+
+import (
+  "go/token"
+  "go/types"
+  "strings"
+  "testing"
+
+  "golang.org/x/tools/go/packages"
+)
+
+// Verifies producer closure rejects a consumed reference after its only producer is removed.
+//
+// The regression is type-flow specific: callback inputs are producers, callback
+// results are consumers, named contracts retain that variance, and non-pointer
+// values must not enter the object graph.
+//
+//  1. Scan a generic surface containing returns, callbacks, and a source method.
+//  2. Confirm only the intentionally input-only object is initially unreachable.
+//  3. Remove a package producer and confirm its generic type-keyed gap appears.
+//  4. Remove a method consumer's producer and confirm that gap appears too.
+//  5. Repeat through recursive named callbacks and containers without hanging.
+//  6. Prove package-operation cycles fail until an independent root is added.
+func TestProducerSurfaceRejectsUnproducibleReference(t *testing.T) {
+  source := `package fixture
+import inner "github.com/microsoft/typescript-go/internal/fixture"
+func ConsumeToken(value *inner.Token) {}
+func ProduceToken() []*inner.Token { return nil }
+func Register(handler func(*inner.Event) *inner.Reply) {}
+func ProduceReply() *inner.Reply { return nil }
+func RegisterInterface(handler interface { Handle(*inner.Notice) *inner.Ack }) {}
+func ProduceAck() *inner.Ack { return nil }
+type Owner struct{}
+func (*Owner) ConsumeMethod(value *inner.MethodToken) {}
+func ProduceMethodToken() *inner.MethodToken { return nil }
+func ConsumeOrphan(value *inner.Orphan) {}
+func IgnorePointedContainer(value *[]inner.ContainerValue) {}
+func IgnoreValue(value inner.Mode) {}
+func hidden(value *inner.Hidden) {}
+`
+  scanWithInner := func(input string, inner map[string]*packages.Package) []finding {
+    surface := newProducerSurface()
+    definitions, err := scanLocalFlowDefinitions([]byte(input), "fixture.go")
+    if err != nil {
+      t.Fatal(err)
+    }
+    if err := scanProducerFile([]byte(input), "fixture.go", "fixture", definitions, inner, &surface); err != nil {
+      t.Fatal(err)
+    }
+    return evaluateProducerSurface(surface, nil).gaps
+  }
+  scan := func(input string) []finding { return scanWithInner(input, nil) }
+
+  complete := scan(source)
+  if len(complete) != 1 || complete[0].symbol != "Orphan" {
+    t.Fatalf("complete surface findings = %+v, want only input-only Orphan", complete)
+  }
+
+  mutated := scan(strings.Replace(source, "func ProduceToken() []*inner.Token { return nil }\n", "", 1))
+  if len(mutated) != 2 || mutated[0].symbol != "Orphan" || mutated[1].symbol != "Token" {
+    t.Fatalf("mutated surface findings = %+v, want Orphan and Token", mutated)
+  }
+  for _, finding := range mutated {
+    if finding.kind != "PRODUCER" || strings.Contains(finding.detail, "Signature") {
+      t.Fatalf("finding is not generic producer evidence: %+v", finding)
+    }
+  }
+
+  mutatedMethod := scan(strings.Replace(source, "func ProduceMethodToken() *inner.MethodToken { return nil }\n", "", 1))
+  if len(mutatedMethod) != 2 || mutatedMethod[0].symbol != "MethodToken" || mutatedMethod[1].symbol != "Orphan" {
+    t.Fatalf("source-method mutation findings = %+v, want MethodToken and Orphan", mutatedMethod)
+  }
+
+  namedSource := `package fixture
+import inner "github.com/microsoft/typescript-go/internal/fixture"
+type Factory func() *inner.FactoryToken
+type Batch []*inner.BatchToken
+type PointerBatch []*inner.PointerBatchToken
+type Recursive func(Recursive)
+func RegisterFactory(factory Factory) {}
+func ConsumeBatch(batch Batch) {}
+func ConsumePointerBatch(batch *PointerBatch) {}
+func RegisterRecursive(callback Recursive) {}
+func ProduceFactoryToken() *inner.FactoryToken { return nil }
+func ProduceBatchToken() *inner.BatchToken { return nil }
+func ProducePointerBatchToken() *inner.PointerBatchToken { return nil }
+`
+  if findings := scan(namedSource); len(findings) != 0 {
+    t.Fatalf("named callback/container findings = %+v, want none", findings)
+  }
+  namedMutated := strings.Replace(namedSource, "func ProduceFactoryToken() *inner.FactoryToken { return nil }\n", "", 1)
+  namedMutated = strings.Replace(namedMutated, "func ProduceBatchToken() *inner.BatchToken { return nil }\n", "", 1)
+  namedMutated = strings.Replace(namedMutated, "func ProducePointerBatchToken() *inner.PointerBatchToken { return nil }\n", "", 1)
+  namedFindings := scan(namedMutated)
+  if len(namedFindings) != 3 || namedFindings[0].symbol != "BatchToken" || namedFindings[1].symbol != "FactoryToken" || namedFindings[2].symbol != "PointerBatchToken" {
+    t.Fatalf("named callback/container mutation findings = %+v, want BatchToken, FactoryToken, and PointerBatchToken", namedFindings)
+  }
+
+  upstream := types.NewPackage(internalPrefix+"fixture", "fixture")
+  upstreamTokenName := types.NewTypeName(token.NoPos, upstream, "UpstreamToken", nil)
+  upstreamToken := types.NewNamed(upstreamTokenName, types.NewStruct(nil, nil), nil)
+  upstream.Scope().Insert(upstreamTokenName)
+  upstreamFactoryName := types.NewTypeName(token.NoPos, upstream, "UpstreamFactory", nil)
+  types.NewNamed(upstreamFactoryName, types.NewSignatureType(
+    nil,
+    nil,
+    nil,
+    types.NewTuple(),
+    types.NewTuple(types.NewVar(token.NoPos, upstream, "value", types.NewPointer(upstreamToken))),
+    false,
+  ), nil)
+  upstream.Scope().Insert(upstreamFactoryName)
+  upstreamInner := map[string]*packages.Package{"fixture": {Types: upstream}}
+  upstreamSource := `package fixture
+import inner "github.com/microsoft/typescript-go/internal/fixture"
+func RegisterUpstreamFactory(factory inner.UpstreamFactory) {}
+func ProduceUpstreamToken() *inner.UpstreamToken { return nil }
+`
+  if findings := scanWithInner(upstreamSource, upstreamInner); len(findings) != 0 {
+    t.Fatalf("upstream named callback findings = %+v, want none", findings)
+  }
+  upstreamMutated := strings.Replace(upstreamSource, "func ProduceUpstreamToken() *inner.UpstreamToken { return nil }\n", "", 1)
+  upstreamFindings := scanWithInner(upstreamMutated, upstreamInner)
+  if len(upstreamFindings) != 1 || upstreamFindings[0].symbol != "UpstreamToken" {
+    t.Fatalf("upstream named callback mutation findings = %+v, want UpstreamToken", upstreamFindings)
+  }
+
+  cycleSource := `package fixture
+import inner "github.com/microsoft/typescript-go/internal/fixture"
+func AFromB(value *inner.B) *inner.A { return nil }
+func BFromA(value *inner.A) *inner.B { return nil }
+func UseA(value *inner.A) {}
+`
+  cycleFindings := scan(cycleSource)
+  if len(cycleFindings) != 2 || cycleFindings[0].symbol != "A" || cycleFindings[1].symbol != "B" {
+    t.Fatalf("rootless operation cycle findings = %+v, want A and B", cycleFindings)
+  }
+  rootedChain := strings.Replace(cycleSource, "func UseA(value *inner.A) {}\n", "func NewA() *inner.A { return nil }\nfunc UseA(value *inner.A) {}\n", 1)
+  if findings := scan(rootedChain); len(findings) != 0 {
+    t.Fatalf("rooted operation chain findings = %+v, want none", findings)
+  }
+}

package/utility/host.go

@@ -4,6 +4,7 @@ import (
   "encoding/json"
   "flag"
   "fmt"
+  "io"
   "os"
   "path/filepath"
   "strings"
@@ -29,6 +30,8 @@ type hostOptions struct {
   singleThreaded bool
   checkers       int
   tsgoArgs       []string
+  stdout         io.Writer
+  stderr         io.Writer
   // fs overrides the filesystem the program loads from. Only the resident serve
   // host sets it (to an OverlayFS), so build/check/transform leave it nil and
   // LoadProgram falls back to the default filesystem.
@@ -46,7 +49,12 @@ type transformResult struct {
 // RunCheck validates the project and linked plugin configuration without
 // emitting output.
 func RunCheck(args []string) int {
-  opts, ok := parseHostOptions("check", args)
+  return RunCheckWithIO(args, os.Stdout, os.Stderr)
+}
+
+// RunCheckWithIO runs check with invocation-owned output streams.
+func RunCheckWithIO(args []string, stdout, stderr io.Writer) int {
+  opts, ok := parseHostOptions("check", args, stdout, stderr)
   if !ok {
     return 2
   }
@@ -57,7 +65,7 @@ func RunCheck(args []string) int {
   }
   defer prog.Close()
   if err := prog.ApplyLinkedPlugins(); err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(opts.stderr, err)
     return 2
   }
   return 0
@@ -65,7 +73,12 @@ func RunCheck(args []string) int {
 
 // RunBuild hosts linked transform packages inside one compiler emit.
 func RunBuild(args []string) int {
-  opts, ok := parseHostOptions("build", args)
+  return RunBuildWithIO(args, os.Stdout, os.Stderr)
+}
+
+// RunBuildWithIO runs build with invocation-owned output streams.
+func RunBuildWithIO(args []string, stdout, stderr io.Writer) int {
+  opts, ok := parseHostOptions("build", args, stdout, stderr)
   if !ok {
     return 2
   }
@@ -81,21 +94,21 @@ func RunBuild(args []string) int {
     opts.quiet = false // --verbose overrides the default --quiet=true
   }
   if !opts.quiet {
-    fmt.Fprintf(os.Stdout, "// ttsc utility: plugins=%d emit=%v\n", len(entries), !opts.noEmit)
+    fmt.Fprintf(opts.stdout, "// ttsc utility: plugins=%d emit=%v\n", len(entries), !opts.noEmit)
   }
   res, eDiags, err := prog.EmitAllRaw(makeSourcePreambleWriteFile(prog))
   if err != nil {
-    fmt.Fprintf(os.Stderr, "ttsc utility: emit failed: %v\n", err)
+    fmt.Fprintf(opts.stderr, "ttsc utility: emit failed: %v\n", err)
     return 3
   }
   for _, d := range eDiags {
-    fmt.Fprintln(os.Stderr, "  -", d.String())
+    fmt.Fprintln(opts.stderr, "  -", d.String())
   }
   if driver.CountErrors(eDiags) > 0 {
     return 2
   }
   if res != nil && !opts.quiet {
-    fmt.Fprintf(os.Stdout, "// ttsc utility: emitted=%d files\n", len(res.EmittedFiles))
+    fmt.Fprintf(opts.stdout, "// ttsc utility: emitted=%d files\n", len(res.EmittedFiles))
   }
   return 0
 }
@@ -103,7 +116,12 @@ func RunBuild(args []string) int {
 // RunTransform returns the project TypeScript text after linked source
 // mutations.
 func RunTransform(args []string) int {
-  opts, ok := parseHostOptions("transform", args)
+  return RunTransformWithIO(args, os.Stdout, os.Stderr)
+}
+
+// RunTransformWithIO runs transform with invocation-owned output streams.
+func RunTransformWithIO(args []string, stdout, stderr io.Writer) int {
+  opts, ok := parseHostOptions("transform", args, stdout, stderr)
   if !ok {
     return 2
   }
@@ -113,7 +131,7 @@ func RunTransform(args []string) int {
   }
   defer prog.Close()
   if err := prog.ApplyLinkedPlugins(); err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(opts.stderr, err)
     return 2
   }
   printer := shimprinter.NewPrinter(shimprinter.PrinterOptions{}, shimprinter.PrintHandlers{}, nil)
@@ -123,7 +141,7 @@ func RunTransform(args []string) int {
     out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = text
   }
   data, _ := json.Marshal(out)
-  fmt.Fprintln(os.Stdout, string(data))
+  fmt.Fprintln(opts.stdout, string(data))
   return 0
 }
 
@@ -131,9 +149,15 @@ func RunTransform(args []string) int {
 // Unknown flags forwarded from the JS launcher are stripped by filterHostArgs
 // before flag.FlagSet sees them, so spurious "flag provided but not defined"
 // errors are avoided. Returns (zero, false) on any parse or validation error.
-func parseHostOptions(command string, args []string) (hostOptions, bool) {
+func parseHostOptions(command string, args []string, stdout, stderr io.Writer) (hostOptions, bool) {
+  if stdout == nil {
+    stdout = io.Discard
+  }
+  if stderr == nil {
+    stderr = io.Discard
+  }
   fs := flag.NewFlagSet(command, flag.ContinueOnError)
-  fs.SetOutput(os.Stderr)
+  fs.SetOutput(stderr)
   cwd := fs.String("cwd", "", "project directory")
   emit := fs.Bool("emit", false, "force emit")
   noEmit := fs.Bool("noEmit", false, "force no emit")
@@ -151,12 +175,12 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
   var tsgoArgs []string
   if *tsgoArgsRaw != "" {
     if err := json.Unmarshal([]byte(*tsgoArgsRaw), &tsgoArgs); err != nil {
-      fmt.Fprintf(os.Stderr, "ttsc utility: invalid --tsgo-args: %v\n", err)
+      fmt.Fprintf(stderr, "ttsc utility: invalid --tsgo-args: %v\n", err)
       return hostOptions{}, false
     }
   }
   if *emit && *noEmit {
-    fmt.Fprintln(os.Stderr, "ttsc utility: --emit and --noEmit are mutually exclusive")
+    fmt.Fprintln(stderr, "ttsc utility: --emit and --noEmit are mutually exclusive")
     return hostOptions{}, false
   }
   resolvedCwd := *cwd
@@ -164,14 +188,14 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
     var err error
     resolvedCwd, err = os.Getwd()
     if err != nil {
-      fmt.Fprintf(os.Stderr, "ttsc utility: cwd: %v\n", err)
+      fmt.Fprintf(stderr, "ttsc utility: cwd: %v\n", err)
       return hostOptions{}, false
     }
   }
   if !filepath.IsAbs(resolvedCwd) {
     abs, err := filepath.Abs(resolvedCwd)
     if err != nil {
-      fmt.Fprintf(os.Stderr, "ttsc utility: cwd: %v\n", err)
+      fmt.Fprintf(stderr, "ttsc utility: cwd: %v\n", err)
       return hostOptions{}, false
     }
     resolvedCwd = abs
@@ -188,6 +212,8 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
     singleThreaded: *singleThreaded,
     checkers:       *checkers,
     tsgoArgs:       tsgoArgs,
+    stdout:         stdout,
+    stderr:         stderr,
   }, true
 }
 
@@ -243,7 +269,7 @@ func flagName(arg string) (string, bool) {
 func loadUtilityProgram(opts hostOptions) (*driver.Program, []driver.PluginEntry, bool) {
   entries, err := parsePluginEntries(opts.pluginsJSON)
   if err != nil {
-    fmt.Fprintln(os.Stderr, err)
+    fmt.Fprintln(opts.stderr, err)
     return nil, nil, false
   }
   restoreEnv := setLinkedPluginManifest(opts.pluginsJSON)
@@ -259,15 +285,15 @@ func loadUtilityProgram(opts hostOptions) (*driver.Program, []driver.PluginEntry
     FS:             opts.fs,
   })
   if err != nil {
-    fmt.Fprintf(os.Stderr, "ttsc utility: %v\n", err)
+    fmt.Fprintf(opts.stderr, "ttsc utility: %v\n", err)
     return nil, nil, false
   }
   if len(diags) > 0 {
-    driver.WritePrettyDiagnostics(os.Stderr, diags, opts.cwd)
+    driver.WritePrettyDiagnostics(opts.stderr, diags, opts.cwd)
     return nil, nil, false
   }
   if diags := prog.Diagnostics(); len(diags) > 0 {
-    driver.WritePrettyDiagnostics(os.Stderr, diags, opts.cwd)
+    driver.WritePrettyDiagnostics(opts.stderr, diags, opts.cwd)
     _ = prog.Close()
     return nil, nil, false
   }

package/utility/serve.go

@@ -56,7 +56,7 @@ type serveUpdateResponse struct {
 // in and out are explicit so the request loop is testable; the utility-host
 // command wires them to os.Stdin and os.Stdout.
 func RunServe(in io.Reader, out io.Writer, args []string) int {
-  opts, ok := parseHostOptions("serve", args)
+  opts, ok := parseHostOptions("serve", args, out, os.Stderr)
   if !ok {
     return 2
   }

package/shim/checker/signature_api_completeness.go

@@ -1,58 +0,0 @@
-package checker
-
-// Compile-time guard: the signature-introspection surface that typia's
-// plain.classify from/new construction-strategy detection depends on must
-// compose end-to-end through the shim.
-//
-// 0.15.5 exposed a CONSUMER of a *Signature (Checker_getMinArgumentCount)
-// without the PRODUCER that yields one (Checker_getSignaturesOfType): a
-// *Signature was nameable (the `Signature` alias) but unobtainable. The closure
-// auditor checks that every escaping type can be NAMED, not that it can be
-// PRODUCED, so it did not catch the gap and the feature stayed blocked.
-//
-// This lives in a NORMAL (non-_test) file on purpose. The shim/checker package
-// is a nested Go module that no CI job runs `go test` against, so a _test.go
-// guard would never be compiled and would silently stop guarding. As ordinary
-// package code it is type-checked by every build that links the shim (typia's
-// native plugin, ttsc's lint engine), so dropping or renaming any leg below
-// turns those builds red. It never runs (assigned to blank, never called).
-var _ = func(c *Checker, instanceType *Type) {
-  // class instance type -> class symbol -> constructor (static) type, which
-  // carries both the construct signatures and the static `from` member.
-  classSymbol := Type_getTypeNameSymbol(instanceType)
-  ctorType := Checker_getTypeOfSymbol(c, classSymbol)
-
-  // `new C(seed)` strategy: construct signatures -> arity (min args +
-  // parameter count, together disambiguating `()` from `(x?)`) -> return type
-  // -> the seed parameter's type. The seed is Signature_parameters[0]'s type,
-  // EXCEPT a rest-ONLY parameter `(...xs: S[])` — when
-  // `hasRestParameter && parameterCount == 1` — whose seed is the rest ELEMENT
-  // (getRestTypeOfSignature). A leading-required + rest-tail `(s, ...r)` still
-  // has hasRestParameter true but its seed is the first parameter S.
-  for _, sig := range Checker_getSignaturesOfType(c, ctorType, SignatureKindConstruct) {
-    _ = Checker_getMinArgumentCount(c, sig)
-    _ = Signature_parameterCount(sig)
-    _ = Checker_getReturnTypeOfSignature(c, sig)
-    if Signature_hasRestParameter(sig) {
-      _ = Checker_getRestTypeOfSignature(c, sig)
-    }
-    for _, p := range Signature_parameters(sig) {
-      _ = Checker_getTypeOfSymbol(c, p)
-    }
-  }
-
-  // `C.from(seed)` strategy: static `from` member -> its call signatures, read
-  // identically (arity, return type, seed parameter / rest element type).
-  fromType := Checker_getTypeOfPropertyOfType(c, ctorType, "from")
-  for _, sig := range Checker_getSignaturesOfType(c, fromType, SignatureKindCall) {
-    _ = Checker_getMinArgumentCount(c, sig)
-    _ = Signature_parameterCount(sig)
-    _ = Checker_getReturnTypeOfSignature(c, sig)
-    if Signature_hasRestParameter(sig) {
-      _ = Checker_getRestTypeOfSignature(c, sig)
-    }
-    for _, p := range Signature_parameters(sig) {
-      _ = Checker_getTypeOfSymbol(c, p)
-    }
-  }
-}