Make negative indexing work like python.

This would break a lot of code :|
2025-11-13 05:47:14 +00:00 · 2023-07-14 17:18:20 -05:00
38 changed files with 642 additions and 1128 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,19 +1,7 @@
 # Changelog
 All notable changes to this project will be documented in this file.

-## 1.31.0 - 2023-09-17
- Report line and column when using `janet_dobytes`
- Add `:unless` loop modifier
- Allow calling `reverse` on generators.
- Improve performance of a number of core functions including `partition`, `mean`, `keys`, `values`, `pairs`, `interleave`.
- Add `lengthable?`
- Add `os/sigaction`
- Change `every?` and `any?` to behave like the functional versions of the `and` and `or` macros.
- Fix bug with garbage collecting threaded abstract types.
- Add `:signal` to the `sandbox` function to allow intercepting signals.
-
-## 1.30.0 - 2023-08-05
- Change indexing of `array/remove` to start from -1 at the end instead of -2.
+## Unreleased - ???
 - Add new string escape sequences `\\a`, `\\b`, `\\?`, and `\\'`.
 - Fix bug with marshalling channels
 - Add `div` for floored division
--- a/8
+++ b/8
@@ -48,7 +48,6 @@ SONAME_SETTER=-Wl,-soname,
 # For cross compilation
 HOSTCC?=$(CC)
 HOSTAR?=$(AR)
-# Symbols are (optionally) removed later, keep -g as default!
 CFLAGS?=-O2 -g
 LDFLAGS?=-rdynamic
 RUN:=$(RUN)
@@ -196,9 +195,9 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################

 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.31.dylib
+SONAME=libjanet.1.29.dylib
 else
-SONAME=libjanet.so.1.31
+SONAME=libjanet.so.1.29
 endif

 build/c/shell.c: src/mainclient/shell.c
@@ -267,7 +266,6 @@ build/janet-%.tar.gz: $(JANET_TARGET) \
 	README.md build/c/janet.c build/c/shell.c
 	mkdir -p build/$(JANET_DIST_DIR)/bin
 	cp $(JANET_TARGET) build/$(JANET_DIST_DIR)/bin/
-	strip -x -S 'build/$(JANET_DIST_DIR)/bin/janet'
 	mkdir -p build/$(JANET_DIST_DIR)/include
 	cp build/janet.h build/$(JANET_DIST_DIR)/include/
 	mkdir -p build/$(JANET_DIST_DIR)/lib/
@@ -366,7 +364,7 @@ build/janet.tmLanguage: tools/tm_lang_gen.janet $(JANET_TARGET)
 	$(RUN) $(JANET_TARGET) $< > $@

 compile-commands:
-	# Requires pip install compiledb
+	# Requires pip install copmiledb
 	compiledb make

 clean:
--- a/build_win.bat
+++ b/build_win.bat
@@ -41,32 +41,32 @@ if not exist build\boot mkdir build\boot
@rem Build the bootstrap interpreter
 for %%f in (src\core\*.c) do (
    %JANET_COMPILE% /DJANET_BOOTSTRAP /Fobuild\boot\%%~nf.obj %%f
-    @if not errorlevel 0 goto :BUILDFAIL
+    @if errorlevel 1 goto :BUILDFAIL
 )
 for %%f in (src\boot\*.c) do (
    %JANET_COMPILE% /DJANET_BOOTSTRAP /Fobuild\boot\%%~nf.obj %%f
-    @if not errorlevel 0 goto :BUILDFAIL
+    @if errorlevel 1 goto :BUILDFAIL
 )
 %JANET_LINK% /out:build\janet_boot.exe build\boot\*.obj
-@if not errorlevel 0 goto :BUILDFAIL
+@if errorlevel 1 goto :BUILDFAIL
 build\janet_boot . > build\c\janet.c

@rem Build the sources
 %JANET_COMPILE% /Fobuild\janet.obj build\c\janet.c
-@if not errorlevel 0 goto :BUILDFAIL
+@if errorlevel 1 goto :BUILDFAIL
 %JANET_COMPILE% /Fobuild\shell.obj src\mainclient\shell.c
-@if not errorlevel 0 goto :BUILDFAIL
+@if errorlevel 1 goto :BUILDFAIL

@rem Build the resources
 rc /nologo /fobuild\janet_win.res janet_win.rc

@rem Link everything to main client
 %JANET_LINK% /out:janet.exe build\janet.obj build\shell.obj build\janet_win.res
-@if not errorlevel 0 goto :BUILDFAIL
+@if errorlevel 1 goto :BUILDFAIL

-@rem Build static library (libjanet.lib)
+@rem Build static library (libjanet.a)
 %JANET_LINK_STATIC% /out:build\libjanet.lib build\janet.obj
-@if not errorlevel 0 goto :BUILDFAIL
+@if errorlevel 1 goto :BUILDFAIL

 echo === Successfully built janet.exe for Windows ===
 echo === Run 'build_win test' to run tests. ==
@@ -98,7 +98,7 @@ exit /b 0
 :TEST
 for %%f in (test/suite*.janet) do (
    janet.exe test\%%f
-    @if not errorlevel 0 goto TESTFAIL
+    @if errorlevel 1 goto TESTFAIL
 )
 exit /b 0

@@ -117,7 +117,6 @@ copy README.md dist\README.md

 copy janet.lib dist\janet.lib
 copy janet.exp dist\janet.exp
-copy janet.def dist\janet.def

 janet.exe tools\patch-header.janet src\include\janet.h src\conf\janetconf.h build\janet.h
 copy build\janet.h dist\janet.h
--- a/examples/sigaction.janet
+++ b/examples/sigaction.janet
@@ -1,41 +0,0 @@
-###
-### Usage: janet examples/sigaction.janet 1|2|3|4 &
-###
-### Then at shell: kill -s SIGTERM $!
-###
-
-(defn action
-  []
-  (print "Handled SIGTERM!")
-  (flush)
-  (os/exit 1))
-
-(defn main1
-  []
-  (os/sigaction :term action true)
-  (forever))
-
-(defn main2
-  []
-  (os/sigaction :term action)
-  (forever))
-
-(defn main3
-  []
-  (os/sigaction :term action true)
-  (forever (ev/sleep math/inf)))
-
-(defn main4
-  []
-  (os/sigaction :term action)
-  (forever (ev/sleep math/inf)))
-
-(defn main
-  [& args]
-  (def which (scan-number (get args 1 "1")))
-  (case which
-    1 (main1) # should work
-    2 (main2) # will not work
-    3 (main3) # should work
-    4 (main4) # should work
-    (error "bad main")))
--- a/meson.build
+++ b/meson.build
@@ -20,7 +20,7 @@

 project('janet', 'c',
  default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.31.0')
+  version : '1.29.1')

 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -169,7 +169,7 @@ janet_boot = executable('janet-boot', core_src, boot_src,

 # Build janet.c
 janetc = custom_target('janetc',
-  input : [janet_boot, 'src/boot/boot.janet'],
+  input : [janet_boot],
  output : 'janet.c',
  capture : true,
  command : [
@@ -182,30 +182,23 @@ if not get_option('single_threaded')
  janet_dependencies += thread_dep
 endif

-if cc.has_argument('-fvisibility=hidden')
-  lib_cflags = ['-fvisibility=hidden']
-else
-  lib_cflags = []
-endif
 libjanet = library('janet', janetc,
  include_directories : incdir,
  dependencies : janet_dependencies,
  version: meson.project_version(),
  soversion: version_parts[0] + '.' + version_parts[1],
-  c_args : lib_cflags,
  install : true)

 # Extra c flags - adding -fvisibility=hidden matches the Makefile and
 # shaves off about 10k on linux x64, likely similar on other platforms.
 if cc.has_argument('-fvisibility=hidden')
-  extra_cflags = ['-fvisibility=hidden', '-DJANET_DLL_IMPORT']
+  extra_cflags = ['-fvisibility=hidden']
 else
-  extra_cflags = ['-DJANET_DLL_IMPORT']
+  extra_cflags = []
 endif
-janet_mainclient = executable('janet', mainclient_src,
+janet_mainclient = executable('janet', janetc, mainclient_src,
  include_directories : incdir,
  dependencies : janet_dependencies,
-  link_with: [libjanet],
  c_args : extra_cflags,
  install : true)

@@ -288,12 +281,11 @@ patched_janet = custom_target('patched-janeth',
  install : true,
  install_dir : join_paths(get_option('includedir'), 'janet'),
  build_by_default : true,
-  output : ['janet_' + meson.project_version() + '.h'],
+  output : ['janet.h'],
  command : [janet_nativeclient, '@INPUT@', '@OUTPUT@'])

 # Create a version of the janet.h header that matches what jpm often expects
 if meson.version().version_compare('>=0.61')
  install_symlink('janet.h', pointing_to: 'janet/janet.h', install_dir: get_option('includedir'))
-  install_symlink('janet.h', pointing_to: 'janet_' + meson.project_version() + '.h', install_dir: join_paths(get_option('includedir'), 'janet'))
 endif

--- a/meson_options.txt
+++ b/meson_options.txt
@@ -18,7 +18,7 @@ option('realpath', type : 'boolean', value : true)
 option('simple_getline', type : 'boolean', value : false)
 option('epoll', type : 'boolean', value : false)
 option('kqueue', type : 'boolean', value : false)
-option('interpreter_interrupt', type : 'boolean', value : true)
+option('interpreter_interrupt', type : 'boolean', value : false)
 option('ffi', type : 'boolean', value : true)
 option('ffi_jit', type : 'boolean', value : true)

--- a/src/boot/boot.janet
+++ b/src/boot/boot.janet
@@ -103,13 +103,23 @@
 (defn symbol? "Check if x is a symbol." [x] (= (type x) :symbol))
 (defn keyword? "Check if x is a keyword." [x] (= (type x) :keyword))
 (defn buffer? "Check if x is a buffer." [x] (= (type x) :buffer))
-(defn function? "Check if x is a function (not a cfunction)." [x] (= (type x) :function))
+(defn function? "Check if x is a function (not a cfunction)." [x]
+  (= (type x) :function))
 (defn cfunction? "Check if x a cfunction." [x] (= (type x) :cfunction))
 (defn table? "Check if x a table." [x] (= (type x) :table))
 (defn struct? "Check if x a struct." [x] (= (type x) :struct))
 (defn array? "Check if x is an array." [x] (= (type x) :array))
 (defn tuple? "Check if x is a tuple." [x] (= (type x) :tuple))
 (defn boolean? "Check if x is a boolean." [x] (= (type x) :boolean))
+(defn bytes? "Check if x is a string, symbol, keyword, or buffer." [x]
+  (def t (type x))
+  (if (= t :string) true (if (= t :symbol) true (if (= t :keyword) true (= t :buffer)))))
+(defn dictionary? "Check if x is a table or struct." [x]
+  (def t (type x))
+  (if (= t :table) true (= t :struct)))
+(defn indexed? "Check if x is an array or tuple." [x]
+  (def t (type x))
+  (if (= t :array) true (= t :tuple)))
 (defn truthy? "Check if x is truthy." [x] (if x true false))
 (defn true? "Check if x is true." [x] (= x true))
 (defn false? "Check if x is false." [x] (= x false))
@@ -419,11 +429,9 @@
    (error (string "expected tuple for range, got " x))))

 (defn- range-template
-  [binding object kind rest op comparison]
+  [binding object rest op comparison]
  (let [[start stop step] (check-indexed object)]
-    (case kind
-      :range (for-template binding (if stop start 0) (or stop start) (or step 1) comparison op [rest])
-      :down (for-template binding start (or stop 0) (or step 1) comparison op [rest]))))
+    (for-template binding start stop (or step 1) comparison op [rest])))

 (defn- each-template
  [binding inx kind body]
@@ -438,8 +446,8 @@
              :each ~(,in ,ds ,k)
              :keys k
              :pairs ~[,k (,in ,ds ,k)]))
