libghostty,internal: replace wazero with wasm2go

Author: seruman

.gitattributes

@@ -0,0 +1 @@
+libghostty/wasmvt/vt.generated.go linguist-generated=true

.gitignore

@@ -5,3 +5,4 @@ vt/.zig-cache/
 huti.asc
 /ht
 /.pi/
+/libghostty/hauntty-vt.wasm

go.mod

@@ -6,12 +6,12 @@ require (
 	github.com/BurntSushi/toml v1.6.0
 	github.com/alecthomas/kong v1.14.0
 	github.com/creack/pty v1.1.24
-	github.com/tetratelabs/wazero v1.11.0
 	golang.org/x/sys v0.41.0
 	golang.org/x/term v0.40.0
 )
 
 require (
+	github.com/ncruces/wasm2go v0.2.2 // indirect
 	golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 // indirect
 	golang.org/x/mod v0.33.0 // indirect
 	golang.org/x/sync v0.19.0 // indirect
@@ -27,6 +27,7 @@ require (
 )
 
 tool (
+	github.com/ncruces/wasm2go
 	golang.org/x/tools/cmd/deadcode
 	golang.org/x/tools/cmd/goimports
 	honnef.co/go/tools/cmd/staticcheck

go.sum

@@ -18,10 +18,10 @@ github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/ncruces/wasm2go v0.2.2 h1:aPLqdGYGL0YzTajgtzn/a7bNUDJbNrz2imNidR5VmXE=
+github.com/ncruces/wasm2go v0.2.2/go.mod h1:XIM3a6oVdTfxP9RzVa41M2uSCuu5RQBCHG5lMc37OP0=
 github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/tetratelabs/wazero v1.11.0 h1:+gKemEuKCTevU4d7ZTzlsvgd1uaToIDtlQlmNbwqYhA=
-github.com/tetratelabs/wazero v1.11.0/go.mod h1:eV28rsN8Q+xwjogd7f4/Pp4xFxO7uOGbLcD/LzB1wiU=
 golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 h1:1P7xPZEwZMoBoz0Yze5Nx2/4pxj6nw9ZqHWXqP0iRgQ=
 golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
 golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=

internal/daemon/server.go

@@ -47,7 +47,7 @@ func New(ctx context.Context, cfg *config.DaemonConfig, resizePolicy config.Resi
 		return nil, fmt.Errorf("daemon: state_persistence_interval must be > 0 when state persistence is enabled")
 	}
 
-	rt, err := libghostty.NewRuntime(ctx)
+	rt, err := libghostty.NewRuntime()
 	if err != nil {
 		return nil, fmt.Errorf("daemon: init wasm runtime: %w", err)
 	}

internal/daemon/server_control.go

@@ -77,7 +77,7 @@ func (s *Server) handleSendKey(conn *protocol.Conn, msg *protocol.SendKey) {
 		return
 	}
 
-	data, err := sess.term.EncodeKey(s.ctx, libghostty.KeyCode(msg.Key), libghostty.Modifier(msg.Mods))
+	data, err := sess.term.EncodeKey(libghostty.KeyCode(msg.Key), libghostty.Modifier(msg.Mods))
 	if err != nil {
 		writeError(conn, err.Error())
 		return

internal/daemon/server_inspect.go

@@ -119,19 +119,19 @@ func dumpFormat(format protocol.DumpFormat) libghostty.DumpFormat {
 func dumpDeadState(ctx context.Context, rt *libghostty.Runtime, state *sessionState, scrollback uint32, format protocol.DumpFormat) ([]byte, error) {
 	scrollback = max(scrollback, uint32(bytes.Count(state.VT, []byte{'\n'}))+uint32(state.Rows)+1)
 
-	term, err := rt.NewTerminal(ctx, uint32(state.Cols), uint32(state.Rows), scrollback)
+	term, err := rt.NewTerminal(uint32(state.Cols), uint32(state.Rows), scrollback)
 	if err != nil {
 		return nil, fmt.Errorf("dump dead state: new terminal: %w", err)
 	}
-	defer term.Close(ctx)
+	defer term.Close()
 
 	if len(state.VT) > 0 {
-		if err := term.Feed(ctx, state.VT); err != nil {
+		if err := term.Feed(state.VT); err != nil {
 			return nil, fmt.Errorf("dump dead state: feed vt: %w", err)
 		}
 	}
 
-	dump, err := term.DumpScreen(ctx, dumpFormat(format))
+	dump, err := term.DumpScreen(dumpFormat(format))
 	if err != nil {
 		return nil, fmt.Errorf("dump dead state: dump screen: %w", err)
 	}
@@ -227,7 +227,7 @@ func (s *Server) statusSnapshot(sessionName string) (uint32, uint32, *protocol.S
 }
 
 func sessionCWD(ctx context.Context, sess *Session) (string, error) {
-	cwd, ok, err := sess.term.GetCwd(ctx)
+	cwd, ok, err := sess.term.GetCwd()
 	if err != nil {
 		return "", fmt.Errorf("lookup cwd for %s: %w", sess.Name, err)
 	}

internal/daemon/session_clients.go

@@ -97,7 +97,7 @@ func (s *Session) resize(size termSize) {
 		slog.Warn("pty setsize", "session", s.Name, "err", err)
 	}
 	_ = syscall.Kill(-int(s.PID), syscall.SIGWINCH)
-	if err := s.term.Resize(s.ctx, uint32(size.cols), uint32(size.rows)); err != nil {
+	if err := s.term.Resize(uint32(size.cols), uint32(size.rows)); err != nil {
 		slog.Warn("wasm resize", "session", s.Name, "err", err)
 	}
 }

internal/daemon/session_lifecycle.go

@@ -68,48 +68,48 @@ func startSession(ctx context.Context, launch *sessionLaunch, term *libghostty.T
 }
 
 func newSession(ctx context.Context, wasmRT *libghostty.Runtime, resizePolicy config.ResizePolicy, spec sessionStartSpec) (*Session, error) {
-	term, err := wasmRT.NewTerminal(ctx, uint32(spec.size.cols), uint32(spec.size.rows), spec.scrollback)
+	term, err := wasmRT.NewTerminal(uint32(spec.size.cols), uint32(spec.size.rows), spec.scrollback)
 	if err != nil {
 		return nil, err
 	}
 
 	launch, err := launchSessionProcess(spec)
 	if err != nil {
-		term.Close(ctx)
+		term.Close()
 		return nil, err
 	}
 
 	return startSession(ctx, launch, term, resizePolicy, spec), nil
 }
 
 func restoreSession(ctx context.Context, wasmRT *libghostty.Runtime, state *sessionState, resizePolicy config.ResizePolicy, spec sessionStartSpec) (*Session, error) {
-	term, err := wasmRT.NewTerminal(ctx, uint32(state.Cols), uint32(state.Rows), spec.scrollback)
+	term, err := wasmRT.NewTerminal(uint32(state.Cols), uint32(state.Rows), spec.scrollback)
 	if err != nil {
 		return nil, err
 	}
 
 	cleanup := true
 	defer func() {
 		if cleanup {
-			term.Close(ctx)
+			term.Close()
 		}
 	}()
 
 	if len(state.VT) > 0 {
-		if err := term.Feed(ctx, state.VT); err != nil {
+		if err := term.Feed(state.VT); err != nil {
 			return nil, err
 		}
 	}
 	if state.IsAltScreen {
-		if err := term.Feed(ctx, []byte("\x1b[?1049l")); err != nil {
+		if err := term.Feed([]byte("\x1b[?1049l")); err != nil {
 			return nil, err
 		}
 	}
-	if err := term.Feed(ctx, []byte("\x1b[!p")); err != nil {
+	if err := term.Feed([]byte("\x1b[!p")); err != nil {
 		return nil, err
 	}
 	if state.Cols != spec.size.cols || state.Rows != spec.size.rows {
-		if err := term.Resize(ctx, uint32(spec.size.cols), uint32(spec.size.rows)); err != nil {
+		if err := term.Resize(uint32(spec.size.cols), uint32(spec.size.rows)); err != nil {
 			slog.Warn("wasm resize on restore", "session", spec.name, "err", err)
 		}
 	}
@@ -125,7 +125,7 @@ func restoreSession(ctx context.Context, wasmRT *libghostty.Runtime, state *sess
 
 func (s *Session) feedLoop(ctx context.Context) {
 	for item := range s.feedCh {
-		if err := s.term.Feed(ctx, *item.data); err != nil {
+		if err := s.term.Feed(*item.data); err != nil {
 			slog.Debug("wasm feed error", "session", s.Name, "err", err)
 		}
 		s.feedApplied.Store(item.seq)
@@ -240,7 +240,7 @@ func (s *Session) run() {
 				// Attach dumps must reflect every PTY chunk we've already accepted.
 				s.waitFeedApplied(nextFeedSeq)
 
-				dump, err := s.term.DumpScreen(s.ctx, libghostty.DumpVTFull)
+				dump, err := s.term.DumpScreen(libghostty.DumpVTFull)
 				if err != nil {
 					a.result <- attachResp{err: err}
 					continue
@@ -363,7 +363,7 @@ func (s *Session) close(ctx context.Context) {
 		_ = syscall.Kill(-int(s.PID), syscall.SIGKILL)
 		<-s.done
 	}
-	s.term.Close(ctx)
+	s.term.Close()
 	if s.tempDir != "" {
 		os.RemoveAll(s.tempDir)
 	}
@@ -379,7 +379,7 @@ func (s *Session) sendInput(data []byte) error {
 }
 
 func (s *Session) dumpScreen(ctx context.Context, format libghostty.DumpFormat) (*libghostty.ScreenDump, error) {
-	return s.term.DumpScreen(ctx, format)
+	return s.term.DumpScreen(format)
 }
 
 func exitCodeFromWaitStatus(ws syscall.WaitStatus) int32 {

internal/daemon/session_loop_test.go

@@ -25,13 +25,13 @@ func (discardRW) Write(p []byte) (int, error) {
 
 func newSessionLoopHarness(t *testing.T) *Session {
 	ctx := t.Context()
-	rt, err := libghostty.NewRuntime(ctx)
+	rt, err := libghostty.NewRuntime()
 	assert.NilError(t, err)
 	t.Cleanup(func() {
 		assert.NilError(t, rt.Close())
 	})
 
-	term, err := rt.NewTerminal(ctx, 80, 24, 0)
+	term, err := rt.NewTerminal(80, 24, 0)
 	assert.NilError(t, err)
 
 	ptmx, tty, err := pty.Open()
@@ -63,7 +63,7 @@ func newSessionLoopHarness(t *testing.T) *Session {
 		<-s.done
 		assert.NilError(t, ptmx.Close())
 		assert.NilError(t, tty.Close())
-		assert.NilError(t, term.Close(ctx))
+		assert.NilError(t, term.Close())
 	})
 
 	return s