Use zle redraw hook if available (>= 5.4)

CHANGELOG.md

@@ -1,22 +1,5 @@
 # Changelog
 
-## v0.6.0
-- Added `completion` suggestion strategy powered by completion system (#111)
-- Allow setting `ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE` to an empty string (#422)
-- Don't fetch suggestions after copy-earlier-word (#439)
-- Allow users to unignore zle-\* widgets (e.g. zle-line-init) (#432)
-
-
-## v0.5.2
-- Allow disabling automatic widget re-binding for better performance (#418)
-- Fix async suggestions when `SH_WORD_SPLIT` is set
-- Refactor async mode to use process substitution instead of zpty (#417)
-
-## v0.5.1
-- Speed up widget rebinding (#413)
-- Clean up global variable creations (#403)
-- Respect user's set options when running original widget (#402)
-
 ## v0.5.0
 - Don't overwrite config with default values (#335)
 - Support fallback strategies by supplying array to suggestion config var
@@ -53,7 +36,7 @@
 - Experimental support for asynchronous suggestions (#170)
 - Fix problems with multi-line suggestions (#225)
 - Optimize case where manually typing in suggestion
-- Avoid wrapping any zle-\* widgets (#206)
+- Avoid wrapping any zle-* widgets (#206)
 - Remove support for deprecated options from v0.0.x
 - Handle history entries that begin with dashes
 - Gracefully handle being sourced multiple times (#126)

LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2013 Thiago de Arruda
-Copyright (c) 2016-2019 Eric Freese
+Copyright (c) 2016-2018 Eric Freese
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

Makefile

@@ -1,8 +1,10 @@
 SRC_DIR    := ./src
 
 SRC_FILES := \
+	$(SRC_DIR)/setup.zsh \
 	$(SRC_DIR)/config.zsh \
 	$(SRC_DIR)/util.zsh \
+	$(SRC_DIR)/features.zsh \
 	$(SRC_DIR)/bind.zsh \
 	$(SRC_DIR)/highlight.zsh \
 	$(SRC_DIR)/widgets.zsh \

README.md

@@ -2,7 +2,7 @@
 
 _[Fish](http://fishshell.com/)-like fast/unobtrusive autosuggestions for zsh._
 
-It suggests commands as you type.
+It suggests commands as you type, based on command history.
 
 Requirements: Zsh v4.3.11 or later
 
@@ -34,26 +34,15 @@ You may want to override the default global config variables. Default values of
 
 ### Suggestion Highlight Style
 
-Set `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE` to configure the style that the suggestion is shown with. The default is `fg=8`, which will set the foreground color to color 8 from the 256-color palette. If your terminal only supports 8 colors, you will need to use a number between 0 and 7.
+Set `ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE` to configure the style that the suggestion is shown with. The default is `fg=8`.
-
-Background color can also be set, and the suggestion can be styled bold, underlined, or standout. For example, this would show suggestions with bold, underlined, pink text on a cyan background:
-
-```sh
-ZSH_AUTOSUGGEST_HIGHLIGHT_STYLE="fg=#ff00ff,bg=cyan,bold,underline"
-```
-
-For more info, read the Character Highlighting section of the zsh manual: `man zshzle` or [online](http://zsh.sourceforge.net/Doc/Release/Zsh-Line-Editor.html#Character-Highlighting).
 
 
 ### Suggestion Strategy
 
-`ZSH_AUTOSUGGEST_STRATEGY` is an array that specifies how suggestions should be generated. The strategies in the array are tried successively until a suggestion is found. There are currently three built-in strategies to choose from:
+`ZSH_AUTOSUGGEST_STRATEGY` is an array that specifies how suggestions should be generated. The strategies in the array are tried successively until a suggestion is found. There are currently two built-in strategies to choose from:
 
 - `history`: Chooses the most recent match from history.
 - `match_prev_cmd`: Like `history`, but chooses the most recent match whose preceding history item matches the most recently executed command ([more info](src/strategies/match_prev_cmd.zsh)). Note that this strategy won't work as expected with ZSH options that don't preserve the history order such as `HIST_IGNORE_ALL_DUPS` or `HIST_EXPIRE_DUPS_FIRST`.
-- `completion`: (experimental) Chooses a suggestion based on what tab-completion would suggest. (requires `zpty` module)
-
-For example, setting `ZSH_AUTOSUGGEST_STRATEGY=(history completion)` will first try to find a suggestion from your history, but, if it can't find a match, will find a suggestion from the completion engine.
 
 
 ### Widget Mapping
@@ -74,15 +63,11 @@ Widgets that modify the buffer and are not found in any of these arrays will fet
 ### Disabling suggestion for large buffers
 
 Set `ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE` to an integer value to disable autosuggestion for large buffers. The default is unset, which means that autosuggestion will be tried for any buffer size. Recommended value is 20.
-This can be useful when pasting large amount of text in the terminal, to avoid triggering autosuggestion for strings that are too long.
+This can be useful when pasting large amount of text in the terminal, to avoid triggering autosuggestion for too long strings.
 
 ### Enable Asynchronous Mode
 
-As of `v0.4.0`, suggestions can be fetched asynchronously. To enable this behavior, set the `ZSH_AUTOSUGGEST_USE_ASYNC` variable (it can be set to anything).
+As of `v0.4.0`, suggestions can be fetched asynchronously using the `zsh/zpty` module. To enable this behavior, set the `ZSH_AUTOSUGGEST_USE_ASYNC` variable (it can be set to anything).
-
-### Disabling automatic widget re-binding
-
-Set `ZSH_AUTOSUGGEST_MANUAL_REBIND` (it can be set to anything) to disable automatic widget re-binding on each precmd. This can be a big boost to performance, but you'll need to handle re-binding yourself if any of the widget lists change or if you or another plugin wrap any of the autosuggest widgets. To re-bind widgets, run `_zsh_autosuggest_bind_widgets`.
 
 
 ### Key Bindings

VERSION

@@ -1 +1 @@
-v0.6.0
+v0.5.0

ZSH_VERSIONS

@@ -13,4 +13,3 @@
 5.4.2
 5.5.1
 5.6.2
-5.7.1

install_test_zsh.sh

@@ -13,7 +13,7 @@ for v in $(grep "^[^#]" ZSH_VERSIONS); do
               --enable-cap \
               --enable-multibyte \
               --with-term-lib='ncursesw tinfo' \
-              --with-tcsetpgrp \
+              --without-tcsetpgrp \
               --program-suffix="-$v"
 
   make install.bin

spec/async_spec.rb

@@ -1,4 +1,8 @@
 context 'with asynchronous suggestions enabled' do
+  before do
+    skip 'Async mode not supported below v5.0.8' if session.zsh_version < Gem::Version.new('5.0.8')
+  end
+
   let(:options) { ["ZSH_AUTOSUGGEST_USE_ASYNC="] }
 
   describe '`up-line-or-beginning-search`' do
@@ -27,42 +31,52 @@ context 'with asynchronous suggestions enabled' do
     end
   end
 
-  describe '`copy-earlier-word`' do
+  it 'should not add extra carriage returns before newlines' do
-    let(:before_sourcing) do
-      -> do
     session.
-          run_command('autoload -Uz copy-earlier-word').
+      send_string('echo "').
-          run_command('zle -N copy-earlier-word').
+      send_keys('escape').
-          run_command('bindkey "^N" copy-earlier-word')
+      send_keys('enter').
-      end
+      send_string('"').
-    end
+      send_keys('enter')
 
-    it 'should cycle through previous words in the buffer' do
     session.clear_screen
-      session.send_string('foo bar baz')
+
-      sleep 0.5
+    session.send_string('echo')
-      session.send_keys('C-n')
+    wait_for { session.content }.to eq("echo \"\n\"")
-      wait_for { session.content }.to eq('foo bar bazbaz')
-      session.send_keys('C-n')
-      wait_for { session.content }.to eq('foo bar bazbar')
-      session.send_keys('C-n')
-      wait_for { session.content }.to eq('foo bar bazfoo')
-    end
   end
 
-  describe 'pressing ^C after fetching a suggestion' do
+  it 'should treat carriage returns and newlines as separate characters' do
-    before do
+    session.
-      skip 'Workaround does not work below v5.0.8' if session.zsh_version < Gem::Version.new('5.0.8')
+      send_string('echo "').
+      send_keys('C-v').
+      send_keys('enter').
+      send_string('foo"').
+      send_keys('enter')
+
+    session.
+      send_string('echo "').
+      send_keys('control').
+      send_keys('enter').
+      send_string('bar"').
+      send_keys('enter')
+
+    session.clear_screen
+
+    session.
+      send_string('echo "').
+      send_keys('C-v').
+      send_keys('enter')
+
+    wait_for { session.content }.to eq('echo "^Mfoo"')
   end
 
-    it 'terminates the prompt and begins a new one' do
+  describe 'exiting a subshell' do
-      session.send_keys('e')
+    it 'should not cause error messages to be printed' do
-      sleep 0.5
+      session.run_command('$(exit)')
-      session.send_keys('C-c')
-      sleep 0.5
-      session.send_keys('echo')
 
-      wait_for { session.content }.to eq("e\necho")
+      sleep 1
+
+      expect(session.content).to eq('$(exit)')
     end
   end
 end

spec/integrations/bracketed_paste_magic_spec.rb

@@ -24,20 +24,4 @@ describe 'pasting using bracketed-paste-magic' do
       end
     end
   end
-
-  context 'with `bracketed-paste` added to the list of widgets that clear the suggestion' do
-    let(:options) { ['ZSH_AUTOSUGGEST_CLEAR_WIDGETS+=(bracketed-paste)'] }
-
-    it 'does not retain an old suggestion' do
-      with_history ('echo foo') do
-        session.send_string('echo ')
-        wait_for { session.content }.to eq('echo foo')
-        session.paste_string('bar')
-        wait_for { session.content }.to eq('echo bar')
-        session.send_keys('C-a') # Any cursor movement works
-        sleep 1
-        expect(session.content).to eq('echo bar')
-      end
-    end
-  end
 end

spec/integrations/client_zpty_spec.rb

@@ -1,14 +1,10 @@
 describe 'a running zpty command' do
   let(:before_sourcing) { -> { session.run_command('zmodload zsh/zpty && zpty -b kitty cat') } }
 
-  context 'when using `completion` strategy' do
+  it 'is not affected by running zsh-autosuggestions' do
-    let(:options) { ["ZSH_AUTOSUGGEST_STRATEGY=completion"] }
+    sleep 1 # Give a little time for precmd hooks to run
-
-    it 'is not affected' do
-      session.send_keys('a').send_keys('C-h')
     session.run_command('zpty -t kitty; echo $?')
 
     wait_for { session.content }.to end_with("\n0")
   end
-  end
 end

spec/integrations/wrapped_widget_spec.rb

@@ -1,17 +1,25 @@
 describe 'a wrapped widget' do
   let(:widget) { 'backward-delete-char' }
 
-  context 'initialized before sourcing the plugin' do
+  let(:initialize_widget) do
-    let(:before_sourcing) do
     -> do
-        session.
+      session.run_command(<<~ZSH)
-          run_command("_orig_#{widget}() { zle .#{widget} }").
+        if [[ "$widgets[#{widget}]" == "builtin" ]]; then
-          run_command("zle -N orig-#{widget} _orig_#{widget}").
+          _orig_#{widget}() { zle .#{widget} }
-          run_command("#{widget}-magic() { zle orig-#{widget}; BUFFER+=b }").
+          zle -N orig-#{widget} _orig_#{widget}
-          run_command("zle -N #{widget} #{widget}-magic")
+        else
+          zle -N orig-#{widget} ${widgets[#{widget}]#*:}
+        fi
+
+        #{widget}-magic() { zle orig-#{widget}; BUFFER+=b }
+        zle -N #{widget} #{widget}-magic
+      ZSH
     end
   end
 
+  context 'initialized before sourcing the plugin' do
+    let(:before_sourcing) { initialize_widget }
+
     it 'executes the custom behavior and the built-in behavior' do
       with_history('foobar', 'foodar') do
         session.send_string('food').send_keys('C-h')
@@ -21,13 +29,7 @@ describe 'a wrapped widget' do
   end
 
   context 'initialized after sourcing the plugin' do
-    before do
+    let(:after_sourcing) { initialize_widget }
-      session.
-        run_command("zle -N orig-#{widget} ${widgets[#{widget}]#*:}").
-        run_command("#{widget}-magic() { zle orig-#{widget}; BUFFER+=b }").
-        run_command("zle -N #{widget} #{widget}-magic").
-        clear_screen
-    end
 
     it 'executes the custom behavior and the built-in behavior' do
       with_history('foobar', 'foodar') do

spec/integrations/zle_input_stack_spec.rb

@@ -9,8 +9,9 @@ describe 'using `zle -U`' do
 
   let(:options) { ['unset ZSH_AUTOSUGGEST_USE_ASYNC', 'ZSH_AUTOSUGGEST_STRATEGY=test'] }
 
-  # TODO: This is only possible with the $KEYS_QUEUED_COUNT widget parameter, coming soon...
+  it 'does not fetch a suggestion for every inserted character' do
-  xit 'does not fetch a suggestion for every inserted character' do
+    skip 'KEYS_QUEUED_COUNT not supported below v5.4.0' if session.zsh_version < Gem::Version.new('5.4.0')
+
     session.send_keys('C-b')
     wait_for { session.content }.to eq('echo hello')
   end

spec/line_init_spec.rb

@@ -1,17 +0,0 @@
-context 'with zle-line-init unignored' do
-  let(:after_sourcing) do
-    -> do
-      session.
-        run_command('setopt extendedglob').
-        run_command('ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(${(@)ZSH_AUTOSUGGEST_IGNORE_WIDGETS:#zle-\*} zle-\^line-init)').
-        run_command('zle-line-init() { BUFFER="echo" }')
-    end
-  end
-
-  it 'should fetch a suggestion on each line initialization' do
-    with_history('echo foo') do
-      session.run_command('zle -N zle-line-init')
-      wait_for { session.content }.to end_with('echo foo')
-    end
-  end
-end

spec/options/async_zpty_name_spec.rb

@@ -0,0 +1,19 @@
+context 'when async suggestions are enabled' do
+  let(:options) { ["ZSH_AUTOSUGGEST_USE_ASYNC="] }
+
+  describe 'the zpty for async suggestions' do
+    it 'is created with the default name' do
+      session.run_command('zpty -t zsh_autosuggest_pty &>/dev/null; echo $?')
+      wait_for { session.content }.to end_with("\n0")
+    end
+
+    context 'when ZSH_AUTOSUGGEST_ASYNC_PTY_NAME is set' do
+      let(:options) { super() + ['ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=foo_pty'] }
+
+      it 'is created with the specified name' do
+        session.run_command('zpty -t foo_pty &>/dev/null; echo $?')
+        wait_for { session.content }.to end_with("\n0")
+      end
+    end
+  end
+end

spec/options/widget_lists_spec.rb

@@ -41,12 +41,20 @@ describe 'a zle widget' do
     end
   end
 
+  context 'that accesses POSTDISPLAY' do
+    before { session.run_command("#{widget}() { zle -M \"POSTDISPLAY=$POSTDISPLAY\" }") }
+
     context 'when added to ZSH_AUTOSUGGEST_IGNORE_WIDGETS' do
       let(:options) { ["ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(#{widget})"] }
 
-    it 'should not be wrapped with an autosuggest widget' do
+      it 'gets the correct POSTDISPLAY value' do
-      session.run_command("echo $widgets[#{widget}]")
+        with_history('echo hello') do
-      wait_for { session.content }.to end_with("\nuser:#{widget}")
+          session.send_string('e')
+          wait_for { session.content }.to start_with('echo hello')
+          session.send_keys('C-b')
+          wait_for { session.content }.to end_with("\nPOSTDISPLAY=cho hello")
+        end
+      end
     end
   end
 
@@ -94,27 +102,4 @@ describe 'a modification to the widget lists' do
       wait_for { session.content(esc_seqs: true) }.to eq('echo hello')
     end
   end
-
-  context 'when manual rebind is enabled' do
-    let(:options) { ["ZSH_AUTOSUGGEST_MANUAL_REBIND=true"] }
-
-    it 'does not take effect until bind command is re-run' do
-      with_history('echo hello') do
-        session.send_string('e')
-        wait_for { session.content }.to eq('echo hello')
-        session.send_keys('C-b')
-        sleep 1
-        expect(session.content(esc_seqs: true)).not_to eq('echo hello')
-
-        session.send_keys('C-c')
-        session.run_command('_zsh_autosuggest_bind_widgets').clear_screen
-        wait_for { session.content }.to eq('')
-
-        session.send_string('e')
-        wait_for { session.content }.to eq('echo hello')
-        session.send_keys('C-b')
-        wait_for { session.content(esc_seqs: true) }.to eq('echo hello')
-      end
-    end
-  end
 end

spec/spec_helper.rb

@@ -11,7 +11,8 @@ RSpec.shared_context 'terminal session' do
 
   around do |example|
     before_sourcing.call
-    session.run_command(['source zsh-autosuggestions.zsh', *options].join('; '))
+    session.run_command(options.join('; '))
+    session.run_command('source zsh-autosuggestions.zsh')
     after_sourcing.call
     session.clear_screen
 

spec/strategies/completion_spec.rb

@@ -1,38 +0,0 @@
-describe 'the `completion` suggestion strategy' do
-  let(:options) { ['ZSH_AUTOSUGGEST_STRATEGY=completion'] }
-  let(:before_sourcing) do
-    -> do
-      session.
-        run_command('autoload compinit && compinit').
-        run_command('_foo() { compadd bar; compadd bat }').
-        run_command('compdef _foo baz')
-    end
-  end
-
-  it 'suggests the first completion result' do
-    session.send_string('baz ')
-    wait_for { session.content }.to eq('baz bar')
-  end
-
-  it 'does not add extra carriage returns when prefix has a line feed' do
-    skip '`stty` does not work inside zpty below zsh version 5.0.3' if session.zsh_version < Gem::Version.new('5.0.3')
-    session.send_string('baz \\').send_keys('C-v', 'C-j')
-    wait_for { session.content }.to eq("baz \\\nbar")
-  end
-
-  context 'when async mode is enabled' do
-    let(:options) { ['ZSH_AUTOSUGGEST_USE_ASYNC=true', 'ZSH_AUTOSUGGEST_STRATEGY=completion'] }
-
-    it 'suggests the first completion result' do
-      session.send_string('baz ')
-      wait_for { session.content }.to eq('baz bar')
-    end
-
-    it 'does not add extra carriage returns when prefix has a line feed' do
-      skip '`stty` does not work inside zpty below zsh version 5.0.3' if session.zsh_version < Gem::Version.new('5.0.3')
-      session.send_string('baz \\').send_keys('C-v', 'C-j')
-      wait_for { session.content }.to eq("baz \\\nbar")
-    end
-  end
-end
-

src/async.zsh

@@ -3,70 +3,107 @@
 # Async                                                              #
 #--------------------------------------------------------------------#
 
-zmodload zsh/system
+# Zpty process is spawned running this function
+_zsh_autosuggest_async_server() {
+	emulate -R zsh
 
-_zsh_autosuggest_async_request() {
+	# There is a bug in zpty module (fixed in zsh/master) by which a
-	typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
+	# zpty that exits will kill all zpty processes that were forked
+	# before it. Here we set up a zsh exit hook to SIGKILL the zpty
+	# process immediately, before it has a chance to kill any other
+	# zpty processes.
+	zshexit() {
+		kill -KILL $$
+		sleep 1 # Block for long enough for the signal to come through
+	}
 
-	# If we've got a pending request, cancel it
+	# Don't add any extra carriage returns
-	if [[ -n "$_ZSH_AUTOSUGGEST_ASYNC_FD" ]] && { true <&$_ZSH_AUTOSUGGEST_ASYNC_FD } 2>/dev/null; then
+	stty -onlcr
-		# Close the file descriptor and remove the handler
-		exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&-
-		zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD
 
-		# Zsh will make a new process group for the child process only if job
+	# Don't translate carriage returns to newlines
-		# control is enabled (MONITOR option)
+	stty -icrnl
-		if [[ -o MONITOR ]]; then
-			# Send the signal to the process group to kill any processes that may
-			# have been forked by the suggestion strategy
-			kill -TERM -$_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
-		else
-			# Kill just the child process since it wasn't placed in a new process
-			# group. If the suggestion strategy forked any child processes they may
-			# be orphaned and left behind.
-			kill -TERM $_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
-		fi
-	fi
 
-	# Fork a process to fetch a suggestion and open a pipe to read from it
+	# Silence any error messages
-	exec {_ZSH_AUTOSUGGEST_ASYNC_FD}< <(
+	exec 2>/dev/null
-		# Tell parent process our pid
-		echo $sysparams[pid]
 
-		# Fetch and print the suggestion
+	local last_pid
+
+	while IFS='' read -r -d $'\0' query; do
+		# Kill last bg process
+		kill -KILL $last_pid &>/dev/null
+
+		# Run suggestion search in the background
+		(
 			local suggestion
-		_zsh_autosuggest_fetch_suggestion "$1"
+			_zsh_autosuggest_fetch_suggestion "$query"
-		echo -nE "$suggestion"
+			echo -n -E "$suggestion"$'\0'
-	)
+		) &
 
-	# There's a weird bug here where ^C stops working unless we force a fork
+		last_pid=$!
-	# See https://github.com/zsh-users/zsh-autosuggestions/issues/364
+	done
-	command true
-
-	# Read the pid from the child process
-	read _ZSH_AUTOSUGGEST_CHILD_PID <&$_ZSH_AUTOSUGGEST_ASYNC_FD
-
-	# When the fd is readable, call the response handler
-	zle -F "$_ZSH_AUTOSUGGEST_ASYNC_FD" _zsh_autosuggest_async_response
 }
 
-# Called when new data is ready to be read from the pipe
+_zsh_autosuggest_async_request() {
+	# Write the query to the zpty process to fetch a suggestion
+	zpty -w -n $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME "${1}"$'\0'
+}
+
+# Called when new data is ready to be read from the pty
 # First arg will be fd ready for reading
 # Second arg will be passed in case of error
 _zsh_autosuggest_async_response() {
-	emulate -L zsh
+	setopt LOCAL_OPTIONS EXTENDED_GLOB
 
 	local suggestion
 
-	if [[ -z "$2" || "$2" == "hup" ]]; then
+	zpty -rt $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME suggestion '*'$'\0' 2>/dev/null
-		# Read everything from the fd and give it as a suggestion
+	zle autosuggest-suggest -- "${suggestion%%$'\0'##}"
-		IFS='' read -rd '' -u $1 suggestion
+}
-		zle autosuggest-suggest -- "$suggestion"
 
-		# Close the fd
+_zsh_autosuggest_async_pty_create() {
-		exec {1}<&-
+	# With newer versions of zsh, REPLY stores the fd to read from
+	typeset -h REPLY
+
+	# If we won't get a fd back from zpty, try to guess it
+	if (( ! $_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD )); then
+		integer -l zptyfd
+		exec {zptyfd}>&1  # Open a new file descriptor (above 10).
+		exec {zptyfd}>&-  # Close it so it's free to be used by zpty.
 	fi
 
-	# Always remove the handler
+	# Fork a zpty process running the server function
-	zle -F "$1"
+	zpty -b $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME _zsh_autosuggest_async_server
+
+	# Store the fd so we can remove the handler later
+	if (( REPLY )); then
+		_ZSH_AUTOSUGGEST_PTY_FD=$REPLY
+	else
+		_ZSH_AUTOSUGGEST_PTY_FD=$zptyfd
+	fi
+
+	# Set up input handler from the zpty
+	zle -F $_ZSH_AUTOSUGGEST_PTY_FD _zsh_autosuggest_async_response
+}
+
+_zsh_autosuggest_async_pty_destroy() {
+	# Remove the input handler
+	zle -F $_ZSH_AUTOSUGGEST_PTY_FD &>/dev/null
+
+	# Destroy the zpty
+	zpty -d $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME &>/dev/null
+}
+
+_zsh_autosuggest_async_pty_recreate() {
+	_zsh_autosuggest_async_pty_destroy
+	_zsh_autosuggest_async_pty_create
+}
+
+_zsh_autosuggest_async_start() {
+	typeset -g _ZSH_AUTOSUGGEST_PTY_FD
+
+	_zsh_autosuggest_feature_detect_zpty_returns_fd
+	_zsh_autosuggest_async_pty_recreate
+
+	# We recreate the pty to get a fresh list of history events
+	add-zsh-hook precmd _zsh_autosuggest_async_pty_recreate
 }

src/bind.zsh

@@ -4,8 +4,21 @@
 #--------------------------------------------------------------------#
 
 _zsh_autosuggest_incr_bind_count() {
-	typeset -gi bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]+1))
+	if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then
-	_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=$bind_count
+		((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]++))
+	else
+		_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=1
+	fi
+
+	typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]
+}
+
+_zsh_autosuggest_get_bind_count() {
+	if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then
+		typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]
+	else
+		typeset -gi bind_count=0
+	fi
 }
 
 # Bind a single widget to an autosuggest widget, saving a reference to the original widget
@@ -21,30 +34,30 @@ _zsh_autosuggest_bind_widget() {
 	# Save a reference to the original widget
 	case $widgets[$widget] in
 		# Already bound
-		user:_zsh_autosuggest_(bound|orig)_*)
+		user:_zsh_autosuggest_(bound|orig)_*);;
-			bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$widget]))
-			;;
 
 		# User-defined widget
 		user:*)
 			_zsh_autosuggest_incr_bind_count $widget
-			zle -N $prefix$bind_count-$widget ${widgets[$widget]#*:}
+			zle -N $prefix${bind_count}-$widget ${widgets[$widget]#*:}
 			;;
 
 		# Built-in widget
 		builtin)
 			_zsh_autosuggest_incr_bind_count $widget
 			eval "_zsh_autosuggest_orig_${(q)widget}() { zle .${(q)widget} }"
-			zle -N $prefix$bind_count-$widget _zsh_autosuggest_orig_$widget
+			zle -N $prefix${bind_count}-$widget _zsh_autosuggest_orig_$widget
 			;;
 
 		# Completion widget
 		completion:*)
 			_zsh_autosuggest_incr_bind_count $widget
-			eval "zle -C $prefix$bind_count-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
+			eval "zle -C $prefix${bind_count}-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
 			;;
 	esac
 
+	_zsh_autosuggest_get_bind_count $widget
+
 	# Pass the original widget's name explicitly into the autosuggest
 	# function. Use this passed in widget name to call the original
 	# widget instead of relying on the $WIDGET variable being set
@@ -59,8 +72,28 @@ _zsh_autosuggest_bind_widget() {
 	zle -N -- $widget _zsh_autosuggest_bound_${bind_count}_$widget
 }
 
+_zsh_autosuggest_bind_autosuggest_widgets() {
+	local widget
+
+	for widget in $ZSH_AUTOSUGGEST_CLEAR_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget clear
+	done
+
+	for widget in $ZSH_AUTOSUGGEST_ACCEPT_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget accept
+	done
+
+	for widget in $ZSH_AUTOSUGGEST_EXECUTE_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget execute
+	done
+
+	for widget in $ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget partial_accept
+	done
+}
+
 # Map all configured widgets to the right autosuggest widgets
-_zsh_autosuggest_bind_widgets() {
+_zsh_autosuggest_bind_modify_widgets() {
 	emulate -L zsh
 
 	local widget
@@ -69,25 +102,19 @@ _zsh_autosuggest_bind_widgets() {
 	ignore_widgets=(
 		.\*
 		_\*
+		zle-\*
 		autosuggest-\*
 		$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\*
 		$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+		$ZSH_AUTOSUGGEST_CLEAR_WIDGETS
+		$ZSH_AUTOSUGGEST_ACCEPT_WIDGETS
+		$ZSH_AUTOSUGGEST_EXECUTE_WIDGETS
+		$ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS
 	)
 
-	# Find every widget we might want to bind and bind it appropriately
+	# Assume any widget omitted from the config arrays might modify the buffer
 	for widget in ${${(f)"$(builtin zle -la)"}:#${(j:|:)~ignore_widgets}}; do
-		if [[ -n ${ZSH_AUTOSUGGEST_CLEAR_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget clear
-		elif [[ -n ${ZSH_AUTOSUGGEST_ACCEPT_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget accept
-		elif [[ -n ${ZSH_AUTOSUGGEST_EXECUTE_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget execute
-		elif [[ -n ${ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget partial_accept
-		else
-			# Assume any unspecified widget might modify the buffer
 		_zsh_autosuggest_bind_widget $widget modify
-		fi
 	done
 }
 

src/config.zsh

@@ -35,7 +35,6 @@ typeset -g ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
 		up-line-or-history
 		down-line-or-history
 		accept-line
-		copy-earlier-word
 	)
 }
 
@@ -74,6 +73,7 @@ typeset -g ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
 }
 
 # Widgets that should be ignored (globbing supported but must be escaped)
+# Only relevant for zsh versions older than 5.4
 (( ! ${+ZSH_AUTOSUGGEST_IGNORE_WIDGETS} )) && {
 	typeset -ga ZSH_AUTOSUGGEST_IGNORE_WIDGETS
 	ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(
@@ -84,10 +84,13 @@ typeset -g ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
 		which-command
 		yank
 		yank-pop
-		zle-\*
 	)
 }
 
-# Pty name for capturing completions for completion suggestion strategy
+# Max size of buffer to trigger autosuggestion. Leave null for no upper bound.
-(( ! ${+ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME} )) &&
+(( ! ${+ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE} )) &&
-typeset -g ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME=zsh_autosuggest_completion_pty
+typeset -g ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=
+
+# Pty name for calculating autosuggestions asynchronously
+(( ! ${+ZSH_AUTOSUGGEST_ASYNC_PTY_NAME} )) &&
+typeset -g ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=zsh_autosuggest_pty

src/features.zsh

@@ -0,0 +1,19 @@
+
+#--------------------------------------------------------------------#
+# Feature Detection                                                  #
+#--------------------------------------------------------------------#
+
+_zsh_autosuggest_feature_detect_zpty_returns_fd() {
+	typeset -g _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD
+	typeset -h REPLY
+
+	zpty zsh_autosuggest_feature_detect '{ zshexit() { kill -KILL $$; sleep 1 } }'
+
+	if (( REPLY )); then
+		_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=1
+	else
+		_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=0
+	fi
+
+	zpty -d zsh_autosuggest_feature_detect
+}

src/fetch.zsh

@@ -18,10 +18,7 @@ _zsh_autosuggest_fetch_suggestion() {
 		# Try to get a suggestion from this strategy
 		_zsh_autosuggest_strategy_$strategy "$1"
 
-		# Ensure the suggestion matches the prefix
+		# Break once we've found a suggestion
-		[[ "$suggestion" != "$1"* ]] && unset suggestion
-
-		# Break once we've found a valid suggestion
 		[[ -n "$suggestion" ]] && break
 	done
 }

src/setup.zsh

@@ -0,0 +1,12 @@
+
+#--------------------------------------------------------------------#
+# Setup                                                              #
+#--------------------------------------------------------------------#
+
+# Precmd hooks for initializing the library and starting pty's
+autoload -Uz add-zsh-hook
+autoload -Uz add-zle-hook-widget
+autoload -Uz is-at-least
+
+# Asynchronous suggestions are generated in a pty
+zmodload zsh/zpty

src/start.zsh

@@ -5,19 +5,29 @@
 
 # Start the autosuggestion widgets
 _zsh_autosuggest_start() {
-	# By default we re-bind widgets on every precmd to ensure we wrap other
-	# wrappers. Specifically, highlighting breaks if our widgets are wrapped by
-	# zsh-syntax-highlighting widgets. This also allows modifications to the
-	# widget list variables to take effect on the next precmd. However this has
-	# a decent performance hit, so users can set ZSH_AUTOSUGGEST_MANUAL_REBIND
-	# to disable the automatic re-binding.
-	if (( ${+ZSH_AUTOSUGGEST_MANUAL_REBIND} )); then
 	add-zsh-hook -d precmd _zsh_autosuggest_start
+
+	# Re-bind widgets on every precmd to ensure we wrap other wrappers.
+	# Specifically, highlighting breaks if our widgets are wrapped by
+	# zsh-syntax-highlighting widgets. This also allows modifications
+	# to the widget list variables to take effect on the next precmd.
+	_zsh_autosuggest_bind_autosuggest_widgets
+	add-zsh-hook precmd _zsh_autosuggest_bind_autosuggest_widgets
+
+	# If available, use a ZLE redraw hook to trigger fetching suggestions.
+	# Otherwise, we need to wrap all widgets and fetch suggestions after
+	# running them.
+	if is-at-least 5.4; then
+		add-zle-hook-widget line-pre-redraw autosuggest-redraw
+	else
+		_zsh_autosuggest_bind_modify_widgets
+		add-zsh-hook precmd _zsh_autosuggest_bind_modify_widgets
 	fi
 
-	_zsh_autosuggest_bind_widgets
+	if [[ -n "${ZSH_AUTOSUGGEST_USE_ASYNC+x}" ]]; then
+		_zsh_autosuggest_async_start
+	fi
 }
 
 # Start the autosuggestion widgets on the next precmd
-autoload -Uz add-zsh-hook
 add-zsh-hook precmd _zsh_autosuggest_start

src/strategies/completion.zsh

@@ -1,130 +0,0 @@
-
-#--------------------------------------------------------------------#
-# Completion Suggestion Strategy                                     #
-#--------------------------------------------------------------------#
-# Fetches a suggestion from the completion engine
-#
-
-_zsh_autosuggest_capture_postcompletion() {
-	# Always insert the first completion into the buffer
-	compstate[insert]=1
-
-	# Don't list completions
-	unset 'compstate[list]'
-}
-
-_zsh_autosuggest_capture_completion_widget() {
-	# Add a post-completion hook to be called after all completions have been
-	# gathered. The hook can modify compstate to affect what is done with the
-	# gathered completions.
-	local -a +h comppostfuncs
-	comppostfuncs=(_zsh_autosuggest_capture_postcompletion)
-
-	# Only capture completions at the end of the buffer
-	CURSOR=$#BUFFER
-
-	# Run the original widget wrapping `.complete-word` so we don't
-	# recursively try to fetch suggestions, since our pty is forked
-	# after autosuggestions is initialized.
-	zle -- ${(k)widgets[(r)completion:.complete-word:_main_complete]}
-
-	if is-at-least 5.0.3; then
-		# Don't do any cr/lf transformations. We need to do this immediately before
-		# output because if we do it in setup, onlcr will be re-enabled when we enter
-		# vared in the async code path. There is a bug in zpty module in older versions
-		# where the tty is not properly attached to the pty slave, resulting in stty
-		# getting stopped with a SIGTTOU. See zsh-workers thread 31660 and upstream
-		# commit f75904a38
-		stty -onlcr -ocrnl -F /dev/tty
-	fi
-
-	# The completion has been added, print the buffer as the suggestion
-	echo -nE - $'\0'$BUFFER$'\0'
-}
-
-zle -N autosuggest-capture-completion _zsh_autosuggest_capture_completion_widget
-
-_zsh_autosuggest_capture_setup() {
-	autoload -Uz is-at-least
-
-	# There is a bug in zpty module in older zsh versions by which a
-	# zpty that exits will kill all zpty processes that were forked
-	# before it. Here we set up a zsh exit hook to SIGKILL the zpty
-	# process immediately, before it has a chance to kill any other
-	# zpty processes.
-	if ! is-at-least 5.4; then
-		zshexit() {
-			# The zsh builtin `kill` fails sometimes in older versions
-			# https://unix.stackexchange.com/a/477647/156673
-			kill -KILL $$ 2>&- || command kill -KILL $$
-
-			# Block for long enough for the signal to come through
-			sleep 1
-		}
-	fi
-
-	# Try to avoid any suggestions that wouldn't match the prefix
-	zstyle ':completion:*' matcher-list ''
-	zstyle ':completion:*' path-completion false
-	zstyle ':completion:*' max-errors 0 not-numeric
-
-	bindkey '^I' autosuggest-capture-completion
-}
-
-_zsh_autosuggest_capture_completion_sync() {
-	_zsh_autosuggest_capture_setup
-
-	zle autosuggest-capture-completion
-}
-
-_zsh_autosuggest_capture_completion_async() {
-	_zsh_autosuggest_capture_setup
-
-	zmodload zsh/parameter 2>/dev/null || return # For `$functions`
-
-	# Make vared completion work as if for a normal command line
-	# https://stackoverflow.com/a/7057118/154703
-	autoload +X _complete
-	functions[_original_complete]=$functions[_complete]
-	_complete () {
-		unset 'compstate[vared]'
-		_original_complete "$@"
-	}
-
-	# Open zle with buffer set so we can capture completions for it
-	vared 1
-}
-
-_zsh_autosuggest_strategy_completion() {
-	typeset -g suggestion
-	local line REPLY
-
-	# Exit if we don't have completions
-	whence compdef >/dev/null || return
-
-	# Exit if we don't have zpty
-	zmodload zsh/zpty 2>/dev/null || return
-
-	# Zle will be inactive if we are in async mode
-	if zle; then
-		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_sync
-	else
-		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_async "\$1"
-		zpty -w $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME $'\t'
-	fi
-
-	{
-		# The completion result is surrounded by null bytes, so read the
-		# content between the first two null bytes.
-		zpty -r $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME line '*'$'\0''*'$'\0'
-
-		# Extract the suggestion from between the null bytes.  On older
-		# versions of zsh (older than 5.3), we sometimes get extra bytes after
-		# the second null byte, so trim those off the end.
-		# See http://www.zsh.org/mla/workers/2015/msg03290.html
-		suggestion="${${line#*$'\0'}%$'\0'*}"
-	} always {
-		# Destroy the pty
-		zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME
-	}
-}

src/widgets.zsh

@@ -39,63 +39,28 @@ _zsh_autosuggest_clear() {
 _zsh_autosuggest_modify() {
 	local -i retval
 
-	# Only available in zsh >= 5.4
+	# Save the contents of the postdisplay
-	local -i KEYS_QUEUED_COUNT
-
-	# Save the contents of the buffer/postdisplay
-	local orig_buffer="$BUFFER"
 	local orig_postdisplay="$POSTDISPLAY"
 
-	# Clear suggestion while waiting for next one
+	# Clear suggestion while original widget runs
 	unset POSTDISPLAY
 
 	# Original widget may modify the buffer
 	_zsh_autosuggest_invoke_original_widget $@
 	retval=$?
 
-	emulate -L zsh
+	# Restore postdisplay to be used in redraw
-
-	# Don't fetch a new suggestion if there's more input to be read immediately
-	if (( $PENDING > 0 )) || (( $KEYS_QUEUED_COUNT > 0 )); then
 	POSTDISPLAY="$orig_postdisplay"
-		return $retval
-	fi
 
-	# Optimize if manually typing in the suggestion
+	# Run redraw to fetch a suggestion if needed
-	if (( $#BUFFER > $#orig_buffer )); then
+	_zsh_autosuggest_redraw
-		local added=${BUFFER#$orig_buffer}
-
-		# If the string added matches the beginning of the postdisplay
-		if [[ "$added" = "${orig_postdisplay:0:$#added}" ]]; then
-			POSTDISPLAY="${orig_postdisplay:$#added}"
-			return $retval
-		fi
-	fi
-
-	# Don't fetch a new suggestion if the buffer hasn't changed
-	if [[ "$BUFFER" = "$orig_buffer" ]]; then
-		POSTDISPLAY="$orig_postdisplay"
-		return $retval
-	fi
-
-	# Bail out if suggestions are disabled
-	if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then
-		return $?
-	fi
-
-	# Get a new suggestion if the buffer is not empty after modification
-	if (( $#BUFFER > 0 )); then
-		if [[ -z "$ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" ]] || (( $#BUFFER <= $ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE )); then
-			_zsh_autosuggest_fetch
-		fi
-	fi
 
 	return $retval
 }
 
 # Fetch a new suggestion based on what's currently in the buffer
 _zsh_autosuggest_fetch() {
-	if (( ${+ZSH_AUTOSUGGEST_USE_ASYNC} )); then
+	if zpty -t "$ZSH_AUTOSUGGEST_ASYNC_PTY_NAME" &>/dev/null; then
 		_zsh_autosuggest_async_request "$BUFFER"
 	else
 		local suggestion
@@ -190,9 +155,67 @@ _zsh_autosuggest_partial_accept() {
 	return $retval
 }
 
+_zsh_autosuggest_redraw() {
+	emulate -L zsh
+
+	typeset -g _ZSH_AUTOSUGGEST_LAST_BUFFER
+
+	# Only available in zsh >= 5.4
+	local -i KEYS_QUEUED_COUNT
+
+	local orig_buffer="$_ZSH_AUTOSUGGEST_LAST_BUFFER"
+	local widget
+
+	# Store the current state of the buffer for next time
+	_ZSH_AUTOSUGGEST_LAST_BUFFER="$BUFFER"
+
+	# Buffer hasn't changed
+	[[ "$BUFFER" = "$orig_buffer" ]] && return 0
+
+	local ignore_widgets
+	ignore_widgets=(
+		$ZSH_AUTOSUGGEST_CLEAR_WIDGETS
+		$ZSH_AUTOSUGGEST_ACCEPT_WIDGETS
+		$ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS
+		$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+	)
+
+	# Don't fetch a new suggestion after mapped widgets
+	for widget in $ignore_widgets; do
+		[[ "$LASTWIDGET" == "$widget" ]] && return 0
+	done
+
+	# Optimize if manually typing in the suggestion
+	if (( $#BUFFER > $#orig_buffer )); then
+		local added=${BUFFER#$orig_buffer}
+
+		# If the string added matches the beginning of the postdisplay
+		if [[ "$added" = "${POSTDISPLAY:0:$#added}" ]]; then
+			POSTDISPLAY="${POSTDISPLAY:$#added}"
+			return 0
+		fi
+	fi
+
+	unset POSTDISPLAY
+
+	# Don't fetch a new suggestion if there's more input to be read immediately
+	(( $PENDING > 0 )) || (( $KEYS_QUEUED_COUNT > 0 )) && return 0
+
+	# Buffer is empty
+	(( ! $#BUFFER )) && return 0
+
+	# Buffer longer than max size
+	[[ -n "$ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" ]] && (( $#BUFFER > $ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE )) && return 0
+
+	# Suggestions disabled
+	[[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]] && return 0
+
+	_zsh_autosuggest_fetch
+}
+
 () {
 	local action
-	for action in clear modify fetch suggest accept partial_accept execute enable disable toggle; do
+	for action in clear modify fetch suggest accept partial_accept execute enable disable toggle redraw; do
 		eval "_zsh_autosuggest_widget_$action() {
 			local -i retval
 
@@ -209,6 +232,7 @@ _zsh_autosuggest_partial_accept() {
 		}"
 	done
 
+	zle -N autosuggest-redraw _zsh_autosuggest_widget_redraw
 	zle -N autosuggest-fetch _zsh_autosuggest_widget_fetch
 	zle -N autosuggest-suggest _zsh_autosuggest_widget_suggest
 	zle -N autosuggest-accept _zsh_autosuggest_widget_accept

zsh-autosuggestions.zsh

@@ -1,6 +1,6 @@
 # Fish-like fast/unobtrusive autosuggestions for zsh.
 # https://github.com/zsh-users/zsh-autosuggestions
-# v0.6.0
+# v0.5.0
 # Copyright (c) 2013 Thiago de Arruda
 # Copyright (c) 2016-2018 Eric Freese
 # 
@@ -25,6 +25,18 @@
 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 # OTHER DEALINGS IN THE SOFTWARE.
 
+#--------------------------------------------------------------------#
+# Setup                                                              #
+#--------------------------------------------------------------------#
+
+# Precmd hooks for initializing the library and starting pty's
+autoload -Uz add-zsh-hook
+autoload -Uz add-zle-hook-widget
+autoload -Uz is-at-least
+
+# Asynchronous suggestions are generated in a pty
+zmodload zsh/zpty
+
 #--------------------------------------------------------------------#
 # Global Configuration Variables                                     #
 #--------------------------------------------------------------------#
@@ -61,7 +73,6 @@ typeset -g ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
 		up-line-or-history
 		down-line-or-history
 		accept-line
-		copy-earlier-word
 	)
 }
 
@@ -100,6 +111,7 @@ typeset -g ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
 }
 
 # Widgets that should be ignored (globbing supported but must be escaped)
+# Only relevant for zsh versions older than 5.4
 (( ! ${+ZSH_AUTOSUGGEST_IGNORE_WIDGETS} )) && {
 	typeset -ga ZSH_AUTOSUGGEST_IGNORE_WIDGETS
 	ZSH_AUTOSUGGEST_IGNORE_WIDGETS=(
@@ -110,13 +122,16 @@ typeset -g ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX=autosuggest-orig-
 		which-command
 		yank
 		yank-pop
-		zle-\*
 	)
 }
 
-# Pty name for capturing completions for completion suggestion strategy
+# Max size of buffer to trigger autosuggestion. Leave null for no upper bound.
-(( ! ${+ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME} )) &&
+(( ! ${+ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE} )) &&
-typeset -g ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME=zsh_autosuggest_completion_pty
+typeset -g ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE=
+
+# Pty name for calculating autosuggestions asynchronously
+(( ! ${+ZSH_AUTOSUGGEST_ASYNC_PTY_NAME} )) &&
+typeset -g ZSH_AUTOSUGGEST_ASYNC_PTY_NAME=zsh_autosuggest_pty
 
 #--------------------------------------------------------------------#
 # Utility Functions                                                  #
@@ -129,13 +144,45 @@ _zsh_autosuggest_escape_command() {
 	echo -E "${1//(#m)[\"\'\\()\[\]|*?~]/\\$MATCH}"
 }
 
+#--------------------------------------------------------------------#
+# Feature Detection                                                  #
+#--------------------------------------------------------------------#
+
+_zsh_autosuggest_feature_detect_zpty_returns_fd() {
+	typeset -g _ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD
+	typeset -h REPLY
+
+	zpty zsh_autosuggest_feature_detect '{ zshexit() { kill -KILL $$; sleep 1 } }'
+
+	if (( REPLY )); then
+		_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=1
+	else
+		_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD=0
+	fi
+
+	zpty -d zsh_autosuggest_feature_detect
+}
+
 #--------------------------------------------------------------------#
 # Widget Helpers                                                     #
 #--------------------------------------------------------------------#
 
 _zsh_autosuggest_incr_bind_count() {
-	typeset -gi bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]+1))
+	if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then
-	_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=$bind_count
+		((_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]++))
+	else
+		_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]=1
+	fi
+
+	typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]
+}
+
+_zsh_autosuggest_get_bind_count() {
+	if ((${+_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]})); then
+		typeset -gi bind_count=$_ZSH_AUTOSUGGEST_BIND_COUNTS[$1]
+	else
+		typeset -gi bind_count=0
+	fi
 }
 
 # Bind a single widget to an autosuggest widget, saving a reference to the original widget
@@ -151,30 +198,30 @@ _zsh_autosuggest_bind_widget() {
 	# Save a reference to the original widget
 	case $widgets[$widget] in
 		# Already bound
-		user:_zsh_autosuggest_(bound|orig)_*)
+		user:_zsh_autosuggest_(bound|orig)_*);;
-			bind_count=$((_ZSH_AUTOSUGGEST_BIND_COUNTS[$widget]))
-			;;
 
 		# User-defined widget
 		user:*)
 			_zsh_autosuggest_incr_bind_count $widget
-			zle -N $prefix$bind_count-$widget ${widgets[$widget]#*:}
+			zle -N $prefix${bind_count}-$widget ${widgets[$widget]#*:}
 			;;
 
 		# Built-in widget
 		builtin)
 			_zsh_autosuggest_incr_bind_count $widget
 			eval "_zsh_autosuggest_orig_${(q)widget}() { zle .${(q)widget} }"
-			zle -N $prefix$bind_count-$widget _zsh_autosuggest_orig_$widget
+			zle -N $prefix${bind_count}-$widget _zsh_autosuggest_orig_$widget
 			;;
 
 		# Completion widget
 		completion:*)
 			_zsh_autosuggest_incr_bind_count $widget
-			eval "zle -C $prefix$bind_count-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
+			eval "zle -C $prefix${bind_count}-${(q)widget} ${${(s.:.)widgets[$widget]}[2,3]}"
 			;;
 	esac
 
+	_zsh_autosuggest_get_bind_count $widget
+
 	# Pass the original widget's name explicitly into the autosuggest
 	# function. Use this passed in widget name to call the original
 	# widget instead of relying on the $WIDGET variable being set
@@ -189,8 +236,28 @@ _zsh_autosuggest_bind_widget() {
 	zle -N -- $widget _zsh_autosuggest_bound_${bind_count}_$widget
 }
 
+_zsh_autosuggest_bind_autosuggest_widgets() {
+	local widget
+
+	for widget in $ZSH_AUTOSUGGEST_CLEAR_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget clear
+	done
+
+	for widget in $ZSH_AUTOSUGGEST_ACCEPT_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget accept
+	done
+
+	for widget in $ZSH_AUTOSUGGEST_EXECUTE_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget execute
+	done
+
+	for widget in $ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS; do
+		_zsh_autosuggest_bind_widget $widget partial_accept
+	done
+}
+
 # Map all configured widgets to the right autosuggest widgets
-_zsh_autosuggest_bind_widgets() {
+_zsh_autosuggest_bind_modify_widgets() {
 	emulate -L zsh
 
 	local widget
@@ -199,25 +266,19 @@ _zsh_autosuggest_bind_widgets() {
 	ignore_widgets=(
 		.\*
 		_\*
+		zle-\*
 		autosuggest-\*
 		$ZSH_AUTOSUGGEST_ORIGINAL_WIDGET_PREFIX\*
 		$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+		$ZSH_AUTOSUGGEST_CLEAR_WIDGETS
+		$ZSH_AUTOSUGGEST_ACCEPT_WIDGETS
+		$ZSH_AUTOSUGGEST_EXECUTE_WIDGETS
+		$ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS
 	)
 
-	# Find every widget we might want to bind and bind it appropriately
+	# Assume any widget omitted from the config arrays might modify the buffer
 	for widget in ${${(f)"$(builtin zle -la)"}:#${(j:|:)~ignore_widgets}}; do
-		if [[ -n ${ZSH_AUTOSUGGEST_CLEAR_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget clear
-		elif [[ -n ${ZSH_AUTOSUGGEST_ACCEPT_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget accept
-		elif [[ -n ${ZSH_AUTOSUGGEST_EXECUTE_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget execute
-		elif [[ -n ${ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS[(r)$widget]} ]]; then
-			_zsh_autosuggest_bind_widget $widget partial_accept
-		else
-			# Assume any unspecified widget might modify the buffer
 		_zsh_autosuggest_bind_widget $widget modify
-		fi
 	done
 }
 
@@ -301,63 +362,28 @@ _zsh_autosuggest_clear() {
 _zsh_autosuggest_modify() {
 	local -i retval
 
-	# Only available in zsh >= 5.4
+	# Save the contents of the postdisplay
-	local -i KEYS_QUEUED_COUNT
-
-	# Save the contents of the buffer/postdisplay
-	local orig_buffer="$BUFFER"
 	local orig_postdisplay="$POSTDISPLAY"
 
-	# Clear suggestion while waiting for next one
+	# Clear suggestion while original widget runs
 	unset POSTDISPLAY
 
 	# Original widget may modify the buffer
 	_zsh_autosuggest_invoke_original_widget $@
 	retval=$?
 
-	emulate -L zsh
+	# Restore postdisplay to be used in redraw
-
-	# Don't fetch a new suggestion if there's more input to be read immediately
-	if (( $PENDING > 0 )) || (( $KEYS_QUEUED_COUNT > 0 )); then
 	POSTDISPLAY="$orig_postdisplay"
-		return $retval
-	fi
 
-	# Optimize if manually typing in the suggestion
+	# Run redraw to fetch a suggestion if needed
-	if (( $#BUFFER > $#orig_buffer )); then
+	_zsh_autosuggest_redraw
-		local added=${BUFFER#$orig_buffer}
-
-		# If the string added matches the beginning of the postdisplay
-		if [[ "$added" = "${orig_postdisplay:0:$#added}" ]]; then
-			POSTDISPLAY="${orig_postdisplay:$#added}"
-			return $retval
-		fi
-	fi
-
-	# Don't fetch a new suggestion if the buffer hasn't changed
-	if [[ "$BUFFER" = "$orig_buffer" ]]; then
-		POSTDISPLAY="$orig_postdisplay"
-		return $retval
-	fi
-
-	# Bail out if suggestions are disabled
-	if [[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]]; then
-		return $?
-	fi
-
-	# Get a new suggestion if the buffer is not empty after modification
-	if (( $#BUFFER > 0 )); then
-		if [[ -z "$ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" ]] || (( $#BUFFER <= $ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE )); then
-			_zsh_autosuggest_fetch
-		fi
-	fi
 
 	return $retval
 }
 
 # Fetch a new suggestion based on what's currently in the buffer
 _zsh_autosuggest_fetch() {
-	if (( ${+ZSH_AUTOSUGGEST_USE_ASYNC} )); then
+	if zpty -t "$ZSH_AUTOSUGGEST_ASYNC_PTY_NAME" &>/dev/null; then
 		_zsh_autosuggest_async_request "$BUFFER"
 	else
 		local suggestion
@@ -452,9 +478,67 @@ _zsh_autosuggest_partial_accept() {
 	return $retval
 }
 
+_zsh_autosuggest_redraw() {
+	emulate -L zsh
+
+	typeset -g _ZSH_AUTOSUGGEST_LAST_BUFFER
+
+	# Only available in zsh >= 5.4
+	local -i KEYS_QUEUED_COUNT
+
+	local orig_buffer="$_ZSH_AUTOSUGGEST_LAST_BUFFER"
+	local widget
+
+	# Store the current state of the buffer for next time
+	_ZSH_AUTOSUGGEST_LAST_BUFFER="$BUFFER"
+
+	# Buffer hasn't changed
+	[[ "$BUFFER" = "$orig_buffer" ]] && return 0
+
+	local ignore_widgets
+	ignore_widgets=(
+		$ZSH_AUTOSUGGEST_CLEAR_WIDGETS
+		$ZSH_AUTOSUGGEST_ACCEPT_WIDGETS
+		$ZSH_AUTOSUGGEST_PARTIAL_ACCEPT_WIDGETS
+		$ZSH_AUTOSUGGEST_IGNORE_WIDGETS
+	)
+
+	# Don't fetch a new suggestion after mapped widgets
+	for widget in $ignore_widgets; do
+		[[ "$LASTWIDGET" == "$widget" ]] && return 0
+	done
+
+	# Optimize if manually typing in the suggestion
+	if (( $#BUFFER > $#orig_buffer )); then
+		local added=${BUFFER#$orig_buffer}
+
+		# If the string added matches the beginning of the postdisplay
+		if [[ "$added" = "${POSTDISPLAY:0:$#added}" ]]; then
+			POSTDISPLAY="${POSTDISPLAY:$#added}"
+			return 0
+		fi
+	fi
+
+	unset POSTDISPLAY
+
+	# Don't fetch a new suggestion if there's more input to be read immediately
+	(( $PENDING > 0 )) || (( $KEYS_QUEUED_COUNT > 0 )) && return 0
+
+	# Buffer is empty
+	(( ! $#BUFFER )) && return 0
+
+	# Buffer longer than max size
+	[[ -n "$ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE" ]] && (( $#BUFFER > $ZSH_AUTOSUGGEST_BUFFER_MAX_SIZE )) && return 0
+
+	# Suggestions disabled
+	[[ -n "${_ZSH_AUTOSUGGEST_DISABLED+x}" ]] && return 0
+
+	_zsh_autosuggest_fetch
+}
+
 () {
 	local action
-	for action in clear modify fetch suggest accept partial_accept execute enable disable toggle; do
+	for action in clear modify fetch suggest accept partial_accept execute enable disable toggle redraw; do
 		eval "_zsh_autosuggest_widget_$action() {
 			local -i retval
 
@@ -471,6 +555,7 @@ _zsh_autosuggest_partial_accept() {
 		}"
 	done
 
+	zle -N autosuggest-redraw _zsh_autosuggest_widget_redraw
 	zle -N autosuggest-fetch _zsh_autosuggest_widget_fetch
 	zle -N autosuggest-suggest _zsh_autosuggest_widget_suggest
 	zle -N autosuggest-accept _zsh_autosuggest_widget_accept
@@ -481,136 +566,6 @@ _zsh_autosuggest_partial_accept() {
 	zle -N autosuggest-toggle _zsh_autosuggest_widget_toggle
 }
 
-#--------------------------------------------------------------------#
-# Completion Suggestion Strategy                                     #
-#--------------------------------------------------------------------#
-# Fetches a suggestion from the completion engine
-#
-
-_zsh_autosuggest_capture_postcompletion() {
-	# Always insert the first completion into the buffer
-	compstate[insert]=1
-
-	# Don't list completions
-	unset 'compstate[list]'
-}
-
-_zsh_autosuggest_capture_completion_widget() {
-	# Add a post-completion hook to be called after all completions have been
-	# gathered. The hook can modify compstate to affect what is done with the
-	# gathered completions.
-	local -a +h comppostfuncs
-	comppostfuncs=(_zsh_autosuggest_capture_postcompletion)
-
-	# Only capture completions at the end of the buffer
-	CURSOR=$#BUFFER
-
-	# Run the original widget wrapping `.complete-word` so we don't
-	# recursively try to fetch suggestions, since our pty is forked
-	# after autosuggestions is initialized.
-	zle -- ${(k)widgets[(r)completion:.complete-word:_main_complete]}
-
-	if is-at-least 5.0.3; then
-		# Don't do any cr/lf transformations. We need to do this immediately before
-		# output because if we do it in setup, onlcr will be re-enabled when we enter
-		# vared in the async code path. There is a bug in zpty module in older versions
-		# where the tty is not properly attached to the pty slave, resulting in stty
-		# getting stopped with a SIGTTOU. See zsh-workers thread 31660 and upstream
-		# commit f75904a38
-		stty -onlcr -ocrnl -F /dev/tty
-	fi
-
-	# The completion has been added, print the buffer as the suggestion
-	echo -nE - $'\0'$BUFFER$'\0'
-}
-
-zle -N autosuggest-capture-completion _zsh_autosuggest_capture_completion_widget
-
-_zsh_autosuggest_capture_setup() {
-	autoload -Uz is-at-least
-
-	# There is a bug in zpty module in older zsh versions by which a
-	# zpty that exits will kill all zpty processes that were forked
-	# before it. Here we set up a zsh exit hook to SIGKILL the zpty
-	# process immediately, before it has a chance to kill any other
-	# zpty processes.
-	if ! is-at-least 5.4; then
-		zshexit() {
-			# The zsh builtin `kill` fails sometimes in older versions
-			# https://unix.stackexchange.com/a/477647/156673
-			kill -KILL $$ 2>&- || command kill -KILL $$
-
-			# Block for long enough for the signal to come through
-			sleep 1
-		}
-	fi
-
-	# Try to avoid any suggestions that wouldn't match the prefix
-	zstyle ':completion:*' matcher-list ''
-	zstyle ':completion:*' path-completion false
-	zstyle ':completion:*' max-errors 0 not-numeric
-
-	bindkey '^I' autosuggest-capture-completion
-}
-
-_zsh_autosuggest_capture_completion_sync() {
-	_zsh_autosuggest_capture_setup
-
-	zle autosuggest-capture-completion
-}
-
-_zsh_autosuggest_capture_completion_async() {
-	_zsh_autosuggest_capture_setup
-
-	zmodload zsh/parameter 2>/dev/null || return # For `$functions`
-
-	# Make vared completion work as if for a normal command line
-	# https://stackoverflow.com/a/7057118/154703
-	autoload +X _complete
-	functions[_original_complete]=$functions[_complete]
-	_complete () {
-		unset 'compstate[vared]'
-		_original_complete "$@"
-	}
-
-	# Open zle with buffer set so we can capture completions for it
-	vared 1
-}
-
-_zsh_autosuggest_strategy_completion() {
-	typeset -g suggestion
-	local line REPLY
-
-	# Exit if we don't have completions
-	whence compdef >/dev/null || return
-
-	# Exit if we don't have zpty
-	zmodload zsh/zpty 2>/dev/null || return
-
-	# Zle will be inactive if we are in async mode
-	if zle; then
-		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_sync
-	else
-		zpty $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME _zsh_autosuggest_capture_completion_async "\$1"
-		zpty -w $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME $'\t'
-	fi
-
-	{
-		# The completion result is surrounded by null bytes, so read the
-		# content between the first two null bytes.
-		zpty -r $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME line '*'$'\0''*'$'\0'
-
-		# Extract the suggestion from between the null bytes.  On older
-		# versions of zsh (older than 5.3), we sometimes get extra bytes after
-		# the second null byte, so trim those off the end.
-		# See http://www.zsh.org/mla/workers/2015/msg03290.html
-		suggestion="${${line#*$'\0'}%$'\0'*}"
-	} always {
-		# Destroy the pty
-		zpty -d $ZSH_AUTOSUGGEST_COMPLETIONS_PTY_NAME
-	}
-}
-
 #--------------------------------------------------------------------#
 # History Suggestion Strategy                                        #
 #--------------------------------------------------------------------#
@@ -714,10 +669,7 @@ _zsh_autosuggest_fetch_suggestion() {
 		# Try to get a suggestion from this strategy
 		_zsh_autosuggest_strategy_$strategy "$1"
 
-		# Ensure the suggestion matches the prefix
+		# Break once we've found a suggestion
-		[[ "$suggestion" != "$1"* ]] && unset suggestion
-
-		# Break once we've found a valid suggestion
 		[[ -n "$suggestion" ]] && break
 	done
 }
@@ -726,72 +678,109 @@ _zsh_autosuggest_fetch_suggestion() {
 # Async                                                              #
 #--------------------------------------------------------------------#
 
-zmodload zsh/system
+# Zpty process is spawned running this function
+_zsh_autosuggest_async_server() {
+	emulate -R zsh
 
-_zsh_autosuggest_async_request() {
+	# There is a bug in zpty module (fixed in zsh/master) by which a
-	typeset -g _ZSH_AUTOSUGGEST_ASYNC_FD _ZSH_AUTOSUGGEST_CHILD_PID
+	# zpty that exits will kill all zpty processes that were forked
+	# before it. Here we set up a zsh exit hook to SIGKILL the zpty
+	# process immediately, before it has a chance to kill any other
+	# zpty processes.
+	zshexit() {
+		kill -KILL $$
+		sleep 1 # Block for long enough for the signal to come through
+	}
 
-	# If we've got a pending request, cancel it
+	# Don't add any extra carriage returns
-	if [[ -n "$_ZSH_AUTOSUGGEST_ASYNC_FD" ]] && { true <&$_ZSH_AUTOSUGGEST_ASYNC_FD } 2>/dev/null; then
+	stty -onlcr
-		# Close the file descriptor and remove the handler
-		exec {_ZSH_AUTOSUGGEST_ASYNC_FD}<&-
-		zle -F $_ZSH_AUTOSUGGEST_ASYNC_FD
 
-		# Zsh will make a new process group for the child process only if job
+	# Don't translate carriage returns to newlines
-		# control is enabled (MONITOR option)
+	stty -icrnl
-		if [[ -o MONITOR ]]; then
-			# Send the signal to the process group to kill any processes that may
-			# have been forked by the suggestion strategy
-			kill -TERM -$_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
-		else
-			# Kill just the child process since it wasn't placed in a new process
-			# group. If the suggestion strategy forked any child processes they may
-			# be orphaned and left behind.
-			kill -TERM $_ZSH_AUTOSUGGEST_CHILD_PID 2>/dev/null
-		fi
-	fi
 
-	# Fork a process to fetch a suggestion and open a pipe to read from it
+	# Silence any error messages
-	exec {_ZSH_AUTOSUGGEST_ASYNC_FD}< <(
+	exec 2>/dev/null
-		# Tell parent process our pid
-		echo $sysparams[pid]
 
-		# Fetch and print the suggestion
+	local last_pid
+
+	while IFS='' read -r -d $'\0' query; do
+		# Kill last bg process
+		kill -KILL $last_pid &>/dev/null
+
+		# Run suggestion search in the background
+		(
 			local suggestion
-		_zsh_autosuggest_fetch_suggestion "$1"
+			_zsh_autosuggest_fetch_suggestion "$query"
-		echo -nE "$suggestion"
+			echo -n -E "$suggestion"$'\0'
-	)
+		) &
 
-	# There's a weird bug here where ^C stops working unless we force a fork
+		last_pid=$!
-	# See https://github.com/zsh-users/zsh-autosuggestions/issues/364
+	done
-	command true
-
-	# Read the pid from the child process
-	read _ZSH_AUTOSUGGEST_CHILD_PID <&$_ZSH_AUTOSUGGEST_ASYNC_FD
-
-	# When the fd is readable, call the response handler
-	zle -F "$_ZSH_AUTOSUGGEST_ASYNC_FD" _zsh_autosuggest_async_response
 }
 
-# Called when new data is ready to be read from the pipe
+_zsh_autosuggest_async_request() {
+	# Write the query to the zpty process to fetch a suggestion
+	zpty -w -n $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME "${1}"$'\0'
+}
+
+# Called when new data is ready to be read from the pty
 # First arg will be fd ready for reading
 # Second arg will be passed in case of error
 _zsh_autosuggest_async_response() {
-	emulate -L zsh
+	setopt LOCAL_OPTIONS EXTENDED_GLOB
 
 	local suggestion
 
-	if [[ -z "$2" || "$2" == "hup" ]]; then
+	zpty -rt $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME suggestion '*'$'\0' 2>/dev/null
-		# Read everything from the fd and give it as a suggestion
+	zle autosuggest-suggest -- "${suggestion%%$'\0'##}"
-		IFS='' read -rd '' -u $1 suggestion
+}
-		zle autosuggest-suggest -- "$suggestion"
 
-		# Close the fd
+_zsh_autosuggest_async_pty_create() {
-		exec {1}<&-
+	# With newer versions of zsh, REPLY stores the fd to read from
+	typeset -h REPLY
+
+	# If we won't get a fd back from zpty, try to guess it
+	if (( ! $_ZSH_AUTOSUGGEST_ZPTY_RETURNS_FD )); then
+		integer -l zptyfd
+		exec {zptyfd}>&1  # Open a new file descriptor (above 10).
+		exec {zptyfd}>&-  # Close it so it's free to be used by zpty.
 	fi
 
-	# Always remove the handler
+	# Fork a zpty process running the server function
-	zle -F "$1"
+	zpty -b $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME _zsh_autosuggest_async_server
+
+	# Store the fd so we can remove the handler later
+	if (( REPLY )); then
+		_ZSH_AUTOSUGGEST_PTY_FD=$REPLY
+	else
+		_ZSH_AUTOSUGGEST_PTY_FD=$zptyfd
+	fi
+
+	# Set up input handler from the zpty
+	zle -F $_ZSH_AUTOSUGGEST_PTY_FD _zsh_autosuggest_async_response
+}
+
+_zsh_autosuggest_async_pty_destroy() {
+	# Remove the input handler
+	zle -F $_ZSH_AUTOSUGGEST_PTY_FD &>/dev/null
+
+	# Destroy the zpty
+	zpty -d $ZSH_AUTOSUGGEST_ASYNC_PTY_NAME &>/dev/null
+}
+
+_zsh_autosuggest_async_pty_recreate() {
+	_zsh_autosuggest_async_pty_destroy
+	_zsh_autosuggest_async_pty_create
+}
+
+_zsh_autosuggest_async_start() {
+	typeset -g _ZSH_AUTOSUGGEST_PTY_FD
+
+	_zsh_autosuggest_feature_detect_zpty_returns_fd
+	_zsh_autosuggest_async_pty_recreate
+
+	# We recreate the pty to get a fresh list of history events
+	add-zsh-hook precmd _zsh_autosuggest_async_pty_recreate
 }
 
 #--------------------------------------------------------------------#
@@ -800,19 +789,29 @@ _zsh_autosuggest_async_response() {
 
 # Start the autosuggestion widgets
 _zsh_autosuggest_start() {
-	# By default we re-bind widgets on every precmd to ensure we wrap other
-	# wrappers. Specifically, highlighting breaks if our widgets are wrapped by
-	# zsh-syntax-highlighting widgets. This also allows modifications to the
-	# widget list variables to take effect on the next precmd. However this has
-	# a decent performance hit, so users can set ZSH_AUTOSUGGEST_MANUAL_REBIND
-	# to disable the automatic re-binding.
-	if (( ${+ZSH_AUTOSUGGEST_MANUAL_REBIND} )); then
 	add-zsh-hook -d precmd _zsh_autosuggest_start
+
+	# Re-bind widgets on every precmd to ensure we wrap other wrappers.
+	# Specifically, highlighting breaks if our widgets are wrapped by
+	# zsh-syntax-highlighting widgets. This also allows modifications
+	# to the widget list variables to take effect on the next precmd.
+	_zsh_autosuggest_bind_autosuggest_widgets
+	add-zsh-hook precmd _zsh_autosuggest_bind_autosuggest_widgets
+
+	# If available, use a ZLE redraw hook to trigger fetching suggestions.
+	# Otherwise, we need to wrap all widgets and fetch suggestions after
+	# running them.
+	if is-at-least 5.4; then
+		add-zle-hook-widget line-pre-redraw autosuggest-redraw
+	else
+		_zsh_autosuggest_bind_modify_widgets
+		add-zsh-hook precmd _zsh_autosuggest_bind_modify_widgets
 	fi
 
-	_zsh_autosuggest_bind_widgets
+	if [[ -n "${ZSH_AUTOSUGGEST_USE_ASYNC+x}" ]]; then
+		_zsh_autosuggest_async_start
+	fi
 }
 
 # Start the autosuggestion widgets on the next precmd
-autoload -Uz add-zsh-hook
 add-zsh-hook precmd _zsh_autosuggest_start