@ttsc/wasm 0.11.0-dev.20260517

package/host/api.go

@@ -0,0 +1,205 @@
+// Shared API helpers behind the wasm and non-wasm entrypoints.
+//
+// `host.Expose` (under //go:build js) and the cmd's native `main.go` both
+// call into these helpers so build/check/transform behavior stays
+// bit-identical across the two surfaces.
+package host
+
+import (
+	"encoding/json"
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	shimcompiler "github.com/microsoft/typescript-go/shim/compiler"
+
+	"github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// APIResult is the JSON shape every plugin-dispatch endpoint returns to the
+// JS host. `code` follows the native CLI exit-code contract (0 success, 2
+// usage error, 3 runtime error). `stdout` / `stderr` are raw strings the
+// caller can render in a console panel.
+type APIResult struct {
+	Code   int    `json:"code"`
+	Stdout string `json:"stdout"`
+	Stderr string `json:"stderr"`
+}
+
+// CompileResult mirrors `ttsc api-compile`. Field names are TypeScript-style
+// so JS callers can use it directly without remapping.
+type CompileResult struct {
+	Diagnostics []CompileDiagnostic `json:"diagnostics,omitempty"`
+	// Output maps cwd-relative paths to emitted JS / d.ts text. Empty when
+	// the program produced no files (e.g. `noEmit` projects).
+	Output map[string]string `json:"output"`
+}
+
+// TransformResult is the no-emit companion. The `typescript` map keys files
+// the same way `output` does in compile mode.
+type TransformResult struct {
+	Diagnostics []CompileDiagnostic `json:"diagnostics,omitempty"`
+	TypeScript  map[string]string   `json:"typescript"`
+}
+
+// CompileDiagnostic is the public TypeScript-side diagnostic DTO. Mirrors the
+// shape `ttsc api-compile` writes so the JS host can render it without
+// remapping fields.
+type CompileDiagnostic struct {
+	File        *string `json:"file"`
+	Category    string  `json:"category"`
+	Code        int32   `json:"code"`
+	Start       *int    `json:"start,omitempty"`
+	Length      *int    `json:"length,omitempty"`
+	Line        int     `json:"line,omitempty"`
+	Character   int     `json:"character,omitempty"`
+	MessageText string  `json:"messageText"`
+}
+
+// Build runs `ttsc build`-shaped emit: load the project, emit JS, return the
+// emitted text map + diagnostics as JSON. `cwd` must be an absolute path
+// inside the host filesystem; `tsconfigPath` may be relative to cwd.
+func Build(cwd, tsconfigPath string) ([]byte, int, error) {
+	prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
+		ForceEmit: true,
+	})
+	if err != nil {
+		return nil, 2, err
+	}
+	if prog != nil {
+		defer prog.Close()
+		diags = append(diags, prog.Diagnostics()...)
+	}
+	output := map[string]string{}
+	if prog != nil {
+		rewrites := driver.NewRewriteSet()
+		writeFile := shimcompiler.WriteFile(
+			func(fileName, text string, _ *shimcompiler.WriteFileData) error {
+				output[apiOutputKey(cwd, fileName)] = text
+				return nil
+			},
+		)
+		_, emitDiags, eerr := prog.EmitAll(rewrites, writeFile)
+		if eerr != nil {
+			return nil, 3, fmt.Errorf("emit failed: %w", eerr)
+		}
+		diags = append(diags, emitDiags...)
+	}
+	result := CompileResult{
+		Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
+		Output:      output,
+	}
+	for _, d := range diags {
+		result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
+	}
+	data, err := json.Marshal(result)
+	if err != nil {
+		return nil, 3, fmt.Errorf("result marshal failed: %w", err)
+	}
+	code := 0
+	if driver.CountErrors(diags) > 0 {
+		code = 2
+	}
+	return data, code, nil
+}
+
+// Check runs the typecheck pipeline without emitting JS. The returned JSON
+// has the same shape as Build but with an empty `output` map.
+func Check(cwd, tsconfigPath string) ([]byte, int, error) {
+	prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
+		ForceNoEmit: true,
+	})
+	if err != nil {
+		return nil, 2, err
+	}
+	if prog != nil {
+		defer prog.Close()
+		diags = append(diags, prog.Diagnostics()...)
+	}
+	result := CompileResult{
+		Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
+		Output:      map[string]string{},
+	}
+	for _, d := range diags {
+		result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
+	}
+	data, err := json.Marshal(result)
+	if err != nil {
+		return nil, 3, fmt.Errorf("result marshal failed: %w", err)
+	}
+	code := 0
+	if driver.CountErrors(diags) > 0 {
+		code = 2
+	}
+	return data, code, nil
+}
+
+// Transform returns every source file the program saw, keyed by
+// project-relative path. The playground uses this to render the TS view
+// after source rewrites (e.g. paths rewriting) have been applied.
+func Transform(cwd, tsconfigPath string) ([]byte, int, error) {
+	prog, diags, err := driver.LoadProgram(cwd, tsconfigPath, driver.LoadProgramOptions{
+		ForceNoEmit: true,
+	})
+	if err != nil {
+		return nil, 2, err
+	}
+	typescript := map[string]string{}
+	if prog != nil {
+		defer prog.Close()
+		for _, file := range prog.SourceFiles() {
+			typescript[apiOutputKey(cwd, file.FileName())] = file.Text()
+		}
+		diags = append(diags, prog.Diagnostics()...)
+	}
+	result := TransformResult{
+		Diagnostics: make([]CompileDiagnostic, 0, len(diags)),
+		TypeScript:  typescript,
+	}
+	for _, d := range diags {
+		result.Diagnostics = append(result.Diagnostics, toAPIDiagnostic(d))
+	}
+	data, err := json.Marshal(result)
+	if err != nil {
+		return nil, 3, fmt.Errorf("result marshal failed: %w", err)
+	}
+	code := 0
+	if driver.CountErrors(diags) > 0 {
+		code = 2
+	}
+	return data, code, nil
+}
+
+func toAPIDiagnostic(diag driver.Diagnostic) CompileDiagnostic {
+	var file *string
+	if diag.File != "" {
+		value := filepath.ToSlash(diag.File)
+		file = &value
+	}
+	category := "error"
+	if diag.Severity == driver.SeverityWarning {
+		category = "warning"
+	}
+	return CompileDiagnostic{
+		File:        file,
+		Category:    category,
+		Code:        diag.Code,
+		Start:       diag.Start,
+		Length:      diag.Length,
+		Line:        diag.Line,
+		Character:   diag.Column,
+		MessageText: diag.Message,
+	}
+}
+
+func apiOutputKey(cwd, fileName string) string {
+	rel, err := filepath.Rel(cwd, fileName)
+	if err != nil || isOutsideRelativePath(rel) {
+		return filepath.ToSlash(fileName)
+	}
+	return filepath.ToSlash(rel)
+}
+
+func isOutsideRelativePath(rel string) bool {
+	return rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator))
+}

