@ttsc/wasm 0.11.0-dev.20260517

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeongho Nam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,125 @@
+# @ttsc/wasm
+
+> **API stability: experimental until v1.0.** Public signatures (`Plugin.Run`, the `host.Expose` argv shape, the JS `ITtscApi` surface, the linker-symbol contract below) may change between minor releases. Pin exact versions in production playgrounds.
+
+In-browser ttsc playground scaffolding. Compose ttsc + typescript-go with your own plugins by writing a single Go entry that calls `host.Expose(...)`, then boot it from JS with `bootTtsc(...)`.
+
+## What you get
+
+- A base `ttsc.wasm` (under `dist/`) that exposes vanilla `build` / `check` / `transform` — no plugins linked. Useful as a sanity test or a no-plugin baseline.
+- A Go helper package (`host/`) plugin authors import from their own `main_wasm.go` to bind a wasm to `globalThis[yourApiName]`.
+- A JS runtime (`bootTtsc`, `createMemFS`, typed `ITtscApi` surface) that loads any host-built wasm into a Web Worker.
+
+The package is plugin-agnostic. Downstream playgrounds (the ttsc.dev website, typia, anything else) build their own wasm against the same `host/` package.
+
+## Build your own playground in 30 lines
+
+1. Add the dependency:
+
+```bash
+npm install -D @ttsc/wasm
+```
+
+2. Create `your-pkg/cmd/your-wasm/main_wasm.go`:
+
+```go
+//go:build js && wasm
+
+package main
+
+import (
+  "github.com/samchon/ttsc/packages/wasm/host"
+  yourplugin "example.com/your/plugin"
+)
+
+func main() {
+  host.Expose("yourApi", host.Config{
+    Plugins: []host.Plugin{yourplugin.New()},
+  })
+}
+```
+
+The native sibling `main.go` is recommended so `go run ./cmd/your-wasm` exercises the same host helpers without the browser MemFS bridge — see `packages/wasm/cmd/ttsc-wasm/main.go` in the repo for a reference layout:
+
+```go
+//go:build !js
+
+package main
+
+import (
+  "os"
+
+  "github.com/samchon/ttsc/packages/wasm/host"
+)
+
+func main() {
+  os.Exit(host.Run(os.Args[1:]))
+}
+```
+
+3. Build the wasm:
+
+```bash
+GOOS=js GOARCH=wasm go build -trimpath -ldflags "-s -w" \
+  -o public/your.wasm ./cmd/your-wasm
+cp node_modules/@ttsc/wasm/dist/wasm_exec.js public/wasm_exec.js
+```
+
+### Stamping version metadata at link time
+
+The `host` package exposes a build-time variable contract you can override via `-ldflags "-X ..."`:
+
+```bash
+GOOS=js GOARCH=wasm go build -trimpath \
+  -ldflags "-s -w -X github.com/samchon/ttsc/packages/wasm/host.version=$(cat package.json | jq -r .version)" \
+  -o public/your.wasm ./cmd/your-wasm
+```
+
+The `version`, `commit`, and `date` variables in `host/host.go` are all overridable. `globalThis[apiName].version()` reads from them.
+
+4. Boot it from JS (a Web Worker is **required** — Go's `syscall/js` blocks the runtime while the wasm is alive; running on the main thread freezes the page):
+
+```ts
+import { bootTtsc } from "@ttsc/wasm";
+
+const { api, host } = await bootTtsc({
+  wasmUrl: "/your.wasm",
+  apiName: "yourApi",
+});
+
+host.writeFile("/work/tsconfig.json", '{"compilerOptions":{"strict":true}}');
+host.writeFile("/work/src/index.ts", "export const x: number = 1;");
+
+const result = await api.build({ cwd: "/work" });
+console.log(result.result); // JSON: { diagnostics, output }
+```
+
+Booting two wasms with the same `apiName` panics; pick a unique `apiName` per binary.
+
+## Plugin contract
+
+`host.Plugin` matches ttsc's existing CLI sidecar dispatch:
+
+```go
+type Plugin interface {
+  Name() string                            // e.g. "@ttsc/banner"
+  Run(command string, args []string) int   // returns CLI exit code
+}
+```
+
+The host installs `globalThis[apiName].plugin({ name, command, ...opts })` that translates the JS options object into a CLI-shaped argv and calls your plugin's `Run`. Your `Run` body can forward to the same function the native sidecar's `main.go` calls — for example `utility.RunBuild(args)` for plugins backed by `packages/ttsc/utility`.
+
+## Published-tarball Go module layout
+
+The published `@ttsc/wasm` tarball ships:
+
+- A rewritten root `go.mod` whose `replace` directives point at `./vendor/shim/*` (vendored at pack time from `packages/ttsc/shim/`).
+- The full `host/`, `cmd/`, `build/` Go source so consumers can `go build -tags '...'` their own wasm against your host helper.
+- `dist/ttsc.wasm` + `dist/wasm_exec.js` — the no-plugin sanity binary and the Go runtime loader.
+
+The tarball intentionally drops the `replace github.com/samchon/ttsc/packages/ttsc => ../ttsc` directive that the in-repo `go.mod` carries: consumers of the published module who want to rebuild the wasm must supply their own `replace` (or vendor `packages/ttsc` themselves). The published `dist/ttsc.wasm` is plug-and-play for runtime use; the Go module is for **plugin authors extending the host**, not for vanilla consumers.
+
+## Documents
+
+- The base wasm (`dist/ttsc.wasm`) is the binary `cmd/ttsc-wasm/main_wasm.go` produces. Look there for a minimal example.
+- Plugin authors should also read `docs/wasm-plugin.md` (TBD) for the Go host helper deep-dive.

package/build/build-wasm.cjs

@@ -0,0 +1,240 @@
+// Build the base `ttsc.wasm` and stage the matching `wasm_exec.js`.
+//
+// Usage: node build/build-wasm.cjs [--force]
+//
+// Behavior:
+//   * Skips the Go build when `dist/ttsc.wasm` is newer than every .go file
+//     under `packages/{ttsc,wasm}/`. Pass `--force` or set
+//     `TTSC_WASM_FORCE=1` to rebuild unconditionally.
+//   * Hard failure if the Go toolchain is missing.
+//
+// Outputs:
+//   * packages/wasm/dist/ttsc.wasm
+//   * packages/wasm/dist/wasm_exec.js
+//
+// Downstream consumers (the website, plugin-author playgrounds) point their
+// own bundle pipelines at `node_modules/@ttsc/wasm/dist/wasm_exec.js` and
+// build their own .wasm against the same Go module.
+
+const cp = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const repoRoot = path.resolve(packageRoot, "..", "..");
+const ttscDir = path.join(repoRoot, "packages", "ttsc");
+const shimSrc = path.join(ttscDir, "shim");
+const vendorDir = path.join(packageRoot, "vendor");
+const vendorShimDir = path.join(vendorDir, "shim");
+const outDir = path.join(packageRoot, "dist");
+const wasmOut = path.join(outDir, "ttsc.wasm");
+const wasmExecOut = path.join(outDir, "wasm_exec.js");
+const goModPath = path.join(packageRoot, "go.mod");
+const publishedGoModOut = path.join(outDir, "go.mod");
+const forceRebuild =
+  process.argv.includes("--force") || !!process.env.TTSC_WASM_FORCE;
+
+fs.mkdirSync(outDir, { recursive: true });
+
+function hasGoToolchain() {
+  try {
+    cp.execSync("go env GOROOT", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function locateWasmExec() {
+  if (!hasGoToolchain()) return null;
+  const goroot =
+    process.env.GOROOT ??
+    cp.execSync("go env GOROOT", { encoding: "utf8" }).trim();
+  // Go 1.24+ ships wasm_exec.js under lib/wasm/. Older releases kept it
+  // under misc/wasm/. Try both so the build works across Go installs.
+  const candidates = [
+    path.join(goroot, "lib", "wasm", "wasm_exec.js"),
+    path.join(goroot, "misc", "wasm", "wasm_exec.js"),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function newestMtime(...roots) {
+  let max = 0;
+  for (const root of roots) {
+    if (!root || !fs.existsSync(root)) continue;
+    walk(root, (_file, stat) => {
+      if (stat.mtimeMs > max) max = stat.mtimeMs;
+    });
+  }
+  return max;
+}
+
+function walk(root, visit) {
+  const stack = [root];
+  while (stack.length) {
+    const cur = stack.pop();
+    let stat;
+    try {
+      stat = fs.statSync(cur);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      const base = path.basename(cur);
+      if (
+        base === "node_modules" ||
+        base === ".ttsc" ||
+        base === ".git" ||
+        base === "lib" ||
+        base === "dist"
+      )
+        continue;
+      for (const entry of fs.readdirSync(cur)) {
+        stack.push(path.join(cur, entry));
+      }
+    } else if (stat.isFile() && cur.endsWith(".go")) {
+      visit(cur, stat);
+    }
+  }
+}
+
+function buildWasm() {
+  console.log(`build/build-wasm.cjs: building ${wasmOut}`);
+  cp.execFileSync(
+    "go",
+    [
+      "build",
+      "-trimpath",
+      "-ldflags",
+      "-s -w",
+      "-o",
+      wasmOut,
+      "./cmd/ttsc-wasm",
+    ],
+    {
+      cwd: packageRoot,
+      env: { ...process.env, GOOS: "js", GOARCH: "wasm" },
+      stdio: "inherit",
+    },
+  );
+}
+
+// Mirror packages/ttsc/shim/* into packages/wasm/vendor/shim/* so the
+// published @ttsc/wasm tarball is self-contained: consumers extending the
+// wasm binary against the @ttsc/wasm Go module no longer need a sibling
+// `packages/ttsc/shim/` working tree. The vendored copy is checked in so
+// `pnpm pack --dry-run` agrees with what `go build` would see at install
+// time. The working-tree `go.mod` still points at `../ttsc/shim/*` for
+// local dev; the published `go.mod` is rewritten into `dist/go.mod` and
+// swapped in via prepack/postpack.
+function vendorShim() {
+  if (!fs.existsSync(shimSrc)) {
+    throw new Error(
+      `build/build-wasm.cjs: shim source missing at ${shimSrc}; run from a full repo checkout`,
+    );
+  }
+  fs.rmSync(vendorShimDir, { recursive: true, force: true });
+  fs.mkdirSync(vendorShimDir, { recursive: true });
+  copyTree(shimSrc, vendorShimDir);
+  console.log(
+    `build/build-wasm.cjs: vendored shim/* → ${path.relative(packageRoot, vendorShimDir)}`,
+  );
+}
+
+function copyTree(src, dst) {
+  const stat = fs.statSync(src);
+  if (stat.isDirectory()) {
+    const base = path.basename(src);
+    if (base === "node_modules" || base === ".git") return;
+    fs.mkdirSync(dst, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      copyTree(path.join(src, entry), path.join(dst, entry));
+    }
+  } else if (stat.isFile()) {
+    fs.copyFileSync(src, dst);
+  }
+}
+
+// Rewrite go.mod so the published copy points at ./vendor/shim/* instead of
+// ../ttsc/shim/*. The `replace github.com/samchon/ttsc/packages/ttsc => ...`
+// line is dropped: consumers of the published tarball who want to compile
+// their own wasm binary must supply that module themselves (documented in
+// README.md). The working-tree go.mod is untouched.
+function rewritePublishedGoMod() {
+  const src = fs.readFileSync(goModPath, "utf8");
+  const lines = src.split(/\r?\n/);
+  const out = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    // Drop the ../ttsc consumer-module replace (handled at consumer side).
+    if (
+      /^github\.com\/samchon\/ttsc\/packages\/ttsc\s+=>\s+\.\.\/ttsc\b/.test(
+        trimmed,
+      )
+    ) {
+      continue;
+    }
+    // Rewrite each shim replace from ../ttsc/shim/X to ./vendor/shim/X.
+    const shimMatch = trimmed.match(
+      /^(github\.com\/microsoft\/typescript-go\/shim\/[A-Za-z0-9_/]+)\s+=>\s+\.\.\/ttsc\/shim\/([A-Za-z0-9_/]+)$/,
+    );
+    if (shimMatch) {
+      const indent = line.match(/^\s*/)[0];
+      out.push(`${indent}${shimMatch[1]} => ./vendor/shim/${shimMatch[2]}`);
+      continue;
+    }
+    out.push(line);
+  }
+  fs.writeFileSync(publishedGoModOut, out.join("\n"));
+  console.log(
+    `build/build-wasm.cjs: emitted published go.mod → ${path.relative(packageRoot, publishedGoModOut)}`,
+  );
+}
+
+const wasmExecSrc = locateWasmExec();
+
+if (!forceRebuild && fs.existsSync(wasmOut)) {
+  const wasmMtime = fs.statSync(wasmOut).mtimeMs;
+  const sourceMtime = newestMtime(packageRoot, ttscDir);
+  if (sourceMtime > 0 && wasmMtime >= sourceMtime) {
+    console.log(
+      `build/build-wasm.cjs: cached ttsc.wasm is up to date (${(
+        fs.statSync(wasmOut).size /
+        1024 /
+        1024
+      ).toFixed(2)} MiB) — skipping rebuild`,
+    );
+    if (wasmExecSrc && !fs.existsSync(wasmExecOut)) {
+      fs.copyFileSync(wasmExecSrc, wasmExecOut);
+    }
+    // Even on cache hit, refresh the vendored shim + published go.mod so
+    // `pnpm pack` always sees up-to-date publish artifacts.
+    vendorShim();
+    rewritePublishedGoMod();
+    return;
+  }
+}
+
+if (!wasmExecSrc) {
+  console.error(
+    "build/build-wasm.cjs: wasm_exec.js not located. Install Go 1.24+.",
+  );
+  process.exit(1);
+}
+
+vendorShim();
+rewritePublishedGoMod();
+buildWasm();
+fs.copyFileSync(wasmExecSrc, wasmExecOut);
+
+console.log(
+  `build/build-wasm.cjs: done. ttsc.wasm = ${(
+    fs.statSync(wasmOut).size /
+    1024 /
+    1024
+  ).toFixed(2)} MiB`,
+);

package/build/pack-prepare.cjs

@@ -0,0 +1,68 @@
+// prepack/postpack helper for @ttsc/wasm.
+//
+// `pnpm pack` and `npm publish` both honor `files` against the working
+// directory's `go.mod`, so the published tarball would otherwise carry the
+// dev-time `replace ../ttsc/shim/*` paths. Those paths don't exist inside
+// the consumer's `node_modules/@ttsc/wasm/`, so the module would fail to
+// resolve.
+//
+// build-wasm.cjs emits a rewritten `dist/go.mod` that points at the
+// vendored `./vendor/shim/*` tree. Pack-prepare swaps the working-tree
+// `go.mod` for that copy just before pack, then restores the original
+// afterwards. The original is stashed in `build/.go.mod.stash` so an
+// interrupted pack can be recovered by running `--restore`.
+//
+// Usage:
+//   node build/pack-prepare.cjs --stash    # prepack: stash + swap
+//   node build/pack-prepare.cjs --restore  # postpack: restore stash
+
+const fs = require("fs");
+const path = require("path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const goModPath = path.join(packageRoot, "go.mod");
+const publishedGoMod = path.join(packageRoot, "dist", "go.mod");
+// Stash lives in node_modules/.cache to keep it out of the tarball (node_modules
+// is never packed). Using package-local dist/ would risk shipping the stash;
+// __dirname (`build/`) is in `files` so the stash would leak too.
+const stashDir = path.join(packageRoot, "node_modules", ".cache", "ttsc-wasm");
+const stashPath = path.join(stashDir, "go.mod.stash");
+
+function stash() {
+  if (!fs.existsSync(publishedGoMod)) {
+    throw new Error(
+      `pack-prepare: dist/go.mod missing. Run \`pnpm --filter @ttsc/wasm build\` first.`,
+    );
+  }
+  if (fs.existsSync(stashPath)) {
+    throw new Error(
+      `pack-prepare: stale stash at ${stashPath}. Run \`--restore\` first or delete the stash.`,
+    );
+  }
+  fs.mkdirSync(stashDir, { recursive: true });
+  fs.copyFileSync(goModPath, stashPath);
+  fs.copyFileSync(publishedGoMod, goModPath);
+  console.log("pack-prepare: swapped go.mod for published copy");
+}
+
+function restore() {
+  if (!fs.existsSync(stashPath)) {
+    console.log("pack-prepare: no stash to restore");
+    return;
+  }
+  fs.copyFileSync(stashPath, goModPath);
+  fs.rmSync(stashPath);
+  console.log("pack-prepare: restored working-tree go.mod");
+}
+
+const mode = process.argv[2];
+if (mode === "--stash") {
+  stash();
+} else if (mode === "--restore") {
+  restore();
+} else {
+  console.error(
+    "pack-prepare: usage: node build/pack-prepare.cjs [--stash|--restore]",
+  );
+  process.exit(2);
+}

package/cmd/ttsc-wasm/main.go

@@ -0,0 +1,130 @@
+//go:build !js
+
+// Command ttsc-wasm is the non-wasm sanity entrypoint for `@ttsc/wasm`.
+//
+// The same binary, compiled with GOOS=js GOARCH=wasm, becomes the browser
+// wasm consumed by `bootTtsc`. For native targets we expose a minimal CLI so
+// `go run ./cmd/ttsc-wasm` exercises the same host helpers without needing
+// the browser MemFS bridge.
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+
+	"github.com/samchon/ttsc/packages/wasm/host"
+)
+
+// Build metadata. Overridden via -ldflags from build/build-wasm.cjs.
+var (
+	version = "0.0.0-dev"
+	commit  = "dev"
+	date    = "unknown"
+)
+
+func main() {
+	os.Exit(run(os.Args[1:]))
+}
+
+func run(args []string) int {
+	if len(args) == 0 {
+		printHelp(os.Stdout)
+		return 0
+	}
+	switch args[0] {
+	case "-h", "--help", "help":
+		printHelp(os.Stdout)
+		return 0
+	case "-v", "--version", "version":
+		printVersion(os.Stdout)
+		return 0
+	case "build":
+		return runBuild(args[1:])
+	case "check":
+		return runCheck(args[1:])
+	case "transform":
+		return runTransform(args[1:])
+	default:
+		fmt.Fprintf(os.Stderr, "ttsc-wasm: unknown command %q\n", args[0])
+		printHelp(os.Stderr)
+		return 2
+	}
+}
+
+func runBuild(args []string) int {
+	cwd, tsconfig := parseProject(args)
+	data, code, err := host.Build(cwd, tsconfig)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ttsc-wasm build: %v\n", err)
+		return 2
+	}
+	_, _ = os.Stdout.Write(append(data, '\n'))
+	return code
+}
+
+func runCheck(args []string) int {
+	cwd, tsconfig := parseProject(args)
+	data, code, err := host.Check(cwd, tsconfig)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ttsc-wasm check: %v\n", err)
+		return 2
+	}
+	_, _ = os.Stdout.Write(append(data, '\n'))
+	return code
+}
+
+func runTransform(args []string) int {
+	cwd, tsconfig := parseProject(args)
+	data, code, err := host.Transform(cwd, tsconfig)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "ttsc-wasm transform: %v\n", err)
+		return 2
+	}
+	_, _ = os.Stdout.Write(append(data, '\n'))
+	return code
+}
+
+func parseProject(args []string) (string, string) {
+	cwd, _ := os.Getwd()
+	tsconfig := "tsconfig.json"
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "--cwd" && i+1 < len(args):
+			cwd = args[i+1]
+			i++
+		case len(arg) > len("--cwd=") && arg[:6] == "--cwd=":
+			cwd = arg[6:]
+		case arg == "--tsconfig" && i+1 < len(args):
+			tsconfig = args[i+1]
+			i++
+		case len(arg) > len("--tsconfig=") && arg[:11] == "--tsconfig=":
+			tsconfig = arg[11:]
+		}
+	}
+	return cwd, tsconfig
+}
+
+func printHelp(w io.Writer) {
+	fmt.Fprintln(w, "Usage: ttsc-wasm <command> [--cwd=<dir>] [--tsconfig=<path>]")
+	fmt.Fprintln(w, "Commands:")
+	fmt.Fprintln(w, "  build       compile a project and print the JSON result")
+	fmt.Fprintln(w, "  check       type-check a project without emit")
+	fmt.Fprintln(w, "  transform   return every source file the program saw")
+	fmt.Fprintln(w, "  version     print version banner")
+}
+
+func printVersion(w io.Writer) {
+	fmt.Fprintf(
+		w,
+		"ttsc-wasm %s (commit %s, built %s, %s/%s, go %s)\n",
+		version,
+		commit,
+		date,
+		runtime.GOOS,
+		runtime.GOARCH,
+		runtime.Version(),
+	)
+}

