@ttsc/wasm 0.12.2 → 0.12.4

package/host/host.go

@@ -10,20 +10,20 @@
 package host
 
 import (
-	"fmt"
-	"os"
-	"runtime"
-	"sync/atomic"
-	"syscall/js"
-	"time"
+  "fmt"
+  "os"
+  "runtime"
+  "sync/atomic"
+  "syscall/js"
+  "time"
 )
 
 // Build metadata. Override at link time via
 // `-ldflags "-X github.com/samchon/ttsc/packages/wasm/host.version=..."`.
 var (
-	version = "0.0.0-dev"
-	commit  = "dev"
-	date    = "unknown"
+  version = "0.0.0-dev"
+  commit  = "dev"
+  date    = "unknown"
 )
 
 // API stability: experimental until v1.0; signatures may change between
@@ -44,153 +44,153 @@ var (
 // A matching readiness resolver is invoked: `globalThis[`${apiName}Ready`]`.
 // JS callers register this BEFORE go.run begins so they can await wasm boot.
 func Expose(apiName string, cfg Config) {
-	plugins := map[string]Plugin{}
-	pluginNames := make([]string, 0, len(cfg.Plugins))
-	for _, p := range cfg.Plugins {
-		if p == nil {
-			continue
-		}
-		name := p.Name()
-		if name == "" {
-			continue
-		}
-		if _, dup := plugins[name]; dup {
-			panic(fmt.Sprintf("host.Expose: duplicate plugin name %q", name))
-		}
-		plugins[name] = p
-		pluginNames = append(pluginNames, name)
-	}
+  plugins := map[string]Plugin{}
+  pluginNames := make([]string, 0, len(cfg.Plugins))
+  for _, p := range cfg.Plugins {
+    if p == nil {
+      continue
+    }
+    name := p.Name()
+    if name == "" {
+      continue
+    }
+    if _, dup := plugins[name]; dup {
+      panic(fmt.Sprintf("host.Expose: duplicate plugin name %q", name))
+    }
+    plugins[name] = p
+    pluginNames = append(pluginNames, name)
+  }
 
-	api := map[string]any{
-		"version":   js.FuncOf(jsVersion),
-		"build":     js.FuncOf(jsBuild),
-		"check":     js.FuncOf(jsCheck),
-		"transform": js.FuncOf(jsTransform),
-		"plugin":    js.FuncOf(jsPluginDispatch(plugins)),
-		"plugins":   js.FuncOf(jsPluginsList(pluginNames)),
-	}
-	js.Global().Set(apiName, js.ValueOf(api))
+  api := map[string]any{
+    "version":   js.FuncOf(jsVersion),
+    "build":     js.FuncOf(jsBuild),
+    "check":     js.FuncOf(jsCheck),
+    "transform": js.FuncOf(jsTransform),
+    "plugin":    js.FuncOf(jsPluginDispatch(plugins)),
+    "plugins":   js.FuncOf(jsPluginsList(pluginNames)),
+  }
+  js.Global().Set(apiName, js.ValueOf(api))
 
-	if ready := js.Global().Get(apiName + "Ready"); ready.Type() == js.TypeFunction {
-		ready.Invoke()
-	}
+  if ready := js.Global().Get(apiName + "Ready"); ready.Type() == js.TypeFunction {
+    ready.Invoke()
+  }
 
-	// A perpetual idle goroutine keeps the wasm runtime alive without
-	// tripping Go's deadlock detector while syscall.fsCall callbacks are in
-	// flight. `select {}` alone is wrongly classified as "all goroutines
-	// asleep" the moment the FS path hands a request to JS.
-	go func() {
-		for {
-			time.Sleep(time.Hour)
-		}
-	}()
-	select {}
+  // A perpetual idle goroutine keeps the wasm runtime alive without
+  // tripping Go's deadlock detector while syscall.fsCall callbacks are in
+  // flight. `select {}` alone is wrongly classified as "all goroutines
+  // asleep" the moment the FS path hands a request to JS.
+  go func() {
+    for {
+      time.Sleep(time.Hour)
+    }
+  }()
+  select {}
 }
 
 // jsVersion returns the build metadata for this wasm binary.
 func jsVersion(this js.Value, args []js.Value) any {
-	return js.ValueOf(map[string]any{
-		"version": version,
-		"commit":  commit,
-		"date":    date,
-		"go":      runtime.Version(),
-		"goos":    runtime.GOOS,
-		"goarch":  runtime.GOARCH,
-	})
+  return js.ValueOf(map[string]any{
+    "version": version,
+    "commit":  commit,
+    "date":    date,
+    "go":      runtime.Version(),
+    "goos":    runtime.GOOS,
+    "goarch":  runtime.GOARCH,
+  })
 }
 
 // jsBuild → Promise<{ code, stdout, stderr, result }>. `result` carries the
 // compile JSON; the surrounding shape mirrors plugin dispatch so JS callers
 // can write one error-handling branch.
 func jsBuild(this js.Value, args []js.Value) any {
-	opts := optionsArg(args)
-	return makePromise(func() any {
-		return runProjectCommand(opts, Build)
-	})
+  opts := optionsArg(args)
+  return makePromise(func() any {
+    return runProjectCommand(opts, Build)
+  })
 }
 
 // jsCheck → Promise<{ code, stdout, stderr, result }>.
 func jsCheck(this js.Value, args []js.Value) any {
-	opts := optionsArg(args)
-	return makePromise(func() any {
-		return runProjectCommand(opts, Check)
-	})
+  opts := optionsArg(args)
+  return makePromise(func() any {
+    return runProjectCommand(opts, Check)
+  })
 }
 
 // jsTransform → Promise<{ code, stdout, stderr, result }>.
 func jsTransform(this js.Value, args []js.Value) any {
-	opts := optionsArg(args)
-	return makePromise(func() any {
-		return runProjectCommand(opts, Transform)
-	})
+  opts := optionsArg(args)
+  return makePromise(func() any {
+    return runProjectCommand(opts, Transform)
+  })
 }
 
 // jsPluginDispatch routes `api.plugin({ name, command, ...opts })` to the
 // matching registered Plugin's Run. The returned shape is identical to the
 // base endpoints so a JS caller has one result type to handle.
 func jsPluginDispatch(plugins map[string]Plugin) func(this js.Value, args []js.Value) any {
-	return func(this js.Value, args []js.Value) any {
-		opts := optionsArg(args)
-		name := stringProp(opts, "name")
-		command := stringProp(opts, "command")
-		argv := buildPluginArgv(opts)
-		plugin, ok := plugins[name]
-		if !ok {
-			return errorPromise(2, fmt.Sprintf("host: unknown plugin %q", name))
-		}
-		return makePromise(func() any {
-			res := runWithCapturedIO(func() int {
-				return plugin.Run(command, argv)
-			})
-			return js.ValueOf(map[string]any{
-				"code":   res.Code,
-				"stdout": res.Stdout,
-				"stderr": res.Stderr,
-				"result": "",
-			})
-		})
-	}
+  return func(this js.Value, args []js.Value) any {
+    opts := optionsArg(args)
+    name := stringProp(opts, "name")
+    command := stringProp(opts, "command")
+    argv := buildPluginArgv(opts)
+    plugin, ok := plugins[name]
+    if !ok {
+      return errorPromise(2, fmt.Sprintf("host: unknown plugin %q", name))
+    }
+    return makePromise(func() any {
+      res := runWithCapturedIO(func() int {
+        return plugin.Run(command, argv)
+      })
+      return js.ValueOf(map[string]any{
+        "code":   res.Code,
+        "stdout": res.Stdout,
+        "stderr": res.Stderr,
+        "result": "",
+      })
+    })
+  }
 }
 
 // jsPluginsList returns the registered plugin names so JS callers can probe
 // the wasm's contents at boot time.
 func jsPluginsList(names []string) func(this js.Value, args []js.Value) any {
-	return func(this js.Value, args []js.Value) any {
-		out := make([]any, len(names))
-		for i, n := range names {
-			out[i] = n
-		}
-		return js.ValueOf(out)
-	}
+  return func(this js.Value, args []js.Value) any {
+    out := make([]any, len(names))
+    for i, n := range names {
+      out[i] = n
+    }
+    return js.ValueOf(out)
+  }
 }
 
 // runProjectCommand wraps the base build/check/transform endpoints into the
 // uniform `{ code, stdout, stderr, result }` shape. The result string is the
 // JSON the endpoint produced; JSON.parse it on the JS side.
 func runProjectCommand(opts js.Value, fn func(cwd, tsconfig string) ([]byte, int, error)) any {
-	cwd := stringProp(opts, "cwd")
-	tsconfig := stringProp(opts, "tsconfig")
-	if tsconfig == "" {
-		tsconfig = "tsconfig.json"
-	}
-	if cwd == "" {
-		return errorResponse(2, "host: \"cwd\" is required")
-	}
-	data, code, err := fn(cwd, tsconfig)
-	if err != nil {
-		return js.ValueOf(map[string]any{
-			"code":   code,
-			"stdout": "",
-			"stderr": err.Error() + "\n",
-			"result": "",
-		})
-	}
-	return js.ValueOf(map[string]any{
-		"code":   code,
-		"stdout": "",
-		"stderr": "",
-		"result": string(data),
-	})
+  cwd := stringProp(opts, "cwd")
+  tsconfig := stringProp(opts, "tsconfig")
+  if tsconfig == "" {
+    tsconfig = "tsconfig.json"
+  }
+  if cwd == "" {
+    return errorResponse(2, "host: \"cwd\" is required")
+  }
+  data, code, err := fn(cwd, tsconfig)
+  if err != nil {
+    return js.ValueOf(map[string]any{
+      "code":   code,
+      "stdout": "",
+      "stderr": err.Error() + "\n",
+      "result": "",
+    })
+  }
+  return js.ValueOf(map[string]any{
+    "code":   code,
+    "stdout": "",
+    "stderr": "",
+    "result": string(data),
+  })
 }
 
 // buildPluginArgv translates the JS options object into a CLI-shaped argv. We
@@ -198,31 +198,31 @@ func runProjectCommand(opts js.Value, fn func(cwd, tsconfig string) ([]byte, int
 // `name` / `command` slots which the host consumes itself. This is the same
 // translation typia's wasm does for `--cwd / --tsconfig / --output / ...`.
 func buildPluginArgv(opts js.Value) []string {
-	out := []string{}
-	if opts.Type() != js.TypeObject {
-		return out
-	}
-	keys := js.Global().Get("Object").Call("keys", opts)
-	n := keys.Length()
-	for i := 0; i < n; i++ {
-		key := keys.Index(i).String()
-		switch key {
-		case "name", "command":
-			continue
-		}
-		value := opts.Get(key)
-		switch value.Type() {
-		case js.TypeString:
-			out = append(out, "--"+key+"="+value.String())
-		case js.TypeBoolean:
-			if value.Bool() {
-				out = append(out, "--"+key)
-			}
-		case js.TypeNumber:
-			out = append(out, fmt.Sprintf("--%s=%v", key, value.Float()))
-		}
-	}
-	return out
+  out := []string{}
+  if opts.Type() != js.TypeObject {
+    return out
+  }
+  keys := js.Global().Get("Object").Call("keys", opts)
+  n := keys.Length()
+  for i := 0; i < n; i++ {
+    key := keys.Index(i).String()
+    switch key {
+    case "name", "command":
+      continue
+    }
+    value := opts.Get(key)
+    switch value.Type() {
+    case js.TypeString:
+      out = append(out, "--"+key+"="+value.String())
+    case js.TypeBoolean:
+      if value.Bool() {
+        out = append(out, "--"+key)
+      }
+    case js.TypeNumber:
+      out = append(out, fmt.Sprintf("--%s=%v", key, value.Float()))
+    }
+  }
+  return out
 }
 
 // makePromise wraps a Go computation as a JS Promise. The executor
@@ -230,51 +230,58 @@ func buildPluginArgv(opts js.Value) []string {
 // in a goroutine so the JS event loop can drive `fs.stat` and friends to
 // completion before we ask Go to receive the callback.
 func makePromise(work func() any) js.Value {
-	var executor js.Func
-	executor = js.FuncOf(func(this js.Value, args []js.Value) any {
-		resolve := args[0]
-		reject := args[1]
-		go func() {
-			defer func() {
-				if r := recover(); r != nil {
-					err := js.Global().Get("Error").New(fmt.Sprintf("%v", r))
-					reject.Invoke(err)
-				}
-				executor.Release()
-			}()
-			resolve.Invoke(work())
-		}()
-		return nil
-	})
-	return js.Global().Get("Promise").New(executor)
+  var executor js.Func
+  executor = js.FuncOf(func(this js.Value, args []js.Value) any {
+    resolve := args[0]
+    reject := args[1]
+    go func() {
+      defer func() {
+        if r := recover(); r != nil {
+          err := js.Global().Get("Error").New(fmt.Sprintf("%v", r))
+          reject.Invoke(err)
+        }
+        executor.Release()
+      }()
+      resolve.Invoke(work())
+    }()
+    return nil
+  })
+  return js.Global().Get("Promise").New(executor)
 }
 
+// errorPromise returns a pre-resolved Promise carrying an error response.
 func errorPromise(code int, message string) js.Value {
-	return makePromise(func() any { return errorResponse(code, message) })
+  return makePromise(func() any { return errorResponse(code, message) })
 }
 
+// errorResponse builds the uniform JS result object for error cases.
 func errorResponse(code int, message string) any {
-	return js.ValueOf(map[string]any{
-		"code":   code,
-		"stdout": "",
-		"stderr": message + "\n",
-		"result": "",
-	})
+  return js.ValueOf(map[string]any{
+    "code":   code,
+    "stdout": "",
+    "stderr": message + "\n",
+    "result": "",
+  })
 }
 
+// optionsArg returns the first JS argument if it is an object, otherwise an
+// empty JS object. Guards all endpoint handlers against missing or wrong-typed
+// argument lists.
 func optionsArg(args []js.Value) js.Value {
-	if len(args) == 0 || args[0].Type() != js.TypeObject {
-		return js.ValueOf(map[string]any{})
-	}
-	return args[0]
+  if len(args) == 0 || args[0].Type() != js.TypeObject {
+    return js.ValueOf(map[string]any{})
+  }
+  return args[0]
 }
 
+// stringProp reads a string property from a JS object. Returns "" if the
+// property is absent or not a string.
 func stringProp(obj js.Value, key string) string {
-	v := obj.Get(key)
-	if v.Type() != js.TypeString {
-		return ""
-	}
-	return v.String()
+  v := obj.Get(key)
+  if v.Type() != js.TypeString {
+    return ""
+  }
+  return v.String()
 }
 
 // runWithCapturedIO redirects os.Stdout / os.Stderr to temp MemFS files for
@@ -287,63 +294,67 @@ func stringProp(obj js.Value, key string) string {
 // supported on the wasm target. The temp-file approach works because the
 // MemFS shim implements file open/write/read.
 func runWithCapturedIO(task func() int) APIResult {
-	prevOut, prevErr := os.Stdout, os.Stderr
-	defer func() {
-		os.Stdout = prevOut
-		os.Stderr = prevErr
-	}()
+  prevOut, prevErr := os.Stdout, os.Stderr
+  // The defer is a safety net: if an early return skips the explicit restore
+  // below, os.Stdout/os.Stderr are still restored. The explicit restore that
+  // follows the task call is a no-op for the defer but makes the happy path
+  // readable without tracing the defer.
+  defer func() {
+    os.Stdout = prevOut
+    os.Stderr = prevErr
+  }()
 
-	stdoutPath := fmt.Sprintf("/tmp/ttsc-host-capture-%d-%d.stdout", os.Getpid(), captureCounter.Add(1))
-	stderrPath := fmt.Sprintf("/tmp/ttsc-host-capture-%d-%d.stderr", os.Getpid(), captureCounter.Add(1))
+  stdoutPath := fmt.Sprintf("/tmp/ttsc-host-capture-%d-%d.stdout", os.Getpid(), captureCounter.Add(1))
+  stderrPath := fmt.Sprintf("/tmp/ttsc-host-capture-%d-%d.stderr", os.Getpid(), captureCounter.Add(1))
 
-	outFile, outErr := os.Create(stdoutPath)
-	errFile, errErr := os.Create(stderrPath)
-	if outErr != nil || errErr != nil {
-		// Fall back to the original streams. Better to lose capture than the
-		// call. The MemFS writeSync shim surfaces the failure to the host
-		// console so the regression is visible.
-		if outErr != nil {
-			fmt.Fprintf(prevErr, "host.runWithCapturedIO: stdout temp file failed: %v\n", outErr)
-		}
-		if errErr != nil {
-			fmt.Fprintf(prevErr, "host.runWithCapturedIO: stderr temp file failed: %v\n", errErr)
-		}
-		if outFile != nil {
-			_ = outFile.Close()
-			_ = os.Remove(stdoutPath)
-		}
-		if errFile != nil {
-			_ = errFile.Close()
-			_ = os.Remove(stderrPath)
-		}
-		return APIResult{Code: task()}
-	}
+  outFile, outErr := os.Create(stdoutPath)
+  errFile, errErr := os.Create(stderrPath)
+  if outErr != nil || errErr != nil {
+    // Fall back to the original streams. Better to lose capture than the
+    // call. The MemFS writeSync shim surfaces the failure to the host
+    // console so the regression is visible.
+    if outErr != nil {
+      fmt.Fprintf(prevErr, "host.runWithCapturedIO: stdout temp file failed: %v\n", outErr)
+    }
+    if errErr != nil {
+      fmt.Fprintf(prevErr, "host.runWithCapturedIO: stderr temp file failed: %v\n", errErr)
+    }
+    if outFile != nil {
+      _ = outFile.Close()
+      _ = os.Remove(stdoutPath)
+    }
+    if errFile != nil {
+      _ = errFile.Close()
+      _ = os.Remove(stderrPath)
+    }
+    return APIResult{Code: task()}
+  }
 
-	os.Stdout = outFile
-	os.Stderr = errFile
+  os.Stdout = outFile
+  os.Stderr = errFile
 
-	code := task()
+  code := task()
 
-	// Sync + close BEFORE swapping back, so the plugin's last writes hit the
-	// file before we read it.
-	_ = outFile.Sync()
-	_ = errFile.Sync()
-	_ = outFile.Close()
-	_ = errFile.Close()
+  // Sync + close BEFORE swapping back, so the plugin's last writes hit the
+  // file before we read it.
+  _ = outFile.Sync()
+  _ = errFile.Sync()
+  _ = outFile.Close()
+  _ = errFile.Close()
 
-	os.Stdout = prevOut
-	os.Stderr = prevErr
+  os.Stdout = prevOut
+  os.Stderr = prevErr
 
-	stdoutBytes, _ := os.ReadFile(stdoutPath)
-	stderrBytes, _ := os.ReadFile(stderrPath)
-	_ = os.Remove(stdoutPath)
-	_ = os.Remove(stderrPath)
+  stdoutBytes, _ := os.ReadFile(stdoutPath)
+  stderrBytes, _ := os.ReadFile(stderrPath)
+  _ = os.Remove(stdoutPath)
+  _ = os.Remove(stderrPath)
 
-	return APIResult{
-		Code:   code,
-		Stdout: string(stdoutBytes),
-		Stderr: string(stderrBytes),
-	}
+  return APIResult{
+    Code:   code,
+    Stdout: string(stdoutBytes),
+    Stderr: string(stderrBytes),
+  }
 }
 
 // captureCounter avoids temp-file name collisions when plugin dispatches

package/host/host_native.go

@@ -1,5 +1,8 @@
 //go:build !js
 
+// Stub implementations of JS-only host helpers for non-wasm targets.
+// This file keeps the package importable by `go build ./...` on linux/darwin
+// without GOOS=js, which native CI jobs need.
 package host
 
 // Expose is a no-op on native targets. Consumers can `go build ./...` to
@@ -7,6 +10,6 @@ package host
 // stays in scope but the body short-circuits so it's safe to call from a
 // non-wasm sanity-test entrypoint.
 func Expose(apiName string, cfg Config) {
-	_ = apiName
-	_ = cfg
+  _ = apiName
+  _ = cfg
 }

package/host/plugin.go

@@ -13,47 +13,47 @@ package host
 // A typical Plugin implementation in the consumer wasm is a thin adapter that
 // forwards to the same Run* function the native sidecar's `main.go` calls:
 //
-//	type bannerPlugin struct{}
+//  type bannerPlugin struct{}
 //
-//	func (bannerPlugin) Name() string { return "@ttsc/banner" }
-//	func (bannerPlugin) Run(command string, args []string) int {
-//	  switch command {
-//	  case "build":     return utility.RunBuild(args)
-//	  case "check":     return utility.RunCheck(args)
-//	  case "transform": return utility.RunTransform(args)
-//	  default:          return 2
-//	  }
-//	}
+//  func (bannerPlugin) Name() string { return "@ttsc/banner" }
+//  func (bannerPlugin) Run(command string, args []string) int {
+//    switch command {
+//    case "build":     return utility.RunBuild(args)
+//    case "check":     return utility.RunCheck(args)
+//    case "transform": return utility.RunTransform(args)
+//    default:          return 2
+//    }
+//  }
 //
 // The host installs the package-level writers in `runWithCapturedIO` before
 // calling Run, so anything the plugin writes to ttsc's `stdout` / `stderr`
 // streams is captured and returned to the JS caller.
 type Plugin interface {
-	// Name is the npm-style plugin id (e.g. `@ttsc/banner`). The JS side
-	// passes this exact string when dispatching: `api.plugin("@ttsc/banner",
-	// "build", opts)`. Names must be unique within a Config.
-	Name() string
+  // Name is the npm-style plugin id (e.g. `@ttsc/banner`). The JS side
+  // passes this exact string when dispatching: `api.plugin("@ttsc/banner",
+  // "build", opts)`. Names must be unique within a Config.
+  Name() string
 
-	// Run dispatches a subcommand. `command` is the verb the JS caller asked
-	// for (typically build / check / transform / fix / format / version);
-	// `args` is the rest of the argv, already prefixed with `--flag=value`
-	// pairs the host built from the JS options object.
-	//
-	// Return the exit code (0 for success, 2 for usage errors, 3 for runtime
-	// errors — mirrors the native CLI exit-code contract). Anything written
-	// to `os.Stdout` / `os.Stderr` is captured by the host.
-	//
-	// API stability: experimental until v1.0; the signature is expected to
-	// change to `Run(ctx *PluginContext) int` in a follow-up release.
-	Run(command string, args []string) int
+  // Run dispatches a subcommand. `command` is the verb the JS caller asked
+  // for (typically build / check / transform / fix / format / version);
+  // `args` is the rest of the argv, already prefixed with `--flag=value`
+  // pairs the host built from the JS options object.
+  //
+  // Return the exit code (0 for success, 2 for usage errors, 3 for runtime
+  // errors — mirrors the native CLI exit-code contract). Anything written
+  // to `os.Stdout` / `os.Stderr` is captured by the host.
+  //
+  // API stability: experimental until v1.0; the signature is expected to
+  // change to `Run(ctx *PluginContext) int` in a follow-up release.
+  Run(command string, args []string) int
 }
 
 // Config carries the optional registrations the host applies before binding
 // `globalThis[name]`. Pass `Config{}` for a vanilla ttsc + tsgo wasm.
 type Config struct {
-	// Plugins are dispatched through `api.plugin(name, command, opts)` from
-	// JS. Their Run methods share the same `os.Stdout` / `os.Stderr` streams
-	// the base build/check/transform endpoints use, so diagnostics render
-	// the same way no matter which lane produced them.
-	Plugins []Plugin
+  // Plugins are dispatched through `api.plugin(name, command, opts)` from
+  // JS. Their Run methods share the same `os.Stdout` / `os.Stderr` streams
+  // the base build/check/transform endpoints use, so diagnostics render
+  // the same way no matter which lane produced them.
+  Plugins []Plugin
 }