package/host/doc.go

@@ -0,0 +1,31 @@
+// Package host is the reusable Go scaffolding plugin authors import to build
+// their own ttsc playground wasm.
+//
+// A consumer wasm looks like this:
+//
+//	//go:build js
+//	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()},
+//	  })
+//	  select {}
+//	}
+//
+// Expose binds `globalThis[name]` to an object that exposes ttsc's base
+// project commands (build, check, transform, version) plus a `plugin(name,
+// command, opts)` dispatcher that routes into a Plugin's CLI-shaped Run
+// callback. Plugins keep ttsc's existing argv-based contract — the same
+// shape the native sidecars implement — so the wasm and the native CLI can
+// share their Run* entry points byte-for-byte.
+//
+// The package is browser-agnostic: every JS-facing helper sits behind
+// //go:build js, so a consumer can `go build ./...` natively without GOOS=js
+// to keep CI happy.
+package host

package/host/host.go

@@ -0,0 +1,317 @@
+//go:build js && wasm
+
+// JS-side bindings for the host package.
+//
+// `Expose` installs `globalThis[apiName]` with the base ttsc endpoints
+// (version, build, check, transform) plus a `plugin(name, command, opts)`
+// dispatcher that routes into the consumer's registered plugins. The handler
+// shape mirrors typia's `ttsc-typia` wasm so JS callers can build a single
+// boot helper that works against any host-built binary.
+package host
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"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"
+)
+
+// API stability: experimental until v1.0; signatures may change between
+// minor releases. Pin exact versions in production playgrounds.
+//
+// Expose installs `globalThis[apiName]` with the base API endpoints and the
+// plugin dispatcher, then keeps the Go runtime alive forever.
+//
+// The contract:
+//
+//   - globalThis[apiName].version()                        → version banner
+//   - globalThis[apiName].build({ cwd, tsconfig })         → Promise<CompileResult>
+//   - globalThis[apiName].check({ cwd, tsconfig })         → Promise<CompileResult>
+//   - globalThis[apiName].transform({ cwd, tsconfig })     → Promise<TransformResult>
+//   - globalThis[apiName].plugin({ name, command, ...opts}) → Promise<APIResult>
+//   - globalThis[apiName].plugins()                        → string[] of registered names
+//
+// 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)
+	}
+
+	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()
+	}
+
+	// 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,
+	})
+}
+
+// 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)
+	})
+}
+
+// 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)
+	})
+}
+
+// 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)
+	})
+}
+
+// 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": "",
+			})
+		})
+	}
+}
+
+// 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)
+	}
+}
+
+// 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),
+	})
+}
+
+// buildPluginArgv translates the JS options object into a CLI-shaped argv. We
+// pass through every string / boolean property the caller set, except the
+// `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
+}
+
+// makePromise wraps a Go computation as a JS Promise. The executor
+// synchronously captures the resolve/reject callbacks; the work itself runs
+// 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)
+}
+
+func errorPromise(code int, message string) js.Value {
+	return makePromise(func() any { return errorResponse(code, message) })
+}
+
+func errorResponse(code int, message string) any {
+	return js.ValueOf(map[string]any{
+		"code":   code,
+		"stdout": "",
+		"stderr": message + "\n",
+		"result": "",
+	})
+}
+
+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]
+}
+
+func stringProp(obj js.Value, key string) string {
+	v := obj.Get(key)
+	if v.Type() != js.TypeString {
+		return ""
+	}
+	return v.String()
+}
+
+// runWithCapturedIO redirects os.Stdout / os.Stderr through in-memory pipes
+// for the duration of `task`. Plugin Run methods write to os.Stdout / os.Stderr
+// the same way the native sidecar binaries do; capturing the output lets the
+// JS host render it in a console panel without spawning a subprocess.
+func runWithCapturedIO(task func() int) APIResult {
+	prevOut, prevErr := os.Stdout, os.Stderr
+	rOut, wOut, _ := os.Pipe()
+	rErr, wErr, _ := os.Pipe()
+	os.Stdout = wOut
+	os.Stderr = wErr
+
+	var outBuf, errBuf bytes.Buffer
+	done := make(chan struct{}, 2)
+	go func() {
+		_, _ = io.Copy(&outBuf, rOut)
+		done <- struct{}{}
+	}()
+	go func() {
+		_, _ = io.Copy(&errBuf, rErr)
+		done <- struct{}{}
+	}()
+
+	code := task()
+
+	_ = wOut.Close()
+	_ = wErr.Close()
+	<-done
+	<-done
+	os.Stdout = prevOut
+	os.Stderr = prevErr
+
+	return APIResult{
+		Code:   code,
+		Stdout: outBuf.String(),
+		Stderr: errBuf.String(),
+	}
+}