package/cmd/ttsc-wasm/main_wasm.go

@@ -0,0 +1,17 @@
+//go:build js && wasm
+
+// Browser entry for the base `ttsc.wasm`. Ships ttsc + typescript-go only —
+// no first-party plugins are linked here. Downstream playgrounds bundle their
+// own plugins by writing their own `main_wasm.go` against the same host
+// helper and producing a separate `.wasm`.
+package main
+
+import (
+	"github.com/samchon/ttsc/packages/wasm/host"
+)
+
+func main() {
+	host.Expose("ttsc", host.Config{
+		Plugins: nil,
+	})
+}

package/dist/go.mod

@@ -0,0 +1,54 @@
+module github.com/samchon/ttsc/packages/wasm
+
+go 1.26
+
+// The wasm package is a thin Go-side shell around `packages/ttsc/driver`.
+// It re-uses the same shim/* tree that the native CLI ships with, so every
+// replace directive mirrors `packages/ttsc/go.mod`. Without these, the
+// public proxy cannot resolve the in-tree shim modules.
+replace (
+	github.com/microsoft/typescript-go/shim/ast => ./vendor/shim/ast
+	github.com/microsoft/typescript-go/shim/bundled => ./vendor/shim/bundled
+	github.com/microsoft/typescript-go/shim/checker => ./vendor/shim/checker
+	github.com/microsoft/typescript-go/shim/compiler => ./vendor/shim/compiler
+	github.com/microsoft/typescript-go/shim/core => ./vendor/shim/core
+	github.com/microsoft/typescript-go/shim/diagnosticwriter => ./vendor/shim/diagnosticwriter
+	github.com/microsoft/typescript-go/shim/lsp => ./vendor/shim/lsp
+	github.com/microsoft/typescript-go/shim/parser => ./vendor/shim/parser
+	github.com/microsoft/typescript-go/shim/printer => ./vendor/shim/printer
+	github.com/microsoft/typescript-go/shim/scanner => ./vendor/shim/scanner
+	github.com/microsoft/typescript-go/shim/tsoptions => ./vendor/shim/tsoptions
+	github.com/microsoft/typescript-go/shim/tspath => ./vendor/shim/tspath
+	github.com/microsoft/typescript-go/shim/vfs => ./vendor/shim/vfs
+	github.com/microsoft/typescript-go/shim/vfs/cachedvfs => ./vendor/shim/vfs/cachedvfs
+	github.com/microsoft/typescript-go/shim/vfs/osvfs => ./vendor/shim/vfs/osvfs
+)
+
+require (
+	github.com/microsoft/typescript-go/shim/compiler v0.0.0
+	github.com/samchon/ttsc/packages/ttsc v0.0.0
+)
+
+require (
+	github.com/Microsoft/go-winio v0.6.2 // indirect
+	github.com/go-json-experiment/json v0.0.0-20260214004413-d219187c3433 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/mackerelio/go-osstat v0.2.7 // indirect
+	github.com/microsoft/typescript-go v0.0.0-20260429010842-56ab4af42157 // indirect
+	github.com/microsoft/typescript-go/shim/ast v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/bundled v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/checker v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/core v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/diagnosticwriter v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/lsp v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/scanner v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/tsoptions v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/tspath v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/vfs v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/vfs/cachedvfs v0.0.0 // indirect
+	github.com/microsoft/typescript-go/shim/vfs/osvfs v0.0.0 // indirect
+	github.com/zeebo/xxh3 v1.1.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
+	golang.org/x/sys v0.43.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
+)