-         (set ,k (,next ,ds ,k))
-         ,;body))))
+         ,;body
+         (set ,k (,next ,ds ,k))))))

 (defn- iterate-template
  [binding expr body]
@@ -473,17 +481,16 @@
          :repeat (with-syms [iter]
                    ~(do (var ,iter ,verb) (while (> ,iter 0) ,rest (-- ,iter))))
          :when ~(when ,verb ,rest)
-          :unless ~(unless ,verb ,rest)
          (error (string "unexpected loop modifier " binding))))))

  # 3 term expression
  (def {(+ i 2) object} head)
  (let [rest (loop1 body head (+ i 3))]
    (case verb
-      :range (range-template binding object :range rest + <)
-      :range-to (range-template binding object :range rest + <=)
-      :down (range-template binding object :down rest - >)
-      :down-to (range-template binding object :down rest - >=)
+      :range (range-template binding object rest + <)
+      :range-to (range-template binding object rest + <=)
+      :down (range-template binding object rest - >)
+      :down-to (range-template binding object rest - >=)
      :keys (each-template binding object :keys [rest])
      :pairs (each-template binding object :pairs [rest])
      :in (each-template binding object :each [rest])
@@ -590,10 +597,7 @@
  * `:repeat n` -- repeats the next inner loop `n` times.

  * `:when condition` -- only evaluates the current loop body when `condition`
-    is truthy.
-
-  * `:unless condition` -- only evaluates the current loop body when `condition`
-    is falsey.
+    is true.

  The `loop` macro always evaluates to nil.
  ```
@@ -647,12 +651,7 @@
 (defn mean
  "Returns the mean of xs. If empty, returns NaN."
  [xs]
-  (if (lengthable? xs)
-    (/ (sum xs) (length xs))
-    (do
-      (var [accum total] [0 0])
-      (each x xs (+= accum x) (++ total))
-      (/ accum total))))
+  (/ (sum xs) (length xs)))

 (defn product
  "Returns the product of xs. If xs is empty, returns 1."
@@ -701,7 +700,7 @@
    4 (let [[f g h i] functions] (fn [& x] (f (g (h (i ;x))))))
    (let [[f g h i] functions]
      (comp (fn [x] (f (g (h (i x)))))
-            ;(tuple/slice functions 4 -1)))))
+            ;(tuple/slice functions 4)))))

 (defn identity
  "A function that returns its argument."
@@ -713,38 +712,30 @@
  [f]
  (fn [x] (not (f x))))

-(defmacro- do-extreme
-  [order args]
-  ~(do
-     (def ds ,args)
-     (var k (next ds nil))
-     (var ret (get ds k))
-     (while (,not= nil (set k (next ds k)))
-       (def x (in ds k))
-       (if (,order x ret) (set ret x)))
-     ret))
-
 (defn extreme
  ``Returns the most extreme value in `args` based on the function `order`.
  `order` should take two values and return true or false (a comparison).
  Returns nil if `args` is empty.``
-  [order args] (do-extreme order args))
+  [order args]
+  (var [ret] args)
+  (each x args (if (order x ret) (set ret x)))
+  ret)

 (defn max
  "Returns the numeric maximum of the arguments."
-  [& args] (do-extreme > args))
+  [& args] (extreme > args))

 (defn min
  "Returns the numeric minimum of the arguments."
-  [& args] (do-extreme < args))
+  [& args] (extreme < args))

 (defn max-of
  "Returns the numeric maximum of the argument sequence."
-  [args] (do-extreme > args))
+  [args] (extreme > args))

 (defn min-of
  "Returns the numeric minimum of the argument sequence."
-  [args] (do-extreme < args))
+  [args] (extreme < args))

 (defn first
  "Get the first element from an indexed data structure."
@@ -758,14 +749,6 @@

 ## Polymorphic comparisons

-(defmacro- do-compare
-  [x y]
-  ~(if (def f (get ,x :compare))
-     (f ,x ,y)
-     (if (def f (get ,y :compare))
-       (- (f ,y ,x))
-       (cmp ,x ,y))))
-
 (defn compare
  ``Polymorphic compare. Returns -1, 0, 1 for x < y, x = y, x > y respectively.
  Differs from the primitive comparators in that it first checks to
@@ -773,18 +756,20 @@
  compare x and y. If so, it uses that method. If not, it
  delegates to the primitive comparators.``
  [x y]
-  (do-compare x y))
+  (or
+    (when-let [f (get x :compare)] (f x y))
+    (when-let [f (get y :compare)] (- (f y x)))
+    (cmp x y)))

-(defmacro- compare-reduce [op xs]
-  ~(do
-     (var res true)
-     (var x (get ,xs 0))
-     (forv i 1 (length ,xs)
-       (let [y (in ,xs i)]
-         (if (,op (do-compare x y) 0)
-           (set x y)
-           (do (set res false) (break)))))
-     res))
+(defn- compare-reduce [op xs]
+  (var r true)
+  (loop [i :range [0 (- (length xs) 1)]
+         :let [c (compare (xs i) (xs (+ i 1)))
+               ok (op c 0)]
+         :when (not ok)]
+    (set r false)
+    (break))
+  r)

 (defn compare=
  ``Equivalent of `=` but using polymorphic `compare` instead of primitive comparator.``
@@ -824,31 +809,21 @@
 ###
 ###

-(defmacro- median-of-three
-  [x y z]
-  ~(if (<= ,x ,y)
-     (if (<= ,y ,z) ,y (if (<= ,z ,x) ,x ,z))
-     (if (<= ,z ,y) ,y (if (<= ,x ,z) ,x ,z))))
-
-(defmacro- sort-partition-template
-  [ind before? left right pivot]
-  ~(do
-     (while (,before? (in ,ind ,left) ,pivot) (++ ,left))
-     (while (,before? ,pivot (in ,ind ,right)) (-- ,right))))
+(defn- median-of-three [a b c]
+  (if (not= (> a b) (> a c))
+    a
+    (if (not= (> b a) (> b c)) b c)))

 (defn- sort-help [a lo hi before?]
  (when (< lo hi)
-    (def [x y z] [(in a lo)
-                  (in a (div (+ lo hi) 2))
-                  (in a hi)])
-    (def pivot (median-of-three x y z))
+    (def pivot
+      (median-of-three (in a hi) (in a lo)
+                       (in a (math/floor (/ (+ lo hi) 2)))))
    (var left lo)
    (var right hi)
    (while true
-      (case before?
-        < (sort-partition-template a < left right pivot)
-        > (sort-partition-template a > left right pivot)
-        (sort-partition-template a before? left right pivot))
+      (while (before? (in a left) pivot) (++ left))
+      (while (before? pivot (in a right)) (-- right))
      (when (<= left right)
        (def tmp (in a left))
        (set (a left) (in a right))
@@ -856,10 +831,8 @@
        (++ left)
        (-- right))
      (if (>= left right) (break)))
-    (if (< lo right)
-      (sort-help a lo right before?))
-    (if (< left hi)
-      (sort-help a left hi before?)))
+    (sort-help a lo right before?)
+    (sort-help a left hi before?))
  a)

 (defn sort
@@ -867,8 +840,7 @@
  If a `before?` comparator function is provided, sorts elements using that,
  otherwise uses `<`.``
  [ind &opt before?]
-  (default before? <)
-  (sort-help ind 0 (- (length ind) 1) before?))
+  (sort-help ind 0 (- (length ind) 1) (or before? <)))

 (defn sort-by
  ``Sorts `ind` in-place by calling a function `f` on each element and
@@ -975,6 +947,7 @@
       1 (map-n 1 ,maptype ,res ,f ,ind ,inds)
       2 (map-n 2 ,maptype ,res ,f ,ind ,inds)
       3 (map-n 3 ,maptype ,res ,f ,ind ,inds)
+       4 (map-n 4 ,maptype ,res ,f ,ind ,inds)
       (do
         (def iter-keys (array/new-filled ninds))
         (def call-buffer (array/new-filled ninds))
@@ -1034,6 +1007,30 @@
  (map-template :keep res pred ind inds)
  res)

+(defn range
+  `Create an array of values [start, end) with a given step.
+  With one argument, returns a range [0, end). With two arguments, returns
+  a range [start, end). With three, returns a range with optional step size.`
+  [& args]
+  (case (length args)
+    1 (do
+        (def [n] args)
+        (def arr (array/new n))
+        (forv i 0 n (put arr i i))
+        arr)
+    2 (do
+        (def [n m] args)
+        (def arr (array/new (- m n)))
+        (forv i n m (put arr (- i n) i))
+        arr)
+    3 (do
+        (def [n m s] args)
+        (cond
+          (zero? s) @[]
+          (neg? s) (seq [i :down [n m (- s)]] i)
+          (seq [i :range [n m s]] i)))
+    (error "expected 1 to 3 arguments to range")))
+
 (defn find-index
  ``Find the index of indexed type for which `pred` is true. Returns `dflt` if not found.``
  [pred ind &opt dflt]
@@ -1211,7 +1208,7 @@
  (assert (symbol? alias) "alias must be a symbol")
  (assert (and (> (length alias) 2) (= 42 (first alias) (last alias))) "name must have leading and trailing '*' characters")
  (def prefix (dyn :defdyn-prefix))
-  (def kw (keyword prefix (slice alias 1 -2)))
+  (def kw (keyword prefix (slice alias 1 -1)))
  ~(def ,alias :dyn ,;more ,kw))

 (defn has-key?
@@ -1442,50 +1439,48 @@
    (fn [& r] (f ;more ;r))))

 (defn every?
-  ``Evaluates to the last element of `ind` if all preceding elements are truthy,
-  otherwise evaluates to the first falsey element.``
+  ``Returns true if each value in `ind` is truthy, otherwise returns the first
+  falsey value.``
  [ind]
  (var res true)
  (loop [x :in ind :while res]
-    (set res x))
+    (if x nil (set res x)))
  res)

 (defn any?
-  ``Evaluates to the last element of `ind` if all preceding elements are falsey,
-  otherwise evaluates to the first truthy element.``
+  ``Returns the first truthy value in `ind`, otherwise nil.``
  [ind]
  (var res nil)
  (loop [x :in ind :until res]
-    (set res x))
+    (if x (set res x)))
  res)

 (defn reverse!
  `Reverses the order of the elements in a given array or buffer and returns it
  mutated.`
  [t]
-  (var i 0)
-  (var j (length t))
-  (while (< i (-- j))
-    (def ti (in t i))
-    (put t i (in t j))
-    (put t j ti)
-    (++ i))
+  (def len-1 (- (length t) 1))
+  (def half (/ len-1 2))
+  (forv i 0 half
+    (def j (- len-1 i))
+    (def l (in t i))
+    (def r (in t j))
+    (put t i r)
+    (put t j l))
  t)

 (defn reverse
  `Reverses the order of the elements in a given array or tuple and returns
-  a new array. If a string or buffer is provided, returns a buffer instead.`
+  a new array. If a string or buffer is provided, returns an array of its
+  byte values, reversed.`
  [t]
-  (if (lengthable? t)
-    (do
-      (var n (length t))
-      (def ret (if (bytes? t)
-                 (buffer/new-filled n)
-                 (array/new-filled n)))
-      (each v t
-        (put ret (-- n) v))
-      ret)
-    (reverse! (seq [v :in t] v))))
+  (def len (length t))
+  (var n (- len 1))
+  (def ret (array/new len))
+  (while (>= n 0)
+    (array/push ret (in t n))
+    (-- n))
+  ret)

 (defn invert
  ``Given an associative data structure `ds`, returns a new table where the
@@ -1595,41 +1590,32 @@
 (defn keys
  "Get the keys of an associative data structure."
  [x]
-  (if (lengthable? x)
-    (do
-      (def arr (array/new-filled (length x)))
-      (var i 0)
-      (eachk k x
-        (put arr i k)
-        (++ i))
-      arr)
-    (seq [k :keys x] k)))
+  (def arr @[])
+  (var k (next x nil))
+  (while (not= nil k)
+    (array/push arr k)
+    (set k (next x k)))
+  arr)

 (defn values
  "Get the values of an associative data structure."
  [x]
-  (if (lengthable? x)
-    (do
-      (def arr (array/new-filled (length x)))
-      (var i 0)
-      (each v x
-        (put arr i v)
-        (++ i))
-      arr)
-    (seq [v :in x] v)))
+  (def arr @[])
+  (var k (next x nil))
+  (while (not= nil k)
+    (array/push arr (in x k))
+    (set k (next x k)))
+  arr)

 (defn pairs
  "Get the key-value pairs of an associative data structure."
  [x]
-  (if (lengthable? x)
-    (do
-      (def arr (array/new-filled (length x)))
-      (var i 0)
-      (eachp p x
-        (put arr i p)
-        (++ i))
-      arr)
-    (seq [p :pairs x] p)))
+  (def arr @[])
+  (var k (next x nil))
+  (while (not= nil k)
+    (array/push arr (tuple k (in x k)))
+    (set k (next x k)))
+  arr)

 (defn frequencies
  "Get the number of occurrences of each value in an indexed data structure."
@@ -1674,7 +1660,14 @@
 (defn interleave
  "Returns an array of the first elements of each col, then the second elements, etc."
  [& cols]
-  (mapcat tuple ;cols))
+  (def res @[])
+  (def ncol (length cols))
+  (when (> ncol 0)
+    (def len (min ;(map length cols)))
+    (loop [i :range [0 len]
+           ci :range [0 ncol]]
+      (array/push res (in (in cols ci) i))))
+  res)

 (defn distinct
  "Returns an array of the deduplicated values in `xs`."
@@ -1721,46 +1714,29 @@
  ``Returns a sequence of the elements of `ind` separated by
  `sep`. Returns a new array.``
  [sep ind]
-  (var k (next ind nil))
-  (if (not= nil k)
-    (if (lengthable? ind)
-      (do
-        (def ret (array/new-filled (- (* 2 (length ind)) 1) sep))
-        (var i 0)
-        (while (not= nil k)
-          (put ret i (in ind k))
-          (set k (next ind k))
-          (+= i 2))
-        ret)
-      (do
-        (def ret @[(in ind k)])
-        (while (not= nil (set k (next ind k)))
-          (array/push ret sep (in ind k)))
-        ret))
-    @[]))
-
-(defn- partition-slice
-  [f n ind]
-  (var [start end] [0 n])
  (def len (length ind))
-  (def parts (div len n))
-  (def ret (array/new-filled parts))
-  (forv k 0 parts
-    (put ret k (f ind start end))
-    (set start end)
-    (+= end n))
-  (if (< start len)
-    (array/push ret (f ind start)))
+  (def ret (array/new (- (* 2 len) 1)))
+  (if (> len 0) (put ret 0 (in ind 0)))
+  (var i 1)
+  (while (< i len)
+    (array/push ret sep (in ind i))
+    (++ i))
  ret)

 (defn partition
  ``Partition an indexed data structure `ind` into tuples
  of size `n`. Returns a new array.``
  [n ind]
-  (cond
-    (indexed? ind) (partition-slice tuple/slice n ind)
-    (bytes? ind) (partition-slice string/slice n ind)
-    (partition-slice tuple/slice n (values ind))))
+  (var i 0) (var nextn n)
+  (def len (length ind))
+  (def ret (array/new (math/ceil (/ len n))))
+  (def slicer (if (bytes? ind) string/slice tuple/slice))
+  (while (<= nextn len)
+    (array/push ret (slicer ind i nextn))
+    (set i nextn)
+    (+= nextn n))
+  (if (not= i len) (array/push ret (slicer ind i)))
+  ret)

 ###
 ###
@@ -1845,7 +1821,7 @@
  # Partition body into sections.
  (def oddlen (odd? (length cases)))
  (def else (if oddlen (last cases)))
-  (def patterns (partition 2 (if oddlen (slice cases 0 -2) cases)))
+  (def patterns (partition 2 (if oddlen (slice cases 0 -1) cases)))

  # Keep an array for accumulating the compilation output
  (def x-sym (if (idempotent? x) x (gensym)))