package/host/host_native.go

@@ -0,0 +1,12 @@
+//go:build !js
+
+package host
+
+// Expose is a no-op on native targets. Consumers can `go build ./...` to
+// type-check their wasm entry point without GOOS=js; the function symbol
+// 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
+}

package/host/plugin.go

@@ -0,0 +1,59 @@
+package host
+
+// API stability: experimental until v1.0; signatures may change between
+// minor releases. Pin exact versions in production playgrounds.
+//
+// Plugin is the in-process equivalent of ttsc's native CLI sidecar.
+//
+// The native CLI invokes plugins by spawning their binary with argv (e.g.
+// `@ttsc/lint check --tsconfig=tsconfig.json --plugins-json=...`). Inside the
+// wasm there is no subprocess support, so the consumer wasm bundles plugin
+// code directly and exposes the same dispatch through Plugin.Run.
+//
+// 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{}
+//
+//	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
+
+	// 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
+}

package/lib/src/MemFS.d.ts

@@ -0,0 +1,68 @@
+export interface IWasmExecFS {
+    constants: Record<string, number>;
+    writeSync(fd: number, buf: Uint8Array): number;
+    write(fd: number, buf: Uint8Array, offset: number, length: number, position: number | null, callback: (err: NodeJS.ErrnoException | null, n: number) => void): void;
+    open(path: string, flags: number, mode: number, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    close(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, callback: (err: NodeJS.ErrnoException | null, n: number) => void): void;
+    readdir(path: string, callback: (err: NodeJS.ErrnoException | null, entries: string[]) => void): void;
+    mkdir(path: string, perm: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    stat(path: string, callback: (err: NodeJS.ErrnoException | null, stats: IFileStats) => void): void;
+    lstat(path: string, callback: (err: NodeJS.ErrnoException | null, stats: IFileStats) => void): void;
+    fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: IFileStats) => void): void;
+    fsync(fd: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    unlink(path: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    rename(from: string, to: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    rmdir(path: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    chmod(path: string, mode: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    fchmod(fd: number, mode: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    chown(path: string, uid: number, gid: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    fchown(fd: number, uid: number, gid: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    lchown(path: string, uid: number, gid: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    utimes(path: string, atime: number, mtime: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    link(path: string, link: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    symlink(path: string, link: string, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    readlink(path: string, callback: (err: NodeJS.ErrnoException | null, link: string) => void): void;
+    truncate(path: string, length: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    ftruncate(fd: number, length: number, callback: (err: NodeJS.ErrnoException | null) => void): void;
+}
+export interface IFileStats {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    size: number;
+    mode: number;
+    mtimeMs: number;
+    atimeMs: number;
+    ctimeMs: number;
+    dev: number;
+    ino: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    blksize: number;
+    blocks: number;
+}
+export declare class MemFSError extends Error {
+    code: string;
+    errno: number;
+    path?: string;
+    syscall?: string;
+    constructor(code: string, syscall: string, path?: string);
+}
+export interface IMemFSHost {
+    fs: IWasmExecFS;
+    writeFile(path: string, data: string | Uint8Array): void;
+    readFile(path: string): Uint8Array | null;
+    readFileText(path: string): string | null;
+    exists(path: string): boolean;
+    mkdirp(path: string): void;
+    stdout: {
+        buffer: string;
+    };
+    stderr: {
+        buffer: string;
+    };
+    resetStdio(): void;
+}
+export declare function createMemFS(): IMemFSHost;