samchon
diff --git a/‎.github/workflows/test.yml‎
Lines changed: 9 additions & 2 deletions b/‎.github/workflows/test.yml‎
Lines changed: 9 additions & 2 deletions
diff --git a/‎packages/banner/driver/banner.go‎
Lines changed: 74 additions & 2 deletions b/‎packages/banner/driver/banner.go‎
Lines changed: 74 additions & 2 deletions
diff --git a/‎packages/banner/test/config_loader_temp_base_stays_on_config_volume_test.go‎
Lines changed: 111 additions & 0 deletions b/‎packages/banner/test/config_loader_temp_base_stays_on_config_volume_test.go‎
Lines changed: 111 additions & 0 deletions
diff --git a/‎packages/banner/test/helpers_test.go‎
Lines changed: 37 additions & 0 deletions b/‎packages/banner/test/helpers_test.go‎
Lines changed: 37 additions & 0 deletions
diff --git a/‎packages/banner/test/linkname_helpers_test.go‎
Lines changed: 3 additions & 0 deletions b/‎packages/banner/test/linkname_helpers_test.go‎
Lines changed: 3 additions & 0 deletions
diff --git a/‎packages/banner/test/node_environment_helpers_test.go‎
Lines changed: 10 additions & 3 deletions b/‎packages/banner/test/node_environment_helpers_test.go‎
Lines changed: 10 additions & 3 deletions
diff --git a/‎packages/banner/test/resolve_banner_text_branches_test.go‎
Lines changed: 1 addition & 1 deletion b/‎packages/banner/test/resolve_banner_text_branches_test.go‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎packages/banner/test/script_config_loader_test.go‎
Lines changed: 3 additions & 3 deletions b/‎packages/banner/test/script_config_loader_test.go‎
Lines changed: 3 additions & 3 deletions
@@ -20,12 +20,18 @@ concurrency:
 jobs:
   test:
     name: ${{ matrix.name }}
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os || 'ubuntu-latest' }}
     strategy:
       fail-fast: false
       matrix:
         include:
           - { name: go, run: "pnpm run test:go && pnpm --filter ttsc go:vet" }
+          # Minimal Windows safety net: the Go unit suites cover the
+          # platform-sensitive layers (config loaders, path handling) without
+          # the e2e runner, which is POSIX-only. Only the ttsx launcher build
+          # is needed (test-go-lint drives real ttsx), so the full
+          # build:current is skipped.
+          - { name: windows-go, os: windows-latest, build: "pnpm --filter ttsc build", run: "pnpm run test:go" }
           - { name: shim-audit, run: "pnpm --filter ttsc shim:audit:test && pnpm --filter ttsc shim:audit" }
           - { name: typecheck, run: "pnpm run check:flags && pnpm run test:typecheck" }
           - { name: banner, run: "pnpm --filter @ttsc/test-banner start" }
@@ -61,10 +67,11 @@ jobs:
         run: pnpm install --frozen-lockfile
 
       - name: Use System Go For Source Plugin Tests
+        shell: bash
         run: echo "TTSC_GO_BINARY=$(go env GOROOT)/bin/go" >> "$GITHUB_ENV"
 
       - name: Build Current Platform
-        run: pnpm run build:current
+        run: ${{ matrix.build || 'pnpm run build:current' }}
 
       - name: Run ${{ matrix.name }}
         run: ${{ matrix.run }}
