ttsc 0.26.2 → 0.28.0

package/README.md

@@ -30,6 +30,15 @@ npx ttsc --watch        # rebuild on save
 
 `ttsx` runs a file the way `tsx` or `ts-node` does, but it type-checks the whole project first, so a type error stops the run before anything executes.
 
+Preload the same checked runtime when Node or a test runner owns the process:
+
+```bash
+node --require ttsc/register src/index.ts
+mocha --require ttsc/register --extension ts,tsx "test/**/*.ts"
+```
+
+`ttsc/register` discovers the nearest `tsconfig.json` for each TypeScript root, applies its plugins, and refuses to execute when the project does not type-check.
+
 That covers the CLI. The integrations each have a short guide:
 
 - [`@ttsc/unplugin`](https://ttsc.dev/docs/setup/unplugin): Vite, Rollup, Rolldown, esbuild, webpack, Rspack, Next.js, Turbopack, Farm, and Bun.

package/cmd/graphbench/main.go

@@ -29,10 +29,16 @@ type metrics struct {
   Nodes         int            `json:"nodes"`
   ExternalNodes int            `json:"externalNodes"`
   Edges         map[string]int `json:"edges"`
-  TotalEdges    int            `json:"totalEdges"`
-  SymbolFiles   int            `json:"symbolFiles"`
-  CoveredFiles  int            `json:"coveredFiles"`
-  Coverage      float64        `json:"coverage"`
+  // EdgeVocabulary names which of the three edge-kind vocabularies Edges is
+  // keyed by, so a reader comparing these numbers against a dump does not
+  // compare the wrong things. Build produces *internal* kinds; a dump carries
+  // finer *wire* kinds (value-call splits into calls/instantiates/renders);
+  // the viewer folds wire kinds onto *display* families.
+  EdgeVocabulary string  `json:"edgeVocabulary"`
+  TotalEdges     int     `json:"totalEdges"`
+  SymbolFiles    int     `json:"symbolFiles"`
+  CoveredFiles   int     `json:"coveredFiles"`
+  Coverage       float64 `json:"coverage"`
 }
 
 func main() {
@@ -82,10 +88,13 @@ func run() int {
 // counts, edges per kind, and fair coverage (workspace files holding at least one
 // node that an edge connects to a node in another file).
 func summarize(g *graph.Graph, sourceFiles int) metrics {
-  edges := map[string]int{
-    string(graph.EdgeHeritage):  0,
-    string(graph.EdgeValueCall): 0,
-    string(graph.EdgeTypeRef):   0,
+  // Seeded with every kind Build can produce, so a family that happened not to
+  // occur reports 0 rather than vanishing from the object. Three of the seven
+  // used to be seeded and the map grew the rest on first sight, which meant the
+  // reported shape depended on the project measured.
+  edges := map[string]int{}
+  for _, kind := range graph.EdgeKinds() {
+    edges[string(kind)] = 0
   }
   for _, edge := range g.Edges {
     edges[string(edge.Kind)]++
@@ -123,13 +132,14 @@ func summarize(g *graph.Graph, sourceFiles int) metrics {
   }
 
   return metrics{
-    SourceFiles:   sourceFiles,
-    Nodes:         len(g.Nodes),
-    ExternalNodes: external,
-    Edges:         edges,
-    TotalEdges:    len(g.Edges),
-    SymbolFiles:   len(symbolFiles),
-    CoveredFiles:  len(coveredFiles),
-    Coverage:      coverage,
+    SourceFiles:    sourceFiles,
+    Nodes:          len(g.Nodes),
+    ExternalNodes:  external,
+    Edges:          edges,
+    EdgeVocabulary: "internal",
+    TotalEdges:     len(g.Edges),
+    SymbolFiles:    len(symbolFiles),
+    CoveredFiles:   len(coveredFiles),
+    Coverage:       coverage,
   }
 }

package/cmd/graphdump/main.go

@@ -6,8 +6,10 @@
 package main
 
 import (
+  "errors"
   "flag"
   "fmt"
+  "io"
   "os"
   "path/filepath"
 
@@ -17,18 +19,37 @@ import (
   "github.com/samchon/ttsc/packages/ttsc/internal/graph"
 )
 
+// Package-level streams so command tests can capture I/O without patching the
+// os globals, and argv arrives as a parameter for the same reason. Both mirror
+// the shipped sibling in cmd/ttscgraph, whose capability claim is tested the
+// same way; this command's claim went undefended because it had neither seam.
+var (
+  stdout io.Writer = os.Stdout
+  stderr io.Writer = os.Stderr
+)
+
 func main() {
-  os.Exit(run())
+  os.Exit(run(os.Args[1:]))
 }
 
-func run() int {
-  cwd := flag.String("cwd", ".", "project root")
-  tsconfig := flag.String("tsconfig", "tsconfig.json", "tsconfig path, relative to cwd")
-  pretty := flag.Bool("pretty", false, "indent the JSON output")
-  flag.Parse()
+func run(args []string) int {
+  fs := flag.NewFlagSet("graphdump", flag.ContinueOnError)
+  fs.SetOutput(stderr)
+  cwd := fs.String("cwd", ".", "project root")
+  tsconfig := fs.String("tsconfig", "tsconfig.json", "tsconfig path, relative to cwd")
+  pretty := fs.Bool("pretty", false, "indent the JSON output")
+  if err := fs.Parse(args); err != nil {
+    // `-h` asks for the usage this just printed, so it is a request that
+    // succeeded rather than an argument that failed. Under the global flag set
+    // this command used to read, `ExitOnError` already exited 0 for it.
+    if errors.Is(err, flag.ErrHelp) {
+      return 0
+    }
+    return 2
+  }
 
   // Resolve the project root the same way LoadProgram does (absolute, then
-  // tsgo-normalized) so the schema-v6 mapper receives the same canonical root
+  // tsgo-normalized) so the dump path mapper receives the same canonical root
   // grammar and drive-letter case as the compiler's source paths.
   root := *cwd
   if abs, err := filepath.Abs(root); err == nil {
@@ -38,11 +59,11 @@ func run() int {
 
   prog, _, err := driver.LoadProgram(root, *tsconfig, driver.LoadProgramOptions{})
   if err != nil {
-    fmt.Fprintf(os.Stderr, "graphdump: could not load %s/%s: %v\n", root, *tsconfig, err)
+    fmt.Fprintf(stderr, "graphdump: could not load %s/%s: %v\n", root, *tsconfig, err)
     return 1
   }
   if prog == nil {
-    fmt.Fprintf(os.Stderr, "graphdump: could not load %s/%s\n", root, *tsconfig)
+    fmt.Fprintf(stderr, "graphdump: could not load %s/%s\n", root, *tsconfig)
     return 1
   }
   defer func() { _ = prog.Close() }()
@@ -62,7 +83,11 @@ func run() int {
       // No version: this tool is built from the tree on demand and never
       // stamped, and an invented one would be worse than an absent one.
       graph.Producer{Tool: "graphdump", Typescript: graph.TypescriptVersion()},
-      []string{graph.CapabilitySourceDigests},
+      // The declaration walk is the shipped one, so this dump carries every
+      // documentation tag and must say so: under the capability contract an
+      // absent claim means the producer never looked, which would make a
+      // consumer read a tagged declaration as citing nothing.
+      []string{graph.CapabilitySourceDigests, graph.CapabilityDocTags},
       nil,
       nil,
       texts,
@@ -70,9 +95,9 @@ func run() int {
     ),
   }, *pretty)
   if err != nil {
-    fmt.Fprintf(os.Stderr, "graphdump: %v\n", err)
+    fmt.Fprintf(stderr, "graphdump: %v\n", err)
     return 1
   }
-  fmt.Println(string(data))
+  fmt.Fprintln(stdout, string(data))
   return 0
 }

package/cmd/graphdump/run_declares_the_capability_its_output_carries_test.go

@@ -0,0 +1,137 @@
+package main
+
+import (
+  "bytes"
+  "encoding/json"
+  "os"
+  "path/filepath"
+  "slices"
+  "strings"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+)
+
+// TestRunDeclaresTheCapabilityItsOutputCarries verifies that every capability
+// this command declares is paired with the output that backs it, and that a
+// project carrying no documentation tag emits that field nowhere.
+//
+// The claim is a separate literal from the shipped `ttscgraph dump`'s, so the
+// test that guards that one guards nothing here: deleting graph.CapabilityDocTags
+// from this command's list used to break nothing at all, in a package that had
+// never had a test file. The claim matters because the two states a consumer must
+// distinguish — "this declaration cites nothing" and "this producer never
+// looked" — are the same absent field, so a dump that carries tags and forgets to
+// say so is read as a repository where nothing cites anything.
+//
+// The declared set is compared whole rather than member by member, so a
+// capability added to the list arrives with the evidence for it or fails here.
+//
+//  1. Run the command over a project with a tag, capturing stdout.
+//  2. Assert the declared set is exactly what this command claims, and that each
+//     claim is backed: a tag in the output, and a digested source.
+//  3. Run it over a project with no tag and assert the field appears nowhere,
+//     while both claims still do.
+func TestRunDeclaresTheCapabilityItsOutputCarries(t *testing.T) {
+  tagged := runGraphdump(t, `/** @evidence docs/a.md#x Cited. */
+export function subject(): void {}
+`)
+  untagged := runGraphdump(t, `/** Ordinary documentation. */
+export function subject(): void {}
+`)
+
+  declared := []string{graph.CapabilityDocTags, graph.CapabilitySourceDigests}
+  slices.Sort(declared)
+  for name, raw := range map[string]string{"tagged": tagged, "untagged": untagged} {
+    var parsed struct {
+      Provenance struct {
+        Capabilities []string `json:"capabilities"`
+        Sources      []struct {
+          File          string `json:"file"`
+          CheckerDigest string `json:"checkerDigest"`
+        } `json:"sources"`
+      } `json:"provenance"`
+    }
+    if err := json.Unmarshal([]byte(raw), &parsed); err != nil {
+      t.Fatalf("%s dump is not JSON: %v", name, err)
+    }
+    got := slices.Clone(parsed.Provenance.Capabilities)
+    slices.Sort(got)
+    if !slices.Equal(got, declared) {
+      t.Fatalf("%s dump declares %v, want %v; an absent claim means the producer "+
+        "never looked, so a tagged declaration reads as citing nothing and a "+
+        "digested source reads as unread",
+        name, got, declared)
+    }
+    // The sourceDigests claim, backed the same way the docTags claim is: a
+    // declared capability whose output carries nothing is the tautology this
+    // test exists to avoid.
+    digested := 0
+    for _, source := range parsed.Provenance.Sources {
+      if source.CheckerDigest != "" {
+        digested++
+      }
+    }
+    if digested == 0 {
+      t.Fatalf("%s dump declares %q over %d sources, none of which carries a checker digest",
+        name, graph.CapabilitySourceDigests, len(parsed.Provenance.Sources))
+    }
+  }
+
+  if !strings.Contains(tagged, `"docs/a.md#x Cited."`) {
+    t.Fatalf("the tagged dump carried no tag text")
+  }
+  // Read the raw document rather than a decoded slice: an absent field and an
+  // empty one decode identically, and absent is what the wire contract says. The
+  // key is matched with its colon, because the capability shares the name and
+  // rides the same document as a bare string.
+  if strings.Contains(untagged, `"docTags":`) {
+    t.Fatalf("the untagged dump carried a docTags field; it must be absent")
+  }
+  if !strings.Contains(tagged, `"docTags":`) {
+    t.Fatalf("the tagged dump carried no docTags field, so the check above proves nothing")
+  }
+}
+
+// runGraphdump runs the command over a one-file project and returns its stdout.
+//
+// It goes through run(args) and the package streams rather than through os.Args,
+// flag.CommandLine, and an os.Stdout pipe. Those seams exist on the shipped
+// sibling for this reason, and this command grew them so its own claim could be
+// asserted against its own output without patching process globals.
+func runGraphdump(t *testing.T, source string) string {
+  t.Helper()
+  root := t.TempDir()
+  writeGraphdumpFile(t, filepath.Join(root, "tsconfig.json"), `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "strict": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "files": ["src/main.ts"]
+}
+`)
+  writeGraphdumpFile(t, filepath.Join(root, "src", "main.ts"), source)
+
+  var out, errOut bytes.Buffer
+  restoreStdout, restoreStderr := stdout, stderr
+  stdout, stderr = &out, &errOut
+  defer func() { stdout, stderr = restoreStdout, restoreStderr }()
+
+  if code := run([]string{"--cwd", root, "--tsconfig", "tsconfig.json"}); code != 0 {
+    t.Fatalf("graphdump exited %d: %s", code, errOut.String())
+  }
+  return out.String()
+}
+
+func writeGraphdumpFile(t *testing.T, path, content string) {
+  t.Helper()
+  if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.WriteFile(path, []byte(content), 0o644); err != nil {
+    t.Fatal(err)
+  }
+}

package/cmd/graphdump/run_reports_an_unknown_flag_without_exiting_the_process_test.go

@@ -0,0 +1,56 @@
+package main
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestRunReportsAnUnknownFlagWithoutExitingTheProcess verifies that a bad
+// argument returns an exit code and writes usage to the command's own stream,
+// instead of terminating the process.
+//
+// This is the negative twin of the capability case and the reason the seams
+// exist. The command used to parse flag.CommandLine, whose default error
+// handling is flag.ExitOnError: a malformed argument called os.Exit(2) from
+// inside run, which no test can observe and which would take a test binary down
+// with it. Nothing else about the command is reachable while that is true.
+//
+//  1. Run the command with an unknown flag, capturing both streams.
+//  2. Assert it returns 2 rather than exiting, and that nothing reached stdout.
+//  3. Assert the usage text went to the command's stderr stream.
+//  4. Assert `-h` still succeeds, because asking for usage is not an error.
+func TestRunReportsAnUnknownFlagWithoutExitingTheProcess(t *testing.T) {
+  var out, errOut bytes.Buffer
+  restoreStdout, restoreStderr := stdout, stderr
+  stdout, stderr = &out, &errOut
+  defer func() { stdout, stderr = restoreStdout, restoreStderr }()
+
+  code := run([]string{"--not-a-flag"})
+
+  if code != 2 {
+    t.Fatalf("graphdump exited %d for an unknown flag, want 2", code)
+  }
+  if out.Len() != 0 {
+    t.Fatalf("a rejected invocation wrote %q to stdout; the viewer pipeline parses that stream as JSON", out.String())
+  }
+  if !strings.Contains(errOut.String(), "not-a-flag") {
+    t.Fatalf("stderr does not name the rejected flag: %q", errOut.String())
+  }
+  if !strings.Contains(errOut.String(), "-tsconfig") {
+    t.Fatalf("stderr carried no usage text: %q", errOut.String())
+  }
+
+  // The negative twin of the rejection: `flag.ContinueOnError` reports `-h` as
+  // an error too, and mapping every parse failure to 2 would turn the help flag
+  // into a failed invocation. The global flag set this command used to read
+  // exited 0 for it.
+  out.Reset()
+  errOut.Reset()
+  if code := run([]string{"-h"}); code != 0 {
+    t.Fatalf("graphdump exited %d for -h, want 0", code)
+  }
+  if !strings.Contains(errOut.String(), "-tsconfig") {
+    t.Fatalf("-h printed no usage text: %q", errOut.String())
+  }
+}

package/cmd/graphdump/run_reports_an_unloadable_project_without_printing_a_dump_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+  "bytes"
+  "strings"
+  "testing"
+)
+
+// TestRunReportsAnUnloadableProjectWithoutPrintingADump verifies that a project
+// the command cannot load exits non-zero, prints nothing to stdout, and names
+// what it could not load.
+//
+// The benchmark viewer pipeline runs this command through `execFileSync`, which
+// raises only on a non-zero exit and otherwise parses stdout as JSON. Every
+// failure path here therefore has to be a non-zero exit: turning one into 0
+// hands the pipeline an empty string, and the caller dies inside its JSON parse
+// with an opaque error instead of reading the diagnostic this command already
+// wrote. All three failure paths used to be unpinned, so replacing every
+// `return 1` with `return 0` broke no test.
+//
+//  1. Run the command against a tsconfig that does not exist.
+//  2. Assert it returns 1 and wrote nothing to stdout.
+//  3. Assert stderr names the command and the path it could not load.
+func TestRunReportsAnUnloadableProjectWithoutPrintingADump(t *testing.T) {
+  root := t.TempDir()
+
+  var out, errOut bytes.Buffer
+  restoreStdout, restoreStderr := stdout, stderr
+  stdout, stderr = &out, &errOut
+  defer func() { stdout, stderr = restoreStdout, restoreStderr }()
+
+  code := run([]string{"--cwd", root, "--tsconfig", "absent.json"})
+
+  if code != 1 {
+    t.Fatalf("graphdump exited %d for an unloadable project, want 1", code)
+  }
+  if out.Len() != 0 {
+    t.Fatalf("a failed run wrote %q to stdout; the viewer pipeline parses that stream as JSON", out.String())
+  }
+  if !strings.Contains(errOut.String(), "graphdump:") {
+    t.Fatalf("stderr does not identify the command: %q", errOut.String())
+  }
+  if !strings.Contains(errOut.String(), "absent.json") {
+    t.Fatalf("stderr does not name the tsconfig it could not load: %q", errOut.String())
+  }
+}

package/cmd/ttsc/api_transform.go

@@ -26,6 +26,18 @@ type apiTransformResult struct {
   // content can influence a transformed module, so bundler caches invalidate
   // soundly without per-plugin reporting.
   Graph *driver.TransformGraph `json:"graph,omitempty"`
+  // Dependencies and DependenciesComplete are the envelope's dependency side
+  // channel. This lane runs no plugin transform at all — each output is the
+  // file's own parsed text — so every file is complete with an empty list
+  // unless a linked plugin is active and declares otherwise; see
+  // driver.Program.TransformDependenciesFor.
+  Dependencies         map[string][]string `json:"dependencies,omitempty"`
+  DependenciesComplete []string            `json:"dependenciesComplete,omitempty"`
+  // HostInputs are absolute native plugin config files evaluated while this
+  // generation loaded. JavaScript hosts merge them with descriptor inputs.
+  HostInputs         []string           `json:"hostInputs,omitempty"`
+  HostInputHashes    map[string]*string `json:"hostInputHashes,omitempty"`
+  HostInputRealpaths map[string]*string `json:"hostInputRealpaths,omitempty"`
 }
 
 // runAPITransform implements the `api-transform` sub-command. It loads the
@@ -69,7 +81,11 @@ func runAPITransform(args []string) int {
     return 2
   }
   typescript := map[string]string{}
+  var dependencies driver.TransformDependencies
   var graph *driver.TransformGraph
+  var hostInputs []string
+  var hostInputHashes map[string]*string
+  var hostInputRealpaths map[string]*string
   if prog != nil {
     defer prog.Close()
     // Compute the reference graph before SourceFiles() runs linked plugin
@@ -81,12 +97,21 @@ func runAPITransform(args []string) int {
       typescript[apiOutputKey(cwd, file.FileName())] = file.Text()
     }
     diags = append(diags, prog.Diagnostics()...)
+    dependencies = prog.TransformDependenciesFor(cwd)
+    hostInputs = prog.PluginHostInputs()
+    hostInputHashes = prog.PluginHostInputHashes()
+    hostInputRealpaths = prog.PluginHostInputRealpaths()
   }
 
   result := apiTransformResult{
-    Diagnostics: make([]apiCompileDiagnostic, 0, len(diags)),
-    TypeScript:  typescript,
-    Graph:       graph,
+    Dependencies:         dependencies.Dependencies,
+    DependenciesComplete: dependencies.Complete,
+    Diagnostics:          make([]apiCompileDiagnostic, 0, len(diags)),
+    Graph:                graph,
+    HostInputs:           hostInputs,
+    HostInputHashes:      hostInputHashes,
+    HostInputRealpaths:   hostInputRealpaths,
+    TypeScript:           typescript,
   }
   for _, diag := range diags {
     result.Diagnostics = append(result.Diagnostics, toAPICompileDiagnostic(diag))

package/cmd/ttscgraph/auxiliary_identity_state_tracks_retargets_not_source_contents_test.go

@@ -0,0 +1,85 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "runtime"
+  "testing"
+)
+
+// TestAuxiliaryIdentityStateTracksRetargetsNotSourceContents proves the two
+// owners of a selected lexical module path stay separate:
+//
+//  1. ordinary source bytes are owned by graphSession.sourceHashes, so an
+//     identity-only auxiliary state must not turn their edit into a reload;
+//  2. retargeting the same lexical symlink or junction must invalidate even
+//     when the old and new target bytes agree.
+func TestAuxiliaryIdentityStateTracksRetargetsNotSourceContents(t *testing.T) {
+  root := t.TempDir()
+  first := filepath.Join(root, "first")
+  second := filepath.Join(root, "second")
+  if err := os.MkdirAll(first, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  if err := os.MkdirAll(second, 0o755); err != nil {
+    t.Fatal(err)
+  }
+  for _, directory := range []string{first, second} {
+    if err := os.WriteFile(filepath.Join(directory, "selection.ts"), []byte("export const value = 1;\n"), 0o644); err != nil {
+      t.Fatal(err)
+    }
+  }
+
+  link := filepath.Join(root, "linked")
+  createAuxiliaryDirectoryLink(t, first, link)
+  selected := filepath.Join(link, "selection.ts")
+  previous := captureDiskStates([]auxiliaryInput{{path: selected, identityOnly: true}})
+  initial := previous[selected]
+  if !initial.Exists || initial.Realpath == "" || !initial.IdentityOnly {
+    t.Fatalf("initial identity state = %+v", initial)
+  }
+
+  if err := os.WriteFile(filepath.Join(first, "selection.ts"), []byte("export const value = 2;\n"), 0o644); err != nil {
+    t.Fatal(err)
+  }
+  if diskStatesChanged(previous) {
+    t.Fatal("selected source contents leaked into identity-only auxiliary invalidation")
+  }
+
+  if err := os.Remove(link); err != nil {
+    t.Fatal(err)
+  }
+  createAuxiliaryDirectoryLink(t, second, link)
+  if !diskStatesChanged(previous) {
+    t.Fatal("same-byte lexical link retarget did not invalidate its physical identity")
+  }
+
+  merged := compactAuxiliaryInputs([]auxiliaryInput{
+    {path: selected, identityOnly: true},
+    {path: selected},
+  })
+  if len(merged) != 1 || merged[0].identityOnly {
+    t.Fatalf("content-sensitive duplicate did not win: %+v", merged)
+  }
+}
+
+func createAuxiliaryDirectoryLink(t *testing.T, target, link string) {
+  t.Helper()
+  if runtime.GOOS == "windows" {
+    command := exec.Command(
+      "node",
+      "-e",
+      `require("node:fs").symlinkSync(process.argv[1], process.argv[2], "junction")`,
+      target,
+      link,
+    )
+    if output, err := command.CombinedOutput(); err != nil {
+      t.Skipf("directory junction unavailable on this host: %v: %s", err, output)
+    }
+    return
+  }
+  if err := os.Symlink(target, link); err != nil {
+    t.Skipf("directory symlink unavailable on this host: %v", err)
+  }
+}

package/cmd/ttscgraph/disk_realpath_other.go

@@ -0,0 +1,16 @@
+//go:build !windows
+
+package main
+
+import "path/filepath"
+
+func diskRealpath(path string) string {
+  resolved, err := filepath.EvalSymlinks(path)
+  if err != nil {
+    return ""
+  }
+  if absolute, err := filepath.Abs(resolved); err == nil {
+    resolved = absolute
+  }
+  return filepath.Clean(resolved)
+}

package/cmd/ttscgraph/disk_realpath_windows.go

@@ -0,0 +1,56 @@
+//go:build windows
+
+package main
+
+import (
+  "path/filepath"
+  "strings"
+
+  "golang.org/x/sys/windows"
+)
+
+// diskRealpath asks the opened object for its final path. filepath.EvalSymlinks
+// can leave a readable file below a directory junction unresolved on Windows,
+// which would erase the physical identity this state exists to retain.
+func diskRealpath(path string) string {
+  pointer, err := windows.UTF16PtrFromString(path)
+  if err != nil {
+    return ""
+  }
+  handle, err := windows.CreateFile(
+    pointer,
+    windows.FILE_READ_ATTRIBUTES,
+    windows.FILE_SHARE_READ|windows.FILE_SHARE_WRITE|windows.FILE_SHARE_DELETE,
+    nil,
+    windows.OPEN_EXISTING,
+    windows.FILE_FLAG_BACKUP_SEMANTICS,
+    0,
+  )
+  if err != nil {
+    return ""
+  }
+  defer windows.CloseHandle(handle)
+
+  buffer := make([]uint16, windows.MAX_PATH)
+  for {
+    length, err := windows.GetFinalPathNameByHandle(
+      handle,
+      &buffer[0],
+      uint32(len(buffer)),
+      0,
+    )
+    if err != nil {
+      return ""
+    }
+    if length < uint32(len(buffer)) {
+      resolved := windows.UTF16ToString(buffer[:length])
+      if strings.HasPrefix(resolved, `\\?\UNC\`) {
+        resolved = `\\` + strings.TrimPrefix(resolved, `\\?\UNC\`)
+      } else {
+        resolved = strings.TrimPrefix(resolved, `\\?\`)
+      }
+      return filepath.Clean(resolved)
+    }
+    buffer = make([]uint16, length+1)
+  }
+}