ttsc 0.8.1 → 0.10.0

package/utility/host.go

@@ -5,6 +5,7 @@ import (
   "flag"
   "fmt"
   "os"
+  "os/exec"
   "path/filepath"
   "sort"
   "strings"
@@ -12,6 +13,7 @@ import (
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
   shimcore "github.com/microsoft/typescript-go/shim/core"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
 
   "github.com/samchon/ttsc/packages/ttsc/driver"
 )
@@ -43,6 +45,22 @@ type transformResult struct {
   TypeScript  map[string]string `json:"typescript"`
 }
 
+// RunCheck validates the project and first-party utility plugin configuration
+// without emitting output.
+func RunCheck(args []string) int {
+  opts, ok := parseHostOptions("check", args)
+  if !ok {
+    return 2
+  }
+  opts.noEmit = true
+  prog, _, _, _, ok := loadUtilityProgram(opts)
+  if !ok {
+    return 2
+  }
+  defer prog.Close()
+  return 0
+}
+
 // RunBuild hosts first-party utility transform plugins inside one compiler emit.
 func RunBuild(args []string) int {
   opts, ok := parseHostOptions("build", args)
@@ -76,6 +94,9 @@ func RunBuild(args []string) int {
   for _, d := range eDiags {
     fmt.Fprintln(os.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))
   }
@@ -88,14 +109,19 @@ func RunTransform(args []string) int {
   if !ok {
     return 2
   }
-  prog, _, _, _, ok := loadUtilityProgram(opts)
+  prog, _, _, sourcePreamble, ok := loadUtilityProgram(opts)
   if !ok {
     return 2
   }
   defer prog.Close()
+  printer := shimprinter.NewPrinter(shimprinter.PrinterOptions{}, shimprinter.PrintHandlers{}, nil)
   out := transformResult{TypeScript: map[string]string{}}
   for _, file := range prog.SourceFiles() {
-    out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = file.Text()
+    text := shimprinter.EmitSourceFile(printer, file)
+    if sourcePreamble != "" && !shouldRemoveComments(prog) && !strings.Contains(text, sourcePreamble) {
+      text = driver.ApplySourcePreamble(text, sourcePreamble)
+    }
+    out.TypeScript[apiOutputKey(opts.cwd, file.FileName())] = text
   }
   data, err := json.Marshal(out)
   if err != nil {
@@ -117,7 +143,11 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
   quiet := fs.Bool("quiet", true, "suppress summary")
   tsconfig := fs.String("tsconfig", "tsconfig.json", "project tsconfig")
   verbose := fs.Bool("verbose", false, "print summary")
-  if err := fs.Parse(args); err != nil {
+  if err := fs.Parse(filterHostArgs(args)); err != nil {
+    return hostOptions{}, false
+  }
+  if *emit && *noEmit {
+    fmt.Fprintln(os.Stderr, "ttsc utility: --emit and --noEmit are mutually exclusive")
     return hostOptions{}, false
   }
   resolvedCwd := *cwd
@@ -149,13 +179,57 @@ func parseHostOptions(command string, args []string) (hostOptions, bool) {
   }, true
 }
 
+func filterHostArgs(args []string) []string {
+  known := map[string]bool{
+    "cwd":          true,
+    "emit":         false,
+    "noEmit":       false,
+    "outDir":       true,
+    "plugins-json": true,
+    "quiet":        false,
+    "tsconfig":     true,
+    "verbose":      false,
+  }
+  filtered := make([]string, 0, len(args))
+  for i := 0; i < len(args); i++ {
+    current := args[i]
+    if current == "--" {
+      break
+    }
+    if !strings.HasPrefix(current, "--") {
+      filtered = append(filtered, current)
+      continue
+    }
+    name, hasInlineValue := flagName(current)
+    takesValue, ok := known[name]
+    if ok {
+      filtered = append(filtered, current)
+      if takesValue && !hasInlineValue && i+1 < len(args) {
+        i++
+        filtered = append(filtered, args[i])
+      }
+      continue
+    }
+    if !hasInlineValue && i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
+      i++
+    }
+  }
+  return filtered
+}
+
+func flagName(arg string) (string, bool) {
+  name := strings.TrimPrefix(arg, "--")
+  before, _, found := strings.Cut(name, "=")
+  return before, found
+}
+
 func loadUtilityProgram(opts hostOptions) (*driver.Program, []pluginEntry, transformState, string, bool) {
   entries, err := parsePluginEntries(opts.pluginsJSON)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, nil, transformState{}, "", false
   }
-  sourcePreamble, err := prepareSourcePreamble(entries)
+  sourcePreamble, err := prepareSourcePreamble(entries, opts.cwd, opts.tsconfig)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
     return nil, nil, transformState{}, "", false
@@ -172,19 +246,25 @@ func loadUtilityProgram(opts hostOptions) (*driver.Program, []pluginEntry, trans
   }
   if len(diags) > 0 {
     driver.WritePrettyDiagnostics(os.Stderr, diags, opts.cwd)
+    if prog != nil {
+      _ = prog.Close()
+    }
     return nil, nil, transformState{}, "", false
   }
   if diags := prog.Diagnostics(); len(diags) > 0 {
     driver.WritePrettyDiagnostics(os.Stderr, diags, opts.cwd)
+    _ = prog.Close()
     return nil, nil, transformState{}, "", false
   }
   state, err := prepareTransforms(prog, entries)
   if err != nil {
     fmt.Fprintln(os.Stderr, err)
+    _ = prog.Close()
     return nil, nil, transformState{}, "", false
   }
   if err := applySourceTransforms(prog, state); err != nil {
     fmt.Fprintln(os.Stderr, err)
+    _ = prog.Close()
     return nil, nil, transformState{}, "", false
   }
   return prog, entries, state, sourcePreamble, true
@@ -218,13 +298,13 @@ func prepareTransforms(prog *driver.Program, entries []pluginEntry) (transformSt
   return state, nil
 }
 
-func prepareSourcePreamble(entries []pluginEntry) (string, error) {
+func prepareSourcePreamble(entries []pluginEntry, cwd, tsconfigPath string) (string, error) {
   var preamble strings.Builder
   for _, entry := range entries {
     if entry.Name != "@ttsc/banner" {
       continue
     }
-    banner, err := parseBanner(entry.Config)
+    banner, err := parseBanner(entry.Config, cwd, tsconfigPath)
     if err != nil {
       return "", err
     }
@@ -239,7 +319,7 @@ func makeSourcePreambleWriteFile(prog *driver.Program, sourcePreamble string) sh
   }
   return func(fileName, text string, _ *shimcompiler.WriteFileData) error {
     if shouldEnsureSourcePreamble(fileName, text, sourcePreamble) {
-      text = sourcePreamble + text
+      text = driver.ApplySourcePreamble(text, sourcePreamble)
     }
     return driver.DefaultWriteFile(fileName, text)
   }
@@ -280,20 +360,20 @@ func applySourceTransforms(prog *driver.Program, state transformState) error {
 
 func apiOutputKey(cwd, fileName string) string {
   rel, err := filepath.Rel(cwd, fileName)
-  if err != nil || strings.HasPrefix(rel, "..") {
+  if err != nil || isOutsideRelativePath(rel) {
     return filepath.ToSlash(fileName)
   }
   return filepath.ToSlash(rel)
 }
 
-func parseBanner(config map[string]any) (string, error) {
-  raw, ok := config["banner"]
-  if !ok {
-    return "", fmt.Errorf("@ttsc/banner: \"banner\" must be a non-empty string")
-  }
-  text, ok := raw.(string)
-  if !ok || strings.TrimSpace(text) == "" {
-    return "", fmt.Errorf("@ttsc/banner: \"banner\" must be a non-empty string")
+func isOutsideRelativePath(rel string) bool {
+  return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
+}
+
+func parseBanner(config map[string]any, cwd, tsconfigPath string) (string, error) {
+  text, err := resolveBannerText(config, cwd, tsconfigPath)
+  if err != nil {
+    return "", err
   }
   lines := strings.Split(strings.ReplaceAll(text, "\r\n", "\n"), "\n")
   for len(lines) > 0 && strings.TrimSpace(lines[len(lines)-1]) == "" {
@@ -316,6 +396,437 @@ func parseBanner(config map[string]any) (string, error) {
   return b.String(), nil
 }
 
+func resolveBannerText(config map[string]any, cwd, tsconfigPath string) (string, error) {
+  if text, ok, err := bannerTextFromConfigValue(config["text"], `"text"`); ok || err != nil {
+    return text, err
+  }
+  if rawConfigPath, ok := config["config"]; ok {
+    configPath, ok := rawConfigPath.(string)
+    if !ok || strings.TrimSpace(configPath) == "" {
+      return "", fmt.Errorf("@ttsc/banner: \"config\" must be a non-empty string path")
+    }
+    location := resolveBannerConfigPath(configPath, cwd, tsconfigPath)
+    raw, err := loadBannerConfigFile(location)
+    if err != nil {
+      return "", err
+    }
+    text, ok, err := bannerTextFromConfigValue(raw, filepath.Base(location))
+    if err != nil {
+      return "", err
+    }
+    if !ok {
+      return "", fmt.Errorf("@ttsc/banner: %s must export a non-empty string or an object with a non-empty \"text\" string", location)
+    }
+    return text, nil
+  }
+  location, err := findBannerConfigFile(cwd, tsconfigPath)
+  if err != nil {
+    return "", err
+  }
+  if location == "" {
+    return "", fmt.Errorf("@ttsc/banner: \"text\" must be a non-empty string or a banner.config.{js,cjs,mjs,ts,mts,cts} file must exist")
+  }
+  raw, err := loadBannerConfigFile(location)
+  if err != nil {
+    return "", err
+  }
+  text, ok, err := bannerTextFromConfigValue(raw, filepath.Base(location))
+  if err != nil {
+    return "", err
+  }
+  if !ok {
+    return "", fmt.Errorf("@ttsc/banner: %s must export a non-empty string or an object with a non-empty \"text\" string", location)
+  }
+  return text, nil
+}
+
+func bannerTextFromConfigValue(raw any, label string) (string, bool, error) {
+  if raw == nil {
+    return "", false, nil
+  }
+  text, ok := raw.(string)
+  if ok {
+    if strings.TrimSpace(text) == "" {
+      return "", true, fmt.Errorf("@ttsc/banner: %s must be a non-empty string", label)
+    }
+    return text, true, nil
+  }
+  object, ok := raw.(map[string]any)
+  if !ok {
+    return "", true, fmt.Errorf("@ttsc/banner: %s must be a string or an object with a non-empty \"text\" string", label)
+  }
+  rawText, ok := object["text"]
+  if !ok {
+    return "", false, nil
+  }
+  text, ok = rawText.(string)
+  if !ok || strings.TrimSpace(text) == "" {
+    return "", true, fmt.Errorf("@ttsc/banner: %s.text must be a non-empty string", label)
+  }
+  return text, true, nil
+}
+
+func findBannerConfigFile(cwd, tsconfigPath string) (string, error) {
+  dir := discoveryConfigBaseDir(cwd, tsconfigPath)
+  for {
+    matches := make([]string, 0, 1)
+    for _, name := range []string{
+      "banner.config.js",
+      "banner.config.cjs",
+      "banner.config.mjs",
+      "banner.config.ts",
+      "banner.config.cts",
+      "banner.config.mts",
+    } {
+      candidate := filepath.Join(dir, name)
+      if stat, err := os.Stat(candidate); err == nil && !stat.IsDir() {
+        matches = append(matches, candidate)
+      }
+    }
+    if len(matches) > 1 {
+      return "", fmt.Errorf("@ttsc/banner: multiple banner.config.* files found in %s", dir)
+    }
+    if len(matches) == 1 {
+      return matches[0], nil
+    }
+    parent := filepath.Dir(dir)
+    if parent == dir {
+      return "", nil
+    }
+    dir = parent
+  }
+}
+
+func resolveBannerConfigPath(configPath, cwd, tsconfigPath string) string {
+  if filepath.IsAbs(configPath) {
+    return configPath
+  }
+  return filepath.Join(tsconfigBaseDir(cwd, tsconfigPath), configPath)
+}
+
+func tsconfigBaseDir(cwd, tsconfigPath string) string {
+  if tsconfigPath == "" {
+    return cwd
+  }
+  resolvedTsconfig := tsconfigPath
+  if !filepath.IsAbs(resolvedTsconfig) {
+    resolvedTsconfig = filepath.Join(cwd, resolvedTsconfig)
+  }
+  return filepath.Dir(resolvedTsconfig)
+}
+
+func discoveryConfigBaseDir(cwd, tsconfigPath string) string {
+  if tsconfigPath != "" {
+    resolvedTsconfig := tsconfigPath
+    if !filepath.IsAbs(resolvedTsconfig) {
+      resolvedTsconfig = filepath.Join(cwd, resolvedTsconfig)
+    }
+    return filepath.Dir(resolvedTsconfig)
+  }
+  return cwd
+}
+
+func loadBannerConfigFile(location string) (any, error) {
+  if !isBannerConfigFileName(filepath.Base(location)) {
+    return nil, fmt.Errorf("@ttsc/banner: config file must be named banner.config.{js,cjs,mjs,ts,mts,cts}: %s", location)
+  }
+  ext := strings.ToLower(filepath.Ext(location))
+  switch ext {
+  case ".js", ".cjs", ".mjs":
+    return loadBannerScriptConfigFile(location)
+  case ".ts", ".cts", ".mts":
+    return loadBannerTypeScriptConfigFile(location)
+  default:
+    return nil, fmt.Errorf("@ttsc/banner: unsupported config file extension %q for %s", ext, location)
+  }
+}
+
+func isBannerConfigFileName(name string) bool {
+  switch name {
+  case "banner.config.js",
+    "banner.config.cjs",
+    "banner.config.mjs",
+    "banner.config.ts",
+    "banner.config.cts",
+    "banner.config.mts":
+    return true
+  default:
+    return false
+  }
+}
+
+func loadBannerScriptConfigFile(location string) (any, error) {
+  const script = `
+const { pathToFileURL } = require("node:url");
+
+(async () => {
+  const mod = await import(pathToFileURL(process.argv[1]).href);
+  const candidate = Object.prototype.hasOwnProperty.call(mod, "default") ? mod.default : mod;
+  const value = typeof candidate === "function" ? await candidate() : candidate;
+  process.stdout.write(JSON.stringify(toSerializableBanner(value)));
+})().catch((error) => {
+  process.stderr.write(error && error.stack ? error.stack : String(error));
+  process.exit(1);
+});
+
+function toSerializableBanner(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value !== null && typeof value === "object" && typeof value.text === "string") {
+    return { text: value.text };
+  }
+  throw new Error("config file must export a string or an object with a text string");
+}
+`
+  node := os.Getenv("TTSC_NODE_BINARY")
+  if node == "" {
+    node = "node"
+  }
+  cmd := exec.Command(node, "-e", script, location)
+  cmd.Env = nodeConfigLoaderEnv(location)
+  output, err := cmd.Output()
+  if err != nil {
+    stderr := ""
+    if exit, ok := err.(*exec.ExitError); ok {
+      stderr = strings.TrimSpace(string(exit.Stderr))
+    }
+    if stderr != "" {
+      return nil, fmt.Errorf("@ttsc/banner: load config file %s: %s", location, stderr)
+    }
+    return nil, fmt.Errorf("@ttsc/banner: load config file %s: %w", location, err)
+  }
+  var out any
+  if err := json.Unmarshal(output, &out); err != nil {
+    return nil, fmt.Errorf("@ttsc/banner: parse config file %s output: %w", location, err)
+  }
+  return out, nil
+}
+
+func loadBannerTypeScriptConfigFile(location string) (any, error) {
+  tempDir, err := os.MkdirTemp("", "ttsc-banner-config-")
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/banner: create config loader tempdir: %w", err)
+  }
+  defer os.RemoveAll(tempDir)
+
+  if err := linkNearestNodeModules(tempDir, filepath.Dir(location)); err != nil {
+    return nil, err
+  }
+
+  loader := filepath.Join(tempDir, "loader.mts")
+  tsconfig := filepath.Join(tempDir, "tsconfig.json")
+  importSpecifier, err := relativeImportSpecifier(tempDir, location)
+  if err != nil {
+    return nil, err
+  }
+  importLiteral, err := json.Marshal(importSpecifier)
+  if err != nil {
+    return nil, fmt.Errorf("@ttsc/banner: encode config import %s: %w", location, err)
+  }
+  if err := os.WriteFile(loader, []byte(bannerTypeScriptConfigLoaderSource(string(importLiteral))), 0o644); err != nil {
+    return nil, fmt.Errorf("@ttsc/banner: write config loader: %w", err)
+  }
+  if err := os.WriteFile(tsconfig, []byte(typeScriptConfigLoaderTsconfig(loader, location, tempDir)), 0o644); err != nil {
+    return nil, fmt.Errorf("@ttsc/banner: write config loader tsconfig: %w", err)
+  }
+
+  args := []string{
+    "--project", tsconfig,
+    "--cwd", tempDir,
+    "--cache-dir", filepath.Join(tempDir, "cache"),
+  }
+  if tsgo := os.Getenv("TTSC_TSGO_BINARY"); tsgo != "" {
+    args = append(args, "--binary", tsgo)
+  }
+  args = append(args, loader)
+
+  cmd := ttsxCommand(args...)
+  cmd.Env = nodeConfigLoaderEnv(location)
+  output, err := cmd.Output()
+  if err != nil {
+    stderr := ""
+    if exit, ok := err.(*exec.ExitError); ok {
+      stderr = strings.TrimSpace(string(exit.Stderr))
+    }
+    if stderr != "" {
+      return nil, fmt.Errorf("@ttsc/banner: load TypeScript config file %s: %s", location, stderr)
+    }
+    return nil, fmt.Errorf("@ttsc/banner: load TypeScript config file %s: %w", location, err)
+  }
+  var out any
+  if err := json.Unmarshal(output, &out); err != nil {
+    return nil, fmt.Errorf("@ttsc/banner: parse TypeScript config file %s output: %w", location, err)
+  }
+  return out, nil
+}
+
+func relativeImportSpecifier(fromDir, location string) (string, error) {
+  relative, err := filepath.Rel(fromDir, location)
+  if err != nil {
+    return "", fmt.Errorf("@ttsc/banner: resolve relative config import %s: %w", location, err)
+  }
+  relative = filepath.ToSlash(relative)
+  if strings.HasPrefix(relative, "../") || strings.HasPrefix(relative, "./") {
+    return relative, nil
+  }
+  return "./" + relative, nil
+}
+
+func bannerTypeScriptConfigLoaderSource(importLiteral string) string {
+  return fmt.Sprintf(`import * as importedConfig from %s;
+
+declare const process: {
+  stdout: { write(value: string): void };
+  stderr: { write(value: string): void };
+  exit(code?: number): never;
+};
+
+try {
+  const value = await resolveConfig(importedConfig);
+  process.stdout.write(JSON.stringify(toSerializableBanner(value)));
+} catch (error) {
+  process.stderr.write(error instanceof Error && error.stack ? error.stack : String(error));
+  process.exit(1);
+}
+
+async function resolveConfig(value: unknown): Promise<unknown> {
+  let current = value;
+  for (let i = 0; i < 8; i++) {
+    if (isObject(current) && hasOwn(current, "default")) {
+      current = current.default;
+      continue;
+    }
+    break;
+  }
+  if (typeof current === "function") {
+    return await (current as () => unknown | Promise<unknown>)();
+  }
+  return current;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object";
+}
+
+function hasOwn(value: Record<string, unknown>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function toSerializableBanner(value: unknown): unknown {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (isObject(value) && typeof value.text === "string") {
+    return { text: value.text };
+  }
+  throw new Error("config file must export a string or an object with a text string");
+}
+`, importLiteral)
+}
+
+func typeScriptConfigLoaderTsconfig(loader, location, outDir string) string {
+  content := map[string]any{
+    "compilerOptions": map[string]any{
+      "allowImportingTsExtensions":      true,
+      "module":                          "ESNext",
+      "moduleResolution":                "bundler",
+      "outDir":                          filepath.ToSlash(filepath.Join(outDir, "out")),
+      "rewriteRelativeImportExtensions": true,
+      "rootDir":                         "/",
+      "skipLibCheck":                    true,
+      "strict":                          true,
+      "target":                          "ES2022",
+    },
+    "files": []string{
+      filepath.ToSlash(loader),
+      filepath.ToSlash(location),
+    },
+  }
+  body, err := json.MarshalIndent(content, "", "  ")
+  if err != nil {
+    panic(err)
+  }
+  return string(body)
+}
+
+func ttsxCommand(args ...string) *exec.Cmd {
+  ttsx := os.Getenv("TTSC_TTSX_BINARY")
+  if ttsx == "" {
+    ttsx = "ttsx"
+  }
+  if shouldRunTtsxThroughNode(ttsx) {
+    node := os.Getenv("TTSC_NODE_BINARY")
+    if node == "" {
+      node = "node"
+    }
+    return exec.Command(node, append([]string{ttsx}, args...)...)
+  }
+  return exec.Command(ttsx, args...)
+}
+
+func shouldRunTtsxThroughNode(binary string) bool {
+  switch strings.ToLower(filepath.Ext(binary)) {
+  case ".js", ".cjs", ".mjs", ".ts", ".cts", ".mts":
+    return true
+  default:
+    return false
+  }
+}
+
+func nodeConfigLoaderEnv(location string) []string {
+  env := os.Environ()
+  parts := make([]string, 0, 2)
+  if nodeModules := findNearestNodeModules(filepath.Dir(location)); nodeModules != "" {
+    parts = append(parts, nodeModules)
+  }
+  if existing := os.Getenv("NODE_PATH"); existing != "" {
+    parts = append(parts, existing)
+  }
+  if len(parts) == 0 {
+    return env
+  }
+  return setEnv(env, "NODE_PATH", strings.Join(parts, string(os.PathListSeparator)))
+}
+
+func linkNearestNodeModules(tempDir, sourceDir string) error {
+  nodeModules := findNearestNodeModules(sourceDir)
+  if nodeModules == "" {
+    return nil
+  }
+  link := filepath.Join(tempDir, "node_modules")
+  if err := os.Symlink(nodeModules, link); err != nil {
+    return fmt.Errorf("@ttsc/banner: link config node_modules %s: %w", nodeModules, err)
+  }
+  return nil
+}
+
+func findNearestNodeModules(start string) string {
+  dir := filepath.Clean(start)
+  for {
+    candidate := filepath.Join(dir, "node_modules")
+    if stat, err := os.Stat(candidate); err == nil && stat.IsDir() {
+      return candidate
+    }
+    parent := filepath.Dir(dir)
+    if parent == dir {
+      return ""
+    }
+    dir = parent
+  }
+}
+
+func setEnv(env []string, key, value string) []string {
+  prefix := key + "="
+  for i, entry := range env {
+    if strings.HasPrefix(entry, prefix) {
+      env[i] = prefix + value
+      return env
+    }
+  }
+  return append(env, prefix+value)
+}
+
 func sanitizeJSDocLine(line string) string {
   return strings.ReplaceAll(line, "*/", "* /")
 }
@@ -402,9 +913,14 @@ func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
     if arg != nil && arg.Kind == shimast.KindLiteralType {
       visit(arg.AsLiteralTypeNode().Literal)
     }
+  case shimast.KindModuleDeclaration:
+    decl := node.AsModuleDeclaration()
+    if decl != nil {
+      visit(decl.Name())
+    }
   case shimast.KindCallExpression:
     call := node.AsCallExpression()
-    if call.Expression != nil && call.Expression.Kind == shimast.KindImportKeyword && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
+    if isModuleSpecifierCall(call) && call.Arguments != nil && len(call.Arguments.Nodes) > 0 {
       visit(call.Arguments.Nodes[0])
     }
   }
@@ -414,6 +930,20 @@ func visitModuleSpecifiers(node *shimast.Node, visit func(*shimast.Node)) {
   })
 }
 
+func isModuleSpecifierCall(call *shimast.CallExpression) bool {
+  if call == nil || call.Expression == nil {
+    return false
+  }
+  switch call.Expression.Kind {
+  case shimast.KindImportKeyword:
+    return true
+  case shimast.KindIdentifier:
+    return call.Expression.Text() == "require"
+  default:
+    return false
+  }
+}
+
 func (r *pathsRewriter) rewrite(fromSource string, specifier string) (string, bool) {
   if specifier == "" || strings.HasPrefix(specifier, ".") || strings.HasPrefix(specifier, "/") {
     return specifier, false
@@ -468,6 +998,11 @@ func (r *pathsRewriter) lookupSource(candidate string) (string, bool) {
       return source, true
     }
   }
+  for _, ext := range []string{".ts", ".tsx", ".mts", ".cts"} {
+    if source, ok := r.sourceFiles[normalizePath(filepath.Join(stem, "index"+ext))]; ok {
+      return source, true
+    }
+  }
   return "", false
 }
 
@@ -476,10 +1011,21 @@ func (r *pathsRewriter) outputPathForSource(source string) string {
     return ""
   }
   rel, err := filepath.Rel(r.rootDir, source)
-  if err != nil || strings.HasPrefix(rel, "..") {
+  if err != nil || isOutsideRelativePath(rel) {
     return ""
   }
-  return normalizePath(filepath.Join(r.outDir, replaceSourceExtension(rel, ".js")))
+  return normalizePath(filepath.Join(r.outDir, replaceSourceExtension(rel, emittedJavaScriptExtension(rel))))
+}
+
+func emittedJavaScriptExtension(source string) string {
+  switch strings.ToLower(filepath.Ext(source)) {
+  case ".mts":
+    return ".mjs"
+  case ".cts":
+    return ".cjs"
+  default:
+    return ".js"
+  }
 }
 
 func matchPattern(pattern string, specifier string) (string, bool) {
@@ -557,6 +1103,14 @@ type callPattern struct {
 }
 
 func parseStrip(config map[string]any) (*stripRewriter, error) {
+  _, hasCalls := config["calls"]
+  _, hasStatements := config["statements"]
+  if !hasCalls && !hasStatements {
+    config = map[string]any{
+      "calls":      []any{"console.log", "console.debug", "assert.*"},
+      "statements": []any{"debugger"},
+    }
+  }
   calls, err := stringArrayConfig(config, "calls")
   if err != nil {
     return nil, fmt.Errorf("@ttsc/strip: %w", err)
@@ -595,7 +1149,7 @@ func filterStatements(list *shimast.NodeList, strip *stripRewriter) {
   if list == nil || len(list.Nodes) == 0 {
     return
   }
-  out := list.Nodes[:0]
+  out := make([]*shimast.Node, 0, len(list.Nodes))
   for _, stmt := range list.Nodes {
     if shouldStripStatement(stmt, strip) {
       continue
@@ -610,6 +1164,7 @@ func filterChildStatements(node *shimast.Node, strip *stripRewriter) {
   if node == nil {
     return
   }
+  filterEmbeddedStatements(node, strip)
   if node.CanHaveStatements() {
     filterStatements(node.StatementList(), strip)
   }
@@ -619,6 +1174,53 @@ func filterChildStatements(node *shimast.Node, strip *stripRewriter) {
   })
 }
 
+func filterEmbeddedStatements(node *shimast.Node, strip *stripRewriter) {
+  switch node.Kind {
+  case shimast.KindIfStatement:
+    stmt := node.AsIfStatement()
+    stmt.ThenStatement = filterEmbeddedStatement(stmt.ThenStatement, strip)
+    stmt.ElseStatement = filterEmbeddedStatement(stmt.ElseStatement, strip)
+  case shimast.KindDoStatement:
+    stmt := node.AsDoStatement()
+    stmt.Statement = filterEmbeddedStatement(stmt.Statement, strip)
+  case shimast.KindWhileStatement:
+    stmt := node.AsWhileStatement()
+    stmt.Statement = filterEmbeddedStatement(stmt.Statement, strip)
+  case shimast.KindForStatement:
+    stmt := node.AsForStatement()
+    stmt.Statement = filterEmbeddedStatement(stmt.Statement, strip)
+  case shimast.KindForInStatement, shimast.KindForOfStatement:
+    stmt := node.AsForInOrOfStatement()
+    stmt.Statement = filterEmbeddedStatement(stmt.Statement, strip)
+  case shimast.KindWithStatement:
+    stmt := node.AsWithStatement()
+    stmt.Statement = filterEmbeddedStatement(stmt.Statement, strip)
+  case shimast.KindLabeledStatement:
+    stmt := node.AsLabeledStatement()
+    stmt.Statement = filterEmbeddedStatement(stmt.Statement, strip)
+  }
+}
+
+func filterEmbeddedStatement(stmt *shimast.Statement, strip *stripRewriter) *shimast.Statement {
+  if stmt == nil {
+    return nil
+  }
+  if shouldStripStatement(stmt, strip) {
+    return emptyStatement(stmt)
+  }
+  filterChildStatements(stmt, strip)
+  return stmt
+}
+
+func emptyStatement(original *shimast.Node) *shimast.Statement {
+  empty := shimast.NewNodeFactory(shimast.NodeFactoryHooks{}).NewEmptyStatement()
+  empty.Flags |= shimast.NodeFlagsSynthesized
+  if original != nil {
+    empty.Loc = original.Loc
+  }
+  return empty
+}
+
 func shouldStripStatement(node *shimast.Node, strip *stripRewriter) bool {
   if node == nil {
     return false