@@ -364,7 +364,7 @@ function toSerializableBanner(value) {
 // build runs with `--no-plugins` so evaluating the config never triggers the
 // host project's transform/check plugins against the loader tsconfig.
 func loadBannerTypeScriptConfigFile(location string) (any, error) {
-  tempDir, err := os.MkdirTemp("", "ttsc-banner-config-")
+  tempDir, err := os.MkdirTemp(loaderTempBase(location, os.TempDir()), "ttsc-banner-config-")
   if err != nil {
     return nil, fmt.Errorf("@ttsc/banner: create config loader tempdir: %w", err)
   }
@@ -507,7 +507,7 @@ func typeScriptConfigLoaderTsconfig(loader, location, outDir string) string {
       "moduleResolution":                "bundler",
       "outDir":                          filepath.ToSlash(filepath.Join(outDir, "out")),
       "rewriteRelativeImportExtensions": true,
-      "rootDir":                         "/",
+      "rootDir":                         loaderRootDir(outDir),
       "skipLibCheck":                    true,
       "strict":                          true,
       "target":                          "ES2022",
@@ -521,6 +521,78 @@ func typeScriptConfigLoaderTsconfig(loader, location, outDir string) string {
   return string(body)
 }
 
+// loaderRootDir returns the widest rootDir that still contains the loader
+// tsconfig's inputs: the volume root of the loader temp dir (`C:/` on
+// Windows, `/` elsewhere). A literal "/" is not an ancestor of drive-letter
+// paths, so tsgo rejects every input with TS6059 (#299, #304). The temp dir
+// is created on the same volume as the config file (see loaderTempBase), so
+// its volume root spans both `files` entries.
+func loaderRootDir(outDir string) string {
+  vol := filepath.VolumeName(outDir)
+  if vol == "" {
+    return "/"
+  }
+  return filepath.ToSlash(vol + `\`)
+}
+
+// loaderTempBase picks the parent directory for the ephemeral config-loader
+// tree. The system temp dir is the default, but when it sits on a different
+// volume than the config file (Windows: TEMP on `C:`, project on `D:`) the
+// loader cannot work from there — no single tsconfig rootDir spans two
+// volumes and filepath.Rel cannot produce a relative import across drives
+// (#305) — so the tree is created under the config's nearest
+// node_modules/.cache instead, falling back to the config's own directory
+// when no node_modules exists (or its .cache cannot be created): any location
+// on the config's volume beats the system temp dir, which is guaranteed to
+// fail. Returns "" (the os.MkdirTemp default) when the volumes already match.
+func loaderTempBase(location, systemTemp string) string {
+  // A relative location has no volume; "" must not be read as "a volume
+  // other than the system temp's" — it keeps the historical default (and
+  // the Rel-failure contract for relative config paths).
+  vol := filepath.VolumeName(location)
+  if vol == "" || strings.EqualFold(filepath.VolumeName(systemTemp), vol) {
+    return ""
+  }
+  nodeModules := findNearestNodeModules(filepath.Dir(location))
+  if nodeModules == "" {
+    return filepath.Dir(location)
+  }
+  // Resolve a linked node_modules (junction/symlink — common in managed
+  // setups) before descending into it: the ESM runtime realpaths the loader
+  // module at import time, and a relative config specifier computed from the
+  // link-form path would resolve against the wrong directory. NTFS junctions
+  // defeat filepath.EvalSymlinks, so the link component is chased by hand
+  // first. Realpathing may also land on another volume, which defeats the
+  // whole point — fall back to the config's directory then.
+  base := filepath.Join(resolveDirLink(nodeModules), ".cache")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    return filepath.Dir(location)
+  }
+  real, err := filepath.EvalSymlinks(base)
+  if err != nil || !strings.EqualFold(filepath.VolumeName(real), filepath.VolumeName(location)) {
+    return filepath.Dir(location)
+  }
+  return real
+}
+
+// resolveDirLink chases a directory that is itself a symlink or NTFS junction
+// to its target (bounded against link cycles). os.Readlink is the probe:
+// it resolves junctions, which report neither ModeSymlink nor an
+// EvalSymlinks-traversable path.
+func resolveDirLink(dir string) string {
+  for i := 0; i < 8; i++ {
+    target, err := os.Readlink(dir)
+    if err != nil {
+      return dir
+    }
+    if !filepath.IsAbs(target) {
+      target = filepath.Join(filepath.Dir(dir), target)
+    }
+    dir = target
+  }
+  return dir
+}
+
 // ttsxCommand builds an exec.Cmd that runs ttsx with the given args.
 // When TTSC_TTSX_BINARY has a script extension (.js, .ts, …) the binary is
 // invoked via the Node runtime so it is executed correctly on all platforms.
 
@@ -0,0 +1,111 @@
+package banner_test
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "strings"
+  "testing"
+)
+
+// TestConfigLoaderTempBaseStaysOnConfigVolume verifies the config-loader
+// temp-dir base follows the config file's volume.
+//
+// When the system temp dir shares the config's volume, the historical default
+// ("" — os.MkdirTemp's system temp) must be kept. When it does not
+// (drive-letter platforms: TEMP on C:, project on D:), the loader must move
+// under the config's nearest node_modules/.cache — a cross-volume loader can
+// neither express a tsconfig rootDir spanning both inputs nor a relative
+// import of the config (#305).
+//
+//  1. Materialize a config next to a node_modules directory.
+//  2. Same-volume systemTemp → expect the "" default.
+//  3. Fake a systemTemp on another volume (drive-letter platforms only) →
+//     expect node_modules/.cache on the config's volume, created on disk.
+//  4. Block node_modules/.cache with a file → expect the config's directory.
+//  5. No node_modules at all → expect the config's directory.
+//  6. A junction node_modules → expect the realpath of its .cache (the ESM
+//     runtime realpaths the loader at import time, so a link-form base breaks
+//     the relative config import).
+func TestConfigLoaderTempBaseStaysOnConfigVolume(t *testing.T) {
+  root := t.TempDir()
+  if err := os.MkdirAll(filepath.Join(root, "node_modules"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  config := filepath.Join(root, "banner.config.ts")
+  if base := bannerLoaderTempBase(config, root); base != "" {
+    t.Fatalf("same-volume base mismatch: %q", base)
+  }
+  // A relative location has no volume and must keep the historical default,
+  // not be mistaken for a cross-volume config.
+  if base := bannerLoaderTempBase("banner.config.ts", root); base != "" {
+    t.Fatalf("relative-location base mismatch: %q", base)
+  }
+  fake := `Z:\ttsc-fake-temp`
+  if strings.EqualFold(filepath.VolumeName(root), "Z:") {
+    fake = `Y:\ttsc-fake-temp`
+  }
+  if filepath.VolumeName(fake) == "" {
+    // No volume concept on this platform; the cross-volume branch is
+    // unreachable by construction.
+    return
+  }
+  base := bannerLoaderTempBase(config, fake)
+  // Normalize the expectation the same way the helper normalizes its result:
+  // EvalSymlinks also expands 8.3 short names (CI runners hand out a
+  // RUNNER~1-style TEMP), so a raw Join of the fixture root won't compare
+  // equal even though both name the same directory.
+  crossWant, crossErr := filepath.EvalSymlinks(filepath.Join(root, "node_modules", ".cache"))
+  if crossErr != nil {
+    t.Fatal(crossErr)
+  }
+  if base != crossWant {
+    t.Fatalf("cross-volume base mismatch: %q != %q", base, crossWant)
+  }
+  if stat, err := os.Stat(base); err != nil || !stat.IsDir() {
+    t.Fatalf("cross-volume base was not created: %v", err)
+  }
+  // A file squatting on node_modules/.cache blocks the cache dir; the
+  // config's own directory is still on the right volume, unlike the system
+  // temp dir which is guaranteed to fail.
+  blockedRoot := t.TempDir()
+  if err := os.MkdirAll(filepath.Join(blockedRoot, "node_modules"), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(filepath.Join(blockedRoot, "node_modules", ".cache"), nil, 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if base := bannerLoaderTempBase(filepath.Join(blockedRoot, "banner.config.ts"), fake); base != blockedRoot {
+    t.Fatalf("blocked-cache base mismatch: %q != %q", base, blockedRoot)
+  }
+  // Same fallback without any node_modules. Guarded: a stray node_modules
+  // above the test temp dir would legitimately route to its .cache.
+  bare := t.TempDir()
+  if bannerFindNearestNodeModules(bare) == "" {
+    if base := bannerLoaderTempBase(filepath.Join(bare, "banner.config.ts"), fake); base != bare {
+      t.Fatalf("no-node_modules base mismatch: %q != %q", base, bare)
+    }
+  }
+  // Junction node_modules (privilege-free on Windows, and this section only
+  // runs on drive-letter platforms).
+  linkedRoot := t.TempDir()
+  realModules := filepath.Join(linkedRoot, "real-modules")
+  project := filepath.Join(linkedRoot, "project")
+  for _, dir := range []string{realModules, project} {
+    if err := os.MkdirAll(dir, 0o755); err != nil {
+      t.Fatal(err)
+    }
+  }
+  junction := filepath.Join(project, "node_modules")
+  if out, err := exec.Command("cmd", "/c", "mklink", "/J", junction, realModules).CombinedOutput(); err != nil {
+    t.Fatalf("mklink /J failed: %v: %s", err, out)
+  }
+  base = bannerLoaderTempBase(filepath.Join(project, "banner.config.ts"), fake)
+  want, err := filepath.EvalSymlinks(filepath.Join(realModules, ".cache"))
+  if err != nil {
+    t.Fatal(err)
+  }
+  if base != want {
+    t.Fatalf("junction base mismatch: %q != %q", base, want)
+  }
+}
@@ -139,6 +139,43 @@ func writeExecutable(t *testing.T, file string, contents string) string {
   return file
 }
 
+// writeDirectLauncher writes a fake launcher that prints fixed bytes and
+// exits. POSIX gets a `#!/bin/sh` script; Windows cannot spawn an
+// extensionless shell script, so it gets the equivalent `.cmd` batch file and
+// the returned path carries that extension. Both stay OFF the script-extension
+// list, preserving the direct-exec (not node-routed) classification under
+// test. Payloads must avoid cmd metacharacters (%, ^, &, |, <, >) — batch has
+// no way to quote them that sh's single quotes would mirror.
+func writeDirectLauncher(t *testing.T, file, stdout, stderr string, exitCode int) string {
+  t.Helper()
+  var b strings.Builder
+  if runtime.GOOS == "windows" {
+    b.WriteString("@echo off\r\n")
+    if stdout != "" {
+      b.WriteString("echo " + stdout + "\r\n")
+    }
+    if stderr != "" {
+      // The redirect goes up front: a trailing `1>&2` would emit "x ", and
+      // a bare `>&2` glued to a payload ending in a digit would turn that
+      // digit into a file-descriptor redirect.
+      b.WriteString("1>&2 echo " + stderr + "\r\n")
+    }
+    b.WriteString("exit /b " + strconv.Itoa(exitCode) + "\r\n")
+    return writeExecutable(t, file+".cmd", b.String())
+  }
+  b.WriteString("#!/bin/sh\n")
+  if stdout != "" {
+    b.WriteString("printf '" + stdout + "'\n")
+  }
+  if stderr != "" {
+    b.WriteString("printf '" + stderr + "' >&2\n")
+  }
+  if exitCode != 0 {
+    b.WriteString("exit " + strconv.Itoa(exitCode) + "\n")
+  }
+  return writeExecutable(t, file, b.String())
+}
+
 // bannerManifest builds the plugin manifest shape that ttsc passes to native
 // plugins through --plugins-json. It writes a temporary banner.config.cjs file
 // in dir exporting an object with a "text" string and returns a manifest that
 
@@ -57,6 +57,9 @@ func bannerTypeScriptConfigLoaderSource(importLiteral string) string
 //go:linkname bannerTypeScriptConfigLoaderTsconfig github.com/samchon/ttsc/packages/banner/driver.typeScriptConfigLoaderTsconfig
 func bannerTypeScriptConfigLoaderTsconfig(loader, location, outDir string) string
 
+//go:linkname bannerLoaderTempBase github.com/samchon/ttsc/packages/banner/driver.loaderTempBase
+func bannerLoaderTempBase(location, systemTemp string) string
+
 //go:linkname bannerTtsxCommand github.com/samchon/ttsc/packages/banner/driver.ttsxCommand
 func bannerTtsxCommand(args ...string) *exec.Cmd
 
 
@@ -29,7 +29,10 @@ func TestNodeEnvironmentHelpers(t *testing.T) {
   if got := bannerFindNearestNodeModules(nested); got != nodeModules {
     t.Fatalf("nearest node_modules mismatch: %q", got)
   }
-  if got := bannerFindNearestNodeModules(filepath.Join(root, "without-modules")); got != "" {
+  // Hermetic: a stray node_modules above the test temp dir (developer
+  // machines have them at drive roots) is a legitimate discovery — only a
+  // hit inside the fixture would be a bug.
+  if got := bannerFindNearestNodeModules(filepath.Join(root, "without-modules")); got != "" && strings.HasPrefix(got, root) {
     t.Fatalf("unexpected node_modules discovery: %q", got)
   }
 
@@ -59,8 +62,12 @@ func TestNodeEnvironmentHelpers(t *testing.T) {
     t.Fatalf("append env mismatch: %#v", appended)
   }
 
-  if err := bannerLinkNearestNodeModules(filepath.Join(root, "no-link"), filepath.Join(root, "without-modules")); err != nil {
-    t.Fatalf("no node_modules link should be a no-op: %v", err)
+  // Hermetic for the same reason as above: with a stray ancestor
+  // node_modules the call is a real link attempt, not a no-op.
+  if bannerFindNearestNodeModules(filepath.Join(root, "without-modules")) == "" {
+    if err := bannerLinkNearestNodeModules(filepath.Join(root, "no-link"), filepath.Join(root, "without-modules")); err != nil {
+      t.Fatalf("no node_modules link should be a no-op: %v", err)
+    }
   }
   if runtime.GOOS == "windows" {
     t.Skip("symlink creation is privilege-dependent on Windows")
 
@@ -77,7 +77,7 @@ func TestResolveBannerTextBranches(t *testing.T) {
     t.Fatalf("expected explicit empty-text export error, got %v", err)
   }
 
-  fakeTtsx := writeExecutable(t, filepath.Join(root, "fake-ttsx"), "#!/bin/sh\nprintf '{}'\n")
+  fakeTtsx := writeDirectLauncher(t, filepath.Join(root, "fake-ttsx"), "{}", "", 0)
   t.Setenv("TTSC_TTSX_BINARY", fakeTtsx)
   noTextTS := filepath.Join(project, "ts", "banner.config.ts")
   writeFile(t, noTextTS, `export default {};`)
 
@@ -49,19 +49,19 @@ func TestScriptConfigLoader(t *testing.T) {
     t.Fatalf("expected invalid export error, got %v", err)
   }
 
-  invalidJSONNode := writeExecutable(t, filepath.Join(root, "fake-node-invalid-json"), "#!/bin/sh\nprintf 'not-json'\n")
+  invalidJSONNode := writeDirectLauncher(t, filepath.Join(root, "fake-node-invalid-json"), "not-json", "", 0)
   t.Setenv("TTSC_NODE_BINARY", invalidJSONNode)
   if _, err := bannerLoadBannerScriptConfigFile(cjs); err == nil || !strings.Contains(err.Error(), "parse config file") {
     t.Fatalf("expected invalid stdout error, got %v", err)
   }
 
-  stderrNode := writeExecutable(t, filepath.Join(root, "fake-node-stderr"), "#!/bin/sh\nprintf 'loader failed' >&2\nexit 7\n")
+  stderrNode := writeDirectLauncher(t, filepath.Join(root, "fake-node-stderr"), "", "loader failed", 7)
   t.Setenv("TTSC_NODE_BINARY", stderrNode)
   if _, err := bannerLoadBannerScriptConfigFile(cjs); err == nil || !strings.Contains(err.Error(), "loader failed") {
     t.Fatalf("expected stderr error, got %v", err)
   }
 
-  silentNode := writeExecutable(t, filepath.Join(root, "fake-node-silent"), "#!/bin/sh\nexit 7\n")
+  silentNode := writeDirectLauncher(t, filepath.Join(root, "fake-node-silent"), "", "", 7)
   t.Setenv("TTSC_NODE_BINARY", silentNode)
   if _, err := bannerLoadBannerScriptConfigFile(cjs); err == nil || !strings.Contains(err.Error(), "exit status") {
     t.Fatalf("expected silent exit error, got %v", err)
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,10 @@ func TestNodeEnvironmentHelpers(t *testing.T) {`
`29`	`29`	`if got := bannerFindNearestNodeModules(nested); got != nodeModules {`
`30`	`30`	`t.Fatalf("nearest node_modules mismatch: %q", got)`
`31`	`31`	`}`
`32`		`- if got := bannerFindNearestNodeModules(filepath.Join(root, "without-modules")); got != "" {`
	`32`	`+ // Hermetic: a stray node_modules above the test temp dir (developer`
	`33`	`+ // machines have them at drive roots) is a legitimate discovery — only a`
	`34`	`+ // hit inside the fixture would be a bug.`
	`35`	`+ if got := bannerFindNearestNodeModules(filepath.Join(root, "without-modules")); got != "" && strings.HasPrefix(got, root) {`
`33`	`36`	`t.Fatalf("unexpected node_modules discovery: %q", got)`
`34`	`37`	`}`
`35`	`38`
`@@ -59,8 +62,12 @@ func TestNodeEnvironmentHelpers(t *testing.T) {`
`59`	`62`	`t.Fatalf("append env mismatch: %#v", appended)`
`60`	`63`	`}`
`61`	`64`
`62`		`- if err := bannerLinkNearestNodeModules(filepath.Join(root, "no-link"), filepath.Join(root, "without-modules")); err != nil {`
`63`		`- t.Fatalf("no node_modules link should be a no-op: %v", err)`
	`65`	`+ // Hermetic for the same reason as above: with a stray ancestor`
	`66`	`+ // node_modules the call is a real link attempt, not a no-op.`
	`67`	`+ if bannerFindNearestNodeModules(filepath.Join(root, "without-modules")) == "" {`
	`68`	`+ if err := bannerLinkNearestNodeModules(filepath.Join(root, "no-link"), filepath.Join(root, "without-modules")); err != nil {`
	`69`	`+ t.Fatalf("no node_modules link should be a no-op: %v", err)`
	`70`	`+ }`
`64`	`71`	`}`
`65`	`72`	`if runtime.GOOS == "windows" {`
`66`	`73`	`t.Skip("symlink creation is privilege-dependent on Windows")`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ func TestResolveBannerTextBranches(t *testing.T) {`
`77`	`77`	`t.Fatalf("expected explicit empty-text export error, got %v", err)`
`78`	`78`	`}`
`79`	`79`
`80`		`- fakeTtsx := writeExecutable(t, filepath.Join(root, "fake-ttsx"), "#!/bin/sh\nprintf '{}'\n")`
	`80`	`+ fakeTtsx := writeDirectLauncher(t, filepath.Join(root, "fake-ttsx"), "{}", "", 0)`
`81`	`81`	`t.Setenv("TTSC_TTSX_BINARY", fakeTtsx)`
`82`	`82`	`noTextTS := filepath.Join(project, "ts", "banner.config.ts")`
`83`	`83`	writeFile(t, noTextTS, `export default {};`)