ttsc 0.30.3 → 0.31.0

package/tools/shim_audit/enum_generation_preserves_existing_family_members_test.go

@@ -0,0 +1,182 @@
+package main
+
+import (
+  "bytes"
+  "go/ast"
+  "go/parser"
+  "go/token"
+  "go/types"
+  "os"
+  "path/filepath"
+  "slices"
+  "testing"
+
+  "golang.org/x/tools/go/packages"
+)
+
+// Verifies enum generation preserves a family's existing members on every run.
+//
+// The generator must calculate its entire output independently of its previous
+// file. Private references and exports from another shim cannot replace the
+// owning package's public constants.
+//
+//  1. Type-check a literal enum and scan real authored shim files.
+//  2. Generate missing members despite private and foreign-package references.
+//  3. Repeat generation and require identical bytes and complete public coverage.
+//  4. Remove authored constants and retain the existing public family on repeated runs.
+//  5. Add a sibling, then hand all constants to authored exports without duplicates.
+//
+// @evidence contracts/testing.md#behavioral-verification Actual scan, analyze and runFix operations write and reread an owned temporary shim; exported constant names and repeated output bytes detect destructive replacement rather than merely checking an exit status.
+// @evidence contracts/testing.md#independent-expectations Literal upstream declarations establish Alpha, Beta, Delta and the later Gamma; expected public names are authored independently of analyzer findings and generated text.
+// @evidence contracts/testing.md#distinguishing-cases A public Alpha contrasts with private Delta and a foreign shim's Beta alias; first, repeated and expanded generation distinguish missing members and lost siblings. Zero authored constants retain the already public family; complete authored handoff removes duplicate generated output and remains idempotent.
+// @evidence contracts/testing.md#execution-ownership This direct source unit runs in the tools/shim_audit module through go test (the shim:audit:test package script); Go's parser, type checker and filesystem APIs execute in the owning process over temporary shim files without a native compiler producer or subprocess.
+func TestEnumGenerationPreservesExistingFamilyMembers(t *testing.T) {
+  root := t.TempDir()
+  write := func(relative, text string) {
+    t.Helper()
+    filename := filepath.Join(root, relative)
+    if err := os.MkdirAll(filepath.Dir(filename), 0o755); err != nil {
+      t.Fatal(err)
+    }
+    if err := os.WriteFile(filename, []byte(text), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+  write("ast/shim.go", `package ast
+import innerast "github.com/microsoft/typescript-go/internal/ast"
+type Mode = innerast.Mode
+const Alpha = innerast.Alpha
+const privateDelta = innerast.Delta
+func privateReference() { _ = innerast.Beta }
+`)
+  write("checker/shim.go", `package checker
+import innerast "github.com/microsoft/typescript-go/internal/ast"
+const ForeignBeta = innerast.Beta
+`)
+  upstream := func(expanded bool) map[string]*packages.Package {
+    t.Helper()
+    source := `package ast
+type Mode int
+const ( Alpha Mode = iota; Beta; Delta )
+`
+    if expanded {
+      source += "const Gamma Mode = 3\n"
+    }
+    fset := token.NewFileSet()
+    file, err := parser.ParseFile(fset, "upstream.go", source, 0)
+    if err != nil {
+      t.Fatal(err)
+    }
+    pkg, err := (&types.Config{}).Check(internalPrefix+"ast", fset, []*ast.File{file}, nil)
+    if err != nil {
+      t.Fatal(err)
+    }
+    return map[string]*packages.Package{"ast": {Types: pkg}}
+  }
+  generate := func(expanded bool) []byte {
+    t.Helper()
+    reachable, err := scanShimReachable(root)
+    if err != nil {
+      t.Fatal(err)
+    }
+    exports, err := scanShimEnumExports(root, false)
+    if err != nil {
+      t.Fatal(err)
+    }
+    family, err := scanShimEnumExports(root, true)
+    if err != nil {
+      t.Fatal(err)
+    }
+    findings, _ := analyze(reachable, upstream(expanded), exports, family)
+    if err := runFix(findings, root); err != nil {
+      t.Fatal(err)
+    }
+    output, err := os.ReadFile(filepath.Join(root, "ast", "enums_gen.go"))
+    if err != nil {
+      t.Fatal(err)
+    }
+    return output
+  }
+  assertMembers := func(expanded bool, expected []string) {
+    t.Helper()
+    exports, err := scanShimEnumExports(root, true)
+    if err != nil {
+      t.Fatal(err)
+    }
+    actual := make([]string, 0, len(exports["ast"]))
+    for name := range exports["ast"] {
+      actual = append(actual, name)
+    }
+    slices.Sort(actual)
+    if !slices.Equal(actual, expected) {
+      t.Fatalf("public members = %v, want %v", actual, expected)
+    }
+    reachable, err := scanShimReachable(root)
+    if err != nil {
+      t.Fatal(err)
+    }
+    findings, _ := analyze(reachable, upstream(expanded), exports, exports)
+    for _, finding := range findings {
+      if finding.kind == "ENUM" {
+        t.Fatalf("generated family remains incomplete: %+v", finding)
+      }
+    }
+  }
+  first := generate(false)
+  assertMembers(false, []string{"Alpha", "Beta", "Delta"})
+  second := generate(false)
+  if !bytes.Equal(first, second) {
+    t.Fatal("second generation changed the complete family")
+  }
+  assertMembers(false, []string{"Alpha", "Beta", "Delta"})
+  write("ast/shim.go", `package ast
+import innerast "github.com/microsoft/typescript-go/internal/ast"
+type Mode = innerast.Mode
+const privateAlpha = innerast.Alpha
+`)
+  withoutAuthoredMembers := generate(false)
+  assertMembers(false, []string{"Alpha", "Beta", "Delta"})
+  if !bytes.Equal(withoutAuthoredMembers, generate(false)) {
+    t.Fatal("family with no authored constants lost prior public members")
+  }
+  expanded := generate(true)
+  if bytes.Equal(first, expanded) {
+    t.Fatal("new upstream sibling was not generated")
+  }
+  assertMembers(true, []string{"Alpha", "Beta", "Delta", "Gamma"})
+  if !bytes.Equal(expanded, generate(true)) {
+    t.Fatal("repeated expanded generation changed earlier members")
+  }
+  write("ast/shim.go", `package ast
+import innerast "github.com/microsoft/typescript-go/internal/ast"
+type Mode = innerast.Mode
+const (
+  Alpha = innerast.Alpha
+  Beta = innerast.Beta
+  Delta = innerast.Delta
+  Gamma = innerast.Gamma
+)
+`)
+  for iteration := range 2 {
+    reachable, err := scanShimReachable(root)
+    if err != nil {
+      t.Fatal(err)
+    }
+    exports, err := scanShimEnumExports(root, false)
+    if err != nil {
+      t.Fatal(err)
+    }
+    family, err := scanShimEnumExports(root, true)
+    if err != nil {
+      t.Fatal(err)
+    }
+    findings, _ := analyze(reachable, upstream(true), exports, family)
+    if err := runFix(findings, root); err != nil {
+      t.Fatal(err)
+    }
+    if _, err := os.Stat(filepath.Join(root, "ast", "enums_gen.go")); !os.IsNotExist(err) {
+      t.Fatalf("authored handoff %d retained duplicate generated members: %v", iteration, err)
+    }
+    assertMembers(true, []string{"Alpha", "Beta", "Delta", "Gamma"})
+  }
+}

package/tools/shim_audit/enum_generation_refuses_removed_public_members_test.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+  "bytes"
+  "go/ast"
+  "go/parser"
+  "go/token"
+  "go/types"
+  "os"
+  "path/filepath"
+  "strings"
+  "testing"
+
+  "golang.org/x/tools/go/packages"
+)
+
+// Verifies a removed public member blocks generation before existing output changes.
+//
+// Another missing sibling must not turn an upstream removal into a successful
+// rewrite that silently deletes the old API. Migration requires an explicit
+// decision about the removed member's meaning.
+//
+//  1. Publish Alpha and an earlier generated Delta in an owned shim.
+//  2. Type-check current upstream Alpha and new Beta, with Delta absent.
+//  3. Run the actual analyzer and generator and require unchanged old output.
+//
+// @evidence contracts/testing.md#behavioral-verification Real source scanning, Go type checking, analysis and generation exercise the missing-member boundary and verify the previously published file remains byte-identical.
+// @evidence contracts/testing.md#independent-expectations Literal authored old Delta and current Alpha/Beta declarations establish the removal and concurrent new sibling independently of analyzer findings.
+// @evidence contracts/testing.md#distinguishing-cases An upstream removal and a new gap coexist in the same package, so ordinary sibling regeneration cannot conceal public API loss.
+// @evidence contracts/testing.md#execution-ownership The owning auditor unit uses temporary source files and in-process parser/type-checker/generator operations; no native artifact, subprocess or installation executes.
+func TestEnumGenerationRefusesRemovedPublicMembers(t *testing.T) {
+  root := t.TempDir()
+  directory := filepath.Join(root, "ast")
+  if err := os.MkdirAll(directory, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  authored := `package ast
+import innerast "github.com/microsoft/typescript-go/internal/ast"
+type Mode = innerast.Mode
+const Alpha = innerast.Alpha
+`
+  previous := []byte(`package ast
+import innerast "github.com/microsoft/typescript-go/internal/ast"
+const Delta = innerast.Delta
+`)
+  output := filepath.Join(directory, "enums_gen.go")
+  if err := os.WriteFile(filepath.Join(directory, "shim.go"), []byte(authored), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(output, previous, 0o644); err != nil {
+    t.Fatal(err)
+  }
+  fset := token.NewFileSet()
+  file, err := parser.ParseFile(fset, "upstream.go", "package ast\ntype Mode int\nconst ( Alpha Mode = iota; Beta )\n", 0)
+  if err != nil {
+    t.Fatal(err)
+  }
+  pkg, err := (&types.Config{}).Check(internalPrefix+"ast", fset, []*ast.File{file}, nil)
+  if err != nil {
+    t.Fatal(err)
+  }
+  reachable, err := scanShimReachable(root)
+  if err != nil {
+    t.Fatal(err)
+  }
+  exports, err := scanShimEnumExports(root, false)
+  if err != nil {
+    t.Fatal(err)
+  }
+  family, err := scanShimEnumExports(root, true)
+  if err != nil {
+    t.Fatal(err)
+  }
+  findings, _ := analyze(reachable, map[string]*packages.Package{"ast": {Types: pkg}}, exports, family)
+  refusal := runFix(findings, root)
+  if refusal == nil || !strings.Contains(refusal.Error(), "ast.Delta") {
+    t.Fatalf("removed member was not named in the refusal: %v", refusal)
+  }
+  evaluation := evaluateBaseline(findings, baselineFile{Accepted: []string{"ENUM_REMOVED|ast|Delta"}}, nil)
+  if len(evaluation.enumRemovals) != 1 || evaluation.enumRemovals[0].symbol != "Delta" || len(evaluation.enumGaps) != 1 || evaluation.enumGaps[0].symbol != "Beta" {
+    t.Fatalf("removal and new sibling must remain separate non-grandfathered findings: %#v", evaluation)
+  }
+  if tierOf("ENUM_REMOVED") != 1 {
+    t.Fatal("public removal was hidden in the informational summary")
+  }
+  current, err := os.ReadFile(output)
+  if err != nil {
+    t.Fatal(err)
+  }
+  if !bytes.Equal(previous, current) {
+    t.Fatal("upstream removal was silently overwritten while adding Beta")
+  }
+}

package/tools/shim_audit/main.go

@@ -4,8 +4,8 @@
 // Background. ttsc re-exports typescript-go's `internal/*` packages through the
 // shim so plugin authors (typia, nestia, third-party rules) never touch Go
 // internals. A missing re-export is an ttsc bug, not a plugin bug — yet they
-// keep being discovered one reactive issue at a time (#217, #218, #220, #221,
-// #226, #230). This tool computes the shortfall mechanically instead.
+// keep being discovered one reactive report at a time. This tool computes the
+// shortfall mechanically instead.
 //
 // The invariant. The shim should be TRANSITIVELY CLOSED over the operations of
 // the types it already exposes. If the shim already aliases an upstream type T,
@@ -13,8 +13,8 @@
 // through the shim. Four closure rules are checked:
 //
 //   - ENUM   every exported const whose type is an already-exposed enum type
-//     must be re-exported. (This is the `SignatureKindConstruct` class —
-//     #230 rule 1. `SignatureKind` is exposed but only `...Call` is, so
+//     must be re-exported. (This is the `SignatureKindConstruct` class.
+//     `SignatureKind` is exposed but only `...Call` is, so
 //     `...Construct` is a deterministic gap.)
 //   - FUNC   every exported package-level func whose params and results are all
 //     already-reachable types must be reachable. (A plugin holding those
@@ -28,7 +28,7 @@
 //     type alias alone only makes the object nameable; it provides no value.
 //
 // What it deliberately does NOT find: UNEXPORTED helpers a plugin needs by name
-// (e.g. `(*Checker).getMinArgumentCount`, #230 rule 2). Those are invisible to
+// (e.g. `(*Checker).getMinArgumentCount`). Those are invisible to
 // closure and must come from the consumer-demand scan. The audit prints the
 // unexported method/func pool of exposed types as a triage list so the demand
 // side has a bounded candidate set.
@@ -73,6 +73,7 @@ const internalPrefix = "github.com/microsoft/typescript-go/internal/"
 // package suffix. Kept explicit (rather than globbed) so a new shim dir is a
 // conscious add.
 var shimDirs = map[string]string{
+  "stringutil":       "stringutil",
   "ast":              "ast",
   "bundled":          "bundled",
   "checker":          "checker",
@@ -269,6 +270,64 @@ func scanShimReachable(shimRoot string) (reachable, error) {
   return r, nil
 }
 
+// scanShimEnumExports records constants that an owning shim actually publishes.
+// References inside another shim's functions do not make an enum member public.
+// Generation excludes its previous output so rewriting a family preserves all
+// required members instead of writing only additions since the previous run.
+func scanShimEnumExports(shimRoot string, includeGenerated bool) (reachable, error) {
+  exports := reachable{}
+  fset := token.NewFileSet()
+  for dir, suffix := range shimDirs {
+    paths, err := filepath.Glob(filepath.Join(shimRoot, dir, "*.go"))
+    if err != nil {
+      return nil, err
+    }
+    for _, filename := range paths {
+      if !includeGenerated && filepath.Base(filename) == "enums_gen.go" {
+        continue
+      }
+      file, err := parser.ParseFile(fset, filename, nil, parser.SkipObjectResolution)
+      if err != nil {
+        return nil, err
+      }
+      aliases := map[string]bool{}
+      for _, imp := range file.Imports {
+        if strings.Trim(imp.Path.Value, `"`) != internalPrefix+suffix {
+          continue
+        }
+        name := filepath.Base(suffix)
+        if imp.Name != nil {
+          name = imp.Name.Name
+        }
+        aliases[name] = true
+      }
+      for _, declaration := range file.Decls {
+        group, ok := declaration.(*ast.GenDecl)
+        if !ok || group.Tok != token.CONST {
+          continue
+        }
+        for _, specification := range group.Specs {
+          values := specification.(*ast.ValueSpec)
+          for index, name := range values.Names {
+            if !name.IsExported() || index >= len(values.Values) {
+              continue
+            }
+            selector, ok := values.Values[index].(*ast.SelectorExpr)
+            if !ok {
+              continue
+            }
+            qualifier, ok := selector.X.(*ast.Ident)
+            if ok && aliases[qualifier.Name] {
+              exports.add(suffix, selector.Sel.Name)
+            }
+          }
+        }
+      }
+    }
+  }
+  return exports, nil
+}
+
 // scanShimProducerSurface parses normal shim source and models value flow over
 // exported package functions and methods. A pointer to an internal named type is a
 // compiler-owned graph object: parameters consume one and results produce one.
@@ -647,7 +706,7 @@ func indexInternalPackages(roots []*packages.Package) (map[string]*packages.Pack
 // *types.Alias matters: an enum declared `type PragmaKindFlags = uint8` (a Go
 // type alias to a basic) gives its member consts an *types.Alias type, and a
 // bare *types.Named assertion would drop them — leaving a partial re-export of
-// that #230-class enum invisible to the zero-tolerance ENUM check.
+// that partially re-exported enum invisible to the zero-tolerance ENUM check.
 func namedInfo(t types.Type) (pkgSuffix, name string, ok bool) {
   var obj *types.TypeName
   switch n := t.(type) {
@@ -824,6 +883,11 @@ func main() {
     fmt.Fprintln(os.Stderr, "shim_audit:", err)
     os.Exit(1)
   }
+  enumExports, err := scanShimEnumExports(*shimRoot, !*fix)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, "shim_audit:", err)
+    os.Exit(1)
+  }
   inner, err := loadInner(*anchor)
   if err != nil {
     fmt.Fprintln(os.Stderr, "shim_audit:", err)
@@ -840,13 +904,21 @@ func main() {
     os.Exit(1)
   }
 
-  findings, pool := analyze(r, inner)
+  familyExports, err := scanShimEnumExports(*shimRoot, true)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, "shim_audit:", err)
+    os.Exit(1)
+  }
+  findings, pool := analyze(r, inner, enumExports, familyExports)
   addExposedMethodFlow(r, inner, &producerSurface)
   producerSurface = canonicalizeProducerSurface(producerSurface, typeGraph)
 
   switch {
   case *fix:
-    runFix(findings, *shimRoot)
+    if err := runFix(findings, *shimRoot); err != nil {
+      fmt.Fprintln(os.Stderr, "shim_audit:", err)
+      os.Exit(1)
+    }
   case *writeBaseline:
     runWriteBaseline(findings, *baselinePath)
   case *check:
@@ -1159,9 +1231,14 @@ func collectGoTypeFlowSeen(typ types.Type, direction flowDirection, pointerLike
 
 // analyze runs the upstream closure checks plus the unexported demand-pool scan and
 // returns the deduped findings and pool.
-func analyze(r reachable, inner map[string]*packages.Package) (findings, unexportedPool []finding) {
+func analyze(r reachable, inner map[string]*packages.Package, enumExports, familyExports reachable) (findings, unexportedPool []finding) {
   for suffix, pkg := range inner {
     scope := pkg.Types.Scope()
+    for name := range familyExports[suffix] {
+      if _, exists := scope.Lookup(name).(*types.Const); !exists {
+        findings = append(findings, finding{"ENUM_REMOVED", suffix, name, "previous public constant is absent from current upstream; resolve its migration before generation"})
+      }
+    }
 
     // CHECK 1 (ENUM): consts of an exposed enum type that are not re-exported.
     // Two passes so we also catch family members that upstream declares as
@@ -1177,7 +1254,7 @@ func analyze(r reachable, inner map[string]*packages.Package) (findings, unexpor
     // be typed. This is essential: an enum whose members are ALL untyped (every
     // member `= iota` / `1<<n` with no annotation, e.g. printer's
     // GeneratedIdentifierFlags) would otherwise never register as a family, and
-    // a partial re-export of exactly the #230 class would pass the gate.
+    // a partial re-export of exactly that class would pass the gate.
     var enumNames []string
     for _, name := range scope.Names() {
       tn, ok := scope.Lookup(name).(*types.TypeName)
@@ -1211,7 +1288,7 @@ func analyze(r reachable, inner map[string]*packages.Package) (findings, unexpor
     // matches the longest of each enum's prefixes — the type name, plus the
     // abbreviation prefix shared by its typed members — so untyped+unprefixed
     // members (e.g. OuterExpressionKinds' OEKExcludeJSDocTypeAssertion = 1<<6)
-    // are not silently dropped from the #230 enum-closure check.
+    // are not silently dropped from the enum-closure check.
     typedMembers := make(map[string][]string, len(enumNames))
     for _, en := range enumNames {
       typedMembers[en] = constsByType[suffix+"."+en]
@@ -1227,13 +1304,13 @@ func analyze(r reachable, inner map[string]*packages.Package) (findings, unexpor
         continue // the enum type itself isn't exposed; not a closure gap
       }
       // Tier by partial exposure: an enum with SOME members already
-      // re-exported but not all is the near-certain #230 bug class
+      // re-exported but not all is the near-certain bug class
       // (e.g. SignatureKindCall present, SignatureKindConstruct absent).
       // An enum with zero members exposed is a deliberate type-only
       // aliasing choice — report it, but at INFO.
       var exposed, missing int
       for _, n := range names {
-        if r.has(suffix, n) {
+        if enumExports.has(suffix, n) {
           exposed++
         } else {
           missing++
@@ -1241,14 +1318,21 @@ func analyze(r reachable, inner map[string]*packages.Package) (findings, unexpor
       }
       kind := "ENUM"
       detail := "member of exposed enum " + tk[1]
-      if exposed == 0 {
+      previouslyExposed := false
+      for _, name := range names {
+        if familyExports.has(suffix, name) {
+          previouslyExposed = true
+          break
+        }
+      }
+      if exposed == 0 && !previouslyExposed {
         kind = "ENUM?"
         detail += " (type-only: NO members exposed — likely intentional)"
       } else {
         detail += fmt.Sprintf(" (PARTIAL: %d/%d members exposed — missing siblings)", exposed, exposed+missing)
       }
       for _, n := range names {
-        if !r.has(suffix, n) {
+        if !enumExports.has(suffix, n) {
           findings = append(findings, finding{kind, suffix, n, detail})
         }
       }
@@ -1419,10 +1503,10 @@ func dedupe(in []finding) []finding {
 }
 
 // tierOf maps a finding kind to a confidence tier. Tier 1 is the near-certain
-// bug class (#230); higher tiers are progressively noisier candidate pools.
+// bug class; higher tiers are progressively noisier candidate pools.
 func tierOf(kind string) int {
   switch kind {
-  case "ENUM": // partial enum — some members exposed, siblings missing
+  case "ENUM", "ENUM_REMOVED": // public enum closure and migration failures
     return 1
   case "FUNC", "PRODUCER": // callable ops and constructible object flow
     return 2
@@ -1464,10 +1548,10 @@ func report(findings, pool []finding, md bool) {
   } else {
     fmt.Printf("=== Shim closure audit ===\n")
   }
-  fmt.Printf("Tier 1 PARTIAL-ENUM (near-certain bugs): %d | Tier 2 FUNC/PRODUCER: %d | Tier 3 ESCAPE: %d | Tier 4 type-only enums: %d | Unexported demand pool: %d\n",
+  fmt.Printf("Tier 1 ENUM-COMPATIBILITY (near-certain bugs): %d | Tier 2 FUNC/PRODUCER: %d | Tier 3 ESCAPE: %d | Tier 4 type-only enums: %d | Unexported demand pool: %d\n",
     len(tiers[1]), len(tiers[2]), len(tiers[3]), len(tiers[4]), len(pool))
 
-  h("TIER 1 — partial enums (a sibling const is missing; this is the #230 class)")
+  h("TIER 1 — public enum closure and upstream migration")
   thead()
   for _, f := range tiers[1] {
     row(f)
@@ -1529,6 +1613,7 @@ type baselineFile struct {
 
 type baselineEvaluation struct {
   enumGaps       []finding
+  enumRemovals   []finding
   newGaps        []finding
   producerGaps   []finding
   invalidReasons []string
@@ -1547,6 +1632,8 @@ func evaluateBaseline(findings []finding, baseline baselineFile, usedProducerRoo
     switch f.kind {
     case "ENUM":
       evaluation.enumGaps = append(evaluation.enumGaps, f)
+    case "ENUM_REMOVED":
+      evaluation.enumRemovals = append(evaluation.enumRemovals, f)
     case "FUNC", "ESCAPE":
       key := findingKey(f)
       liveAccepted[key] = true
@@ -1589,22 +1676,63 @@ func shimPackageName(dir string) string {
 // runFix writes shim/<pkg>/enums_gen.go for every package carrying TIER-1 enum
 // gaps, re-exporting each missing member so the family is complete. Const
 // re-exports carry no behavior and no ABI risk, so closing the whole family is
-// always safe — and makes the #230 class structurally impossible.
+// always safe — and makes a partially re-exported enum family structurally impossible.
 //
-// A member REMOVAL across a typescript-go bump is the one case -fix does not
-// auto-heal: a package whose last gap disappears is not rewritten here, so a
-// stale enums_gen.go still referencing the removed symbol must be deleted by
-// hand (the native build catches the dangling reference).
-func runFix(findings []finding, shimRoot string) {
+// A generated member handed over to an authored export no longer belongs in
+// the output. Remove an obsolete file only when all of its members remain
+// authored exports; an upstream removal is not silently accepted here.
+func runFix(findings []finding, shimRoot string) error {
+  var removed []string
+  for _, f := range findings {
+    if f.kind == "ENUM_REMOVED" {
+      removed = append(removed, f.pkg+"."+f.symbol)
+    }
+  }
+  if len(removed) != 0 {
+    sort.Strings(removed)
+    return fmt.Errorf("refusing enum generation: previous public constants absent from upstream: %s; resolve their migration first", strings.Join(removed, ", "))
+  }
   byPkg := map[string][]string{}
   for _, f := range findings {
     if f.kind == "ENUM" {
       byPkg[f.pkg] = append(byPkg[f.pkg], f.symbol)
     }
   }
+  authored, err := scanShimEnumExports(shimRoot, false)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, "shim_audit:", err)
+    os.Exit(1)
+  }
+  withGenerated, err := scanShimEnumExports(shimRoot, true)
+  if err != nil {
+    fmt.Fprintln(os.Stderr, "shim_audit:", err)
+    os.Exit(1)
+  }
+  for dir, suffix := range shimDirs {
+    if len(byPkg[suffix]) != 0 {
+      continue
+    }
+    complete := len(withGenerated[suffix]) != 0
+    for member := range withGenerated[suffix] {
+      if !authored[suffix][member] {
+        complete = false
+        break
+      }
+    }
+    if !complete {
+      continue
+    }
+    filename := filepath.Join(shimRoot, dir, "enums_gen.go")
+    if err := os.Remove(filename); err == nil {
+      fmt.Printf("shim_audit: removed obsolete %s\n", filename)
+    } else if !os.IsNotExist(err) {
+      fmt.Fprintln(os.Stderr, "shim_audit:", err)
+      os.Exit(1)
+    }
+  }
   if len(byPkg) == 0 {
-    fmt.Println("shim_audit: no enum-family gaps; nothing to fix")
-    return
+    fmt.Println("shim_audit: no enum-family gaps remain")
+    return nil
   }
   pkgs := make([]string, 0, len(byPkg))
   for p := range byPkg {
@@ -1621,8 +1749,8 @@ func runFix(findings []finding, shimRoot string) {
     b.WriteString("// Code generated by packages/ttsc/tools/shim_audit -fix. DO NOT EDIT.\n//\n")
     b.WriteString("// Completes every exposed enum family: re-exports each member not already\n")
     b.WriteString("// re-exported elsewhere in the shim package, so a plugin that can name the\n")
-    b.WriteString("// enum type can name all of its values. Prevents the #230 class (a sibling\n")
-    b.WriteString("// const silently missing). Regenerate after a typescript-go bump with\n")
+    b.WriteString("// enum type can name all of its values. Prevents a partially re-exported\n")
+    b.WriteString("// family (a sibling const silently missing). Regenerate after a typescript-go bump with\n")
     b.WriteString("// `pnpm --filter ttsc shim:audit -fix`.\n\n")
     fmt.Fprintf(&b, "package %s\n\n", pkgName)
     fmt.Fprintf(&b, "import %s %q\n\n", alias, internalPrefix+pkg)
@@ -1646,6 +1774,7 @@ func runFix(findings []finding, shimRoot string) {
     }
     fmt.Printf("shim_audit: wrote %s (%d members)\n", out, len(names))
   }
+  return nil
 }
 
 // runWriteBaseline records the current TIER-2/3 gaps as accepted, so the gate
@@ -1709,18 +1838,24 @@ func runCheck(findings []finding, surface producerSurface, path string) {
     fmt.Fprintf(os.Stderr, "shim_audit: note: %d producer exemption(s) no longer match a gap; remove them\n", evaluation.staleProducers)
   }
 
-  if len(evaluation.enumGaps) == 0 && len(evaluation.newGaps) == 0 &&
+  if len(evaluation.enumGaps) == 0 && len(evaluation.enumRemovals) == 0 && len(evaluation.newGaps) == 0 &&
     len(evaluation.producerGaps) == 0 && len(evaluation.invalidReasons) == 0 {
     fmt.Println("shim_audit: OK — exposed enums, reachable symbols, and compiler-object producers are closed")
     return
   }
   if len(evaluation.enumGaps) > 0 {
     fmt.Fprintf(os.Stderr, "\nshim_audit: FAIL — %d enum-family member(s) of an EXPOSED enum are not re-exported.\n", len(evaluation.enumGaps))
-    fmt.Fprintf(os.Stderr, "  This is the #230 class. Fix mechanically: `pnpm --filter ttsc shim:audit -fix`.\n")
+    fmt.Fprintf(os.Stderr, "  This is a partially re-exported enum family. Fix mechanically: `pnpm --filter ttsc shim:audit -fix`.\n")
     for _, f := range evaluation.enumGaps {
       fmt.Fprintf(os.Stderr, "    ENUM   %s.%s\n", f.pkg, f.symbol)
     }
   }
+  if len(evaluation.enumRemovals) > 0 {
+    fmt.Fprintf(os.Stderr, "\nshim_audit: FAIL — %d previous public constant(s) are absent from upstream. Resolve their migration before generation.\n", len(evaluation.enumRemovals))
+    for _, f := range evaluation.enumRemovals {
+      fmt.Fprintf(os.Stderr, "    ENUM_REMOVED %s.%s\n", f.pkg, f.symbol)
+    }
+  }
   if len(evaluation.newGaps) > 0 {
     fmt.Fprintf(os.Stderr, "\nshim_audit: FAIL — %d new reachable gap(s) not in the baseline.\n", len(evaluation.newGaps))
     fmt.Fprintf(os.Stderr, "  Expose them in the shim, or accept deliberately: `pnpm --filter ttsc shim:audit -write-baseline`.\n")