@ttsc/strip 0.26.1 → 0.26.2

package/driver/config.go

@@ -55,6 +55,10 @@ func loadStripConfigMap(pluginConfig map[string]any, cwd, tsconfigPath string) (
     }
   }
 
+  // The discovery base directory doubles as the resolution root the config
+  // loader anchors its toolchain lookup on; see stripConfigToolAnchors.
+  resolutionRoot := stripDiscoveryBaseDir(cwd, tsconfigPath)
+
   // Resolve the config file: explicit configFile wins over discovery.
   configFilePath := ""
   if rawCF, ok := pluginConfig["configFile"]; ok {
@@ -77,7 +81,7 @@ func loadStripConfigMap(pluginConfig map[string]any, cwd, tsconfigPath string) (
     return map[string]any{}, nil
   }
 
-  raw, err := loadStripConfigFile(configFilePath)
+  raw, err := loadStripConfigFile(configFilePath, resolutionRoot)
   if err != nil {
     return nil, err
   }
@@ -147,7 +151,12 @@ func resolveStripConfigFilePath(configPath, cwd, tsconfigPath string) string {
 // loadStripConfigFile loads and deserializes a strip config file at location.
 // The format is determined by extension: .json is parsed natively; .js/.cjs/.mjs
 // run through a Node subprocess; .ts/.cts/.mts run through ttsx.
-func loadStripConfigFile(location string) (any, error) {
+//
+// resolutionRoot is the project directory the TypeScript branch anchors its
+// toolchain resolution on when the config file's own ancestry answers nothing;
+// see stripConfigToolAnchors. The JSON and JS branches spawn no ttsx and
+// ignore it.
+func loadStripConfigFile(location, resolutionRoot string) (any, error) {
   ext := strings.ToLower(filepath.Ext(location))
   switch ext {
   case ".json":
@@ -155,7 +164,7 @@ func loadStripConfigFile(location string) (any, error) {
   case ".js", ".cjs", ".mjs":
     return loadStripScriptConfigFile(location)
   case ".ts", ".cts", ".mts":
-    return loadStripTypeScriptConfigFile(location)
+    return loadStripTypeScriptConfigFile(location, resolutionRoot)
   default:
     return nil, fmt.Errorf("@ttsc/strip: unsupported config file extension %q for %s", ext, location)
   }
@@ -307,7 +316,11 @@ declare const process: {
 // type-check and execute the strip config file, so loading the host
 // project's transform/check plugins would be wasteful and could fail the
 // build against this deliberately lenient loader tsconfig.
-func loadStripTypeScriptConfigFile(location string) (any, error) {
+//
+// Both tools this spawns — the launcher and the compiler handed to it — are
+// resolved from the project rather than from the process environment alone;
+// see stripConfigToolAnchors.
+func loadStripTypeScriptConfigFile(location, resolutionRoot string) (any, error) {
   tempDir, err := os.MkdirTemp(stripLoaderTempBase(location, os.TempDir()), "ttsc-strip-config-")
   if err != nil {
     return nil, fmt.Errorf("@ttsc/strip: create config loader tempdir: %w", err)
@@ -341,14 +354,15 @@ func loadStripTypeScriptConfigFile(location string) (any, error) {
     "--cache-dir", filepath.Join(tempDir, "cache"),
     "--no-plugins",
   }
-  if tsgo := os.Getenv("TTSC_TSGO_BINARY"); tsgo != "" {
+  anchors := stripConfigToolAnchors(location, resolutionRoot)
+  if tsgo := stripResolveConfigTsgo(anchors); tsgo != "" {
     args = append(args, "--binary", tsgo)
   }
   args = append(args, loader)
 
   ctx, cancel := context.WithCancel(context.Background())
   defer cancel()
-  cmd := stripTtsxCommandContext(ctx, args...)
+  cmd := stripTtsxCommandContext(ctx, anchors, args...)
   cmd.Env = stripNodeConfigLoaderEnv(location)
   // The child's stderr is human output and goes straight to this process's
   // stderr as it is written. Collecting it only to replay it afterwards is what
@@ -414,6 +428,23 @@ func stripTypeScriptLoaderTsconfig(loader, location, outDir string) string {
   return string(body)
 }
 
+// ttsc:config-loader-shared begin
+//
+// One policy in three Go copies: everything between these markers is
+// duplicated verbatim in packages/lint/linthost/config.go,
+// packages/banner/driver/banner.go and packages/strip/driver/config.go. #1169
+// decided against extracting it — the only home the three modules could share
+// is the public `packages/ttsc/driver` seam, and packages/lint's go.mod
+// deliberately requires no in-tree ttsc module — and replaced the checklist
+// with a gate: `scripts/ci/config-loader-copies.cjs` compares every function
+// between these markers across all three copies on every pull request, so
+// editing one and not the others fails by name. That file's header carries the
+// full decision and the rules for changing this block.
+//
+// The code between the markers must stay identical. Comments may differ, the
+// `@ttsc/<pkg>:` error prefix may differ, and @ttsc/strip spells each name with
+// a `strip` prefix. Anything package-specific belongs outside the markers.
+
 // stripConfigModuleOption returns the loader tsconfig's "module" for a config
 // file: the module kind Node itself would give that file.
 //
@@ -536,13 +567,233 @@ func stripResolveDirLink(dir string) string {
   return dir
 }
 
+// stripRealpathIfPossible resolves location through its symlinks, and returns
+// it unchanged when it cannot be evaluated (a path that does not exist, or an
+// NTFS junction filepath.EvalSymlinks refuses to traverse).
+func stripRealpathIfPossible(location string) string {
+  real, err := filepath.EvalSymlinks(location)
+  if err != nil {
+    return location
+  }
+  return real
+}
+
+// Both tools the TypeScript config evaluator needs — the `ttsx` launcher it
+// spawns and the native compiler it hands that launcher — are resolved from
+// the project being compiled, with an explicit environment variable winning
+// and a last resort that invents no path.
+//
+// The three Go copies are held identical by the gate named at the top of this
+// block. The JS original — `resolveConfigTsgo` / `resolveTtsxLauncher` in
+// packages/lint/src/index.ts — is a fourth copy in another language that no Go
+// gate can reach; what it owes is that both policies stay describable in one
+// sentence.
+//
+// The environment alone is the wrong place to ask. `ttsx` exports
+// TTSC_TSGO_BINARY and TTSC_TTSX_BINARY to its own descendants, so a host
+// launched under `ttsx` inherited both and a host launched any other way
+// inherited neither. The shipped `ttscserver` binary invoked with its
+// documented `--tsgo <path>` flag keeps that path in a local and exports
+// nothing, and an embedder of the driver package exports nothing either. For
+// those the evaluator spawned a bare `ttsx` that only a global install puts on
+// PATH, and, past that, a compiler-less child that aborted with
+// `ttsc: typescript is required` before a line of the config was read.
+//
+// stripConfigToolAnchors lists the file paths those resolutions walk upward
+// from, in order: the config file being evaluated, then the resolution root's
+// manifest. The config comes first because it is the file whose own
+// installation decides which toolchain the config's imports were written
+// against; the resolution root answers for a config that lives outside the
+// project tree (a `configFile` pointed at a shared package), and for one
+// discovered above a workspace that installs its own toolchain.
+func stripConfigToolAnchors(configPath, resolutionRoot string) []string {
+  anchors := make([]string, 0, 2)
+  if strings.TrimSpace(configPath) != "" {
+    anchors = append(anchors, configPath)
+  }
+  if strings.TrimSpace(resolutionRoot) != "" {
+    anchors = append(anchors, filepath.Join(resolutionRoot, "package.json"))
+  }
+  return anchors
+}
+
+// stripResolveConfigTsgo returns the native TypeScript compiler the evaluator
+// hands its ttsx child through `--binary`, or "" to leave the child resolving
+// for itself.
+//
+// The child runs with `--cwd <ephemeral loader dir>`, so it cannot discover
+// `typescript` the way an ordinary invocation does: stripLinkNearestNodeModules
+// is the only thing that puts the project's modules within its reach, and it
+// links nothing when the config's ancestry carries no node_modules. An explicit
+// TTSC_TSGO_BINARY still wins, so an embedder that pins a compiler keeps
+// pinning it. "" is the unchanged last resort: a project that cannot answer
+// here could not answer inside the child either, and the child's own diagnostic
+// is the one that names the missing package.
+func stripResolveConfigTsgo(anchors []string) string {
+  if explicit := strings.TrimSpace(os.Getenv("TTSC_TSGO_BINARY")); explicit != "" {
+    return explicit
+  }
+  for _, anchor := range anchors {
+    if binary := stripTsgoBinaryFrom(anchor); binary != "" {
+      return binary
+    }
+  }
+  return ""
+}
+
+// stripTsgoBinaryFrom returns the platform compiler executable of the
+// `typescript` install `anchor` can see, or "" when this anchor reaches neither
+// the package nor its platform dependency.
+//
+// Mirrors resolveTsgo.ts so the Go plugin and the JS launcher name one file:
+// the `typescript` manifest, then `@typescript/typescript-<platform>-<arch>`
+// resolved from that manifest, then `lib/tsc` inside it.
+//
+// The install is chased to its real directory before the second hop, because
+// Node resolves a module's own dependencies from its real location. pnpm keeps
+// the real `typescript` directory in its content-addressed store with the
+// platform package beside it and leaves a link in the project's node_modules,
+// so a walk that started at the link would climb straight past the platform
+// package. NTFS junctions defeat filepath.EvalSymlinks, so the link component
+// is chased by hand first, the same order stripLoaderTempBase uses.
+func stripTsgoBinaryFrom(anchor string) string {
+  manifest := stripNodePackageManifestFrom(anchor, "typescript")
+  if manifest == "" {
+    return ""
+  }
+  packageDir := stripRealpathIfPossible(stripResolveDirLink(filepath.Dir(manifest)))
+  platform, arch := stripNodePlatformPair()
+  platformManifest := stripNodePackageManifestFrom(
+    filepath.Join(packageDir, "package.json"),
+    "@typescript/typescript-"+platform+"-"+arch,
+  )
+  if platformManifest == "" {
+    return ""
+  }
+  name := "tsc"
+  if runtime.GOOS == "windows" {
+    name = "tsc.exe"
+  }
+  binary := filepath.Join(filepath.Dir(platformManifest), "lib", name)
+  if stat, err := os.Stat(binary); err != nil || stat.IsDir() {
+    return ""
+  }
+  return binary
+}
+
+// stripResolveTtsxLauncher returns the launcher stripTtsxCommandContext spawns.
+//
+// An explicit TTSC_TTSX_BINARY wins. Otherwise the launcher is derived from the
+// `ttsc` installation one of the anchors can see, because a bare command name
+// only works when a bin link happens to be on PATH — which it is for a global
+// install and is not for the ordinary project-local one. The bare `"ttsx"` name
+// remains the unchanged last resort for an installation no anchor reaches.
+func stripResolveTtsxLauncher(anchors []string) string {
+  if explicit := strings.TrimSpace(os.Getenv("TTSC_TTSX_BINARY")); explicit != "" {
+    return explicit
+  }
+  for _, anchor := range anchors {
+    if launcher := stripTtsxLauncherFrom(anchor); launcher != "" {
+      return launcher
+    }
+  }
+  return "ttsx"
+}
+
+// stripTtsxLauncherFrom returns `lib/launcher/ttsx.js` of the `ttsc` install
+// `anchor` can see, or "" when this anchor reaches no such install. Only the
+// manifest is an exported subpath, so the launcher is derived from where the
+// manifest resolved rather than requested as a subpath of its own.
+func stripTtsxLauncherFrom(anchor string) string {
+  manifest := stripNodePackageManifestFrom(anchor, "ttsc")
+  if manifest == "" {
+    return ""
+  }
+  launcher := filepath.Join(filepath.Dir(manifest), "lib", "launcher", "ttsx.js")
+  if stat, err := os.Stat(launcher); err != nil || stat.IsDir() {
+    return ""
+  }
+  return launcher
+}
+
+// stripNodePackageManifestFrom resolves `<pkg>/package.json` the way Node's
+// require.resolve does from the FILE `anchor`: walk upward from the anchor's
+// directory and return the first `<dir>/node_modules/<pkg>/package.json` that
+// exists. The anchor is treated as a file path, so its own directory is the
+// first candidate's parent, and it need not exist — Node derives the search
+// paths from the string alone.
+//
+// A directory already named `node_modules` contributes no candidate of its own,
+// matching Module._nodeModulePaths, so nothing ever resolves through
+// `node_modules/node_modules`.
+//
+// A relative anchor is resolved against the process directory before the walk,
+// again matching Node. Walking a relative path instead would terminate at "."
+// after one step and silently answer nothing for a config named relatively.
+func stripNodePackageManifestFrom(anchor, pkg string) string {
+  if strings.TrimSpace(anchor) == "" || pkg == "" {
+    return ""
+  }
+  if absolute, err := filepath.Abs(anchor); err == nil {
+    anchor = absolute
+  }
+  dir := filepath.Dir(filepath.Clean(anchor))
+  for {
+    if filepath.Base(dir) != "node_modules" {
+      candidate := filepath.Join(dir, "node_modules", filepath.FromSlash(pkg), "package.json")
+      if stat, err := os.Stat(candidate); err == nil && !stat.IsDir() {
+        return candidate
+      }
+    }
+    parent := filepath.Dir(dir)
+    if parent == dir {
+      return ""
+    }
+    dir = parent
+  }
+}
+
+// stripNodePlatformPair is stripNodePlatformPairFor applied to this build's own
+// target.
+func stripNodePlatformPair() (string, string) {
+  return stripNodePlatformPairFor(runtime.GOOS, runtime.GOARCH)
+}
+
+// stripNodePlatformPairFor maps a Go build target onto the `process.platform`
+// and `process.arch` pair npm spells a platform package with, so the package
+// name this plugin resolves is the same one the JS launcher resolves.
+//
+// Only the members whose two vocabularies disagree are mapped. Every other
+// value is identical on both sides and passes through, which keeps a target
+// neither side publishes yet resolvable rather than silently wrong, and keeps
+// this from becoming a list that has to grow with every new port.
+func stripNodePlatformPairFor(goos, goarch string) (string, string) {
+  platform := goos
+  switch platform {
+  case "windows":
+    platform = "win32"
+  case "solaris":
+    platform = "sunos"
+  }
+  arch := goarch
+  switch arch {
+  case "amd64":
+    arch = "x64"
+  case "386":
+    arch = "ia32"
+  case "ppc64le":
+    arch = "ppc64"
+  }
+  return platform, arch
+}
+
 // stripTtsxCommandContext returns an exec.Cmd that runs ttsx with the given
 // arguments, routing through node when the resolved binary is a script file.
-func stripTtsxCommandContext(ctx context.Context, args ...string) *exec.Cmd {
-  ttsx := os.Getenv("TTSC_TTSX_BINARY")
-  if ttsx == "" {
-    ttsx = "ttsx"
-  }
+//
+// `anchors` are the file paths the launcher is resolved from; see
+// stripResolveTtsxLauncher.
+func stripTtsxCommandContext(ctx context.Context, anchors []string, args ...string) *exec.Cmd {
+  ttsx := stripResolveTtsxLauncher(anchors)
   if stripShouldRunThroughNode(ttsx) {
     node := os.Getenv("TTSC_NODE_BINARY")
     if node == "" {
@@ -673,3 +924,5 @@ func loaderFailureReason(output []byte) string {
   }
   return strings.TrimSpace(envelope.Message)
 }
+
+// ttsc:config-loader-shared end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/strip",
-  "version": "0.26.1",
+  "version": "0.26.2",
   "description": "First-party ttsc plugin that removes configured calls and statements from emitted JavaScript.",
   "main": "src/index.cjs",
   "types": "src/index.d.ts",