@@ -2076,7 +2052,7 @@
    (tuple/slice
      (array/concat
        @[(in t 0) (expand-bindings bound)]
-        (tuple/slice t 2 -2)
+        (tuple/slice t 2 -1)
        @[(recur last)])))

  (defn expandall [t]
@@ -2251,7 +2227,7 @@
  [name & body]
  (def expansion (apply defn name body))
  (def fbody (last expansion))
-  (def modifiers (tuple/slice expansion 2 -2))
+  (def modifiers (tuple/slice expansion 2 -1))
  (def metadata @{})
  (each m modifiers
    (cond
@@ -2907,12 +2883,7 @@
    (if (= :dead fs)
      (when is-repl
        (put env '_ @{:value x})
-        (def pf (get env *pretty-format* "%q"))
-        (try
-          (printf pf x)
-          ([e]
-            (eprintf "bad pretty format %v: %v" pf e)
-            (eflush)))
+        (printf (get env *pretty-format* "%q") x)
        (flush))
      (do
        (debug/stacktrace f x "")
@@ -2946,7 +2917,7 @@
    (def buf @"")
    (with-dyns [*err* buf *err-color* false]
      (bad-parse x y))
-    (set exit-error (string/slice buf 0 -2)))
+    (set exit-error (string/slice buf 0 -1)))
  (defn bc [&opt x y z a b]
    (when exit
      (bad-compile x y z a b)
@@ -2955,7 +2926,7 @@
    (def buf @"")
    (with-dyns [*err* buf *err-color* false]
      (bad-compile x nil z a b))
-    (set exit-error (string/slice buf 0 -2))
+    (set exit-error (string/slice buf 0 -1))
    (set exit-fiber y))
  (unless f
    (error (string "could not find file " path)))
@@ -3766,7 +3737,7 @@
    [host port &opt handler type]
    (def s (net/listen host port type))
    (if handler
-      (ev/go (fn [] (net/accept-loop s handler))))
+      (ev/call (fn [] (net/accept-loop s handler))))
    s))

 ###
@@ -3818,7 +3789,7 @@
    "Generate bindings for native functions in a convenient manner."
    [name ret-type & body]
    (def real-ret-type (eval ret-type))
-    (def meta (slice body 0 -2))
+    (def meta (slice body 0 -1))
    (def arg-pairs (partition 2 (last body)))
    (def formal-args (map 0 arg-pairs))
    (def type-args (map 1 arg-pairs))
--- a/src/conf/janetconf.h
+++ b/src/conf/janetconf.h
@@ -4,10 +4,10 @@
 #define JANETCONF_H

 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 31
-#define JANET_VERSION_PATCH 0
+#define JANET_VERSION_MINOR 29
+#define JANET_VERSION_PATCH 1
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.31.0"
+#define JANET_VERSION "1.29.1"

 /* #define JANET_BUILD "local" */

--- a/src/core/array.c
+++ b/src/core/array.c
@@ -177,8 +177,8 @@ JANET_CORE_FN(cfun_array_peek,
 }

 JANET_CORE_FN(cfun_array_push,
-              "(array/push arr & xs)",
-              "Push all the elements of xs to the end of an array. Modifies the input array and returns it.") {
+              "(array/push arr x)",
+              "Insert an element in the end of an array. Modifies the input array and returns it.") {
    janet_arity(argc, 1, -1);
    JanetArray *array = janet_getarray(argv, 0);
    if (INT32_MAX - argc + 1 <= array->count) {
@@ -211,7 +211,7 @@ JANET_CORE_FN(cfun_array_slice,
              "Takes a slice of array or tuple from `start` to `end`. The range is half open, "
              "[start, end). Indexes can also be negative, indicating indexing from the "
              "end of the array. By default, `start` is 0 and `end` is the length of the array. "
-              "Note that if the range is negative, it is taken as (start, end] to allow a full "
+              "Note that index -1 is synonymous with index `(length arrtup)` to allow a full "
              "negative slice range. Returns a new array.") {
    JanetView view = janet_getindexed(argv, 0);
    JanetRange range = janet_getslice(argc, argv);
@@ -259,8 +259,8 @@ JANET_CORE_FN(cfun_array_insert,
              "(array/insert arr at & xs)",
              "Insert all `xs` into array `arr` at index `at`. `at` should be an integer between "
              "0 and the length of the array. A negative value for `at` will index backwards from "
-              "the end of the array, inserting after the index such that inserting at -1 appends to "
-              "the array. Returns the array.") {
+              "the end of the array, such that inserting at -1 appends to the array. "
+              "Returns the array.") {
    size_t chunksize, restsize;
    janet_arity(argc, 2, -1);
    JanetArray *array = janet_getarray(argv, 0);
--- a/src/core/buffer.c
+++ b/src/core/buffer.c
@@ -221,20 +221,6 @@ JANET_CORE_FN(cfun_buffer_new_filled,
    return janet_wrap_buffer(buffer);
 }

-JANET_CORE_FN(cfun_buffer_frombytes,
-              "(buffer/from-bytes & byte-vals)",
-              "Creates a buffer from integer parameters with byte values. All integers "
-              "will be coerced to the range of 1 byte 0-255.") {
-    int32_t i;
-    JanetBuffer *buffer = janet_buffer(argc);
-    for (i = 0; i < argc; i++) {
-        int32_t c = janet_getinteger(argv, i);
-        buffer->data[i] = c & 0xFF;
-    }
-    buffer->count = argc;
-    return janet_wrap_buffer(buffer);
-}
-
 JANET_CORE_FN(cfun_buffer_fill,
              "(buffer/fill buffer &opt byte)",
              "Fill up a buffer with bytes, defaulting to 0s. Does not change the buffer's length. "
@@ -476,15 +462,13 @@ JANET_CORE_FN(cfun_buffer_blit,
    int same_buf = src.bytes == dest->data;
    int32_t offset_dest = 0;
    int32_t offset_src = 0;
-    if (argc > 2 && !janet_checktype(argv[2], JANET_NIL))
+    if (argc > 2)
        offset_dest = janet_gethalfrange(argv, 2, dest->count, "dest-start");
-    if (argc > 3 && !janet_checktype(argv[3], JANET_NIL))
+    if (argc > 3)
        offset_src = janet_gethalfrange(argv, 3, src.len, "src-start");
    int32_t length_src;
    if (argc > 4) {
-        int32_t src_end = src.len;
-        if (!janet_checktype(argv[4], JANET_NIL))
-            src_end = janet_gethalfrange(argv, 4, src.len, "src-end");
+        int32_t src_end = janet_gethalfrange(argv, 4, src.len, "src-end");
        length_src = src_end - offset_src;
        if (length_src < 0) length_src = 0;
    } else {
@@ -523,7 +507,6 @@ void janet_lib_buffer(JanetTable *env) {
    JanetRegExt buffer_cfuns[] = {
        JANET_CORE_REG("buffer/new", cfun_buffer_new),
        JANET_CORE_REG("buffer/new-filled", cfun_buffer_new_filled),
-        JANET_CORE_REG("buffer/from-bytes", cfun_buffer_frombytes),
        JANET_CORE_REG("buffer/fill", cfun_buffer_fill),
        JANET_CORE_REG("buffer/trim", cfun_buffer_trim),
        JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8),
--- a/src/core/capi.c
+++ b/src/core/capi.c
@@ -334,34 +334,11 @@ size_t janet_getsize(const Janet *argv, int32_t n) {
 }

 int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) {
-    int32_t raw = janet_getinteger(argv, n);
-    int32_t not_raw = raw;
-    if (not_raw < 0) not_raw += length + 1;
-    if (not_raw < 0 || not_raw > length)
-        janet_panicf("%s index %d out of range [%d,%d]", which, raw, -length - 1, length);
-    return not_raw;
-}
-
-int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) {
-    if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
-        return 0;
-    }
-    return janet_gethalfrange(argv, n, length, "start");
-}
-
-int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) {
-    if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
-        return length;
-    }
-    return janet_gethalfrange(argv, n, length, "end");
-}
-
-int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which) {
    int32_t raw = janet_getinteger(argv, n);
    int32_t not_raw = raw;
    if (not_raw < 0) not_raw += length;
    if (not_raw < 0 || not_raw > length)
-        janet_panicf("%s index %d out of range [%d,%d)", which, raw, -length, length);
+        janet_panicf("%s index %d out of range [%d,%d]", which, raw, -length, length);
    return not_raw;
 }

@@ -408,10 +385,24 @@ JanetRange janet_getslice(int32_t argc, const Janet *argv) {
    janet_arity(argc, 1, 3);
    JanetRange range;
    int32_t length = janet_length(argv[0]);
-    range.start = janet_getstartrange(argv, argc, 1, length);
-    range.end = janet_getendrange(argv, argc, 2, length);
-    if (range.end < range.start)
-        range.end = range.start;
+    if (argc == 1) {
+        range.start = 0;
+        range.end = length;
+    } else if (argc == 2) {
+        range.start = janet_checktype(argv[1], JANET_NIL)
+                      ? 0
+                      : janet_gethalfrange(argv, 1, length, "start");
+        range.end = length;
+    } else {
+        range.start = janet_checktype(argv[1], JANET_NIL)
+                      ? 0
+                      : janet_gethalfrange(argv, 1, length, "start");
+        range.end = janet_checktype(argv[2], JANET_NIL)
+                    ? length
+                    : janet_gethalfrange(argv, 2, length, "end");
+        if (range.end < range.start)
+            range.end = range.start;
+    }
    return range;
 }

@@ -493,7 +484,7 @@ void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetA

 /* Some definitions for function-like macros */

-JANET_API JanetStructHead *(janet_struct_head)(JanetStruct st) {
+JANET_API JanetStructHead *(janet_struct_head)(const JanetKV *st) {
    return janet_struct_head(st);
 }

@@ -501,10 +492,10 @@ JANET_API JanetAbstractHead *(janet_abstract_head)(const void *abstract) {
    return janet_abstract_head(abstract);
 }

-JANET_API JanetStringHead *(janet_string_head)(JanetString s) {
+JANET_API JanetStringHead *(janet_string_head)(const uint8_t *s) {
    return janet_string_head(s);
 }

-JANET_API JanetTupleHead *(janet_tuple_head)(JanetTuple tuple) {
+JANET_API JanetTupleHead *(janet_tuple_head)(const Janet *tuple) {
    return janet_tuple_head(tuple);
 }
--- a/src/core/corelib.c
+++ b/src/core/corelib.c
@@ -426,36 +426,6 @@ JANET_CORE_FN(janet_core_slice,
    }
 }

-JANET_CORE_FN(janet_core_range,
-              "(range & args)",
-              "Create an array of values [start, end) with a given step. "
-              "With one argument, returns a range [0, end). With two arguments, returns "
-              "a range [start, end). With three, returns a range with optional step size.") {
-    janet_arity(argc, 1, 3);
-    int32_t start = 0, stop = 0, step = 1, count = 0;
-    if (argc == 3) {
-        start = janet_getinteger(argv, 0);
-        stop = janet_getinteger(argv, 1);
-        step = janet_getinteger(argv, 2);
-        count = (step > 0) ? (stop - start - 1) / step + 1 :
-                ((step < 0) ? (stop - start + 1) / step + 1 : 0);
-    } else if (argc == 2) {
-        start = janet_getinteger(argv, 0);
-        stop = janet_getinteger(argv, 1);
-        count = stop - start;
-    } else {
-        stop = janet_getinteger(argv, 0);
-        count = stop;
-    }
-    count = (count > 0) ? count : 0;
-    JanetArray *array = janet_array(count);
-    for (int32_t i = 0; i < count; i++) {
-        array->data[i] = janet_wrap_number(start + i * step);
-    }
-    array->count = count;
-    return janet_wrap_array(array);
-}
-
 JANET_CORE_FN(janet_core_table,
              "(table & kvs)",
              "Creates a new table from a variadic number of keys and values. "
@@ -659,34 +629,6 @@ ret_false:
    return janet_wrap_false();
 }

-JANET_CORE_FN(janet_core_is_bytes,
-              "(bytes? x)",
-              "Check if x is a string, symbol, keyword, or buffer.") {
-    janet_fixarity(argc, 1);
-    return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_BYTES));
-}
-
-JANET_CORE_FN(janet_core_is_indexed,
-              "(indexed? x)",
-              "Check if x is an array or tuple.") {
-    janet_fixarity(argc, 1);
-    return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_INDEXED));
-}
-
-JANET_CORE_FN(janet_core_is_dictionary,
-              "(dictionary? x)",
-              "Check if x is a table or struct.") {
-    janet_fixarity(argc, 1);
-    return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_DICTIONARY));
-}
-
-JANET_CORE_FN(janet_core_is_lengthable,
-              "(lengthable? x)",
-              "Check if x is a bytes, indexed, or dictionary.") {
-    janet_fixarity(argc, 1);
-    return janet_wrap_boolean(janet_checktypes(argv[0], JANET_TFLAG_LENGTHABLE));
-}
-
 JANET_CORE_FN(janet_core_signal,
              "(signal what x)",
              "Raise a signal with payload x. ") {
@@ -748,7 +690,6 @@ static const SandboxOption sandbox_options[] = {
    {"net-connect", JANET_SANDBOX_NET_CONNECT},
    {"net-listen", JANET_SANDBOX_NET_LISTEN},
    {"sandbox", JANET_SANDBOX_SANDBOX},
-    {"signal", JANET_SANDBOX_SIGNAL},
    {"subprocess", JANET_SANDBOX_SUBPROCESS},
    {NULL, 0}
 };
@@ -773,7 +714,6 @@ JANET_CORE_FN(janet_core_sandbox,
              "* :net-connect - disallow making outbound network connections\n"
              "* :net-listen - disallow accepting inbound network connections\n"
              "* :sandbox - disallow calling this function\n"
-              "* :signal - disallow adding or removing signal handlers\n"
              "* :subprocess - disallow running subprocesses") {
    uint32_t flags = 0;
    for (int32_t i = 0; i < argc; i++) {
@@ -1083,12 +1023,7 @@ static void janet_load_libs(JanetTable *env) {
        JANET_CORE_REG("module/expand-path", janet_core_expand_path),
        JANET_CORE_REG("int?", janet_core_check_int),
        JANET_CORE_REG("nat?", janet_core_check_nat),
-        JANET_CORE_REG("bytes?", janet_core_is_bytes),
-        JANET_CORE_REG("indexed?", janet_core_is_indexed),
-        JANET_CORE_REG("dictionary?", janet_core_is_dictionary),
-        JANET_CORE_REG("lengthable?", janet_core_is_lengthable),
        JANET_CORE_REG("slice", janet_core_slice),
-        JANET_CORE_REG("range", janet_core_range),
        JANET_CORE_REG("signal", janet_core_signal),
        JANET_CORE_REG("memcmp", janet_core_memcmp),
        JANET_CORE_REG("getproto", janet_core_getproto),
--- a/src/core/ev.c
+++ b/src/core/ev.c
@@ -127,7 +127,7 @@ static int32_t janet_q_count(JanetQueue *q) {
           : (q->tail - q->head);
 }

-static int janet_q_maybe_resize(JanetQueue *q, size_t itemsize) {
+static int janet_q_push(JanetQueue *q, void *item, size_t itemsize) {
    int32_t count = janet_q_count(q);
    /* Resize if needed */
    if (count + 1 >= q->capacity) {
@@ -151,27 +151,11 @@ static int janet_q_maybe_resize(JanetQueue *q, size_t itemsize) {
        }
        q->capacity = newcap;
    }
-    return 0;
-}
-
-static int janet_q_push(JanetQueue *q, void *item, size_t itemsize) {
-    if (janet_q_maybe_resize(q, itemsize)) return 1;
    memcpy((char *) q->data + itemsize * q->tail, item, itemsize);
    q->tail = q->tail + 1 < q->capacity ? q->tail + 1 : 0;
    return 0;
 }

-static int janet_q_push_head(JanetQueue *q, void *item, size_t itemsize) {
-    if (janet_q_maybe_resize(q, itemsize)) return 1;
-    int32_t newhead = q->head - 1;
-    if (newhead < 0) {
-        newhead += q->capacity;
-    }
-    memcpy((char *) q->data + itemsize * newhead, item, itemsize);
-    q->head = newhead;
-    return 0;
-}
-
 static int janet_q_pop(JanetQueue *q, void *out, size_t itemsize) {
    if (q->head == q->tail) return 1;
    memcpy(out, (char *) q->data + itemsize * q->head, itemsize);
@@ -180,7 +164,7 @@ static int janet_q_pop(JanetQueue *q, void *out, size_t itemsize) {
 }

 /* Forward declaration */
-static void janet_unlisten(JanetListenerState *state);
+static void janet_unlisten(JanetListenerState *state, int is_gc);

 /* Get current timestamp (millisecond precision) */
 static JanetTimestamp ts_now(void);
@@ -254,100 +238,76 @@ static void add_timeout(JanetTimeout to) {
    }
 }

-static int janet_listener_gc(void *p, size_t s);
-static int janet_listener_mark(void *p, size_t s);
-
-static const JanetAbstractType janet_listener_AT = {
-    "core/ev-listener",
-    janet_listener_gc,
-    janet_listener_mark,
-    JANET_ATEND_GCMARK
-};
-
 /* Create a new event listener */
 static JanetListenerState *janet_listen_impl(JanetStream *stream, JanetListener behavior, int mask, size_t size, void *user) {
    if (stream->flags & JANET_STREAM_CLOSED) {
        janet_panic("cannot listen on closed stream");
    }
-    if ((mask & JANET_ASYNC_LISTEN_READ) && stream->read_state) goto bad_listen_read;
-    if ((mask & JANET_ASYNC_LISTEN_WRITE) && stream->write_state) goto bad_listen_write;
-    janet_assert(size >= sizeof(JanetListenerState), "bad size");
-    JanetListenerState *state = janet_abstract(&janet_listener_AT, size);
+    if (stream->_mask & mask) {
+        janet_panic("cannot listen for duplicate event on stream");
+    }
+    if (janet_vm.root_fiber->waiting != NULL) {
+        janet_panic("current fiber is already waiting for event");
+    }
+    if (size < sizeof(JanetListenerState))
+        size = sizeof(JanetListenerState);
+    JanetListenerState *state = janet_malloc(size);
+    if (NULL == state) {
+        JANET_OUT_OF_MEMORY;
+    }
    state->machine = behavior;
    state->fiber = janet_vm.root_fiber;
-    state->flags = 0;
    janet_vm.root_fiber->waiting = state;
-    if (mask & JANET_ASYNC_LISTEN_READ) stream->read_state = state;
-    if (mask & JANET_ASYNC_LISTEN_WRITE) stream->write_state = state;
    state->stream = stream;
+    state->_mask = mask;
+    stream->_mask |= mask;
+    state->_next = stream->state;
+    stream->state = state;
+
+    /* Keep track of a listener for GC purposes */
+    int resize = janet_vm.listener_cap == janet_vm.listener_count;
+    if (resize) {
+        size_t newcap = janet_vm.listener_count ? janet_vm.listener_cap * 2 : 16;
+        janet_vm.listeners = janet_realloc(janet_vm.listeners, newcap * sizeof(JanetListenerState *));
+        if (NULL == janet_vm.listeners) {
+            JANET_OUT_OF_MEMORY;
+        }
+        janet_vm.listener_cap = newcap;
+    }
+    size_t index = janet_vm.listener_count++;
+    janet_vm.listeners[index] = state;
+    state->_index = index;
+
+    /* Emit INIT event for convenience */
    state->event = user;
    state->machine(state, JANET_ASYNC_EVENT_INIT);
-    janet_ev_inc_refcount();
-    state->index = janet_vm.listeners->count;
-    janet_array_push(janet_vm.listeners, janet_wrap_abstract(state));
    return state;
-bad_listen_write:
-    janet_panic("cannot listen for duplicate write event on stream");
-bad_listen_read:
-    janet_panic("cannot listen for duplicate read event on stream");
 }

-void janet_fiber_did_resume(JanetFiber *fiber) {
-    if (fiber->waiting) {
-        janet_unlisten(fiber->waiting);
-        fiber->waiting = NULL;
-    }
-}
-
-static void janet_unlisten_impl(JanetListenerState *state) {
-    /* Move last listener to position of this listener - O(1) removal and keep things densely packed. */
-    if (state->stream) {
-        Janet popped = janet_array_pop(janet_vm.listeners);
-        janet_assert(janet_checktype(popped, JANET_ABSTRACT), "pop check");
-        JanetListenerState *popped_state = (JanetListenerState *) janet_unwrap_abstract(popped);
-        janet_vm.listeners->data[state->index] = popped;
-        popped_state->index = state->index;
-        state->index = UINT32_MAX; /* just in case */
-        janet_ev_dec_refcount();
-        if (state->stream->read_state == state) {
-            state->stream->read_state = NULL;
+/* Indicate we are no longer listening for an event. This
+ * frees the memory of the state machine as well. */
+static void janet_unlisten_impl(JanetListenerState *state, int is_gc) {
+    state->machine(state, JANET_ASYNC_EVENT_DEINIT);
+    /* Remove state machine from poll list */
+    JanetListenerState **iter = &(state->stream->state);
+    while (*iter && *iter != state)
+        iter = &((*iter)->_next);
+    janet_assert(*iter, "failed to remove listener");
+    *iter = state->_next;
+    /* Remove mask */
+    state->stream->_mask &= ~(state->_mask);
+    /* Ensure fiber does not reference this state */
+    if (!is_gc) {
+        JanetFiber *fiber = state->fiber;
+        if (NULL != fiber && fiber->waiting == state) {
+            fiber->waiting = NULL;
        }
-        if (state->stream->write_state == state) {
-            state->stream->write_state = NULL;
-        }
-        state->stream = NULL;
-    }
-}
-
-static int janet_listener_gc(void *p, size_t size) {
-    (void) size;
-    JanetListenerState *state = (JanetListenerState *)p;
-    if (state->stream) {
-        janet_ev_dec_refcount();
-    }
-    if (state->machine) {
-        state->machine(state, JANET_ASYNC_EVENT_DEINIT);
-    }
-    return 0;
-}
-
-static int janet_listener_mark(void *p, size_t size) {
-    (void) size;
-    JanetListenerState *state = (JanetListenerState *)p;
-    if (state->stream) {
-        janet_mark(janet_wrap_abstract(state->stream));
-    }
-    if (state->fiber) {
-        janet_mark(janet_wrap_fiber(state->fiber));
-    }
-    state->machine(state, JANET_ASYNC_EVENT_MARK);
-    return 0;
-}
-
-static void janet_stream_checktoclose(JanetStream *stream) {
-    if ((stream->flags & JANET_STREAM_TOCLOSE) && !stream->read_state && !stream->write_state) {
-        janet_stream_close(stream);
    }
+    /* Untrack a listener for gc purposes */
+    size_t index = state->_index;
+    janet_vm.listeners[index] = janet_vm.listeners[--janet_vm.listener_count];
+    janet_vm.listeners[index]->_index = index;
+    janet_free(state);
 }

 static const JanetMethod ev_default_stream_methods[] = {
@@ -363,52 +323,52 @@ JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod
    JanetStream *stream = janet_abstract(&janet_stream_type, sizeof(JanetStream));
    stream->handle = handle;
    stream->flags = flags;
-    stream->read_state = NULL;
-    stream->write_state = NULL;
+    stream->state = NULL;
+    stream->_mask = 0;
    if (methods == NULL) methods = ev_default_stream_methods;
    stream->methods = methods;
    return stream;
 }

-static void janet_stream_close_impl(JanetStream *stream) {
+/* Close a stream */
+static void janet_stream_close_impl(JanetStream *stream, int is_gc) {
+    if (stream->flags & JANET_STREAM_CLOSED) return;
+    JanetListenerState *state = stream->state;
+    while (NULL != state) {
+        if (!is_gc) {
+            state->machine(state, JANET_ASYNC_EVENT_CLOSE);
+        }
+        JanetListenerState *next_state = state->_next;
+        janet_unlisten(state, is_gc);
+        state = next_state;
+    }
+    stream->state = NULL;
    stream->flags |= JANET_STREAM_CLOSED;
 #ifdef JANET_WINDOWS
-    if (stream->handle != INVALID_HANDLE_VALUE) {
 #ifdef JANET_NET
-        if (stream->flags & JANET_STREAM_SOCKET) {
-            closesocket((SOCKET) stream->handle);
-        } else
+    if (stream->flags & JANET_STREAM_SOCKET) {
+        closesocket((SOCKET) stream->handle);
+    } else
 #endif
-        {
-            CloseHandle(stream->handle);
-        }
-        stream->handle = INVALID_HANDLE_VALUE;
+    {
+        CloseHandle(stream->handle);
    }
+    stream->handle = INVALID_HANDLE_VALUE;
 #else
-    if (stream->handle != -1) {
-        close(stream->handle);
-        stream->handle = -1;
-    }
+    close(stream->handle);
+    stream->handle = -1;
 #endif
 }

 void janet_stream_close(JanetStream *stream) {
-    if (stream->read_state) {
-        stream->read_state->machine(stream->read_state, JANET_ASYNC_EVENT_CLOSE);
-        janet_unlisten(stream->read_state);
-    }
-    if (stream->write_state) {
-        stream->write_state->machine(stream->write_state, JANET_ASYNC_EVENT_CLOSE);
-        janet_unlisten(stream->write_state);
-    }
-    janet_stream_close_impl(stream);
+    janet_stream_close_impl(stream, 0);
 }

 /* Called to clean up a stream */
 static int janet_stream_gc(void *p, size_t s) {
    (void) s;
    JanetStream *stream = (JanetStream *)p;
-    janet_stream_close_impl(stream);
+    janet_stream_close_impl(stream, 1);
    return 0;
 }

@@ -416,11 +376,13 @@ static int janet_stream_gc(void *p, size_t s) {
 static int janet_stream_mark(void *p, size_t s) {
    (void) s;
    JanetStream *stream = (JanetStream *) p;
-    if (NULL != stream->read_state) {
-        janet_mark(janet_wrap_abstract(stream->read_state));
-    }
-    if (NULL != stream->write_state) {
-        janet_mark(janet_wrap_abstract(stream->write_state));
+    JanetListenerState *state = stream->state;
+    while (NULL != state) {
+        if (NULL != state->fiber) {
+            janet_mark(janet_wrap_fiber(state->fiber));
+        }
+        (state->machine)(state, JANET_ASYNC_EVENT_MARK);
+        state = state->_next;
    }
    return 0;
 }
@@ -473,8 +435,8 @@ static void *janet_stream_unmarshal(JanetMarshalContext *ctx) {
    }
    JanetStream *p = janet_unmarshal_abstract(ctx, sizeof(JanetStream));
    /* Can't share listening state and such across threads */
-    p->read_state = NULL;
-    p->write_state = NULL;
+    p->_mask = 0;
+    p->state = NULL;
    p->flags = (uint32_t) janet_unmarshal_int(ctx);
    p->methods =  janet_unmarshal_ptr(ctx);
 #ifdef JANET_WINDOWS
@@ -506,7 +468,7 @@ const JanetAbstractType janet_stream_type = {
 };

 /* Register a fiber to resume with value */
-static void janet_schedule_general(JanetFiber *fiber, Janet value, JanetSignal sig, int soon) {
+void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig) {
    if (fiber->gc.flags & JANET_FIBER_EV_FLAG_CANCELED) return;
    if (!(fiber->gc.flags & JANET_FIBER_FLAG_ROOT)) {
        Janet task_element = janet_wrap_fiber(fiber);
@@ -515,19 +477,7 @@ static void janet_schedule_general(JanetFiber *fiber, Janet value, JanetSignal s
    JanetTask t = { fiber, value, sig, ++fiber->sched_id };
    fiber->gc.flags |= JANET_FIBER_FLAG_ROOT;
    if (sig == JANET_SIGNAL_ERROR) fiber->gc.flags |= JANET_FIBER_EV_FLAG_CANCELED;
-    if (soon) {
-        janet_q_push_head(&janet_vm.spawn, &t, sizeof(t));
-    } else {
-        janet_q_push(&janet_vm.spawn, &t, sizeof(t));
-    }
-}
-
-void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig) {
-    janet_schedule_general(fiber, value, sig, 0);
-}
-
-void janet_schedule_soon(JanetFiber *fiber, Janet value, JanetSignal sig) {
-    janet_schedule_general(fiber, value, sig, 1);
+    janet_q_push(&janet_vm.spawn, &t, sizeof(t));
 }

 void janet_cancel(JanetFiber *fiber, Janet value) {
@@ -538,6 +488,14 @@ void janet_schedule(JanetFiber *fiber, Janet value) {
    janet_schedule_signal(fiber, value, JANET_SIGNAL_OK);
 }

+void janet_fiber_did_resume(JanetFiber *fiber) {
+    /* Cancel any pending fibers */
+    if (fiber->waiting) {
+        fiber->waiting->machine(fiber->waiting, JANET_ASYNC_EVENT_CANCEL);
+        janet_unlisten(fiber->waiting, 0);
+    }
+}
+
 /* Mark all pending tasks */
 void janet_ev_mark(void) {

@@ -566,6 +524,16 @@ void janet_ev_mark(void) {
            janet_mark(janet_wrap_fiber(janet_vm.tq[i].curr_fiber));
        }
    }
+
+    /* Pending listeners */
+    for (size_t i = 0; i < janet_vm.listener_count; i++) {
+        JanetListenerState *state = janet_vm.listeners[i];
+        if (NULL != state->fiber) {
+            janet_mark(janet_wrap_fiber(state->fiber));
+        }
+        janet_stream_mark(state->stream, sizeof(JanetStream));
+        (state->machine)(state, JANET_ASYNC_EVENT_MARK);
+    }
 }

 static int janet_channel_push(JanetChannel *channel, Janet x, int mode);
@@ -586,15 +554,15 @@ static Janet make_supervisor_event(const char *name, JanetFiber *fiber, int thre
 /* Common init code */
 void janet_ev_init_common(void) {
    janet_q_init(&janet_vm.spawn);
+    janet_vm.listener_count = 0;
+    janet_vm.listener_cap = 0;
+    janet_vm.listeners = NULL;
    janet_vm.tq = NULL;
    janet_vm.tq_count = 0;
    janet_vm.tq_capacity = 0;
    janet_table_init_raw(&janet_vm.threaded_abstracts, 0);
    janet_table_init_raw(&janet_vm.active_tasks, 0);
-    janet_table_init_raw(&janet_vm.signal_handlers, 0);
    janet_rng_seed(&janet_vm.ev_rng, 0);
-    janet_vm.listeners = janet_array(0);
-    janet_gcroot(janet_wrap_array(janet_vm.listeners));
 #ifndef JANET_WINDOWS
    pthread_attr_init(&janet_vm.new_thread_attr);
    pthread_attr_setdetachstate(&janet_vm.new_thread_attr, PTHREAD_CREATE_DETACHED);
@@ -605,10 +573,10 @@ void janet_ev_init_common(void) {
 void janet_ev_deinit_common(void) {
    janet_q_deinit(&janet_vm.spawn);
    janet_free(janet_vm.tq);
+    janet_free(janet_vm.listeners);
+    janet_vm.listeners = NULL;
    janet_table_deinit(&janet_vm.threaded_abstracts);
    janet_table_deinit(&janet_vm.active_tasks);
-    janet_table_deinit(&janet_vm.signal_handlers);
-    janet_vm.listeners = NULL;
 #ifndef JANET_WINDOWS
    pthread_attr_destroy(&janet_vm.new_thread_attr);
 #endif
@@ -633,27 +601,11 @@ void janet_addtimeout(double sec) {
 }

 void janet_ev_inc_refcount(void) {
-#ifdef JANET_WINDOWS
-#ifdef JANET_64
-    InterlockedIncrement64((int64_t volatile *) &janet_vm.extra_listeners);
-#else
-    InterlockedIncrement((int32_t volatile *) &janet_vm.extra_listeners);
-#endif
-#else
-    __atomic_add_fetch(&janet_vm.extra_listeners, 1, __ATOMIC_RELAXED);
-#endif
+    janet_vm.extra_listeners++;
 }

 void janet_ev_dec_refcount(void) {
-#ifdef JANET_WINDOWS
-#ifdef JANET_64
-    InterlockedDecrement64((int64_t volatile *) &janet_vm.extra_listeners);
-#else
-    InterlockedDecrement((int32_t volatile *) &janet_vm.extra_listeners);
-#endif
-#else
-    __atomic_add_fetch(&janet_vm.extra_listeners, -1, __ATOMIC_RELAXED);
-#endif
+    janet_vm.extra_listeners--;
 }

 /* Channels */
@@ -1272,7 +1224,6 @@ static Janet janet_chanat_next(void *p, Janet key) {

 static void janet_chanat_marshal(void *p, JanetMarshalContext *ctx) {
    JanetChannel *channel = (JanetChannel *)p;
-    janet_marshal_byte(ctx, channel->is_threaded);
    janet_marshal_abstract(ctx, channel);
    janet_marshal_byte(ctx, channel->closed);
    janet_marshal_int(ctx, channel->limit);
@@ -1292,13 +1243,7 @@ static void janet_chanat_marshal(void *p, JanetMarshalContext *ctx) {
 }

 static void *janet_chanat_unmarshal(JanetMarshalContext *ctx) {
-    uint8_t is_threaded = janet_unmarshal_byte(ctx);
-    JanetChannel *abst;
-    if (is_threaded) {
-        abst = janet_unmarshal_abstract_threaded(ctx, sizeof(JanetChannel));
-    } else {
-        abst = janet_unmarshal_abstract(ctx, sizeof(JanetChannel));
-    }
+    JanetChannel *abst = janet_unmarshal_abstract(ctx, sizeof(JanetChannel));
    uint8_t is_closed = janet_unmarshal_byte(ctx);
    int32_t limit = janet_unmarshal_int(ctx);
    int32_t count = janet_unmarshal_int(ctx);
@@ -1332,7 +1277,8 @@ const JanetAbstractType janet_channel_type = {
 void janet_loop1_impl(int has_timeout, JanetTimestamp timeout);

 int janet_loop_done(void) {
-    return !((janet_vm.spawn.head != janet_vm.spawn.tail) ||
+    return !(janet_vm.listener_count ||
+             (janet_vm.spawn.head != janet_vm.spawn.tail) ||
             janet_vm.tq_count ||
             janet_vm.extra_listeners);
 }
@@ -1359,10 +1305,8 @@ JanetFiber *janet_loop1(void) {
        }
    }

-    /* Run scheduled fibers unless interrupts need to be handled. */
+    /* Run scheduled fibers */
    while (janet_vm.spawn.head != janet_vm.spawn.tail) {
-        /* Don't run until all interrupts have been marked as handled by calling janet_interpreter_interrupt_handled */
-        if (janet_vm.auto_suspend) break;
        JanetTask task = {NULL, janet_wrap_nil(), JANET_SIGNAL_OK, 0};
        janet_q_pop(&janet_vm.spawn, &task, sizeof(task));
        if (task.fiber->gc.flags & JANET_FIBER_EV_FLAG_SUSPENDED) janet_ev_dec_refcount();
@@ -1391,12 +1335,13 @@ JanetFiber *janet_loop1(void) {
            janet_stacktrace_ext(task.fiber, res, "");
        }
        if (sig == JANET_SIGNAL_INTERRUPT) {
+            /* On interrupts, return the interrupted fiber immediately */
            return task.fiber;
        }
    }

    /* Poll for events */
-    if (janet_vm.tq_count || janet_vm.extra_listeners) {
+    if (janet_vm.listener_count || janet_vm.tq_count || janet_vm.extra_listeners) {
        JanetTimeout to;
        memset(&to, 0, sizeof(to));
        int has_timeout;
@@ -1415,7 +1360,7 @@ JanetFiber *janet_loop1(void) {
            break;
        }
        /* Run polling implementation only if pending timeouts or pending events */
-        if (janet_vm.tq_count || janet_vm.extra_listeners) {
+        if (janet_vm.tq_count || janet_vm.listener_count || janet_vm.extra_listeners) {
            janet_loop1_impl(has_timeout, to.when);
        }
    }
@@ -1507,8 +1452,8 @@ JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, in
    return state;
 }

-static void janet_unlisten(JanetListenerState *state) {
-    janet_unlisten_impl(state);
+static void janet_unlisten(JanetListenerState *state, int is_gc) {
+    janet_unlisten_impl(state, is_gc);
 }

 void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
@@ -1530,11 +1475,7 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
    }
    BOOL result = GetQueuedCompletionStatus(janet_vm.iocp, &num_bytes_transfered, &completionKey, &overlapped, (DWORD) waittime);

-    if (!result) {
-        return;
-    }
-
-    if (overlapped) {
+    if (result || overlapped) {
        if (0 == completionKey) {
            /* Custom event */
            JanetSelfPipeEvent *response = (JanetSelfPipeEvent *)(overlapped);
@@ -1545,22 +1486,24 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp to) {
        } else {
            /* Normal event */
            JanetStream *stream = (JanetStream *) completionKey;
-            janet_assert(stream->handle != INVALID_HANDLE_VALUE, "got closed stream event");
-            JanetListenerState *state = NULL;
-            if (stream->read_state && stream->read_state->tag == overlapped) {
-                state = stream->read_state;
-            } else if (stream->write_state && stream->write_state->tag == overlapped) {
-                state = stream->write_state;
-            }
-            if (state != NULL) {
-                state->event = overlapped;
-                state->bytes = num_bytes_transfered;
-                JanetAsyncStatus status = state->machine(state, JANET_ASYNC_EVENT_COMPLETE);
-                if (status == JANET_ASYNC_STATUS_DONE) {
-                    janet_unlisten(state);
+            JanetListenerState *state = stream->state;
+            while (state != NULL) {
+                if (state->tag == overlapped) {
+                    state->event = overlapped;
+                    state->bytes = num_bytes_transfered;
+                    JanetAsyncStatus status = state->machine(state, JANET_ASYNC_EVENT_COMPLETE);
+                    if (status == JANET_ASYNC_STATUS_DONE) {
+                        janet_unlisten(state, 0);
+                    }
+                    break;
+                } else {
+                    state = state->_next;
                }
            }
-            janet_stream_checktoclose(stream);
+            /* Close the stream if requested and no more listeners are left */
+            if ((stream->flags & JANET_STREAM_TOCLOSE) && !stream->state) {
+                janet_stream_close(stream);
+            }
        }
    }
 }
@@ -1575,17 +1518,26 @@ static JanetTimestamp ts_now(void) {
    return res;
 }

+static int make_epoll_events(int mask) {
+    int events = 0;
+    if (mask & JANET_ASYNC_LISTEN_READ)
+        events |= EPOLLIN;
+    if (mask & JANET_ASYNC_LISTEN_WRITE)
+        events |= EPOLLOUT;
+    return events;
+}
+
 static void janet_epoll_sync_callback(JanetEVGenericMessage msg) {
    JanetListenerState *state = msg.argp;
    JanetAsyncStatus status1 = JANET_ASYNC_STATUS_NOT_DONE;
    JanetAsyncStatus status2 = JANET_ASYNC_STATUS_NOT_DONE;
-    if (state == state->stream->read_state)
-        status1 = state->machine(state, JANET_ASYNC_EVENT_READ);
-    if (state == state->stream->write_state)
-        status2 = state->machine(state, JANET_ASYNC_EVENT_WRITE);
+    if (state->stream->_mask & JANET_ASYNC_LISTEN_WRITE)
+        status1 = state->machine(state, JANET_ASYNC_EVENT_WRITE);
+    if (state->stream->_mask & JANET_ASYNC_LISTEN_READ)
+        status2 = state->machine(state, JANET_ASYNC_EVENT_READ);
    if (status1 == JANET_ASYNC_STATUS_DONE ||
            status2 == JANET_ASYNC_STATUS_DONE) {
-        janet_unlisten(state);
+        janet_unlisten(state, 0);
    } else {
        /* Repost event */
        janet_ev_post_event(NULL, janet_epoll_sync_callback, msg);
@@ -1594,13 +1546,11 @@ static void janet_epoll_sync_callback(JanetEVGenericMessage msg) {

 /* Wait for the next event */
 JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, int mask, size_t size, void *user) {
-    int is_first = !stream->read_state && !stream->write_state;
+    int is_first = !(stream->state);
    int op = is_first ? EPOLL_CTL_ADD : EPOLL_CTL_MOD;
    JanetListenerState *state = janet_listen_impl(stream, behavior, mask, size, user);
    struct epoll_event ev;
-    ev.events = 0;
-    if (stream->read_state) ev.events |= EPOLLIN;
-    if (stream->write_state) ev.events |= EPOLLOUT;
+    ev.events = make_epoll_events(state->stream->_mask);
    ev.data.ptr = stream;
    int status;
    do {
@@ -1614,13 +1564,13 @@ JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, in
             * event to a file. So we just post a custom event to do the read/write
             * asap. */
            /* Use flag to indicate state is not registered in epoll */
-            state->flags = 1;
+            state->_mask |= (1 << JANET_ASYNC_EVENT_COMPLETE);
            JanetEVGenericMessage msg = {0};
            msg.argp = state;
            janet_ev_post_event(NULL, janet_epoll_sync_callback, msg);
        } else {
            /* Unexpected error */
-            janet_unlisten_impl(state);
+            janet_unlisten_impl(state, 0);
            janet_panicv(janet_ev_lasterr());
        }
    }
@@ -1628,19 +1578,15 @@ JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, in
 }

 /* Tell system we are done listening for a certain event */
-static void janet_unlisten(JanetListenerState *state) {
+static void janet_unlisten(JanetListenerState *state, int is_gc) {
    JanetStream *stream = state->stream;
-    if (stream && (stream->handle != -1)) {
+    if (!(stream->flags & JANET_STREAM_CLOSED)) {
        /* Use flag to indicate state is not registered in epoll */
-        if (!state->flags) {
-            int is_read = (stream->read_state != state) && stream->read_state;
-            int is_write = (stream->write_state != state) && stream->write_state;
-            int is_last = !is_read && !is_write;
+        if (!(state->_mask & (1 << JANET_ASYNC_EVENT_COMPLETE))) {
+            int is_last = (state->_next == NULL && stream->state == state);
            int op = is_last ? EPOLL_CTL_DEL : EPOLL_CTL_MOD;
            struct epoll_event ev;
-            ev.events = 0;
-            if (is_read) ev.events |= EPOLLIN;
-            if (is_write) ev.events |= EPOLLOUT;
+            ev.events = make_epoll_events(stream->_mask & ~state->_mask);
            ev.data.ptr = stream;
            int status;
            do {
@@ -1652,7 +1598,7 @@ static void janet_unlisten(JanetListenerState *state) {
        }
    }
    /* Destroy state machine and free memory */
-    janet_unlisten_impl(state);
+    janet_unlisten_impl(state, is_gc);
 }

 #define JANET_EPOLL_MAX_EVENTS 64
@@ -1689,11 +1635,10 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
        } else {
            JanetStream *stream = p;
            int mask = events[i].events;
-            JanetListenerState *states[2] = {stream->read_state, stream->write_state};
-            for (int j = 0; j < 2; j++) {
-                JanetListenerState *state = states[j];
-                if (!state) continue;
+            JanetListenerState *state = stream->state;
+            while (NULL != state) {
                state->event = events + i;
+                JanetListenerState *next_state = state->_next;
                JanetAsyncStatus status1 = JANET_ASYNC_STATUS_NOT_DONE;
                JanetAsyncStatus status2 = JANET_ASYNC_STATUS_NOT_DONE;
                JanetAsyncStatus status3 = JANET_ASYNC_STATUS_NOT_DONE;
@@ -1709,11 +1654,14 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
                if (status1 == JANET_ASYNC_STATUS_DONE ||
                        status2 == JANET_ASYNC_STATUS_DONE ||
                        status3 == JANET_ASYNC_STATUS_DONE ||
-                        status4 == JANET_ASYNC_STATUS_DONE) {
-                    janet_unlisten(state);
-                }
+                        status4 == JANET_ASYNC_STATUS_DONE)
+                    janet_unlisten(state, 0);
+                state = next_state;
+            }
+            /* Close the stream if requested and no more listeners are left */
+            if ((stream->flags & JANET_STREAM_TOCLOSE) && !stream->state) {
+                janet_stream_close(stream);
            }
-            janet_stream_checktoclose(stream);
        }
    }
 }
@@ -1807,44 +1755,46 @@ JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, in
    struct kevent kev[2];

    int length = 0;
-    if (mask & JANET_ASYNC_LISTEN_READ) {
+    if (state->stream->_mask & JANET_ASYNC_LISTEN_READ) {
        EV_SETx(&kev[length], stream->handle, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, stream);
        length++;
    }
-    if (mask & JANET_ASYNC_LISTEN_WRITE) {
+    if (state->stream->_mask & JANET_ASYNC_LISTEN_WRITE) {
        EV_SETx(&kev[length], stream->handle, EVFILT_WRITE, EV_ADD | EV_ENABLE, 0, 0, stream);
        length++;
    }

-    janet_assert(length, "expected to add kqueue events");
-    add_kqueue_events(kev, length);
+    if (length > 0) {
+        add_kqueue_events(kev, length);
+    }

    return state;
 }

-static void janet_unlisten(JanetListenerState *state) {
+static void janet_unlisten(JanetListenerState *state, int is_gc) {
    JanetStream *stream = state->stream;
-    if (stream && (stream->handle != -1)) {
-        int is_read = (stream->read_state != state) && stream->read_state;
-        int is_write = (stream->write_state != state) && stream->write_state;
-        int is_last = !is_read && !is_write;
-        int op = is_last ? EV_DELETE : EV_DISABLE | EV_ADD;
-        struct kevent kev[2];
-        EV_SETx(&kev[1], stream->handle, EVFILT_WRITE, op, 0, 0, stream);
+    if (!(stream->flags & JANET_STREAM_CLOSED)) {
+        /* Use flag to indicate state is not registered in kqueue */
+        if (!(state->_mask & (1 << JANET_ASYNC_EVENT_COMPLETE))) {
+            int is_last = (state->_next == NULL && stream->state == state);
+            int op = is_last ? EV_DELETE : EV_DISABLE | EV_ADD;
+            struct kevent kev[2];
+            EV_SETx(&kev[1], stream->handle, EVFILT_WRITE, op, 0, 0, stream);

-        int length = 0;
-        if (stream->read_state == state) {
-            EV_SETx(&kev[length], stream->handle, EVFILT_WRITE, op, 0, 0, stream);
-            length++;
-        }
-        if (stream->write_state == state) {
-            EV_SETx(&kev[length], stream->handle, EVFILT_READ, op, 0, 0, stream);
-            length++;
-        }
+            int length = 0;
+            if (stream->_mask & JANET_ASYNC_EVENT_WRITE) {
+                EV_SETx(&kev[length], stream->handle, EVFILT_WRITE, op, 0, 0, stream);
+                length++;
+            }
+            if (stream->_mask & JANET_ASYNC_EVENT_READ) {
+                EV_SETx(&kev[length], stream->handle, EVFILT_READ, op, 0, 0, stream);
+                length++;
+            }

-        add_kqueue_events(kev, length);
+            add_kqueue_events(kev, length);
+        }
    }
-    janet_unlisten_impl(state);
+    janet_unlisten_impl(state, is_gc);
 }

 #define JANET_KQUEUE_MAX_EVENTS 64
@@ -1884,14 +1834,14 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
            janet_ev_handle_selfpipe();
        } else {
            JanetStream *stream = p;
-            JanetListenerState *states[2] = {stream->read_state, stream->write_state};
-            for (int j = 0; j < 2; j++) {
-                JanetListenerState *state = states[j];
-                if (!state) continue;
+            JanetListenerState *state = stream->state;
+            while (NULL != state) {
+                JanetListenerState *next_state = state->_next;
                state->event = events + i;
                JanetAsyncStatus statuses[4];
                for (int i = 0; i < 4; i++)
                    statuses[i] = JANET_ASYNC_STATUS_NOT_DONE;
+
                if (!(events[i].flags & EV_ERROR)) {
                    if (events[i].filter == EVFILT_WRITE)
                        statuses[0] = state->machine(state, JANET_ASYNC_EVENT_WRITE);
@@ -1905,11 +1855,15 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
                if (statuses[0] == JANET_ASYNC_STATUS_DONE ||
                        statuses[1] == JANET_ASYNC_STATUS_DONE ||
                        statuses[2] == JANET_ASYNC_STATUS_DONE ||
-                        statuses[3] == JANET_ASYNC_STATUS_DONE) {
-                    janet_unlisten(state);
-                }
+                        statuses[3] == JANET_ASYNC_STATUS_DONE)
+                    janet_unlisten(state, 0);
+
+                state = next_state;
+            }
+            /* Close the stream if requested and no more listeners are left */
+            if ((stream->flags & JANET_STREAM_TOCLOSE) && !stream->state) {
+                janet_stream_close(stream);
            }
-            janet_stream_checktoclose(stream);
        }
    }
 }
@@ -1947,11 +1901,20 @@ static JanetTimestamp ts_now(void) {
    return res;
 }

+static int make_poll_events(int mask) {
+    int events = 0;
+    if (mask & JANET_ASYNC_LISTEN_READ)
+        events |= POLLIN;
+    if (mask & JANET_ASYNC_LISTEN_WRITE)
+        events |= POLLOUT;
+    return events;
+}
+
 /* Wait for the next event */
 JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, int mask, size_t size, void *user) {
-    size_t oldsize = janet_vm.listeners->capacity;
+    size_t oldsize = janet_vm.listener_cap;
    JanetListenerState *state = janet_listen_impl(stream, behavior, mask, size, user);
-    size_t newsize = janet_vm.listeners->capacity;
+    size_t newsize = janet_vm.listener_cap;
    if (newsize > oldsize) {
        janet_vm.fds = janet_realloc(janet_vm.fds, (newsize + 1) * sizeof(struct pollfd));
        if (NULL == janet_vm.fds) {
@@ -1960,19 +1923,15 @@ JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, in
    }
    struct pollfd ev;
    ev.fd = stream->handle;
-    ev.events = 0;
-    if (stream->read_state) ev.events |= POLLIN;
-    if (stream->write_state) ev.events |= POLLOUT;
+    ev.events = make_poll_events(state->stream->_mask);
    ev.revents = 0;
-    janet_vm.fds[state->index + 1] = ev;
+    janet_vm.fds[state->_index + 1] = ev;
    return state;
 }

-static void janet_unlisten(JanetListenerState *state) {
-    if (state->stream) {
-        janet_vm.fds[state->index + 1] = janet_vm.fds[janet_vm.listeners->count];
-    }
-    janet_unlisten_impl(state);
+static void janet_unlisten(JanetListenerState *state, int is_gc) {
+    janet_vm.fds[state->_index + 1] = janet_vm.fds[janet_vm.listener_count];
+    janet_unlisten_impl(state, is_gc);
 }

 void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
@@ -1984,7 +1943,7 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
            JanetTimestamp now = ts_now();
            to = now > timeout ? 0 : (int)(timeout - now);
        }
-        ready = poll(janet_vm.fds, janet_vm.listeners->count + 1, to);
+        ready = poll(janet_vm.fds, janet_vm.listener_count + 1, to);
    } while (ready == -1 && errno == EINTR);
    if (ready == -1) {
        JANET_EXIT("failed to poll events");
@@ -1997,10 +1956,10 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
    }

    /* Step state machines */
-    for (int32_t i = 0; i < janet_vm.listeners->count; i++) {
+    for (size_t i = 0; i < janet_vm.listener_count; i++) {
        struct pollfd *pfd = janet_vm.fds + i + 1;
        /* Skip fds where nothing interesting happened */
-        JanetListenerState *state = (JanetListenerState *) janet_unwrap_abstract(janet_vm.listeners->data[i]);
+        JanetListenerState *state = janet_vm.listeners[i];
        /* Normal event */
        int mask = pfd->revents;
        JanetAsyncStatus status1 = JANET_ASYNC_STATUS_NOT_DONE;
@@ -2020,10 +1979,12 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
        if (status1 == JANET_ASYNC_STATUS_DONE ||
                status2 == JANET_ASYNC_STATUS_DONE ||
                status3 == JANET_ASYNC_STATUS_DONE ||
-                status4 == JANET_ASYNC_STATUS_DONE) {
-            janet_unlisten(state);
+                status4 == JANET_ASYNC_STATUS_DONE)
+            janet_unlisten(state, 0);
+        /* Close the stream if requested and no more listeners are left */
+        if ((stream->flags & JANET_STREAM_TOCLOSE) && !stream->state) {
+            janet_stream_close(stream);
        }
-        janet_stream_checktoclose(stream);
    }
 }

@@ -2510,7 +2471,8 @@ void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, in
 typedef enum {
    JANET_ASYNC_WRITEMODE_WRITE,
    JANET_ASYNC_WRITEMODE_SEND,
-    JANET_ASYNC_WRITEMODE_SENDTO
+    JANET_ASYNC_WRITEMODE_SENDTO,
+    JANET_ASYNC_WRITEMODE_CONNECT
 } JanetWriteMode;

 typedef struct {
@@ -2534,12 +2496,36 @@ typedef struct {
 #endif
 } StateWrite;

+static JanetAsyncStatus handle_connect(JanetListenerState *s) {
+#ifdef JANET_WINDOWS
+    int res = 0;
+    int size = sizeof(res);
+    int r = getsockopt((SOCKET)s->stream->handle, SOL_SOCKET, SO_ERROR, (char *)&res, &size);
+#else
+    int res = 0;
+    socklen_t size = sizeof res;
+    int r = getsockopt(s->stream->handle, SOL_SOCKET, SO_ERROR, &res, &size);
+#endif
+    if (r == 0) {
+        if (res == 0) {
+            janet_schedule(s->fiber, janet_wrap_abstract(s->stream));
+        } else {
+            s->stream->flags |= JANET_STREAM_TOCLOSE;
+            janet_cancel(s->fiber, janet_cstringv(strerror(res)));
+        }
+    } else {
+        s->stream->flags |= JANET_STREAM_TOCLOSE;
+        janet_cancel(s->fiber, janet_ev_lasterr());
+    }
+    return JANET_ASYNC_STATUS_DONE;
+}
+
 JanetAsyncStatus ev_machine_write(JanetListenerState *s, JanetAsyncEvent event) {
    StateWrite *state = (StateWrite *) s;
    switch (event) {
        default:
            break;
-        case JANET_ASYNC_EVENT_MARK: {
+        case JANET_ASYNC_EVENT_MARK:
            janet_mark(state->is_buffer
                       ? janet_wrap_buffer(state->src.buf)
                       : janet_wrap_string(state->src.str));
@@ -2547,7 +2533,6 @@ JanetAsyncStatus ev_machine_write(JanetListenerState *s, JanetAsyncEvent event)
                janet_mark(janet_wrap_abstract(state->dest_abst));
            }
            break;
-        }
        case JANET_ASYNC_EVENT_CLOSE:
            janet_cancel(s->fiber, janet_cstringv("stream closed"));
            return JANET_ASYNC_STATUS_DONE;
@@ -2564,6 +2549,11 @@ JanetAsyncStatus ev_machine_write(JanetListenerState *s, JanetAsyncEvent event)
        }
        break;
        case JANET_ASYNC_EVENT_USER: {
+#ifdef JANET_NET
+            if (state->mode == JANET_ASYNC_WRITEMODE_CONNECT) {
+                return handle_connect(s);
+            }
+#endif
            /* Begin write */
            int32_t len;
            const uint8_t *bytes;
@@ -2627,6 +2617,11 @@ JanetAsyncStatus ev_machine_write(JanetListenerState *s, JanetAsyncEvent event)
            janet_cancel(s->fiber, janet_cstringv("stream hup"));
            return JANET_ASYNC_STATUS_DONE;
        case JANET_ASYNC_EVENT_WRITE: {
+#ifdef JANET_NET
+            if (state->mode == JANET_ASYNC_WRITEMODE_CONNECT) {
+                return handle_connect(s);
+            }
+#endif
            int32_t start, len;
            const uint8_t *bytes;
            start = state->start;
@@ -2728,6 +2723,10 @@ void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, i
 void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags) {
    janet_ev_write_generic(stream, (void *) str, dest, JANET_ASYNC_WRITEMODE_SENDTO, 0, flags);
 }
+
+void janet_ev_connect(JanetStream *stream, int flags) {
+    janet_ev_write_generic(stream, NULL, NULL, JANET_ASYNC_WRITEMODE_CONNECT, 0, flags);
+}
 #endif

 /* For a pipe ID */
--- a/src/core/fiber.c
+++ b/src/core/fiber.c
@@ -39,8 +39,8 @@ static void fiber_reset(JanetFiber *fiber) {
    fiber->env = NULL;
    fiber->last_value = janet_wrap_nil();
 #ifdef JANET_EV
-    fiber->sched_id = 0;
    fiber->waiting = NULL;
+    fiber->sched_id = 0;
    fiber->supervisor_channel = NULL;
 #endif
    janet_fiber_set_status(fiber, JANET_STATUS_NEW);
@@ -85,6 +85,7 @@ JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t
    if (janet_fiber_funcframe(fiber, callee)) return NULL;
    janet_fiber_frame(fiber)->flags |= JANET_STACKFRAME_ENTRANCE;
 #ifdef JANET_EV
+    fiber->waiting = NULL;
    fiber->supervisor_channel = NULL;
 #endif
    return fiber;
--- a/src/core/gc.c
+++ b/src/core/gc.c
@@ -268,9 +268,6 @@ recur:
    if (fiber->supervisor_channel) {
        janet_mark_abstract(fiber->supervisor_channel);
    }
-    if (fiber->waiting) {
-        janet_mark_abstract(fiber->waiting);
-    }
 #endif

    /* Explicit tail recursion */
@@ -373,15 +370,14 @@ void janet_sweep() {
                    if (head->type->gc) {
                        janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
                    }
+                    /* Mark as tombstone in place */
+                    items[i].key = janet_wrap_nil();
+                    items[i].value = janet_wrap_false();
+                    janet_vm.threaded_abstracts.deleted++;
+                    janet_vm.threaded_abstracts.count--;
                    /* Free memory */
                    janet_free(janet_abstract_head(abst));
                }
-
-                /* Mark as tombstone in place */
-                items[i].key = janet_wrap_nil();
-                items[i].value = janet_wrap_false();
-                janet_vm.threaded_abstracts.deleted++;
-                janet_vm.threaded_abstracts.count--;
            }

            /* Reset for next sweep */
@@ -441,7 +437,6 @@ void janet_collect(void) {
    uint32_t i;
    if (janet_vm.gc_suspend) return;
    depth = JANET_RECURSION_GUARD;
-    janet_vm.gc_mark_phase = 1;
    /* Try and prevent many major collections back to back.
     * A full collection will take O(janet_vm.block_count) time.
     * If we have a large heap, make sure our interval is not too
@@ -461,7 +456,6 @@ void janet_collect(void) {
        Janet x = janet_vm.roots[--janet_vm.root_count];
        janet_mark(x);
    }
-    janet_vm.gc_mark_phase = 0;
    janet_sweep();
    janet_vm.next_collection = 0;
    janet_free_all_scratch();
@@ -565,9 +559,7 @@ void janet_gcunlock(int handle) {
    janet_vm.gc_suspend = handle;
 }

-/* Scratch memory API
- * Scratch memory allocations do not need to be free (but optionally can be), and will be automatically cleaned
- * up in the next call to janet_collect. */
+/* Scratch memory API */

 void *janet_smalloc(size_t size) {
    JanetScratch *s = janet_malloc(sizeof(JanetScratch) + size);
--- a/src/core/io.c
+++ b/src/core/io.c
@@ -131,7 +131,7 @@ JANET_CORE_FN(cfun_io_temp,
 }

 JANET_CORE_FN(cfun_io_fopen,
-              "(file/open path &opt mode buffer-size)",
+              "(file/open path &opt mode)",
              "Open a file. `path` is an absolute or relative path, and "
              "`mode` is a set of flags indicating the mode to open the file in. "
              "`mode` is a keyword where each character represents a flag. If the file "
@@ -143,9 +143,8 @@ JANET_CORE_FN(cfun_io_fopen,
              "Following one of the initial flags, 0 or more of the following flags can be appended:\n\n"
              "* b - open the file in binary mode (rather than text mode)\n\n"
              "* + - append to the file instead of overwriting it\n\n"
-              "* n - error if the file cannot be opened instead of returning nil\n\n"
-              "See fopen (<stdio.h>, C99) for further details.") {
-    janet_arity(argc, 1, 3);
+              "* n - error if the file cannot be opened instead of returning nil") {
+    janet_arity(argc, 1, 2);
    const uint8_t *fname = janet_getstring(argv, 0);
    const uint8_t *fmode;
    int32_t flags;
@@ -158,15 +157,6 @@ JANET_CORE_FN(cfun_io_fopen,
        flags = JANET_FILE_READ;
    }
    FILE *f = fopen((const char *)fname, (const char *)fmode);
-    if (f != NULL) {
-        size_t bufsize = janet_optsize(argv, argc, 2, BUFSIZ);
-        if (bufsize != BUFSIZ) {
-            int result = setvbuf(f, NULL, bufsize ? _IOFBF : _IONBF, bufsize);
-            if (result) {
-                janet_panic("failed to set buffer size for file");
-            }
-        }
-    }
    return f ? janet_makefile(f, flags)
           : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, strerror(errno)), janet_wrap_nil())
           : janet_wrap_nil();
--- a/src/core/marsh.c
+++ b/src/core/marsh.c
@@ -1048,6 +1048,7 @@ static const uint8_t *unmarshal_one_fiber(
    fiber->env = NULL;
    fiber->last_value = janet_wrap_nil();
 #ifdef JANET_EV
+    fiber->waiting = NULL;
    fiber->sched_id = 0;
    fiber->supervisor_channel = NULL;
 #endif
@@ -1244,18 +1245,6 @@ void *janet_unmarshal_abstract(JanetMarshalContext *ctx, size_t size) {
    return p;
 }

-void *janet_unmarshal_abstract_threaded(JanetMarshalContext *ctx, size_t size) {
-#ifdef JANET_THREADS
-    void *p = janet_abstract_threaded(ctx->at, size);
-    janet_unmarshal_abstract_reuse(ctx, p);
-    return p;
-#else
-    (void) ctx;
-    (void) size;
-    janet_panic("threaded abstracts not supported");
-#endif
-}
-
 static const uint8_t *unmarshal_one_abstract(UnmarshalState *st, const uint8_t *data, Janet *out, int flags) {
    Janet key;
    data = unmarshal_one(st, data, &key, flags + 1);
--- a/src/core/net.c
+++ b/src/core/net.c
@@ -111,62 +111,6 @@ static void janet_net_socknoblock(JSock s) {
 #endif
 }

-/* State machine for async connect */
-
-typedef struct {
-    JanetListenerState head;
-    int did_connect;
-} NetStateConnect;
-
-JanetAsyncStatus net_machine_connect(JanetListenerState *s, JanetAsyncEvent event) {
-    NetStateConnect *state = (NetStateConnect *)s;
-    switch (event) {
-        default:
-            return JANET_ASYNC_STATUS_NOT_DONE;
-        case JANET_ASYNC_EVENT_CLOSE:
-            janet_cancel(s->fiber, janet_cstringv("stream closed"));
-            return JANET_ASYNC_STATUS_DONE;
-        case JANET_ASYNC_EVENT_HUP:
-        case JANET_ASYNC_EVENT_ERR:
-        case JANET_ASYNC_EVENT_COMPLETE:
-        case JANET_ASYNC_EVENT_WRITE:
-        case JANET_ASYNC_EVENT_USER:
-            break;
-    }
-    JanetStream *stream = s->stream;
-#ifdef JANET_WINDOWS
-    int res = 0;
-    int size = sizeof(res);
-    int r = getsockopt((SOCKET)stream->handle, SOL_SOCKET, SO_ERROR, (char *)&res, &size);
-#else
-    int res = 0;
-    socklen_t size = sizeof res;
-    int r = getsockopt(stream->handle, SOL_SOCKET, SO_ERROR, &res, &size);
-#endif
-    if (r == 0) {
-        if (res == 0) {
-            state->did_connect = 1;
-            janet_schedule(s->fiber, janet_wrap_abstract(s->stream));
-        } else {
-            janet_cancel(s->fiber, janet_cstringv(strerror(res)));
-            stream->flags |= JANET_STREAM_TOCLOSE;
-        }
-    } else {
-        janet_cancel(s->fiber, janet_ev_lasterr());
-        stream->flags |= JANET_STREAM_TOCLOSE;
-    }
-    return JANET_ASYNC_STATUS_DONE;
-}
-
-static void net_sched_connect(JanetStream *stream) {
-    JanetListenerState *s = janet_listen(stream, net_machine_connect, JANET_ASYNC_LISTEN_WRITE, sizeof(NetStateConnect), NULL);
-    NetStateConnect *state = (NetStateConnect *)s;
-    state->did_connect = 0;
-#ifdef JANET_WINDOWS
-    net_machine_connect(s, JANET_ASYNC_EVENT_USER);
-#endif
-}
-
 /* State machine for accepting connections. */

 #ifdef JANET_WINDOWS
@@ -552,7 +496,7 @@ JANET_CORE_FN(cfun_net_connect,
    }
 #endif

-    if (status) {
+    if (status != 0) {
 #ifdef JANET_WINDOWS
        if (err != WSAEWOULDBLOCK) {
 #else
@@ -564,7 +508,9 @@ JANET_CORE_FN(cfun_net_connect,
        }
    }

-    net_sched_connect(stream);
+    /* Handle the connect() result in the event loop*/
+    janet_ev_connect(stream, MSG_NOSIGNAL);
+
    janet_await();
 }

--- a/src/core/os.c
+++ b/src/core/os.c
@@ -706,18 +706,6 @@ static const struct keyword_signal signal_keywords[] = {
 #endif
    {NULL, 0},
 };
-
-static int get_signal_kw(const Janet *argv, int32_t n) {
-    JanetKeyword signal_kw = janet_getkeyword(argv, n);
-    const struct keyword_signal *ptr = signal_keywords;
-    while (ptr->keyword) {
-        if (!janet_cstrcmp(signal_kw, ptr->keyword)) {
-            return ptr->signal;
-        }
-        ptr++;
-    }
-    janet_panicf("undefined signal %v", argv[n]);
-}
 #endif

 JANET_CORE_FN(os_proc_kill,
@@ -743,7 +731,18 @@ JANET_CORE_FN(os_proc_kill,
 #else
    int signal = -1;
    if (argc == 3) {
-        signal = get_signal_kw(argv, 2);
+        JanetKeyword signal_kw = janet_getkeyword(argv, 2);
+        const struct keyword_signal *ptr = signal_keywords;
+        while (ptr->keyword) {
+            if (!janet_cstrcmp(signal_kw, ptr->keyword)) {
+                signal = ptr->signal;
+                break;
+            }
+            ptr++;
+        }
+        if (signal == -1) {
+            janet_panic("undefined signal");
+        }
    }
    int status = kill(proc->pid, signal == -1 ? SIGKILL : signal);
    if (status) {
@@ -804,108 +803,6 @@ static void close_handle(JanetHandle handle) {
 #endif
 }

-#ifdef JANET_EV
-
-#ifndef JANET_WINDOWS
-static void janet_signal_callback(JanetEVGenericMessage msg) {
-    int sig = msg.tag;
-    if (msg.argi) janet_interpreter_interrupt_handled(NULL);
-    Janet handlerv = janet_table_get(&janet_vm.signal_handlers, janet_wrap_integer(sig));
-    if (!janet_checktype(handlerv, JANET_FUNCTION)) {
-        /* Let another thread/process try to handle this */
-        sigset_t set;
-        sigemptyset(&set);
-        sigaddset(&set, sig);
-#ifdef JANET_THREADS
-        pthread_sigmask(SIG_BLOCK, &set, NULL);
-#else
-        sigprocmask(SIG_BLOCK, &set, NULL);
-#endif
-        raise(sig);
-        return;
-    }
-    JanetFunction *handler = janet_unwrap_function(handlerv);
-    JanetFiber *fiber = janet_fiber(handler, 64, 0, NULL);
-    janet_schedule_soon(fiber, janet_wrap_nil(), JANET_SIGNAL_OK);
-    janet_ev_dec_refcount();
-}
-
-static void janet_signal_trampoline_no_interrupt(int sig) {
-    /* Do not interact with global janet state here except for janet_ev_post_event, unsafe! */
-    JanetEVGenericMessage msg;
-    memset(&msg, 0, sizeof(msg));
-    msg.tag = sig;
-    janet_ev_post_event(&janet_vm, janet_signal_callback, msg);
-    janet_ev_inc_refcount();
-}
-
-static void janet_signal_trampoline(int sig) {
-    /* Do not interact with global janet state here except for janet_ev_post_event, unsafe! */
-    JanetEVGenericMessage msg;
-    memset(&msg, 0, sizeof(msg));
-    msg.tag = sig;
-    msg.argi = 1;
-    janet_interpreter_interrupt(NULL);
-    janet_ev_post_event(&janet_vm, janet_signal_callback, msg);
-    janet_ev_inc_refcount();
-}
-#endif
-
-JANET_CORE_FN(os_sigaction,
-              "(os/sigaction which &opt handler interrupt-interpreter)",
-              "Add a signal handler for a given action. Use nil for the `handler` argument to remove a signal handler. "
-              "All signal handlers are the same as supported by `os/proc-kill`.") {
-    janet_sandbox_assert(JANET_SANDBOX_SIGNAL);
-    janet_arity(argc, 1, 3);
-#ifdef JANET_WINDOWS
-    (void) argv;
-    janet_panic("unsupported on this platform");
-#else
-    /* TODO - per thread signal masks */
-    int rc;
-    int sig = get_signal_kw(argv, 0);
-    JanetFunction *handler = janet_optfunction(argv, argc, 1, NULL);
-    int can_interrupt = janet_optboolean(argv, argc, 2, 0);
-    Janet oldhandler = janet_table_get(&janet_vm.signal_handlers, janet_wrap_integer(sig));
-    if (!janet_checktype(oldhandler, JANET_NIL)) {
-        janet_gcunroot(oldhandler);
-    }
-    if (NULL != handler) {
-        Janet handlerv = janet_wrap_function(handler);
-        janet_gcroot(handlerv);
-        janet_table_put(&janet_vm.signal_handlers, janet_wrap_integer(sig), handlerv);
-    } else {
-        janet_table_put(&janet_vm.signal_handlers, janet_wrap_integer(sig), janet_wrap_nil());
-    }
-    struct sigaction action;
-    sigset_t mask;
-    sigfillset(&mask);
-    memset(&action, 0, sizeof(action));
-    if (can_interrupt) {
-#ifdef JANET_NO_INTERPRETER_INTERRUPT
-        janet_panic("interpreter interrupt not enabled");
-#else
-        action.sa_handler = janet_signal_trampoline;
-#endif
-    } else {
-        action.sa_handler = janet_signal_trampoline_no_interrupt;
-    }
-    action.sa_mask = mask;
-    RETRY_EINTR(rc, sigaction(sig, &action, NULL));
-    sigset_t set;
-    sigemptyset(&set);
-    sigaddset(&set, sig);
-#ifdef JANET_THREADS
-    pthread_sigmask(SIG_UNBLOCK, &set, NULL);
-#else
-    sigprocmask(SIG_UNBLOCK, &set, NULL);
-#endif
-    return janet_wrap_nil();
-#endif
-}
-
-#endif
-
 /* Create piped file for os/execute and os/spawn. Need to be careful that we mark
   the error flag if we can't create pipe and don't leak handles. *handle will be cleaned
   up by the calling function. If everything goes well, *handle is owned by the calling function,
@@ -1437,8 +1334,8 @@ JANET_CORE_FN(os_getenv,
    janet_sandbox_assert(JANET_SANDBOX_ENV);
    janet_arity(argc, 1, 2);
    const char *cstr = janet_getcstring(argv, 0);
-    janet_lock_environ();
    const char *res = getenv(cstr);
+    janet_lock_environ();
    Janet ret = res
                ? janet_cstringv(res)
                : argc == 2
@@ -2639,7 +2536,6 @@ void janet_lib_os(JanetTable *env) {
 #ifdef JANET_EV
        JANET_CORE_REG("os/open", os_open), /* fs read and write */
        JANET_CORE_REG("os/pipe", os_pipe),
-        JANET_CORE_REG("os/sigaction", os_sigaction),
 #endif
 #endif
        JANET_REG_END
--- a/src/core/run.c
+++ b/src/core/run.c
@@ -57,20 +57,12 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                }
            } else {
                ret = janet_wrap_string(cres.error);
-                int32_t line = (int32_t) parser.line;
-                int32_t col = (int32_t) parser.column;
-                if ((cres.error_mapping.line > 0) &&
-                        (cres.error_mapping.column > 0)) {
-                    line = cres.error_mapping.line;
-                    col = cres.error_mapping.column;
-                }
                if (cres.macrofiber) {
-                    janet_eprintf("%s:%d:%d: compile error", sourcePath,
-                                  line, col);
+                    janet_eprintf("compile error in %s: ", sourcePath);
                    janet_stacktrace_ext(cres.macrofiber, ret, "");
                } else {
-                    janet_eprintf("%s:%d:%d: compile error: %s\n", sourcePath,
-                                  line, col, (const char *)cres.error);
+                    janet_eprintf("compile error in %s: %s\n", sourcePath,
+                                  (const char *)cres.error);
                }
                errflags |= 0x02;
                done = 1;
--- a/src/core/specials.c
+++ b/src/core/specials.c
@@ -530,32 +530,6 @@ static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) {
    return ret;
 }

-/* Check if a form matches the pattern (= nil _) or (not= nil _) */
-static int janetc_check_nil_form(JanetFopts opts, Janet x, Janet *capture, uint32_t fun_tag) {
-    if (!janet_checktype(x, JANET_TUPLE)) return 0;
-    JanetTuple tup = janet_unwrap_tuple(x);
-    if (3 != janet_tuple_length(tup)) return 0;
-    Janet op1 = tup[0];
-    if (janet_checktype(op1, JANET_SYMBOL)) {
-        Janet entry = janet_table_get(opts.compiler->env, op1);
-        if (janet_checktype(entry, JANET_TABLE)) {
-            op1 = janet_table_get(janet_unwrap_table(entry), janet_ckeywordv("value"));
-        }
-    }
-    if (!janet_checktype(op1, JANET_FUNCTION)) return 0;
-    JanetFunction *fun = janet_unwrap_function(op1);
-    uint32_t tag = fun->def->flags & JANET_FUNCDEF_FLAG_TAG;
-    if (tag != fun_tag) return 0;
-    if (janet_checktype(tup[1], JANET_NIL)) {
-        *capture = tup[2];
-        return 1;
-    } else if (janet_checktype(tup[2], JANET_NIL)) {
-        *capture = tup[1];
-        return 1;
-    }
-    return 0;
-}
-
 /*
 * :condition
 * ...
@@ -576,7 +550,6 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {
    JanetScope condscope, tempscope;
    const int tail = opts.flags & JANET_FOPTS_TAIL;
    const int drop = opts.flags & JANET_FOPTS_DROP;
-    uint8_t ifnjmp = JOP_JUMP_IF_NOT;

    if (argn < 2 || argn > 3) {
        janetc_cerror(c, "expected 2 or 3 arguments to if");
@@ -599,16 +572,7 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {

    /* Compile condition */
    janetc_scope(&condscope, c, 0, "if");
-
-    Janet condform = argv[0];
-    if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_EQ)) {
-        ifnjmp = JOP_JUMP_IF_NOT_NIL;
-    }
-    if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_NEQ)) {
-        ifnjmp = JOP_JUMP_IF_NIL;
-    }
-
-    cond = janetc_value(condopts, condform);
+    cond = janetc_value(condopts, argv[0]);

    /* Check constant condition. */
    /* TODO: Use type info for more short circuits */
@@ -631,7 +595,7 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {
    }

    /* Compile jump to right */
-    labeljr = janetc_emit_si(c, ifnjmp, cond, 0, 0);
+    labeljr = janetc_emit_si(c, JOP_JUMP_IF_NOT, cond, 0, 0);

    /* Condition left body */
    janetc_scope(&tempscope, c, 0, "if-true");
@@ -641,7 +605,7 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {

    /* Compile jump to done */
    labeljd = janet_v_count(c->buffer);
-    if (!tail && !(drop && janet_checktype(falsebody, JANET_NIL))) janetc_emit(c, JOP_JUMP);
+    if (!tail) janetc_emit(c, JOP_JUMP);

    /* Compile right body */
    labelr = janet_v_count(c->buffer);
@@ -777,6 +741,20 @@ static JanetSlot janetc_break(JanetFopts opts, int32_t argn, const Janet *argv)
    }
 }

+/* Check if a form matches the pattern (not= nil _) */
+static int janetc_check_notnil_form(Janet x, Janet *capture) {
+    if (!janet_checktype(x, JANET_TUPLE)) return 0;
+    JanetTuple tup = janet_unwrap_tuple(x);
+    if (!janet_checktype(tup[0], JANET_FUNCTION)) return 0;
+    if (3 != janet_tuple_length(tup)) return 0;
+    JanetFunction *fun = janet_unwrap_function(tup[0]);
+    uint32_t tag = fun->def->flags & JANET_FUNCDEF_FLAG_TAG;
+    if (tag != JANET_FUN_NEQ) return 0;
+    if (!janet_checktype(tup[1], JANET_NIL)) return 0;
+    *capture = tup[2];
+    return 1;
+}
+
 /*
 * :whiletop
 * ...
@@ -793,7 +771,6 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
    JanetScope tempscope;
    int32_t labelwt, labeld, labeljt, labelc, i;
    int infinite = 0;
-    int is_nil_form = 0;
    int is_notnil_form = 0;
    uint8_t ifjmp = JOP_JUMP_IF;
    uint8_t ifnjmp = JOP_JUMP_IF_NOT;
@@ -807,16 +784,11 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)

    janetc_scope(&tempscope, c, JANET_SCOPE_WHILE, "while");

-    /* Check for `(= nil _)` or `(not= nil _)` in condition, and if so, use the
+    /* Check for `(not= nil _)` in condition, and if so, use the
     * jmpnl or jmpnn instructions. This let's us implement `(each ...)`
     * more efficiently. */
    Janet condform = argv[0];
-    if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_EQ)) {
-        is_nil_form = 1;
-        ifjmp = JOP_JUMP_IF_NIL;
-        ifnjmp = JOP_JUMP_IF_NOT_NIL;
-    }
-    if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_NEQ)) {
+    if (janetc_check_notnil_form(condform, &condform)) {
        is_notnil_form = 1;
        ifjmp = JOP_JUMP_IF_NOT_NIL;
        ifnjmp = JOP_JUMP_IF_NIL;
@@ -828,9 +800,7 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
    /* Check for constant condition */
    if (cond.flags & JANET_SLOT_CONSTANT) {
        /* Loop never executes */
-        int never_executes = is_nil_form
-                             ? !janet_checktype(cond.constant, JANET_NIL)
-                             : is_notnil_form
+        int never_executes = is_notnil_form
                             ? janet_checktype(cond.constant, JANET_NIL)
                             : !janet_truthy(cond.constant);
        if (never_executes) {
--- a/src/core/state.c
+++ b/src/core/state.c
@@ -24,11 +24,6 @@
 #include "features.h"
 #include <janet.h>
 #include "state.h"
-#include "util.h"
-#endif
-
-#ifdef JANET_WINDOWS
-#include <windows.h>
 #endif

 JANET_THREAD_LOCAL JanetVM janet_vm;
@@ -62,18 +57,5 @@ void janet_vm_load(JanetVM *from) {
 * use NULL to interrupt the current VM when convenient */
 void janet_interpreter_interrupt(JanetVM *vm) {
    vm = vm ? vm : &janet_vm;
-#ifdef JANET_WINDOWS
-    InterlockedIncrement(&vm->auto_suspend);
-#else
-    __atomic_add_fetch(&vm->auto_suspend, 1, __ATOMIC_RELAXED);
-#endif
-}
-
-void janet_interpreter_interrupt_handled(JanetVM *vm) {
-    vm = vm ? vm : &janet_vm;
-#ifdef JANET_WINDOWS
-    InterlockedDecrement(&vm->auto_suspend);
-#else
-    __atomic_add_fetch(&vm->auto_suspend, -1, __ATOMIC_RELAXED);
-#endif
+    vm->auto_suspend = 1;
 }
--- a/src/core/state.h
+++ b/src/core/state.h
@@ -89,7 +89,7 @@ struct JanetVM {

    /* If this flag is true, suspend on function calls and backwards jumps.
     * When this occurs, this flag will be reset to 0. */
-    volatile int32_t auto_suspend;
+    int auto_suspend;

    /* The current running fiber on the current thread.
     * Set and unset by functions in vm.c */
@@ -125,7 +125,6 @@ struct JanetVM {
    size_t next_collection;
    size_t block_count;
    int gc_suspend;
-    int gc_mark_phase;

    /* GC roots */
    Janet *roots;
@@ -155,11 +154,12 @@ struct JanetVM {
    JanetQueue spawn;
    JanetTimeout *tq;
    JanetRNG ev_rng;
-    volatile size_t extra_listeners; /* used in signal handler, must be volatile */
+    JanetListenerState **listeners;
+    size_t listener_count;
+    size_t listener_cap;
+    size_t extra_listeners;
    JanetTable threaded_abstracts; /* All abstract types that can be shared between threads (used in this thread) */
    JanetTable active_tasks; /* All possibly live task fibers - used just for tracking */
-    JanetArray *listeners; /* For GC */
-    JanetTable signal_handlers;
 #ifdef JANET_WINDOWS
    void **iocp;
 #elif defined(JANET_EV_EPOLL)
--- a/src/core/string.c
+++ b/src/core/string.c
@@ -175,9 +175,8 @@ JANET_CORE_FN(cfun_string_slice,
              "Returns a substring from a byte sequence. The substring is from "
              "index `start` inclusive to index `end`, exclusive. All indexing "
              "is from 0. `start` and `end` can also be negative to indicate indexing "
-              "from the end of the string. Note that if `start` is negative it is "
-              "exclusive, and if `end` is negative it is inclusive, to allow a full "
-              "negative slice range.") {
+              "from the end of the string. Note that index -1 is synonymous with "
+              "index `(length bytes)` to allow a full negative slice range. ") {
    JanetByteView view = janet_getbytes(argv, 0);
    JanetRange range = janet_getslice(argc, argv);
    return janet_stringv(view.bytes + range.start, range.end - range.start);
--- a/src/core/table.c
+++ b/src/core/table.c
@@ -111,11 +111,12 @@ static void janet_table_rehash(JanetTable *t, int32_t size) {
            JANET_OUT_OF_MEMORY;
        }
    }
-    int32_t oldcapacity = t->capacity;
+    int32_t i, oldcapacity;
+    oldcapacity = t->capacity;
    t->data = newdata;
    t->capacity = size;
    t->deleted = 0;
-    for (int32_t i = 0; i < oldcapacity; i++) {
+    for (i = 0; i < oldcapacity; i++) {
        JanetKV *kv = olddata + i;
        if (!janet_checktype(kv->key, JANET_NIL)) {
            JanetKV *newkv = janet_table_find(t, kv->key);
--- a/src/core/tuple.c
+++ b/src/core/tuple.c
@@ -69,9 +69,9 @@ JANET_CORE_FN(cfun_tuple_slice,
              "inclusive to index `end` exclusive. If `start` or `end` are not provided, "
              "they default to 0 and the length of `arrtup`, respectively. "
              "`start` and `end` can also be negative to indicate indexing "
-              "from the end of the input. Note that if `start` is negative it is "
-              "exclusive, and if `end` is negative it is inclusive, to allow a full "
-              "negative slice range. Returns the new tuple.") {
+              "from the end of the input. Note that index -1 is synonymous with "
+              "index `(length arrtup)` to allow a full negative slice range. "
+              "Returns the new tuple.") {
    JanetView view = janet_getindexed(argv, 0);
    JanetRange range = janet_getslice(argc, argv);
    return janet_wrap_tuple(janet_tuple_n(view.items + range.start, range.end - range.start));
--- a/src/core/util.h
+++ b/src/core/util.h
@@ -49,7 +49,7 @@
 #ifndef JANET_EXIT
 #include <stdio.h>
 #define JANET_EXIT(m) do { \
-    fprintf(stderr, "janet interpreter runtime error at line %d in file %s: %s\n",\
+    fprintf(stderr, "C runtime error at line %d in file %s: %s\n",\
        __LINE__,\
        __FILE__,\
        (m));\
--- a/src/core/vm.c
+++ b/src/core/vm.c
@@ -116,6 +116,7 @@
 #else
 #define vm_maybe_auto_suspend(COND) do { \
    if ((COND) && janet_vm.auto_suspend) { \
+        janet_vm.auto_suspend = 0; \
        fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \
        vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \
    } \
@@ -799,13 +800,13 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {

    VM_OP(JOP_JUMP)
    pc += DS;
-    vm_maybe_auto_suspend(DS <= 0);
+    vm_maybe_auto_suspend(DS < 0);
    vm_next();

    VM_OP(JOP_JUMP_IF)
    if (janet_truthy(stack[A])) {
        pc += ES;
-        vm_maybe_auto_suspend(ES <= 0);
+        vm_maybe_auto_suspend(ES < 0);
    } else {
        pc++;
    }
@@ -816,14 +817,14 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
        pc++;
    } else {
        pc += ES;
-        vm_maybe_auto_suspend(ES <= 0);
+        vm_maybe_auto_suspend(ES < 0);
    }
    vm_next();

    VM_OP(JOP_JUMP_IF_NIL)
    if (janet_checktype(stack[A], JANET_NIL)) {
        pc += ES;
-        vm_maybe_auto_suspend(ES <= 0);
+        vm_maybe_auto_suspend(ES < 0);
    } else {
        pc++;
    }
@@ -834,7 +835,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
        pc++;
    } else {
        pc += ES;
-        vm_maybe_auto_suspend(ES <= 0);
+        vm_maybe_auto_suspend(ES < 0);
    }
    vm_next();

@@ -861,7 +862,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
    vm_pcnext();

    VM_OP(JOP_EQUALS_IMMEDIATE)
-    stack[A] = janet_wrap_boolean(janet_checktype(stack[B], JANET_NUMBER) && (janet_unwrap_number(stack[B]) == (double) CS));
+    stack[A] = janet_wrap_boolean(janet_unwrap_number(stack[B]) == (double) CS);
    vm_pcnext();

    VM_OP(JOP_NOT_EQUALS)
@@ -869,7 +870,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
    vm_pcnext();

    VM_OP(JOP_NOT_EQUALS_IMMEDIATE)
-    stack[A] = janet_wrap_boolean(!janet_checktype(stack[B], JANET_NUMBER) || (janet_unwrap_number(stack[B]) != (double) CS));
+    stack[A] = janet_wrap_boolean(janet_unwrap_number(stack[B]) != (double) CS);
    vm_pcnext();

    VM_OP(JOP_COMPARE)
@@ -1588,7 +1589,6 @@ int janet_init(void) {
    janet_vm.next_collection = 0;
    janet_vm.gc_interval = 0x400000;
    janet_vm.block_count = 0;
-    janet_vm.gc_mark_phase = 0;

    janet_symcache_init();

--- a/src/core/wrap.c
+++ b/src/core/wrap.c
@@ -43,10 +43,10 @@ int (janet_truthy)(Janet x) {
    return janet_truthy(x);
 }

-JanetStruct(janet_unwrap_struct)(Janet x) {
+const JanetKV *(janet_unwrap_struct)(Janet x) {
    return janet_unwrap_struct(x);
 }
-JanetTuple(janet_unwrap_tuple)(Janet x) {
+const Janet *(janet_unwrap_tuple)(Janet x) {
    return janet_unwrap_tuple(x);
 }
 JanetFiber *(janet_unwrap_fiber)(Janet x) {
@@ -61,16 +61,16 @@ JanetTable *(janet_unwrap_table)(Janet x) {
 JanetBuffer *(janet_unwrap_buffer)(Janet x) {
    return janet_unwrap_buffer(x);
 }
-JanetString(janet_unwrap_string)(Janet x) {
+const uint8_t *(janet_unwrap_string)(Janet x) {
    return janet_unwrap_string(x);
 }
-JanetSymbol(janet_unwrap_symbol)(Janet x) {
+const uint8_t *(janet_unwrap_symbol)(Janet x) {
    return janet_unwrap_symbol(x);
 }
-JanetKeyword(janet_unwrap_keyword)(Janet x) {
+const uint8_t *(janet_unwrap_keyword)(Janet x) {
    return janet_unwrap_keyword(x);
 }
-JanetAbstract(janet_unwrap_abstract)(Janet x) {
+void *(janet_unwrap_abstract)(Janet x) {
    return janet_unwrap_abstract(x);
 }
 void *(janet_unwrap_pointer)(Janet x) {
@@ -102,22 +102,22 @@ Janet(janet_wrap_false)(void) {
 Janet(janet_wrap_boolean)(int x) {
    return janet_wrap_boolean(x);
 }
-Janet(janet_wrap_string)(JanetString x) {
+Janet(janet_wrap_string)(const uint8_t *x) {
    return janet_wrap_string(x);
 }
-Janet(janet_wrap_symbol)(JanetSymbol x) {
+Janet(janet_wrap_symbol)(const uint8_t *x) {
    return janet_wrap_symbol(x);
 }
-Janet(janet_wrap_keyword)(JanetKeyword x) {
+Janet(janet_wrap_keyword)(const uint8_t *x) {
    return janet_wrap_keyword(x);
 }
 Janet(janet_wrap_array)(JanetArray *x) {
    return janet_wrap_array(x);
 }
-Janet(janet_wrap_tuple)(JanetTuple x) {
+Janet(janet_wrap_tuple)(const Janet *x) {
    return janet_wrap_tuple(x);
 }
-Janet(janet_wrap_struct)(JanetStruct x) {
+Janet(janet_wrap_struct)(const JanetKV *x) {
    return janet_wrap_struct(x);
 }
 Janet(janet_wrap_fiber)(JanetFiber *x) {
@@ -135,7 +135,7 @@ Janet(janet_wrap_cfunction)(JanetCFunction x) {
 Janet(janet_wrap_table)(JanetTable *x) {
    return janet_wrap_table(x);
 }
-Janet(janet_wrap_abstract)(JanetAbstract x) {
+Janet(janet_wrap_abstract)(void *x) {
    return janet_wrap_abstract(x);
 }
 Janet(janet_wrap_pointer)(void *x) {
@@ -317,3 +317,4 @@ JANET_WRAP_DEFINE(pointer, void *, JANET_POINTER, pointer)
 #undef JANET_WRAP_DEFINE

 #endif
+
--- a/src/include/janet.h
+++ b/src/include/janet.h
@@ -235,22 +235,9 @@ extern "C" {
 #endif

 /* How to export symbols */
-#ifndef JANET_EXPORT
-#ifdef JANET_WINDOWS
-#define JANET_EXPORT __declspec(dllexport)
-#else
-#define JANET_EXPORT __attribute__((visibility ("default")))
-#endif
-#endif
-
-/* How declare API functions */
 #ifndef JANET_API
 #ifdef JANET_WINDOWS
-#ifdef JANET_DLL_IMPORT
-#define JANET_API __declspec(dllimport)
-#else
 #define JANET_API __declspec(dllexport)
-#endif
 #else
 #define JANET_API __attribute__((visibility ("default")))
 #endif
@@ -591,6 +578,7 @@ typedef enum {
    JANET_ASYNC_EVENT_HUP,
    JANET_ASYNC_EVENT_READ,
    JANET_ASYNC_EVENT_WRITE,
+    JANET_ASYNC_EVENT_CANCEL,
    JANET_ASYNC_EVENT_COMPLETE, /* Used on windows for IOCP */
    JANET_ASYNC_EVENT_USER
 } JanetAsyncEvent;
@@ -612,9 +600,13 @@ typedef JanetAsyncStatus(*JanetListener)(JanetListenerState *state, JanetAsyncEv
 struct JanetStream {
    JanetHandle handle;
    uint32_t flags;
-    JanetListenerState *read_state;
-    JanetListenerState *write_state;
+    /* Linked list of all in-flight IO routines for this stream */
+    JanetListenerState *state;
    const void *methods; /* Methods for this stream */
+    /* internal - used to disallow multiple concurrent reads / writes on the same stream.
+     * this constraint may be lifted later but allowing such would require more internal book keeping
+     * for some implementations. You can read and write at the same time on the same stream, though. */
+    int _mask;
 };

 /* Interface for state machine based event loop */
@@ -624,12 +616,14 @@ struct JanetListenerState {
    JanetStream *stream;
    void *event; /* Used to pass data from asynchronous IO event. Contents depend on both
                    implementation of the event loop and the particular event. */
-    uint32_t index; /* Used for GC and poll implentation */
-    uint32_t flags;
 #ifdef JANET_WINDOWS
    void *tag; /* Used to associate listeners with an overlapped structure */
    int bytes; /* Used to track how many bytes were transfered. */
 #endif
+    /* internal */
+    size_t _index;
+    int _mask;
+    JanetListenerState *_next;
 };
 #endif

@@ -659,10 +653,10 @@ struct JanetListenerState {
 * external bindings, we should prefer using the Head structs directly, and
 * use the host language to add sugar around the manipulation of the Janet types. */

-JANET_API JanetStructHead *janet_struct_head(JanetStruct st);
+JANET_API JanetStructHead *janet_struct_head(const JanetKV *st);
 JANET_API JanetAbstractHead *janet_abstract_head(const void *abstract);
-JANET_API JanetStringHead *janet_string_head(JanetString s);
-JANET_API JanetTupleHead *janet_tuple_head(JanetTuple tuple);
+JANET_API JanetStringHead *janet_string_head(const uint8_t *s);
+JANET_API JanetTupleHead *janet_tuple_head(const Janet *tuple);

 /* Some language bindings won't have access to the macro versions. */

@@ -671,16 +665,16 @@ JANET_API int janet_checktype(Janet x, JanetType type);
 JANET_API int janet_checktypes(Janet x, int typeflags);
 JANET_API int janet_truthy(Janet x);

-JANET_API JanetStruct janet_unwrap_struct(Janet x);
-JANET_API JanetTuple janet_unwrap_tuple(Janet x);
+JANET_API const JanetKV *janet_unwrap_struct(Janet x);
+JANET_API const Janet *janet_unwrap_tuple(Janet x);
 JANET_API JanetFiber *janet_unwrap_fiber(Janet x);
 JANET_API JanetArray *janet_unwrap_array(Janet x);
 JANET_API JanetTable *janet_unwrap_table(Janet x);
 JANET_API JanetBuffer *janet_unwrap_buffer(Janet x);
-JANET_API JanetString janet_unwrap_string(Janet x);
-JANET_API JanetSymbol janet_unwrap_symbol(Janet x);
-JANET_API JanetKeyword janet_unwrap_keyword(Janet x);
-JANET_API JanetAbstract janet_unwrap_abstract(Janet x);
+JANET_API const uint8_t *janet_unwrap_string(Janet x);
+JANET_API const uint8_t *janet_unwrap_symbol(Janet x);
+JANET_API const uint8_t *janet_unwrap_keyword(Janet x);
+JANET_API void *janet_unwrap_abstract(Janet x);
 JANET_API void *janet_unwrap_pointer(Janet x);
 JANET_API JanetFunction *janet_unwrap_function(Janet x);
 JANET_API JanetCFunction janet_unwrap_cfunction(Janet x);
@@ -693,18 +687,18 @@ JANET_API Janet janet_wrap_number(double x);
 JANET_API Janet janet_wrap_true(void);
 JANET_API Janet janet_wrap_false(void);
 JANET_API Janet janet_wrap_boolean(int x);
-JANET_API Janet janet_wrap_string(JanetString x);
-JANET_API Janet janet_wrap_symbol(JanetSymbol x);
-JANET_API Janet janet_wrap_keyword(JanetKeyword x);
+JANET_API Janet janet_wrap_string(const uint8_t *x);
+JANET_API Janet janet_wrap_symbol(const uint8_t *x);
+JANET_API Janet janet_wrap_keyword(const uint8_t *x);
 JANET_API Janet janet_wrap_array(JanetArray *x);
-JANET_API Janet janet_wrap_tuple(JanetTuple x);
-JANET_API Janet janet_wrap_struct(JanetStruct x);
+JANET_API Janet janet_wrap_tuple(const Janet *x);
+JANET_API Janet janet_wrap_struct(const JanetKV *x);
 JANET_API Janet janet_wrap_fiber(JanetFiber *x);
 JANET_API Janet janet_wrap_buffer(JanetBuffer *x);
 JANET_API Janet janet_wrap_function(JanetFunction *x);
 JANET_API Janet janet_wrap_cfunction(JanetCFunction x);
 JANET_API Janet janet_wrap_table(JanetTable *x);
-JANET_API Janet janet_wrap_abstract(JanetAbstract x);
+JANET_API Janet janet_wrap_abstract(void *x);
 JANET_API Janet janet_wrap_pointer(void *x);
 JANET_API Janet janet_wrap_integer(int32_t x);

@@ -736,7 +730,6 @@ JANET_API Janet janet_wrap_integer(int32_t x);
        ? janet_nanbox_isnumber(x) \
        : janet_nanbox_checkauxtype((x), (t)))

-/* Use JANET_API so that modules will use a local version of these functions if possible */
 JANET_API void *janet_nanbox_to_pointer(Janet x);
 JANET_API Janet janet_nanbox_from_pointer(void *p, uint64_t tagmask);
 JANET_API Janet janet_nanbox_from_cpointer(const void *p, uint64_t tagmask);
@@ -783,14 +776,14 @@ JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 #define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER)

 /* Unwrap the pointer types */
-#define janet_unwrap_struct(x) ((JanetStruct)janet_nanbox_to_pointer(x))
-#define janet_unwrap_tuple(x) ((JanetTuple)janet_nanbox_to_pointer(x))
+#define janet_unwrap_struct(x) ((const JanetKV *)janet_nanbox_to_pointer(x))
+#define janet_unwrap_tuple(x) ((const Janet *)janet_nanbox_to_pointer(x))
 #define janet_unwrap_fiber(x) ((JanetFiber *)janet_nanbox_to_pointer(x))
 #define janet_unwrap_array(x) ((JanetArray *)janet_nanbox_to_pointer(x))
 #define janet_unwrap_table(x) ((JanetTable *)janet_nanbox_to_pointer(x))
 #define janet_unwrap_buffer(x) ((JanetBuffer *)janet_nanbox_to_pointer(x))
-#define janet_unwrap_string(x) ((JanetString)janet_nanbox_to_pointer(x))
-#define janet_unwrap_symbol(x) ((JanetSymbol)janet_nanbox_to_pointer(x))
+#define janet_unwrap_string(x) ((const uint8_t *)janet_nanbox_to_pointer(x))
+#define janet_unwrap_symbol(x) ((const uint8_t *)janet_nanbox_to_pointer(x))
 #define janet_unwrap_keyword(x) ((const uint8_t *)janet_nanbox_to_pointer(x))
 #define janet_unwrap_abstract(x) (janet_nanbox_to_pointer(x))
 #define janet_unwrap_pointer(x) (janet_nanbox_to_pointer(x))
@@ -832,15 +825,15 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_wrap_cfunction(s) janet_nanbox32_from_tagp(JANET_CFUNCTION, (void *)(s))
 #define janet_wrap_pointer(s) janet_nanbox32_from_tagp(JANET_POINTER, (void *)(s))

-#define janet_unwrap_struct(x) ((JanetStruct)(x).tagged.payload.pointer)
-#define janet_unwrap_tuple(x) ((JanetTuple)(x).tagged.payload.pointer)
+#define janet_unwrap_struct(x) ((const JanetKV *)(x).tagged.payload.pointer)
+#define janet_unwrap_tuple(x) ((const Janet *)(x).tagged.payload.pointer)
 #define janet_unwrap_fiber(x) ((JanetFiber *)(x).tagged.payload.pointer)
 #define janet_unwrap_array(x) ((JanetArray *)(x).tagged.payload.pointer)
 #define janet_unwrap_table(x) ((JanetTable *)(x).tagged.payload.pointer)
 #define janet_unwrap_buffer(x) ((JanetBuffer *)(x).tagged.payload.pointer)
-#define janet_unwrap_string(x) ((JanetString)(x).tagged.payload.pointer)
-#define janet_unwrap_symbol(x) ((JanetSymbol)(x).tagged.payload.pointer)
-#define janet_unwrap_keyword(x) ((JanetKeyword)(x).tagged.payload.pointer)
+#define janet_unwrap_string(x) ((const uint8_t *)(x).tagged.payload.pointer)
+#define janet_unwrap_symbol(x) ((const uint8_t *)(x).tagged.payload.pointer)
+#define janet_unwrap_keyword(x) ((const uint8_t *)(x).tagged.payload.pointer)
 #define janet_unwrap_abstract(x) ((x).tagged.payload.pointer)
 #define janet_unwrap_pointer(x) ((x).tagged.payload.pointer)
 #define janet_unwrap_function(x) ((JanetFunction *)(x).tagged.payload.pointer)
@@ -855,15 +848,15 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_truthy(x) \
    ((x).type != JANET_NIL && ((x).type != JANET_BOOLEAN || ((x).as.u64 & 0x1)))

-#define janet_unwrap_struct(x) ((JanetStruct)(x).as.pointer)
-#define janet_unwrap_tuple(x) ((JanetTuple)(x).as.pointer)
+#define janet_unwrap_struct(x) ((const JanetKV *)(x).as.pointer)
+#define janet_unwrap_tuple(x) ((const Janet *)(x).as.pointer)
 #define janet_unwrap_fiber(x) ((JanetFiber *)(x).as.pointer)
 #define janet_unwrap_array(x) ((JanetArray *)(x).as.pointer)
 #define janet_unwrap_table(x) ((JanetTable *)(x).as.pointer)
 #define janet_unwrap_buffer(x) ((JanetBuffer *)(x).as.pointer)
-#define janet_unwrap_string(x) ((JanetString)(x).as.pointer)
-#define janet_unwrap_symbol(x) ((JanetSymbol)(x).as.pointer)
-#define janet_unwrap_keyword(x) ((JanetKeyword)(x).as.pointer)
+#define janet_unwrap_string(x) ((const uint8_t *)(x).as.pointer)
+#define janet_unwrap_symbol(x) ((const uint8_t *)(x).as.pointer)
+#define janet_unwrap_keyword(x) ((const uint8_t *)(x).as.pointer)
 #define janet_unwrap_abstract(x) ((x).as.pointer)
 #define janet_unwrap_pointer(x) ((x).as.pointer)
 #define janet_unwrap_function(x) ((JanetFunction *)(x).as.pointer)
@@ -919,8 +912,8 @@ struct JanetFiber {
     * that is, fibers that are scheduled on the event loop and behave much like threads
     * in a multi-tasking system. It would be possible to move these fields to a new
     * type, say "JanetTask", that as separate from fibers to save a bit of space. */
-    uint32_t sched_id; /* Increment everytime fiber is scheduled by event loop */
    JanetListenerState *waiting;
+    uint32_t sched_id; /* Increment everytime fiber is scheduled by event loop */
    void *supervisor_channel; /* Channel to push self to when complete */
 #endif
 };
@@ -1395,7 +1388,6 @@ JANET_API void janet_stream_flags(JanetStream *stream, uint32_t flags);
 JANET_API void janet_schedule(JanetFiber *fiber, Janet value);
 JANET_API void janet_cancel(JanetFiber *fiber, Janet value);
 JANET_API void janet_schedule_signal(JanetFiber *fiber, Janet value, JanetSignal sig);
-JANET_API void janet_schedule_soon(JanetFiber *fiber, Janet value, JanetSignal sig);

 /* Start a state machine listening for events from a stream */
 JANET_API JanetListenerState *janet_listen(JanetStream *stream, JanetListener behavior, int mask, size_t size, void *user);
@@ -1492,6 +1484,7 @@ JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t
 JANET_API void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
 JANET_API void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
 JANET_API void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_API void janet_ev_connect(JanetStream *stream, int flags);
 #endif

 /* Write async to a stream */
@@ -1619,7 +1612,7 @@ JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x);
 #define JANET_TUPLE_FLAG_BRACKETCTOR 0x10000

 #define janet_tuple_head(t) ((JanetTupleHead *)((char *)t - offsetof(JanetTupleHead, data)))
-#define janet_tuple_from_head(gcobject) ((JanetTuple)((char *)gcobject + offsetof(JanetTupleHead, data)))
+#define janet_tuple_from_head(gcobject) ((const Janet *)((char *)gcobject + offsetof(JanetTupleHead, data)))
 #define janet_tuple_length(t) (janet_tuple_head(t)->length)
 #define janet_tuple_hash(t) (janet_tuple_head(t)->hash)
 #define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line)
@@ -1665,7 +1658,7 @@ JANET_API JanetSymbol janet_symbol_gen(void);

 /* Structs */
 #define janet_struct_head(t) ((JanetStructHead *)((char *)t - offsetof(JanetStructHead, data)))
-#define janet_struct_from_head(t) ((JanetStruct)((char *)gcobject + offsetof(JanetStructHead, data)))
+#define janet_struct_from_head(t) ((const JanetKV *)((char *)gcobject + offsetof(JanetStructHead, data)))
 #define janet_struct_length(t) (janet_struct_head(t)->length)
 #define janet_struct_capacity(t) (janet_struct_head(t)->capacity)
 #define janet_struct_hash(t) (janet_struct_head(t)->hash)
@@ -1806,7 +1799,6 @@ JANET_API void janet_vm_free(JanetVM *vm);
 JANET_API void janet_vm_save(JanetVM *into);
 JANET_API void janet_vm_load(JanetVM *from);
 JANET_API void janet_interpreter_interrupt(JanetVM *vm);
-JANET_API void janet_interpreter_interrupt_handled(JanetVM *vm);
 JANET_API JanetSignal janet_continue(JanetFiber *fiber, Janet in, Janet *out);
 JANET_API JanetSignal janet_continue_signal(JanetFiber *fiber, Janet in, Janet *out, JanetSignal sig);
 JANET_API JanetSignal janet_pcall(JanetFunction *fun, int32_t argn, const Janet *argv, Janet *out, JanetFiber **f);
@@ -1830,7 +1822,6 @@ JANET_API void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *pr
 #define JANET_SANDBOX_FS_TEMP 1024
 #define JANET_SANDBOX_FFI_USE 2048
 #define JANET_SANDBOX_FFI_JIT 4096
-#define JANET_SANDBOX_SIGNAL 8192
 #define JANET_SANDBOX_FFI (JANET_SANDBOX_FFI_DEFINE | JANET_SANDBOX_FFI_USE | JANET_SANDBOX_FFI_JIT)
 #define JANET_SANDBOX_FS (JANET_SANDBOX_FS_WRITE | JANET_SANDBOX_FS_READ | JANET_SANDBOX_FS_TEMP)
 #define JANET_SANDBOX_NET (JANET_SANDBOX_NET_CONNECT | JANET_SANDBOX_NET_LISTEN)
@@ -1954,10 +1945,10 @@ JANET_API void janet_register(const char *name, JanetCFunction cfun);
 #endif
 #ifndef JANET_ENTRY_NAME
 #define JANET_MODULE_ENTRY \
-    JANET_MODULE_PREFIX JANET_EXPORT JanetBuildConfig _janet_mod_config(void) { \
+    JANET_MODULE_PREFIX JANET_API JanetBuildConfig _janet_mod_config(void) { \
        return janet_config_current(); \
    } \
-    JANET_MODULE_PREFIX JANET_EXPORT void _janet_init
+    JANET_MODULE_PREFIX JANET_API void _janet_init
 #else
 #define JANET_MODULE_ENTRY JANET_MODULE_PREFIX JANET_API void JANET_ENTRY_NAME
 #endif
@@ -2006,9 +1997,6 @@ JANET_API JanetDictView janet_getdictionary(const Janet *argv, int32_t n);
 JANET_API void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *at);
 JANET_API JanetRange janet_getslice(int32_t argc, const Janet *argv);
 JANET_API int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which);
-JANET_API int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length);
-JANET_API int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length);
-JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which);
 JANET_API uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags);

 /* Optionals */
@@ -2081,7 +2069,6 @@ JANET_API uint8_t janet_unmarshal_byte(JanetMarshalContext *ctx);
 JANET_API void janet_unmarshal_bytes(JanetMarshalContext *ctx, uint8_t *dest, size_t len);
 JANET_API Janet janet_unmarshal_janet(JanetMarshalContext *ctx);
 JANET_API JanetAbstract janet_unmarshal_abstract(JanetMarshalContext *ctx, size_t size);
-JANET_API JanetAbstract janet_unmarshal_abstract_threaded(JanetMarshalContext *ctx, size_t size);
 JANET_API void janet_unmarshal_abstract_reuse(JanetMarshalContext *ctx, void *p);

 JANET_API void janet_register_abstract_type(const JanetAbstractType *at);
--- a/test/helper.janet
+++ b/test/helper.janet
@@ -44,7 +44,7 @@
         (number? x) (string x)
         (string? x) (string/slice x
                                   (length "test/suite-")
-                                   (- (inc (length ".janet"))))
+                                   (- (length ".janet")))
         (string x)))
  (set start-time (os/clock))
  (eprint "Starting suite " suite-name "..."))
--- a/test/suite-array.janet
+++ b/test/suite-array.janet
@@ -37,7 +37,7 @@
 (assert (array= @[:one :two :three :four :five]
                @[:one :two :three :four :five]) "array comparison 3")
 (assert (array= (array/slice @[1 2 3] 0 2) @[1 2]) "array/slice 1")
-(assert (array= (array/slice @[0 7 3 9 1 4] 2 -2) @[3 9 1]) "array/slice 2")
+(assert (array= (array/slice @[0 7 3 9 1 4] 2 -1) @[3 9 1]) "array/slice 2")

 # Array remove
 # 687a3c9
--- a/test/suite-boot.janet
+++ b/test/suite-boot.janet
@@ -113,22 +113,13 @@
 # 7478ad11
 (assert (= nil (any? [])) "any? 1")
 (assert (= nil (any? [false nil])) "any? 2")
-(assert (= false (any? [nil false])) "any? 3")
+(assert (= nil (any? [nil false])) "any? 3")
 (assert (= 1 (any? [1])) "any? 4")
 (assert (nan? (any? [nil math/nan nil])) "any? 5")
 (assert (= true
           (any? [nil nil false nil nil true nil nil nil nil false :a nil]))
        "any? 6")

-(assert (= true (every? [])) "every? 1")
-(assert (= true (every? [1 true])) "every? 2")
-(assert (= 1 (every? [true 1])) "every? 3")
-(assert (= nil (every? [nil])) "every? 4")
-(assert (= 2 (every? [1 math/nan 2])) "every? 5")
-(assert (= false
-           (every? [1 1 true 1 1 false 1 1 1 1 true :a nil]))
-        "every? 6")
-
 # Some higher order functions and macros
 # 5e2de33
 (def my-array @[1 2 3 4 5 6])
@@ -186,11 +177,6 @@
 (assert (= txs [[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]])
        "nested seq")

-# :unless modifier
-(assert (deep= (seq [i :range [0 10] :unless (odd? i)] i)
-               @[0 2 4 6 8])
-        ":unless modifier")
-
 # 515891b03
 (assert (deep= (tabseq [i :in (range 3)] i (* 3 i))
               @{0 0 1 3 2 6}))
@@ -209,12 +195,6 @@
 (assert (deep= (seq [x :down-to [10 0]] x) (seq [x :down [10 -1]] x))
        "loop :down-to")

-# one-term :range forms
-(assert (deep= (seq [x :range [10]] x) (seq [x :range [0 10]] x))
-        "one-term :range")
-(assert (deep= (seq [x :down [10]] x) (seq [x :down [10 0]] x))
-        "one-term :down")
-
 # 7880d7320
 (def res @{})
 (loop [[k v] :pairs @{1 2 3 4 5 6}]
@@ -354,13 +334,6 @@
        "sort 5")
 (assert (<= ;(sort (map (fn [x] (math/random)) (range 1000)))) "sort 6")

-# #1283  
-(assert (deep=
-          (partition 2 (generate [ i :in [:a :b :c :d :e]] i))
-          '@[(:a :b) (:c :d) (:e)]))
-(assert (= (mean (generate [i :in [2 3 5 7 11]] i))
-           5.6))
-
 # And and or
 # c16a9d846
 (assert (= (and true true) true) "and true true")
@@ -389,7 +362,14 @@
 (assert (= false (and false false)) "and 1")
 (assert (= false (or false false)) "or 1")

+# Range
+# a982f351d
+(assert (deep= (range 10) @[0 1 2 3 4 5 6 7 8 9]) "range 1 argument")
+(assert (deep= (range 5 10) @[5 6 7 8 9]) "range 2 arguments")
+(assert (deep= (range 5 10 2) @[5 7 9]) "range 3 arguments")
 # 11cd1279d
+(assert (= (length (range 10)) 10) "(range 10)")
+(assert (= (length (range 1 10)) 9) "(range 1 10)")
 (assert (deep= @{:a 1 :b 2 :c 3} (zipcoll '[:a :b :c] '[1 2 3])) "zipcoll")

 # bc8be266f
--- a/test/suite-buffer.janet
+++ b/test/suite-buffer.janet
@@ -77,14 +77,6 @@
 (buffer/push-string b5 "456" @"789")
 (assert (= "123456789" (string b5)) "buffer/push-buffer 2")

-# Buffer from bytes
-(assert (deep= @"" (buffer/from-bytes)) "buffer/from-bytes 1")
-(assert (deep= @"ABC" (buffer/from-bytes 65 66 67)) "buffer/from-bytes 2")
-(assert (deep= @"0123456789" (buffer/from-bytes ;(range 48 58))) "buffer/from-bytes 3")
-(assert (= 0 (length (buffer/from-bytes))) "buffer/from-bytes 4")
-(assert (= 5 (length (buffer/from-bytes ;(range 5)))) "buffer/from-bytes 5")
-(assert-error "bad slot #1, expected 32 bit signed integer" (buffer/from-bytes :abc))
-
 # some tests for buffer/format
 # 029394d
 (assert (= (string (buffer/format @"" "pi = %6.3f" math/pi)) "pi =  3.142")
@@ -104,14 +96,13 @@
 # Regression #301
 # a3d4ecddb
 (def b (buffer/new-filled 128 0x78))
-(assert (= 38 (length (buffer/blit @"" b -1 90))) "buffer/blit 1")
+(assert (= 38 (length (buffer/blit @"" b 0 90))) "buffer/blit 1")

 (def a @"abcdefghijklm")
-(assert (deep= @"abcde" (buffer/blit @"" a -1 0 5)) "buffer/blit 2")
-(assert (deep= @"bcde" (buffer/blit @"" a -1 1 5)) "buffer/blit 3")
-(assert (deep= @"cde" (buffer/blit @"" a -1 2 5)) "buffer/blit 4")
-(assert (deep= @"de" (buffer/blit @"" a -1 3 5)) "buffer/blit 5")
-(assert (deep= @"de" (buffer/blit @"" a nil 3 5)) "buffer/blit 6")
+(assert (deep= @"abcde" (buffer/blit @"" a 0 0 5)) "buffer/blit 2")
+(assert (deep= @"bcde" (buffer/blit @"" a 0 1 5)) "buffer/blit 3")
+(assert (deep= @"cde" (buffer/blit @"" a 0 2 5)) "buffer/blit 4")
+(assert (deep= @"de" (buffer/blit @"" a 0 3 5)) "buffer/blit 5")

 # buffer/push-at
 # c55d93512
@@ -122,5 +113,8 @@
 (assert (deep= @"abc423" (buffer/push-at @"abc123" 3 "4"))
        "buffer/push-at 3")

+# 4782a76
+(assert (= 10 (do (var x 10) (def y x) (++ x) y)) "no invalid aliasing")
+
 (end-suite)

--- a/test/suite-corelib.janet
+++ b/test/suite-corelib.janet
@@ -159,23 +159,5 @@
 (assert-error "invalid offset-a: 1" (memcmp "a" "b" 1 1 0))
 (assert-error "invalid offset-b: 1" (memcmp "a" "b" 1 0 1))

-# Range
-# a982f351d
-(assert (deep= (range 10) @[0 1 2 3 4 5 6 7 8 9]) "(range 10)")
-(assert (deep= (range 5 10) @[5 6 7 8 9]) "(range 5 10)")
-(assert (deep= (range 0 16 4) @[0 4 8 12]) "(range 0 16 4)")
-(assert (deep= (range 0 17 4) @[0 4 8 12 16]) "(range 0 17 4)")
-(assert (deep= (range 16 0 -4) @[16 12 8 4]) "(range 16 0 -4)")
-(assert (deep= (range 17 0 -4) @[17 13 9 5 1]) "(range 17 0 -4)")
-
-(assert (= (length (range 10)) 10) "(range 10)")
-(assert (= (length (range -10)) 0) "(range -10)")
-(assert (= (length (range 1 10)) 9) "(range 1 10)")
-
-# iterating over generator
-(assert-no-error "iterate over coro 1" (values (generate [x :range [0 10]] x)))
-(assert-no-error "iterate over coro 2" (keys (generate [x :range [0 10]] x)))
-(assert-no-error "iterate over coro 3" (pairs (generate [x :range [0 10]] x)))
-
 (end-suite)

--- a/test/suite-parse.janet
+++ b/test/suite-parse.janet
@@ -69,7 +69,7 @@

  (def first-nl (= (chr "\n") (first str)))
  (def last-nl (= (chr "\n") (last str)))
-  (string/slice str (if first-nl 1 0) (if last-nl -2)))
+  (string/slice str (if first-nl 1 0) (if last-nl -1)))

 (defn reindent-reference
  "Same as reindent but use parser functionality. Useful for
--- a/test/suite-pp.janet
+++ b/test/suite-pp.janet
@@ -32,10 +32,10 @@
 # Buffer self blitting, check for use after free
 # bbcfaf128
 (def buf1 @"1234567890")
-(buffer/blit buf1 buf1 -1)
-(buffer/blit buf1 buf1 -1)
-(buffer/blit buf1 buf1 -1)
-(buffer/blit buf1 buf1 -1)
+(buffer/blit buf1 buf1 (length buf1))
+(buffer/blit buf1 buf1 (length buf1))
+(buffer/blit buf1 buf1 (length buf1))
+(buffer/blit buf1 buf1 (length buf1))
 (assert (= (string buf1) (string/repeat "1234567890" 16))
        "buffer blit against self")

--- a/test/suite-unknown.janet
+++ b/test/suite-unknown.janet
@@ -292,8 +292,5 @@
                 [2 6 4 'z]])
        "arg & inner symbolmap")

-# 4782a76
-(assert (= 10 (do (var x 10) (def y x) (++ x) y)) "no invalid aliasing")
-
 (end-suite)