Long way to go.

Address #1434 - add dynamic bindings for module state.
Update freebsd build
2025-10-28 22:27:41 +00:00 · 2024-04-15 17:40:32 -05:00 · 2024-04-15 16:20:13 -05:00 · 2024-04-15 16:02:34 -05:00 · 2024-04-15 07:34:02 -05:00 · 2024-03-27 22:32:27 -07:00
41 changed files with 1181 additions and 452 deletions
--- a/.builds/freebsd.yml
+++ b/.builds/freebsd.yml
@@ -1,4 +1,4 @@
-image: freebsd/12.x
+image: freebsd/14.x
 sources:
 - https://git.sr.ht/~bakpakin/janet
 packages:
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -56,7 +56,7 @@ jobs:
            gcc
      - name: Build the project
        shell: cmd
-        run: make -j CC=gcc
+        run: make -j4 CC=gcc JANET_NO_AMALG=1

  test-mingw-linux:
    name: Build and test with Mingw on Linux + Wine
--- a/.gitignore
+++ b/.gitignore
@@ -34,8 +34,11 @@ local

 # Common test files I use.
 temp.janet
-temp*.janet
+temp.c
+temp*janet
+temp*.c
 scratch.janet
+scratch.c

 # Emscripten
 *.bc
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,47 @@
 # Changelog
 All notable changes to this project will be documented in this file.

-## Unreleased - ???
+## 1.34.0 - 2024-03-22
+- Add a new (split) PEG special by @ianthehenry
+- Add buffer/push-* sized int and float by @pnelson
+- Documentation improvements: @amano-kenji, @llmII, @MaxGyver83, @pepe, @sogaiu.
+- Expose _exit to skip certain cleanup with os/exit.
+- Swap set / body order for each by @sogaiu.
+- Abort on assert failure instead of exit.
+- Fix: os/proc-wait by @llmII.
+- Fix macex1 to keep syntax location for all tuples.
+- Restore if-let tail calls.
+- Don't try and resume fibers that can't be resumed.
+- Register stream on unmarshal.
+- Fix asm roundtrip issue.
+
+## 1.33.0 - 2024-01-07
+- Add more + and * keywords to default-peg-grammar by @sogaiu.
+- Use libc strlen in janet_buffer_push_cstring by @williewillus.
+- Be a bit safer with reference counting.
+- Add support for atomic loads in Janet's atomic abstraction.
+- Fix poll event loop CPU usage issue.
+- Add ipv6, shared, and cryptorand options to meson.
+- Add more ipv6 feature detection.
+- Fix loop for forever loop.
+- Cleaned up unused NetStateConnect, fixed janet_async_end() ev refcount by @zevv.
+- Fix warnings w/ MSVC and format.
+- Fix marshal_one_env w/ JANET_MARSHAL_UNSAFE.
+- Fix `(default)`.
+- Fix cannot marshal fiber with c stackframe, in a dynamic way that is fairly conservative.
+- Fix typo for SIGALARM in os/proc-kill.
+- Prevent bytecode optimization from remove mk* instructions.
+- Fix arity typo in peg.c by @pepe.
+- Update Makefile for MinGW.
+- Fix canceling waiting fiber.
+- Add a new (sub) PEG special by @ianthehenry.
+- Fix if net/server's handler has incorrect arity.
+- Fix macex raising on ().
+
+## 1.32.1 - 2023-10-15
+- Fix return value from C function `janet_dobytes` when called on Janet functions that yield to event loop.
+- Change C API for event loop interaction - get rid of JanetListener and instead use `janet_async_start` and `janet_async_end`.
+- Rework event loop to make fewer system calls on kqueue and epoll.
 - Expose atomic refcount abstraction in janet.h
 - Add `array/weak` for weak references in arrays
 - Add support for weak tables via `table/weak`, `table/weak-keys`, and `table/weak-values`.
--- a/25
+++ b/25
@@ -33,6 +33,7 @@ CLIBS=-lm -lpthread
 JANET_TARGET=build/janet
 JANET_BOOT=build/janet_boot
 JANET_IMPORT_LIB=build/janet.lib
+JANET_LIBRARY_IMPORT_LIB=build/libjanet.lib
 JANET_LIBRARY=build/libjanet.so
 JANET_STATIC_LIBRARY=build/libjanet.a
 JANET_PATH?=$(LIBDIR)/janet
@@ -42,6 +43,7 @@ JANET_DIST_DIR?=janet-dist
 JANET_BOOT_FLAGS:=. JANET_PATH '$(JANET_PATH)'
 JANET_TARGET_OBJECTS=build/janet.o build/shell.o
 JPM_TAG?=master
+HAS_SHARED?=1
 DEBUGGER=gdb
 SONAME_SETTER=-Wl,-soname,

@@ -51,6 +53,7 @@ HOSTAR?=$(AR)
 # Symbols are (optionally) removed later, keep -g as default!
 CFLAGS?=-O2 -g
 LDFLAGS?=-rdynamic
+LIBJANET_LDFLAGS?=$(LD_FLAGS)
 RUN:=$(RUN)

 COMMON_CFLAGS:=-std=c99 -Wall -Wextra -Isrc/include -Isrc/conf -fvisibility=hidden -fPIC
@@ -93,12 +96,17 @@ endif
 ifeq ($(findstring MINGW,$(UNAME)), MINGW)
 	CLIBS:=-lws2_32 -lpsapi -lwsock32
 	LDFLAGS:=-Wl,--out-implib,$(JANET_IMPORT_LIB)
+	LIBJANET_LDFLAGS:=-Wl,--out-implib,$(JANET_LIBRARY_IMPORT_LIB)
 	JANET_TARGET:=$(JANET_TARGET).exe
 	JANET_BOOT:=$(JANET_BOOT).exe
 endif

+
 $(shell mkdir -p build/core build/c build/boot build/mainclient)
-all: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.h
+all: $(JANET_TARGET) $(JANET_STATIC_LIBRARY) build/janet.h
+ifeq ($(HAS_SHARED), 1)
+all: $(JANET_LIBRARY)
+endif

 ######################
 ##### Name Files #####
@@ -196,9 +204,9 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################

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

 build/c/shell.c: src/mainclient/shell.c
@@ -220,7 +228,7 @@ $(JANET_TARGET): $(JANET_TARGET_OBJECTS)
 	$(HOSTCC) $(LDFLAGS) $(BUILD_CFLAGS) -o $@ $^ $(CLIBS)

 $(JANET_LIBRARY): $(JANET_TARGET_OBJECTS)
-	$(HOSTCC) $(LDFLAGS) $(BUILD_CFLAGS) $(SONAME_SETTER)$(SONAME) -shared -o $@ $^ $(CLIBS)
+	$(HOSTCC) $(LIBJANET_LDFLAGS) $(BUILD_CFLAGS) $(SONAME_SETTER)$(SONAME) -shared -o $@ $^ $(CLIBS)

 $(JANET_STATIC_LIBRARY): $(JANET_TARGET_OBJECTS)
 	$(HOSTAR) rcs $@ $^
@@ -263,7 +271,7 @@ dist: build/janet-dist.tar.gz

 build/janet-%.tar.gz: $(JANET_TARGET) \
 	build/janet.h \
-	janet.1 LICENSE CONTRIBUTING.md $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) \
+	janet.1 LICENSE CONTRIBUTING.md $(JANET_STATIC_LIBRARY) \
 	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/
@@ -271,13 +279,17 @@ build/janet-%.tar.gz: $(JANET_TARGET) \
 	mkdir -p build/$(JANET_DIST_DIR)/include
 	cp build/janet.h build/$(JANET_DIST_DIR)/include/
 	mkdir -p build/$(JANET_DIST_DIR)/lib/
-	cp $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/$(JANET_DIST_DIR)/lib/
+	cp $(JANET_STATIC_LIBRARY) build/$(JANET_DIST_DIR)/lib/
+	cp $(JANET_LIBRARY) build/$(JANET_DIST_DIR)/lib/ || true
 	mkdir -p build/$(JANET_DIST_DIR)/man/man1/
 	cp janet.1 build/$(JANET_DIST_DIR)/man/man1/janet.1
 	mkdir -p build/$(JANET_DIST_DIR)/src/
 	cp build/c/janet.c build/c/shell.c build/$(JANET_DIST_DIR)/src/
 	cp CONTRIBUTING.md LICENSE README.md build/$(JANET_DIST_DIR)/
 	cd build && tar -czvf ../$@ ./$(JANET_DIST_DIR)
+ifeq ($(HAS_SHARED), 1)
+build/janet-%.tar.gz: $(JANET_LIBRARY)
+endif

 #########################
 ##### Documentation #####
@@ -331,6 +343,7 @@ install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc
 	mkdir -p '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)'
 	cp build/janet.pc '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)/janet.pc'
 	cp '$(JANET_IMPORT_LIB)' '$(DESTDIR)$(LIBDIR)' || echo 'no import lib to install (mingw only)'
+	cp '$(JANET_LIBRARY_IMPORT_LIB)' '$(DESTDIR)$(LIBDIR)' || echo 'no import lib to install (mingw only)'
 	[ -z '$(DESTDIR)' ] && $(LDCONFIG) || echo "You can ignore this error for non-Linux systems or local installs"

 install-jpm-git: $(JANET_TARGET)
--- a/build_win.bat
+++ b/build_win.bat
@@ -91,7 +91,9 @@ exit /b 0
 :CLEAN
 del *.exe *.lib *.exp
 rd /s /q build
-rd /s /q dist
+if exist dist (
+    rd /s /q dist
+)
 exit /b 0

@rem Run tests
--- a/examples/posix-exec.janet
+++ b/examples/posix-exec.janet
@@ -0,0 +1,5 @@
+# Switch to python
+
+(print "running in Janet")
+(os/posix-exec ["python"] :p)
+(print "will not print")
--- 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.34.0')

 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -61,6 +61,7 @@ conf.set('JANET_NO_SOURCEMAPS', not get_option('sourcemaps'))
 conf.set('JANET_NO_ASSEMBLER', not get_option('assembler'))
 conf.set('JANET_NO_PEG', not get_option('peg'))
 conf.set('JANET_NO_NET', not get_option('net'))
+conf.set('JANET_NO_IPV6', not get_option('ipv6'))
 conf.set('JANET_NO_EV', not get_option('ev') or get_option('single_threaded'))
 conf.set('JANET_REDUCED_OS', get_option('reduced_os'))
 conf.set('JANET_NO_INT_TYPES', not get_option('int_types'))
@@ -78,6 +79,7 @@ conf.set('JANET_EV_NO_KQUEUE', not get_option('kqueue'))
 conf.set('JANET_NO_INTERPRETER_INTERRUPT', not get_option('interpreter_interrupt'))
 conf.set('JANET_NO_FFI', not get_option('ffi'))
 conf.set('JANET_NO_FFI_JIT', not get_option('ffi_jit'))
+conf.set('JANET_NO_CRYPTORAND', not get_option('cryptorand'))
 if get_option('os_name') != ''
  conf.set('JANET_OS_NAME', get_option('os_name'))
 endif
@@ -182,32 +184,41 @@ if not get_option('single_threaded')
  janet_dependencies += thread_dep
 endif

+# Allow building with no shared library
 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)
-
+if get_option('shared')
+  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']
+  if cc.has_argument('-fvisibility=hidden')
+    extra_cflags = ['-fvisibility=hidden', '-DJANET_DLL_IMPORT']
+  else
+    extra_cflags = ['-DJANET_DLL_IMPORT']
+  endif
+  janet_mainclient = executable('janet', mainclient_src,
+    include_directories : incdir,
+    dependencies : janet_dependencies,
+    link_with: [libjanet],
+    c_args : extra_cflags,
+    install : true)
 else
-  extra_cflags = ['-DJANET_DLL_IMPORT']
+  # No shared library
+  janet_mainclient = executable('janet', mainclient_src, janetc,
+    include_directories : incdir,
+    dependencies : janet_dependencies,
+    c_args : lib_cflags,
+    install : true)
 endif
-janet_mainclient = executable('janet', mainclient_src,
-  include_directories : incdir,
-  dependencies : janet_dependencies,
-  link_with: [libjanet],
-  c_args : extra_cflags,
-  install : true)

 if meson.is_cross_build()
  native_cc = meson.get_compiler('c', native: true)
@@ -271,14 +282,15 @@ endforeach
 run_target('repl', command : [janet_nativeclient])

 # For use as meson subproject (wrap)
-janet_dep = declare_dependency(include_directories : incdir,
-  link_with : libjanet)
-
+if get_option('shared')
+  janet_dep = declare_dependency(include_directories : incdir,
+    link_with : libjanet)
 # pkgconfig
-pkg = import('pkgconfig')
-pkg.generate(libjanet,
-  subdirs: 'janet',
-  description: 'Library for the Janet programming language.')
+  pkg = import('pkgconfig')
+  pkg.generate(libjanet,
+    subdirs: 'janet',
+    description: 'Library for the Janet programming language.')
+endif

 # Installation
 install_man('janet.1')
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -11,13 +11,14 @@ option('peg', type : 'boolean', value : true)
 option('int_types', type : 'boolean', value : true)
 option('prf', type : 'boolean', value : false)
 option('net', type : 'boolean', value : true)
+option('ipv6', type : 'boolean', value : true)
 option('ev', type : 'boolean', value : true)
 option('processes', type : 'boolean', value : true)
 option('umask', type : 'boolean', value : true)
 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('epoll', type : 'boolean', value : true)
+option('kqueue', type : 'boolean', value : true)
 option('interpreter_interrupt', type : 'boolean', value : true)
 option('ffi', type : 'boolean', value : true)
 option('ffi_jit', type : 'boolean', value : true)
@@ -29,3 +30,5 @@ option('stack_max', type : 'integer', min : 8096, max : 0x7fffffff, value : 0x7f

 option('arch_name', type : 'string', value: '')
 option('os_name', type : 'string', value: '')
+option('shared', type : 'boolean', value: true)
+option('cryptorand', type : 'boolean', value: true)
--- a/src/boot/boot.janet
+++ b/src/boot/boot.janet
@@ -162,7 +162,7 @@
  ``Define a default value for an optional argument.
  Expands to `(def sym (if (= nil sym) val sym))`.``
  [sym val]
-  ~(def ,sym (if (= nil ,sym) ,val ,sym)))
+  ~(def ,sym (if (,= nil ,sym) ,val ,sym)))

 (defmacro comment
  "Ignores the body of the comment."
@@ -420,10 +420,14 @@

 (defn- range-template
  [binding object kind 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]))))
+  (check-indexed object)
+  (def [a b c] object)
+  (def [start stop step]
+    (case (length object)
+      1 (case kind :range [0 a 1] :down [a 0 1])
+      2 [a b 1]
+      [a b c]))
+  (for-template binding start stop step comparison op [rest]))

 (defn- each-template
  [binding inx kind body]
@@ -438,8 +442,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]
@@ -661,6 +665,9 @@
  (each x xs (*= accum x))
  accum)

+# declare ahead of time
+(var- macexvar nil)
+
 (defmacro if-let
  ``Make multiple bindings, and if all are truthy,
  evaluate the `tru` form. If any are false or nil, evaluate
@@ -669,20 +676,19 @@
  (def len (length bindings))
  (if (= 0 len) (error "expected at least 1 binding"))
  (if (odd? len) (error "expected an even number of bindings"))
-  (def res (gensym))
+  (def fal2 (if macexvar (macexvar fal) fal))
  (defn aux [i]
    (if (>= i len)
-      ~(do (set ,res ,tru) true)
+      tru
      (do
        (def bl (in bindings i))
        (def br (in bindings (+ 1 i)))
        (if (symbol? bl)
-          ~(if (def ,bl ,br) ,(aux (+ 2 i)))
+          ~(if (def ,bl ,br) ,(aux (+ 2 i)) ,fal2)
          ~(if (def ,(def sym (gensym)) ,br)
-             (do (def ,bl ,sym) ,(aux (+ 2 i))))))))
-  ~(do
-     (var ,res nil)
-     (if ,(aux 0) ,res ,fal)))
+             (do (def ,bl ,sym) ,(aux (+ 2 i)))
+             ,fal2)))))
+   (aux 0))

 (defmacro when-let
  "Same as `(if-let bindings (do ;body))`."
@@ -2123,21 +2129,22 @@
     'upscope expandall})

  (defn dotup [t]
+    (if (= nil (next t)) (break ()))
    (def h (in t 0))
    (def s (in specs h))
    (def entry (or (dyn h) {}))
    (def m (do (def r (get entry :ref)) (if r (in r 0) (get entry :value))))
    (def m? (in entry :macro))
    (cond
-      s (s t)
+      s (keep-syntax t (s t))
      m? (do (setdyn *macro-form* t) (m ;(tuple/slice t 1)))
-      (tuple/slice (map recur t))))
+      (keep-syntax! t (map recur t))))

  (def ret
    (case (type x)
      :tuple (if (= (tuple/type x) :brackets)
-               (tuple/brackets ;(map recur x))
-               (dotup x))
+                 (tuple/brackets ;(map recur x))
+                 (dotup x))
      :array (map recur x)
      :struct (table/to-struct (dotable x recur))
      :table (dotable x recur)
@@ -2243,6 +2250,8 @@
    (set current (macex1 current on-binding)))
  current)

+(set macexvar macex)
+
 (defmacro varfn
  ``Create a function that can be rebound. `varfn` has the same signature
  as `defn`, but defines functions in the environment as vars. If a var `name`
@@ -2333,26 +2342,36 @@
 (def default-peg-grammar
  `The default grammar used for pegs. This grammar defines several common patterns
  that should make it easier to write more complex patterns.`
-  ~@{:d (range "09")
-     :a (range "az" "AZ")
+  ~@{:a (range "az" "AZ")
+     :d (range "09")
+     :h (range "09" "af" "AF")
     :s (set " \t\r\n\0\f\v")
     :w (range "az" "AZ" "09")
-     :h (range "09" "af" "AF")
-     :S (if-not :s 1)
-     :W (if-not :w 1)
     :A (if-not :a 1)
     :D (if-not :d 1)
     :H (if-not :h 1)
-     :d+ (some :d)
+     :S (if-not :s 1)
+     :W (if-not :w 1)
     :a+ (some :a)
+     :d+ (some :d)
+     :h+ (some :h)
     :s+ (some :s)
     :w+ (some :w)
-     :h+ (some :h)
-     :d* (any :d)
+     :A+ (some :A)
+     :D+ (some :D)
+     :H+ (some :H)
+     :S+ (some :S)
+     :W+ (some :W)
     :a* (any :a)
-     :w* (any :w)
+     :d* (any :d)
+     :h* (any :h)
     :s* (any :s)
-     :h* (any :h)})
+     :w* (any :w)
+     :A* (any :A)
+     :D* (any :D)
+     :H* (any :H)
+     :S* (any :S)
+     :W* (any :W)})

 (setdyn *peg-grammar* default-peg-grammar)

@@ -2748,6 +2767,11 @@
 (defn- check-is-dep [x] (unless (or (string/has-prefix? "/" x) (string/has-prefix? "@" x) (string/has-prefix? "." x)) x))
 (defn- check-project-relative [x] (if (string/has-prefix? "/" x) x))

+(defdyn *module/cache* "Dynamic binding for overriding `module/cache`")
+(defdyn *module/paths* "Dynamic binding for overriding `module/cache`")
+(defdyn *module/loading* "Dynamic binding for overriding `module/cache`")
+(defdyn *module/loaders* "Dynamic binding for overriding `module/loaders`")
+
 (def module/cache
  "A table, mapping loaded module identifiers to their environments."
  @{})
@@ -2776,24 +2800,25 @@
  keyword name of a loader in `module/loaders`. Returns the modified `module/paths`.
  ```
  [ext loader]
+  (def mp (dyn *module/paths* module/paths))
  (defn- find-prefix
    [pre]
-    (or (find-index |(and (string? ($ 0)) (string/has-prefix? pre ($ 0))) module/paths) 0))
+    (or (find-index |(and (string? ($ 0)) (string/has-prefix? pre ($ 0))) mp) 0))
  (def dyn-index (find-prefix ":@all:"))
-  (array/insert module/paths dyn-index [(string ":@all:" ext) loader check-dyn-relative])
+  (array/insert mp dyn-index [(string ":@all:" ext) loader check-dyn-relative])
  (def all-index (find-prefix ".:all:"))
-  (array/insert module/paths all-index [(string ".:all:" ext) loader check-project-relative])
+  (array/insert mp all-index [(string ".:all:" ext) loader check-project-relative])
  (def sys-index (find-prefix ":sys:"))
-  (array/insert module/paths sys-index [(string ":sys:/:all:" ext) loader check-is-dep])
+  (array/insert mp sys-index [(string ":sys:/:all:" ext) loader check-is-dep])
  (def curall-index (find-prefix ":cur:/:all:"))
-  (array/insert module/paths curall-index [(string ":cur:/:all:" ext) loader check-relative])
-  module/paths)
+  (array/insert mp curall-index [(string ":cur:/:all:" ext) loader check-relative])
+  mp)

 (module/add-paths ":native:" :native)
 (module/add-paths "/init.janet" :source)
 (module/add-paths ".janet" :source)
 (module/add-paths ".jimage" :image)
-(array/insert module/paths 0 [(fn is-cached [path] (if (in module/cache path) path)) :preload check-not-relative])
+(array/insert module/paths 0 [(fn is-cached [path] (if (in (dyn *module/cache* module/cache) path) path)) :preload check-not-relative])

 # Version of fexists that works even with a reduced OS
 (defn- fexists
@@ -2823,7 +2848,8 @@
  ```
  [path]
  (var ret nil)
-  (each [p mod-kind checker] module/paths
+  (def mp (dyn *module/paths* module/paths))
+  (each [p mod-kind checker] mp
    (when (mod-filter checker path)
      (if (function? p)
        (when-let [res (p path)]
@@ -2839,7 +2865,7 @@
                     (when (string? t)
                       (when (mod-filter chk path)
                         (module/expand-path path t))))
-          paths (filter identity (map expander module/paths))
+          paths (filter identity (map expander mp))
          str-parts (interpose "\n    " paths)]
      [nil (string "could not find module " path ":\n    " ;str-parts)])))

@@ -2994,13 +3020,15 @@
  of files as modules.``
  @{:native (fn native-loader [path &] (native path (make-env)))
    :source (fn source-loader [path args]
-              (put module/loading path true)
-              (defer (put module/loading path nil)
+              (def ml (dyn *module/loading* module/loading))
+              (put ml path true)
+              (defer (put ml path nil)
                (dofile path ;args)))
    :preload (fn preload-loader [path & args]
-               (when-let [m (in module/cache path)]
+               (def mc (dyn *module/cache* module/cache))
+               (when-let [m (in mc path)]
                 (if (function? m)
-                   (set (module/cache path) (m path ;args))
+                   (set (mc path) (m path ;args))
                   m)))
    :image (fn image-loader [path &] (load-image (slurp path)))})

@@ -3008,15 +3036,18 @@
  [path args kargs]
  (def [fullpath mod-kind] (module/find path))
  (unless fullpath (error mod-kind))
-  (if-let [check (if-not (kargs :fresh) (in module/cache fullpath))]
+  (def mc (dyn *module/cache* module/cache))
+  (def ml (dyn *module/loading* module/loading))
+  (def mls (dyn *module/loaders* module/loaders))
+  (if-let [check (if-not (kargs :fresh) (in mc fullpath))]
    check
-    (if (module/loading fullpath)
+    (if (ml fullpath)
      (error (string "circular dependency " fullpath " detected"))
      (do
-        (def loader (if (keyword? mod-kind) (module/loaders mod-kind) mod-kind))
+        (def loader (if (keyword? mod-kind) (mls mod-kind) mod-kind))
        (unless loader (error (string "module type " mod-kind " unknown")))
        (def env (loader fullpath args))
-        (put module/cache fullpath env)
+        (put mc fullpath env)
        env))))

 (defn require
@@ -3717,12 +3748,20 @@
    ~(,ev/thread (fn _spawn-thread [&] ,;body) nil :n))

  (defmacro ev/with-deadline
-    `Run a body of code with a deadline, such that if the code does not complete before
-    the deadline is up, it will be canceled.`
-    [deadline & body]
+    ``
+    Create a fiber to execute `body`, schedule the event loop to cancel
+    the task (root fiber) associated with `body`'s fiber, and start
+    `body`'s fiber by resuming it.
+
+    The event loop will try to cancel the root fiber if `body`'s fiber
+    has not completed after at least `sec` seconds.
+
+    `sec` is a number that can have a fractional part.
+    ``
+    [sec & body]
    (with-syms [f]
      ~(let [,f (coro ,;body)]
-         (,ev/deadline ,deadline nil ,f)
+         (,ev/deadline ,sec nil ,f)
         (,resume ,f))))

  (defn- cancel-all [chan fibers reason]
--- 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_MINOR 34
 #define JANET_VERSION_PATCH 0
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.31.0"
+#define JANET_VERSION "1.34.0"

 /* #define JANET_BUILD "local" */

@@ -52,6 +52,9 @@
 /* #define JANET_EV_NO_EPOLL */
 /* #define JANET_EV_NO_KQUEUE */
 /* #define JANET_NO_INTERPRETER_INTERRUPT */
+/* #define JANET_NO_IPV6 */
+/* #define JANET_NO_CRYPTORAND */
+/* #define JANET_USE_STDATOMIC */

 /* Custom vm allocator support */
 /* #include <mimalloc.h> */
--- a/src/core/abstract.c
+++ b/src/core/abstract.c
@@ -31,8 +31,6 @@
 #ifdef JANET_EV
 #ifdef JANET_WINDOWS
 #include <windows.h>
-#else
-#include <stdatomic.h>
 #endif
 #endif

--- a/src/core/array.c
+++ b/src/core/array.c
@@ -30,7 +30,7 @@

 #include <string.h>

-static void janet_array_impl(JanetArray *array, int32_t capacity) {
+static void janet_array_impl(JanetArray *array, size_t capacity) {
    Janet *data = NULL;
    if (capacity > 0) {
        janet_vm.next_collection += capacity * sizeof(Janet);
@@ -45,21 +45,23 @@ static void janet_array_impl(JanetArray *array, int32_t capacity) {
 }

 /* Creates a new array */
-JanetArray *janet_array(int32_t capacity) {
+JanetArray *janet_array(size_t capacity) {
+    if (capacity > JANET_SIZEMAX) capacity = JANET_SIZEMAX;
    JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
    janet_array_impl(array, capacity);
    return array;
 }

 /* Creates a new array with weak references */
-JanetArray *janet_array_weak(int32_t capacity) {
+JanetArray *janet_array_weak(size_t capacity) {
+    if (capacity > JANET_SIZEMAX) capacity = JANET_SIZEMAX;
    JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray));
    janet_array_impl(array, capacity);
    return array;
 }

 /* Creates a new array from n elements. */
-JanetArray *janet_array_n(const Janet *elements, int32_t n) {
+JanetArray *janet_array_n(const Janet *elements, size_t n) {
    JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
    array->capacity = n;
    array->count = n;
@@ -72,13 +74,13 @@ JanetArray *janet_array_n(const Janet *elements, int32_t n) {
 }

 /* Ensure the array has enough capacity for elements */
-void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
+void janet_array_ensure(JanetArray *array, size_t capacity, int32_t growth) {
    Janet *newData;
    Janet *old = array->data;
    if (capacity <= array->capacity) return;
    int64_t new_capacity = ((int64_t) capacity) * growth;
-    if (new_capacity > INT32_MAX) new_capacity = INT32_MAX;
-    capacity = (int32_t) new_capacity;
+    if (new_capacity > JANET_SIZEMAX) new_capacity = JANET_SIZEMAX;
+    capacity = (size_t) new_capacity;
    newData = janet_realloc(old, capacity * sizeof(Janet));
    if (NULL == newData) {
        JANET_OUT_OF_MEMORY;
@@ -89,11 +91,10 @@ void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
 }

 /* Set the count of an array. Extend with nil if needed. */
-void janet_array_setcount(JanetArray *array, int32_t count) {
-    if (count < 0)
-        return;
+void janet_array_setcount(JanetArray *array, size_t count) {
+    if (count > JANET_SIZEMAX) count = JANET_SIZEMAX;
    if (count > array->count) {
-        int32_t i;
+        size_t i;
        janet_array_ensure(array, count, 1);
        for (i = array->count; i < count; i++) {
            array->data[i] = janet_wrap_nil();
@@ -104,10 +105,10 @@ void janet_array_setcount(JanetArray *array, int32_t count) {

 /* Push a value to the top of the array */
 void janet_array_push(JanetArray *array, Janet x) {
-    if (array->count == INT32_MAX) {
+    if (array->count == JANET_SIZEMAX) {
        janet_panic("array overflow");
    }
-    int32_t newcount = array->count + 1;
+    size_t newcount = array->count + 1;
    janet_array_ensure(array, newcount, 2);
    array->data[array->count] = x;
    array->count = newcount;
@@ -138,7 +139,7 @@ JANET_CORE_FN(cfun_array_new,
              "Creates a new empty array with a pre-allocated capacity. The same as "
              "`(array)` but can be more efficient if the maximum size of an array is known.") {
    janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
    JanetArray *array = janet_array(cap);
    return janet_wrap_array(array);
 }
@@ -147,7 +148,7 @@ JANET_CORE_FN(cfun_array_weak,
              "(array/weak capacity)",
              "Creates a new empty array with a pre-allocated capacity and support for weak references. Similar to `array/new`.") {
    janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
    JanetArray *array = janet_array_weak(cap);
    return janet_wrap_array(array);
 }
@@ -156,7 +157,7 @@ JANET_CORE_FN(cfun_array_new_filled,
              "(array/new-filled count &opt value)",
              "Creates a new array of `count` elements, all set to `value`, which defaults to nil. Returns the new array.") {
    janet_arity(argc, 1, 2);
-    int32_t count = janet_getnat(argv, 0);
+    size_t count = janet_getsize(argv, 0);
    Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
    JanetArray *array = janet_array(count);
    for (int32_t i = 0; i < count; i++) {
@@ -201,10 +202,10 @@ JANET_CORE_FN(cfun_array_push,
              "Push all the elements of xs to 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) {
+    if ((size_t)(INT32_MAX - argc + 1) <= array->count) {
        janet_panic("array overflow");
    }
-    int32_t newcount = array->count - 1 + argc;
+    size_t newcount = array->count - 1 + (size_t) argc;
    janet_array_ensure(array, newcount, 2);
    if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet));
    array->count = newcount;
@@ -219,7 +220,7 @@ JANET_CORE_FN(cfun_array_ensure,
              "Otherwise, the backing memory will be reallocated so that there is enough space.") {
    janet_fixarity(argc, 3);
    JanetArray *array = janet_getarray(argv, 0);
-    int32_t newcount = janet_getinteger(argv, 1);
+    size_t newcount = janet_getsize(argv, 1);
    int32_t growth = janet_getinteger(argv, 2);
    if (newcount < 1) janet_panic("expected positive integer");
    janet_array_ensure(array, newcount, growth);
@@ -258,7 +259,7 @@ JANET_CORE_FN(cfun_array_concat,
                break;
            case JANET_ARRAY:
            case JANET_TUPLE: {
-                int32_t j, len = 0;
+                size_t j, len = 0;
                const Janet *vals = NULL;
                janet_indexed_view(argv[i], &vals, &len);
                if (array->data == vals) {
--- a/src/core/asm.c
+++ b/src/core/asm.c
@@ -560,6 +560,9 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
    x = janet_get1(s, janet_ckeywordv("vararg"));
    if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_VARARG;

+    /* Initialize slotcount */
+    def->slotcount = !!(def->flags & JANET_FUNCDEF_FLAG_VARARG) + def->arity;
+
    /* Check structarg */
    x = janet_get1(s, janet_ckeywordv("structarg"));
    if (janet_truthy(x)) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;
@@ -784,8 +787,9 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
    }

    /* Verify the func def */
-    if (janet_verify(def)) {
-        janet_asm_error(&a, "invalid assembly");
+    int verify_status = janet_verify(def);
+    if (verify_status) {
+        janet_asm_errorv(&a, janet_formatc("invalid assembly (%d)", verify_status));
    }

    /* Add final flags */
--- a/src/core/buffer.c
+++ b/src/core/buffer.c
@@ -135,8 +135,7 @@ void janet_buffer_extra(JanetBuffer *buffer, int32_t n) {

 /* Push a cstring to buffer */
 void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) {
-    int32_t len = 0;
-    while (cstring[len]) ++len;
+    int32_t len = (int32_t) strlen(cstring);
    janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len);
 }

@@ -321,6 +320,143 @@ JANET_CORE_FN(cfun_buffer_chars,
    return argv[0];
 }

+static int should_reverse_bytes(const Janet *argv, int32_t argc) {
+    JanetKeyword order_kw = janet_getkeyword(argv, argc);
+    if (!janet_cstrcmp(order_kw, "le")) {
+#if JANET_BIG_ENDIAN
+        return 1;
+#endif
+    } else if (!janet_cstrcmp(order_kw, "be")) {
+#if JANET_LITTLE_ENDIAN
+        return 1;
+#endif
+    } else if (!janet_cstrcmp(order_kw, "native")) {
+        return 0;
+    } else {
+        janet_panicf("expected endianness :le, :be or :native, got %v", argv[1]);
+    }
+    return 0;
+}
+
+static void reverse_u32(uint8_t bytes[4]) {
+    uint8_t temp;
+    temp = bytes[3];
+    bytes[3] = bytes[0];
+    bytes[0] = temp;
+    temp = bytes[2];
+    bytes[2] = bytes[1];
+    bytes[1] = temp;
+}
+
+static void reverse_u64(uint8_t bytes[8]) {
+    uint8_t temp;
+    temp = bytes[7];
+    bytes[7] = bytes[0];
+    bytes[0] = temp;
+    temp = bytes[6];
+    bytes[6] = bytes[1];
+    bytes[1] = temp;
+    temp = bytes[5];
+    bytes[5] = bytes[2];
+    bytes[2] = temp;
+    temp = bytes[4];
+    bytes[4] = bytes[3];
+    bytes[3] = temp;
+}
+
+JANET_CORE_FN(cfun_buffer_push_uint16,
+              "(buffer/push-uint16 buffer order data)",
+              "Push a 16 bit unsigned integer data onto the end of the buffer. "
+              "Returns the modified buffer.") {
+    janet_fixarity(argc, 3);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    int reverse = should_reverse_bytes(argv, 1);
+    union {
+        uint16_t data;
+        uint8_t bytes[2];
+    } u;
+    u.data = (uint16_t) janet_getinteger(argv, 2);
+    if (reverse) {
+        uint8_t temp = u.bytes[1];
+        u.bytes[1] = u.bytes[0];
+        u.bytes[0] = temp;
+    }
+    janet_buffer_push_u16(buffer, *(uint16_t *) u.bytes);
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_push_uint32,
+              "(buffer/push-uint32 buffer order data)",
+              "Push a 32 bit unsigned integer data onto the end of the buffer. "
+              "Returns the modified buffer.") {
+    janet_fixarity(argc, 3);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    int reverse = should_reverse_bytes(argv, 1);
+    union {
+        uint32_t data;
+        uint8_t bytes[4];
+    } u;
+    u.data = (uint32_t) janet_getinteger(argv, 2);
+    if (reverse)
+        reverse_u32(u.bytes);
+    janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes);
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_push_uint64,
+              "(buffer/push-uint64 buffer order data)",
+              "Push a 64 bit unsigned integer data onto the end of the buffer. "
+              "Returns the modified buffer.") {
+    janet_fixarity(argc, 3);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    int reverse = should_reverse_bytes(argv, 1);
+    union {
+        uint64_t data;
+        uint8_t bytes[8];
+    } u;
+    u.data = (uint64_t) janet_getuinteger64(argv, 2);
+    if (reverse)
+        reverse_u64(u.bytes);
+    janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes);
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_push_float32,
+              "(buffer/push-float32 buffer order data)",
+              "Push the underlying bytes of a 32 bit float data onto the end of the buffer. "
+              "Returns the modified buffer.") {
+    janet_fixarity(argc, 3);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    int reverse = should_reverse_bytes(argv, 1);
+    union {
+        float data;
+        uint8_t bytes[4];
+    } u;
+    u.data = (float) janet_getnumber(argv, 2);
+    if (reverse)
+        reverse_u32(u.bytes);
+    janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes);
+    return argv[0];
+}
+
+JANET_CORE_FN(cfun_buffer_push_float64,
+              "(buffer/push-float64 buffer order data)",
+              "Push the underlying bytes of a 64 bit float data onto the end of the buffer. "
+              "Returns the modified buffer.") {
+    janet_fixarity(argc, 3);
+    JanetBuffer *buffer = janet_getbuffer(argv, 0);
+    int reverse = should_reverse_bytes(argv, 1);
+    union {
+        double data;
+        uint8_t bytes[8];
+    } u;
+    u.data = janet_getnumber(argv, 2);
+    if (reverse)
+        reverse_u64(u.bytes);
+    janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes);
+    return argv[0];
+}
+
 static void buffer_push_impl(JanetBuffer *buffer, Janet *argv, int32_t argc_offset, int32_t argc) {
    for (int32_t i = argc_offset; i < argc; i++) {
        if (janet_checktype(argv[i], JANET_NUMBER)) {
@@ -529,6 +665,11 @@ void janet_lib_buffer(JanetTable *env) {
        JANET_CORE_REG("buffer/push-byte", cfun_buffer_u8),
        JANET_CORE_REG("buffer/push-word", cfun_buffer_word),
        JANET_CORE_REG("buffer/push-string", cfun_buffer_chars),
+        JANET_CORE_REG("buffer/push-uint16", cfun_buffer_push_uint16),
+        JANET_CORE_REG("buffer/push-uint32", cfun_buffer_push_uint32),
+        JANET_CORE_REG("buffer/push-uint64", cfun_buffer_push_uint64),
+        JANET_CORE_REG("buffer/push-float32", cfun_buffer_push_float32),
+        JANET_CORE_REG("buffer/push-float64", cfun_buffer_push_float64),
        JANET_CORE_REG("buffer/push", cfun_buffer_push),
        JANET_CORE_REG("buffer/push-at", cfun_buffer_push_at),
        JANET_CORE_REG("buffer/popn", cfun_buffer_popn),
--- a/src/core/bytecode.c
+++ b/src/core/bytecode.c
@@ -226,6 +226,7 @@ void janet_bytecode_movopt(JanetFuncDef *def) {
                case JOP_LOAD_TRUE:
                case JOP_LOAD_FALSE:
                case JOP_LOAD_SELF:
+                    break;
                case JOP_MAKE_ARRAY:
                case JOP_MAKE_BUFFER:
                case JOP_MAKE_STRING:
@@ -233,6 +234,8 @@ void janet_bytecode_movopt(JanetFuncDef *def) {
                case JOP_MAKE_TABLE:
                case JOP_MAKE_TUPLE:
                case JOP_MAKE_BRACKET_TUPLE:
+                    /* Reads from the stack, don't remove */
+                    janetc_regalloc_touch(&ra, DD);
                    break;

                /* Read A */
--- a/src/core/capi.c
+++ b/src/core/capi.c
@@ -35,6 +35,13 @@
 #endif
 #endif

+#ifdef JANET_USE_STDATOMIC
+#include <stdatomic.h>
+/* We don't need stdatomic on most compilers since we use compiler builtins for atomic operations.
+ * Some (TCC), explicitly require using stdatomic.h and don't have any exposed builtins (that I know of).
+ * For TCC and similar compilers, one would need -std=c11 or similar then to get access. */
+#endif
+
 JANET_NO_RETURN static void janet_top_level_signal(const char *msg) {
 #ifdef JANET_TOP_LEVEL_SIGNAL
    JANET_TOP_LEVEL_SIGNAL(msg);
@@ -338,7 +345,7 @@ int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const c
    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);
+        janet_panicf("%s index %d out of range [%d,%d]", which, (int64_t) raw, -(int64_t)length - 1, (int64_t) length);
    return not_raw;
 }

@@ -361,7 +368,7 @@ int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const ch
    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, (int64_t)raw, -(int64_t)length, (int64_t)length);
    return not_raw;
 }

@@ -496,6 +503,8 @@ void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetA
 JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) {
 #ifdef JANET_WINDOWS
    return InterlockedIncrement(x);
+#elif defined(JANET_USE_STDATOMIC)
+    return atomic_fetch_add_explicit(x, 1, memory_order_relaxed) + 1;
 #else
    return __atomic_add_fetch(x, 1, __ATOMIC_RELAXED);
 #endif
@@ -504,8 +513,20 @@ JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) {
 JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x) {
 #ifdef JANET_WINDOWS
    return InterlockedDecrement(x);
+#elif defined(JANET_USE_STDATOMIC)
+    return atomic_fetch_add_explicit(x, -1, memory_order_acq_rel) - 1;
 #else
-    return __atomic_add_fetch(x, -1, __ATOMIC_RELAXED);
+    return __atomic_add_fetch(x, -1, __ATOMIC_ACQ_REL);
+#endif
+}
+
+JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) {
+#ifdef JANET_WINDOWS
+    return InterlockedOr(x, 0);
+#elif defined(JANET_USE_STDATOMIC)
+    return atomic_load_explicit(x, memory_order_acquire);
+#else
+    return __atomic_load_n(x, __ATOMIC_ACQUIRE);
 #endif
 }

--- a/src/core/corelib.c
+++ b/src/core/corelib.c
@@ -110,14 +110,14 @@ JANET_CORE_FN(janet_core_expand_path,
              "(module/expand-path path template)",
              "Expands a path template as found in `module/paths` for `module/find`. "
              "This takes in a path (the argument to require) and a template string, "
-              "to expand the path to a path that can be "
-              "used for importing files. The replacements are as follows:\n\n"
+              "to expand the path to a path that can be used for importing files. "
+              "The replacements are as follows:\n\n"
              "* :all: -- the value of path verbatim.\n\n"
-              "* :@all: -- Same as :all:, but if `path` starts with the @ character,\n"
-              "           the first path segment is replaced with a dynamic binding\n"
-              "           `(dyn <first path segment as keyword>)`.\n\n"
-              "* :cur: -- the current file, or (dyn :current-file)\n\n"
-              "* :dir: -- the directory containing the current file\n\n"
+              "* :@all: -- Same as :all:, but if `path` starts with the @ character, "
+              "the first path segment is replaced with a dynamic binding "
+              "`(dyn <first path segment as keyword>)`.\n\n"
+              "* :cur: -- the directory portion, if any, of (dyn :current-file)\n\n"
+              "* :dir: -- the directory portion, if any, of the path argument\n\n"
              "* :name: -- the name component of path, with extension if given\n\n"
              "* :native: -- the extension used to load natives, .so or .dll\n\n"
              "* :sys: -- the system path, or (dyn :syspath)") {
@@ -1144,17 +1144,20 @@ JanetTable *janet_core_env(JanetTable *replacements) {
                    JDOC("(next ds &opt key)\n\n"
                         "Gets the next key in a data structure. Can be used to iterate through "
                         "the keys of a data structure in an unspecified order. Keys are guaranteed "
-                         "to be seen only once per iteration if they data structure is not mutated "
+                         "to be seen only once per iteration if the data structure is not mutated "
                         "during iteration. If key is nil, next returns the first key. If next "
                         "returns nil, there are no more keys to iterate through."));
    janet_quick_asm(env, JANET_FUN_PROP,
                    "propagate", 2, 2, 2, 2, propagate_asm, sizeof(propagate_asm),
                    JDOC("(propagate x fiber)\n\n"
-                         "Propagate a signal from a fiber to the current fiber. The resulting "
-                         "stack trace from the current fiber will include frames from fiber. If "
-                         "fiber is in a state that can be resumed, resuming the current fiber will "
-                         "first resume fiber. This function can be used to re-raise an error without "
-                         "losing the original stack trace."));
+                         "Propagate a signal from a fiber to the current fiber and "
+                         "set the last value of the current fiber to `x`.  The signal "
+                         "value is then available as the status of the current fiber. "
+                         "The resulting stack trace from the current fiber will include "
+                         "frames from fiber. If fiber is in a state that can be resumed, "
+                         "resuming the current fiber will first resume `fiber`. "
+                         "This function can be used to re-raise an error without losing "
+                         "the original stack trace."));
    janet_quick_asm(env, JANET_FUN_DEBUG,
                    "debug", 1, 0, 1, 1, debug_asm, sizeof(debug_asm),
                    JDOC("(debug &opt x)\n\n"
--- a/src/core/debug.c
+++ b/src/core/debug.c
@@ -388,8 +388,8 @@ JANET_CORE_FN(cfun_debug_stack,
 JANET_CORE_FN(cfun_debug_stacktrace,
              "(debug/stacktrace fiber &opt err prefix)",
              "Prints a nice looking stacktrace for a fiber. Can optionally provide "
-              "an error value to print the stack trace with. If `err` is nil or not "
-              "provided, and no prefix is given, will skip the error line. Returns the fiber.") {
+              "an error value to print the stack trace with. If `prefix` is nil or not "
+              "provided, will skip the error line. Returns the fiber.") {
    janet_arity(argc, 1, 3);
    JanetFiber *fiber = janet_getfiber(argv, 0);
    Janet x = argc == 1 ? janet_wrap_nil() : argv[1];
--- a/src/core/ev.c
+++ b/src/core/ev.c
@@ -255,19 +255,29 @@ static void add_timeout(JanetTimeout to) {

 void janet_async_end(JanetFiber *fiber) {
    if (fiber->ev_callback) {
+        fiber->ev_callback(fiber, JANET_ASYNC_EVENT_DEINIT);
        janet_gcunroot(janet_wrap_abstract(fiber->ev_stream));
        fiber->ev_callback = NULL;
-        if (fiber->ev_state) {
-            if (!(fiber->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) {
+        if (!(fiber->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) {
+            if (fiber->ev_state) {
                janet_free(fiber->ev_state);
-                janet_ev_dec_refcount();
+                fiber->ev_state = NULL;
            }
-            fiber->ev_state = NULL;
+            janet_ev_dec_refcount();
        }
    }
 }

-void *janet_async_start(JanetFiber *fiber, JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, size_t data_size) {
+void janet_async_in_flight(JanetFiber *fiber) {
+#ifdef JANET_WINDOWS
+    fiber->flags |= JANET_FIBER_EV_FLAG_IN_FLIGHT;
+#else
+    (void) fiber;
+#endif
+}
+
+void janet_async_start(JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state) {
+    JanetFiber *fiber = janet_vm.root_fiber;
    janet_assert(!fiber->ev_callback, "double async on fiber");
    if (mode & JANET_ASYNC_LISTEN_READ) stream->read_fiber = fiber;
    if (mode & JANET_ASYNC_LISTEN_WRITE) stream->write_fiber = fiber;
@@ -275,14 +285,9 @@ void *janet_async_start(JanetFiber *fiber, JanetStream *stream, JanetAsyncMode m
    fiber->ev_stream = stream;
    janet_ev_inc_refcount();
    janet_gcroot(janet_wrap_abstract(stream));
-    if (data_size) {
-        void *data = janet_malloc(data_size);
-        fiber->ev_state = data;
-        return data;
-    } else {
-        fiber->ev_state = NULL;
-        return NULL;
-    }
+    fiber->ev_state = state;
+    callback(fiber, JANET_ASYNC_EVENT_INIT);
+    janet_await();
 }

 void janet_fiber_did_resume(JanetFiber *fiber) {
@@ -445,6 +450,9 @@ static void *janet_stream_unmarshal(JanetMarshalContext *ctx) {
    p->handle = (JanetHandle) janet_unmarshal_int64(ctx);
 #else
    p->handle = (JanetHandle) janet_unmarshal_int(ctx);
+#endif
+#ifdef JANET_EV_POLL
+    janet_register_stream(p);
 #endif
    return p;
 }
@@ -1161,10 +1169,12 @@ JANET_CORE_FN(cfun_channel_close,
                msg.argj = janet_wrap_nil();
                janet_ev_post_event(vm, janet_thread_chan_cb, msg);
            } else {
-                if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) {
-                    janet_schedule(writer.fiber, make_close_result(channel));
-                } else {
-                    janet_schedule(writer.fiber, janet_wrap_nil());
+                if (janet_fiber_can_resume(writer.fiber)) {
+                    if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) {
+                        janet_schedule(writer.fiber, make_close_result(channel));
+                    } else {
+                        janet_schedule(writer.fiber, janet_wrap_nil());
+                    }
                }
            }
        }
@@ -1180,10 +1190,12 @@ JANET_CORE_FN(cfun_channel_close,
                msg.argj = janet_wrap_nil();
                janet_ev_post_event(vm, janet_thread_chan_cb, msg);
            } else {
-                if (reader.mode == JANET_CP_MODE_CHOICE_READ) {
-                    janet_schedule(reader.fiber, make_close_result(channel));
-                } else {
-                    janet_schedule(reader.fiber, janet_wrap_nil());
+                if (janet_fiber_can_resume(reader.fiber)) {
+                    if (reader.mode == JANET_CP_MODE_CHOICE_READ) {
+                        janet_schedule(reader.fiber, make_close_result(channel));
+                    } else {
+                        janet_schedule(reader.fiber, janet_wrap_nil());
+                    }
                }
            }
        }
@@ -1279,7 +1291,7 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout);
 int janet_loop_done(void) {
    return !((janet_vm.spawn.head != janet_vm.spawn.tail) ||
             janet_vm.tq_count ||
-             janet_vm.listener_count);
+             janet_atomic_load(&janet_vm.listener_count));
 }

 JanetFiber *janet_loop1(void) {
@@ -1341,7 +1353,7 @@ JanetFiber *janet_loop1(void) {
    }

    /* Poll for events */
-    if (janet_vm.tq_count || janet_vm.listener_count) {
+    if (janet_vm.tq_count || janet_atomic_load(&janet_vm.listener_count)) {
        JanetTimeout to;
        memset(&to, 0, sizeof(to));
        int has_timeout;
@@ -1360,7 +1372,7 @@ JanetFiber *janet_loop1(void) {
            break;
        }
        /* Run polling implementation only if pending timeouts or pending events */
-        if (janet_vm.tq_count || janet_vm.listener_count) {
+        if (janet_vm.tq_count || janet_atomic_load(&janet_vm.listener_count)) {
            janet_loop1_impl(has_timeout, to.when);
        }
    }
@@ -1447,7 +1459,7 @@ void janet_ev_deinit(void) {
    CloseHandle(janet_vm.iocp);
 }

-void janet_register_stream(JanetStream *stream) {
+static void janet_register_stream(JanetStream *stream) {
    if (NULL == CreateIoCompletionPort(stream->handle, janet_vm.iocp, (ULONG_PTR) stream, 0)) {
        janet_panicf("failed to listen for events: %V", janet_ev_lasterr());
    }
@@ -1813,8 +1825,8 @@ void janet_loop1_impl(int has_timeout, JanetTimestamp timeout) {
        JanetStream *stream = janet_vm.streams[i];
        janet_vm.fds[i + 1].events = 0;
        janet_vm.fds[i + 1].revents = 0;
-        if (stream->read_fiber) janet_vm.fds[i + 1].events |= POLLIN;
-        if (stream->write_fiber) janet_vm.fds[i + 1].events |= POLLOUT;
+        if (stream->read_fiber && stream->read_fiber->ev_callback) janet_vm.fds[i + 1].events |= POLLIN;
+        if (stream->write_fiber && stream->write_fiber->ev_callback) janet_vm.fds[i + 1].events |= POLLOUT;
    }

    /* Poll for events */
@@ -2026,33 +2038,35 @@ void janet_ev_default_threaded_callback(JanetEVGenericMessage return_value) {
    if (return_value.fiber == NULL) {
        return;
    }
-    switch (return_value.tag) {
-        default:
-        case JANET_EV_TCTAG_NIL:
-            janet_schedule(return_value.fiber, janet_wrap_nil());
-            break;
-        case JANET_EV_TCTAG_INTEGER:
-            janet_schedule(return_value.fiber, janet_wrap_integer(return_value.argi));
-            break;
-        case JANET_EV_TCTAG_STRING:
-        case JANET_EV_TCTAG_STRINGF:
-            janet_schedule(return_value.fiber, janet_cstringv((const char *) return_value.argp));
-            if (return_value.tag == JANET_EV_TCTAG_STRINGF) janet_free(return_value.argp);
-            break;
-        case JANET_EV_TCTAG_KEYWORD:
-            janet_schedule(return_value.fiber, janet_ckeywordv((const char *) return_value.argp));
-            break;
-        case JANET_EV_TCTAG_ERR_STRING:
-        case JANET_EV_TCTAG_ERR_STRINGF:
-            janet_cancel(return_value.fiber, janet_cstringv((const char *) return_value.argp));
-            if (return_value.tag == JANET_EV_TCTAG_STRINGF) janet_free(return_value.argp);
-            break;
-        case JANET_EV_TCTAG_ERR_KEYWORD:
-            janet_cancel(return_value.fiber, janet_ckeywordv((const char *) return_value.argp));
-            break;
-        case JANET_EV_TCTAG_BOOLEAN:
-            janet_schedule(return_value.fiber, janet_wrap_boolean(return_value.argi));
-            break;
+    if (janet_fiber_can_resume(return_value.fiber)) {
+        switch (return_value.tag) {
+            default:
+            case JANET_EV_TCTAG_NIL:
+                janet_schedule(return_value.fiber, janet_wrap_nil());
+                break;
+            case JANET_EV_TCTAG_INTEGER:
+                janet_schedule(return_value.fiber, janet_wrap_integer(return_value.argi));
+                break;
+            case JANET_EV_TCTAG_STRING:
+            case JANET_EV_TCTAG_STRINGF:
+                janet_schedule(return_value.fiber, janet_cstringv((const char *) return_value.argp));
+                if (return_value.tag == JANET_EV_TCTAG_STRINGF) janet_free(return_value.argp);
+                break;
+            case JANET_EV_TCTAG_KEYWORD:
+                janet_schedule(return_value.fiber, janet_ckeywordv((const char *) return_value.argp));
+                break;
+            case JANET_EV_TCTAG_ERR_STRING:
+            case JANET_EV_TCTAG_ERR_STRINGF:
+                janet_cancel(return_value.fiber, janet_cstringv((const char *) return_value.argp));
+                if (return_value.tag == JANET_EV_TCTAG_STRINGF) janet_free(return_value.argp);
+                break;
+            case JANET_EV_TCTAG_ERR_KEYWORD:
+                janet_cancel(return_value.fiber, janet_ckeywordv((const char *) return_value.argp));
+                break;
+            case JANET_EV_TCTAG_BOOLEAN:
+                janet_schedule(return_value.fiber, janet_wrap_boolean(return_value.argi));
+                break;
+        }
    }
    janet_gcunroot(janet_wrap_fiber(return_value.fiber));
 }
@@ -2199,7 +2213,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
        }

        /* fallthrough */
-        case JANET_ASYNC_EVENT_USER: {
+        case JANET_ASYNC_EVENT_INIT: {
            int32_t chunk_size = state->bytes_left > JANET_EV_CHUNKSIZE ? JANET_EV_CHUNKSIZE : state->bytes_left;
            memset(&(state->overlapped), 0, sizeof(OVERLAPPED));
            int status;
@@ -2237,7 +2251,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
                    return;
                }
            }
-            fiber->flags |= JANET_FIBER_EV_FLAG_IN_FLIGHT;
+            janet_async_in_flight(fiber);
        }
        break;
 #else
@@ -2253,7 +2267,7 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {

    read_more:
        case JANET_ASYNC_EVENT_HUP:
-        case JANET_ASYNC_EVENT_USER:
+        case JANET_ASYNC_EVENT_INIT:
        case JANET_ASYNC_EVENT_READ: {
            JanetBuffer *buffer = state->buf;
            int32_t bytes_left = state->bytes_left;
@@ -2332,9 +2346,8 @@ void ev_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
    }
 }

-static void janet_ev_read_generic(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int is_chunked, JanetReadMode mode, int flags) {
-    JanetFiber *f = janet_vm.root_fiber;
-    StateRead *state = (StateRead *) janet_async_start(f, stream, JANET_ASYNC_LISTEN_READ, ev_callback_read, sizeof(StateRead));
+static JANET_NO_RETURN void janet_ev_read_generic(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int is_chunked, JanetReadMode mode, int flags) {
+    StateRead *state = janet_malloc(sizeof(StateRead));
    state->is_chunk = is_chunked;
    state->buf = buf;
    state->bytes_left = nbytes;
@@ -2345,23 +2358,23 @@ static void janet_ev_read_generic(JanetStream *stream, JanetBuffer *buf, int32_t
 #else
    state->flags = flags;
 #endif
-    ev_callback_read(f, JANET_ASYNC_EVENT_USER);
+    janet_async_start(stream, JANET_ASYNC_LISTEN_READ, ev_callback_read, state);
 }

-void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes) {
+JANET_NO_RETURN void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes) {
    janet_ev_read_generic(stream, buf, nbytes, 0, JANET_ASYNC_READMODE_READ, 0);
 }
-void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes) {
+JANET_NO_RETURN void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes) {
    janet_ev_read_generic(stream, buf, nbytes, 1, JANET_ASYNC_READMODE_READ, 0);
 }
 #ifdef JANET_NET
-void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) {
+JANET_NO_RETURN void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) {
    janet_ev_read_generic(stream, buf, nbytes, 0, JANET_ASYNC_READMODE_RECV, flags);
 }
-void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) {
+JANET_NO_RETURN void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) {
    janet_ev_read_generic(stream, buf, nbytes, 1, JANET_ASYNC_READMODE_RECV, flags);
 }
-void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) {
+JANET_NO_RETURN void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags) {
    janet_ev_read_generic(stream, buf, nbytes, 0, JANET_ASYNC_READMODE_RECVFROM, flags);
 }
 #endif
@@ -2431,7 +2444,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
            return;
        }
        break;
-        case JANET_ASYNC_EVENT_USER: {
+        case JANET_ASYNC_EVENT_INIT: {
            /* Begin write */
            int32_t len;
            const uint8_t *bytes;
@@ -2461,7 +2474,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
                status = WSASendTo(sock, &state->wbuf, 1, NULL, state->flags, to, tolen, &state->overlapped, NULL);
                if (status) {
                    if (WSA_IO_PENDING == WSAGetLastError()) {
-                        fiber->flags |= JANET_FIBER_EV_FLAG_IN_FLIGHT;
+                        janet_async_in_flight(fiber);
                    } else {
                        janet_cancel(fiber, janet_ev_lasterr());
                        janet_async_end(fiber);
@@ -2486,7 +2499,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
                status = WriteFile(stream->handle, bytes, len, NULL, &state->overlapped);
                if (!status) {
                    if (ERROR_IO_PENDING == GetLastError()) {
-                        fiber->flags |= JANET_FIBER_EV_FLAG_IN_FLIGHT;
+                        janet_async_in_flight(fiber);
                    } else {
                        janet_cancel(fiber, janet_ev_lasterr());
                        janet_async_end(fiber);
@@ -2505,7 +2518,7 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
            janet_cancel(fiber, janet_cstringv("stream hup"));
            janet_async_end(fiber);
            break;
-        case JANET_ASYNC_EVENT_USER:
+        case JANET_ASYNC_EVENT_INIT:
        case JANET_ASYNC_EVENT_WRITE: {
            int32_t start, len;
            const uint8_t *bytes;
@@ -2570,10 +2583,8 @@ void ev_callback_write(JanetFiber *fiber, JanetAsyncEvent event) {
    }
 }

-static void janet_ev_write_generic(JanetStream *stream, void *buf, void *dest_abst, JanetWriteMode mode, int is_buffer, int flags) {
-    JanetFiber *f = janet_vm.root_fiber;
-    StateWrite *state = (StateWrite *) janet_async_start(f, stream, JANET_ASYNC_LISTEN_WRITE,
-                        ev_callback_write, sizeof(StateWrite));
+static JANET_NO_RETURN void janet_ev_write_generic(JanetStream *stream, void *buf, void *dest_abst, JanetWriteMode mode, int is_buffer, int flags) {
+    StateWrite *state = janet_malloc(sizeof(StateWrite));
    state->is_buffer = is_buffer;
    state->src.buf = buf;
    state->dest_abst = dest_abst;
@@ -2584,31 +2595,31 @@ static void janet_ev_write_generic(JanetStream *stream, void *buf, void *dest_ab
    state->flags = flags;
    state->start = 0;
 #endif
-    ev_callback_write(f, JANET_ASYNC_EVENT_USER);
+    janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, ev_callback_write, state);
 }

-void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf) {
+JANET_NO_RETURN void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf) {
    janet_ev_write_generic(stream, buf, NULL, JANET_ASYNC_WRITEMODE_WRITE, 1, 0);
 }

-void janet_ev_write_string(JanetStream *stream, JanetString str) {
+JANET_NO_RETURN void janet_ev_write_string(JanetStream *stream, JanetString str) {
    janet_ev_write_generic(stream, (void *) str, NULL, JANET_ASYNC_WRITEMODE_WRITE, 0, 0);
 }

 #ifdef JANET_NET
-void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags) {
+JANET_NO_RETURN void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags) {
    janet_ev_write_generic(stream, buf, NULL, JANET_ASYNC_WRITEMODE_SEND, 1, flags);
 }

-void janet_ev_send_string(JanetStream *stream, JanetString str, int flags) {
+JANET_NO_RETURN void janet_ev_send_string(JanetStream *stream, JanetString str, int flags) {
    janet_ev_write_generic(stream, (void *) str, NULL, JANET_ASYNC_WRITEMODE_SEND, 0, flags);
 }

-void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags) {
+JANET_NO_RETURN void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags) {
    janet_ev_write_generic(stream, buf, dest, JANET_ASYNC_WRITEMODE_SENDTO, 1, flags);
 }

-void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags) {
+JANET_NO_RETURN 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);
 }
 #endif
@@ -2941,10 +2952,15 @@ JANET_CORE_FN(cfun_ev_sleep,

 JANET_CORE_FN(cfun_ev_deadline,
              "(ev/deadline sec &opt tocancel tocheck)",
-              "Set a deadline for a fiber `tocheck`. If `tocheck` is not finished after `sec` seconds, "
-              "`tocancel` will be canceled as with `ev/cancel`. "
-              "If `tocancel` and `tocheck` are not given, they default to `(fiber/root)` and "
-              "`(fiber/current)` respectively. Returns `tocancel`.") {
+              "Schedules the event loop to try to cancel the `tocancel` "
+              "task as with `ev/cancel`. After `sec` seconds, the event "
+              "loop will attempt cancellation of `tocancel` if the "
+              "`tocheck` fiber is resumable. `sec` is a number that can "
+              "have a fractional part. `tocancel` defaults to "
+              "`(fiber/root)`, but if specified, must be a task (root "
+              "fiber). `tocheck` defaults to `(fiber/current)`, but if "
+              "specified, should be a fiber. Returns `tocancel` "
+              "immediately.") {
    janet_arity(argc, 1, 3);
    double sec = janet_getnumber(argv, 0);
    JanetFiber *tocancel = janet_optfiber(argv, argc, 1, janet_vm.root_fiber);
@@ -2999,7 +3015,6 @@ JANET_CORE_FN(janet_cfun_stream_read,
        if (to != INFINITY) janet_addtimeout(to);
        janet_ev_read(stream, buffer, n);
    }
-    janet_await();
 }

 JANET_CORE_FN(janet_cfun_stream_chunk,
@@ -3014,7 +3029,6 @@ JANET_CORE_FN(janet_cfun_stream_chunk,
    double to = janet_optnumber(argv, argc, 3, INFINITY);
    if (to != INFINITY) janet_addtimeout(to);
    janet_ev_readchunk(stream, buffer, n);
-    janet_await();
 }

 JANET_CORE_FN(janet_cfun_stream_write,
@@ -3034,7 +3048,6 @@ JANET_CORE_FN(janet_cfun_stream_write,
        if (to != INFINITY) janet_addtimeout(to);
        janet_ev_write_string(stream, bytes.bytes);
    }
-    janet_await();
 }

 static int mutexgc(void *p, size_t size) {
--- a/src/core/fiber.c
+++ b/src/core/fiber.c
@@ -239,8 +239,8 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
                                         fiber->data + tuplehead,
                                         oldtop - tuplehead)
                                     : janet_wrap_tuple(janet_tuple_n(
-                                                 fiber->data + tuplehead,
-                                                 oldtop - tuplehead));
+                                             fiber->data + tuplehead,
+                                             oldtop - tuplehead));
        }
    }

@@ -370,8 +370,8 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
                                         fiber->data + tuplehead,
                                         fiber->stacktop - tuplehead)
                                     : janet_wrap_tuple(janet_tuple_n(
-                                                 fiber->data + tuplehead,
-                                                 fiber->stacktop - tuplehead));
+                                             fiber->data + tuplehead,
+                                             fiber->stacktop - tuplehead));
        }
        stacksize = tuplehead - fiber->stackstart + 1;
    } else {
@@ -662,7 +662,7 @@ JANET_CORE_FN(cfun_fiber_can_resume,
 }

 JANET_CORE_FN(cfun_fiber_last_value,
-              "(fiber/last-value)",
+              "(fiber/last-value fiber)",
              "Get the last value returned or signaled from the fiber.") {
    janet_fixarity(argc, 1);
    JanetFiber *fiber = janet_getfiber(argv, 0);
--- a/src/core/marsh.c
+++ b/src/core/marsh.c
@@ -185,6 +185,19 @@ static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags);
 /* Prevent stack overflows */
 #define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD) janet_panic("stack overflow")

+/* Quick check if a fiber cannot be marshalled. This is will
+ * have no false positives, but may have false negatives. */
+static int fiber_cannot_be_marshalled(JanetFiber *fiber) {
+    if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) return 1;
+    int32_t i = fiber->frame;
+    while (i > 0) {
+        JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
+        if (!frame->func) return 1; /* has cfunction on stack */
+        i = frame->prevframe;
+    }
+    return 0;
+}
+
 /* Marshal a function env */
 static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags) {
    MARSH_STACKCHECK;
@@ -197,7 +210,9 @@ static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags) {
    }
    janet_env_valid(env);
    janet_v_push(st->seen_envs, env);
-    if (env->offset > 0 && (JANET_STATUS_ALIVE == janet_fiber_status(env->as.fiber))) {
+
+    /* Special case for early detachment */
+    if (env->offset > 0 && fiber_cannot_be_marshalled(env->as.fiber)) {
        pushint(st, 0);
        pushint(st, env->length);
        Janet *values = env->as.fiber->data + env->offset;
@@ -328,7 +343,7 @@ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
    while (i > 0) {
        JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
        if (frame->env) frame->flags |= JANET_STACKFRAME_HASENV;
-        if (!frame->func) janet_panic("cannot marshal fiber with c stackframe");
+        if (!frame->func) janet_panicf("cannot marshal fiber with c stackframe (%v)", janet_wrap_cfunction((JanetCFunction) frame->pc));
        pushint(st, frame->flags);
        pushint(st, frame->prevframe);
        int32_t pcdiff = (int32_t)(frame->pc - frame->func->def->bytecode);
--- a/src/core/net.c
+++ b/src/core/net.c
@@ -79,12 +79,20 @@ const JanetAbstractType janet_address_type = {

 /* maximum number of bytes in a socket address host (post name resolution) */
 #ifdef JANET_WINDOWS
+#ifdef JANET_NO_IPV6
+#define SA_ADDRSTRLEN (INET_ADDRSTRLEN + 1)
+#else
 #define SA_ADDRSTRLEN (INET6_ADDRSTRLEN + 1)
+#endif
 typedef unsigned short in_port_t;
 #else
 #define JANET_SA_MAX(a, b) (((a) > (b))? (a) : (b))
+#ifdef JANET_NO_IPV6
+#define SA_ADDRSTRLEN JANET_SA_MAX(INET_ADDRSTRLEN + 1, (sizeof ((struct sockaddr_un *)0)->sun_path) + 1)
+#else
 #define SA_ADDRSTRLEN JANET_SA_MAX(INET6_ADDRSTRLEN + 1, (sizeof ((struct sockaddr_un *)0)->sun_path) + 1)
 #endif
+#endif

 static JanetStream *make_stream(JSock handle, uint32_t flags);

@@ -114,16 +122,18 @@ static void janet_net_socknoblock(JSock s) {

 /* State machine for async connect */

-typedef struct {
-    int did_connect;
-} NetStateConnect;
-
 void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
    JanetStream *stream = fiber->ev_stream;
-    NetStateConnect *state = (NetStateConnect *)fiber->ev_state;
    switch (event) {
        default:
            break;
+#ifndef JANET_WINDOWS
+        /* Wait until we have an actual event before checking.
+         * Windows doesn't support async connect with this, just try immediately.*/
+        case JANET_ASYNC_EVENT_INIT:
+#endif
+        case JANET_ASYNC_EVENT_DEINIT:
+            return;
        case JANET_ASYNC_EVENT_CLOSE:
            janet_cancel(fiber, janet_cstringv("stream closed"));
            janet_async_end(fiber);
@@ -140,7 +150,6 @@ void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
 #endif
    if (r == 0) {
        if (res == 0) {
-            state->did_connect = 1;
            janet_schedule(fiber, janet_wrap_abstract(stream));
        } else {
            janet_cancel(fiber, janet_cstringv(strerror(res)));
@@ -153,13 +162,8 @@ void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
    janet_async_end(fiber);
 }

-static void net_sched_connect(JanetStream *stream) {
-    JanetFiber *f = janet_vm.root_fiber;
-    NetStateConnect *state = (NetStateConnect *) janet_async_start(f, stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect, sizeof(NetStateConnect));
-    state->did_connect = 0;
-#ifdef JANET_WINDOWS
-    net_callback_connect(f, JANET_ASYNC_EVENT_USER);
-#endif
+static JANET_NO_RETURN void net_sched_connect(JanetStream *stream) {
+    janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect, NULL);
 }

 /* State machine for accepting connections. */
@@ -229,14 +233,16 @@ void net_callback_accept(JanetFiber *fiber, JanetAsyncEvent event) {

 JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) {
    Janet err;
-    JanetFiber *f = janet_vm.root_fiber;
-    NetStateAccept *state = (NetStateAccept *) janet_async_start(f, stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, sizeof(NetStateAccept));
+    NetStateAccept *state = janet_malloc(sizeof(NetStateAccept));
    memset(&state->overlapped, 0, sizeof(WSAOVERLAPPED));
    memset(&state->buf, 0, 1024);
    state->function = fun;
    state->lstream = stream;
-    if (net_sched_accept_impl(state, f, &err)) janet_panicv(err);
-    janet_await();
+    if (net_sched_accept_impl(state, janet_root_fiber(), &err)) {
+        janet_free(state);
+        janet_panicv(err);
+    }
+    janet_async_start(stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, state);
 }

 static int net_sched_accept_impl(NetStateAccept *state, JanetFiber *fiber, Janet *err) {
@@ -253,7 +259,7 @@ static int net_sched_accept_impl(NetStateAccept *state, JanetFiber *fiber, Janet
        int code = WSAGetLastError();
        if (code == WSA_IO_PENDING) {
            /* indicates io is happening async */
-            fiber->flags |= JANET_FIBER_EV_FLAG_IN_FLIGHT;
+            janet_async_in_flight(fiber);
            return 0;
        }
        *err = janet_ev_lasterr();
@@ -282,7 +288,7 @@ void net_callback_accept(JanetFiber *fiber, JanetAsyncEvent event) {
            janet_schedule(fiber, janet_wrap_nil());
            janet_async_end(fiber);
            return;
-        case JANET_ASYNC_EVENT_USER:
+        case JANET_ASYNC_EVENT_INIT:
        case JANET_ASYNC_EVENT_READ: {
 #if defined(JANET_LINUX)
            JSock connfd = accept4(stream->handle, NULL, NULL, SOCK_CLOEXEC);
@@ -310,11 +316,10 @@ void net_callback_accept(JanetFiber *fiber, JanetAsyncEvent event) {
 }

 JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunction *fun) {
-    JanetFiber *f = janet_vm.root_fiber;
-    NetStateAccept *state = (NetStateAccept *) janet_async_start(f, stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, sizeof(NetStateAccept));
+    NetStateAccept *state = janet_malloc(sizeof(NetStateAccept));
+    memset(state, 0, sizeof(NetStateAccept));
    state->function = fun;
-    net_callback_accept(f, JANET_ASYNC_EVENT_USER);
-    janet_await();
+    janet_async_start(stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, state);
 }

 #endif
@@ -570,7 +575,6 @@ JANET_CORE_FN(cfun_net_connect,
    }

    net_sched_connect(stream);
-    janet_await();
 }

 static const char *serverify_socket(JSock sfd) {
@@ -741,6 +745,7 @@ static Janet janet_so_getname(const void *sa_any) {
            Janet pair[2] = {janet_cstringv(buffer), janet_wrap_integer(ntohs(sai->sin_port))};
            return janet_wrap_tuple(janet_tuple_n(pair, 2));
        }
+#ifndef JANET_NO_IPV6
        case AF_INET6: {
            const struct sockaddr_in6 *sai6 = sa_any;
            if (!inet_ntop(AF_INET6, &(sai6->sin6_addr), buffer, sizeof(buffer))) {
@@ -749,6 +754,7 @@ static Janet janet_so_getname(const void *sa_any) {
            Janet pair[2] = {janet_cstringv(buffer), janet_wrap_integer(ntohs(sai6->sin6_port))};
            return janet_wrap_tuple(janet_tuple_n(pair, 2));
        }
+#endif
 #ifndef JANET_WINDOWS
        case AF_UNIX: {
            const struct sockaddr_un *sun = sa_any;
@@ -815,6 +821,7 @@ JANET_CORE_FN(cfun_stream_accept_loop,
    JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
    janet_stream_flags(stream, JANET_STREAM_ACCEPTABLE | JANET_STREAM_SOCKET);
    JanetFunction *fun = janet_getfunction(argv, 1);
+    if (fun->def->min_arity < 1) janet_panic("handler function must take at least 1 argument");
    janet_sched_accept(stream, fun);
 }

@@ -851,7 +858,6 @@ JANET_CORE_FN(cfun_stream_read,
        if (to != INFINITY) janet_addtimeout(to);
        janet_ev_recv(stream, buffer, n, MSG_NOSIGNAL);
    }
-    janet_await();
 }

 JANET_CORE_FN(cfun_stream_chunk,
@@ -866,7 +872,6 @@ JANET_CORE_FN(cfun_stream_chunk,
    double to = janet_optnumber(argv, argc, 3, INFINITY);
    if (to != INFINITY) janet_addtimeout(to);
    janet_ev_recvchunk(stream, buffer, n, MSG_NOSIGNAL);
-    janet_await();
 }

 JANET_CORE_FN(cfun_stream_recv_from,
@@ -881,7 +886,6 @@ JANET_CORE_FN(cfun_stream_recv_from,
    double to = janet_optnumber(argv, argc, 3, INFINITY);
    if (to != INFINITY) janet_addtimeout(to);
    janet_ev_recvfrom(stream, buffer, n, MSG_NOSIGNAL);
-    janet_await();
 }

 JANET_CORE_FN(cfun_stream_write,
@@ -901,7 +905,6 @@ JANET_CORE_FN(cfun_stream_write,
        if (to != INFINITY) janet_addtimeout(to);
        janet_ev_send_string(stream, bytes.bytes, MSG_NOSIGNAL);
    }
-    janet_await();
 }

 JANET_CORE_FN(cfun_stream_send_to,
@@ -922,7 +925,6 @@ JANET_CORE_FN(cfun_stream_send_to,
        if (to != INFINITY) janet_addtimeout(to);
        janet_ev_sendto_string(stream, bytes.bytes, dest, MSG_NOSIGNAL);
    }
-    janet_await();
 }

 JANET_CORE_FN(cfun_stream_flush,
@@ -956,8 +958,10 @@ static const struct sockopt_type sockopt_type_list[] = {
    { "ip-multicast-ttl", IPPROTO_IP, IP_MULTICAST_TTL, JANET_NUMBER },
    { "ip-add-membership", IPPROTO_IP, IP_ADD_MEMBERSHIP, JANET_POINTER },
    { "ip-drop-membership", IPPROTO_IP, IP_DROP_MEMBERSHIP, JANET_POINTER },
+#ifndef JANET_NO_IPV6
    { "ipv6-join-group", IPPROTO_IPV6, IPV6_JOIN_GROUP, JANET_POINTER },
    { "ipv6-leave-group", IPPROTO_IPV6, IPV6_LEAVE_GROUP, JANET_POINTER },
+#endif
    { NULL, 0, 0, JANET_POINTER }
 };

@@ -994,7 +998,9 @@ JANET_CORE_FN(cfun_net_setsockopt,
    union {
        int v_int;
        struct ip_mreq v_mreq;
+#ifndef JANET_NO_IPV6
        struct ipv6_mreq v_mreq6;
+#endif
    } val;

    void *optval = (void *)&val;
@@ -1012,12 +1018,14 @@ JANET_CORE_FN(cfun_net_setsockopt,
        val.v_mreq.imr_interface.s_addr = htonl(INADDR_ANY);
        inet_pton(AF_INET, addr, &val.v_mreq.imr_multiaddr.s_addr);
        optlen = sizeof(val.v_mreq);
+#ifndef JANET_NO_IPV6
    } else if (st->optname == IPV6_JOIN_GROUP || st->optname == IPV6_LEAVE_GROUP) {
        const char *addr = janet_getcstring(argv, 2);
        memset(&val.v_mreq6, 0, sizeof val.v_mreq6);
        val.v_mreq6.ipv6mr_interface = 0;
        inet_pton(AF_INET6, addr, &val.v_mreq6.ipv6mr_multiaddr);
        optlen = sizeof(val.v_mreq6);
+#endif
    } else {
        janet_panicf("invalid socket option type");
    }
--- a/src/core/os.c
+++ b/src/core/os.c
@@ -229,10 +229,11 @@ JANET_CORE_FN(os_compiler,
 #undef janet_stringify

 JANET_CORE_FN(os_exit,
-              "(os/exit &opt x)",
+              "(os/exit &opt x force)",
              "Exit from janet with an exit code equal to x. If x is not an integer, "
-              "the exit with status equal the hash of x.") {
-    janet_arity(argc, 0, 1);
+              "the exit with status equal the hash of x. If `force` is truthy will exit immediately and "
+              "skip cleanup code.") {
+    janet_arity(argc, 0, 2);
    int status;
    if (argc == 0) {
        status = EXIT_SUCCESS;
@@ -242,7 +243,11 @@ JANET_CORE_FN(os_exit,
        status = EXIT_FAILURE;
    }
    janet_deinit();
-    exit(status);
+    if (argc >= 2 && janet_truthy(argv[1])) {
+        _exit(status);
+    } else {
+        exit(status);
+    }
    return janet_wrap_nil();
 }

@@ -500,8 +505,11 @@ static int proc_get_status(JanetProc *proc) {
        status = WEXITSTATUS(status);
    } else if (WIFSTOPPED(status)) {
        status = WSTOPSIG(status) + 128;
-    } else {
+    } else if (WIFSIGNALED(status)) {
        status = WTERMSIG(status) + 128;
+    } else {
+        /* Could possibly return -1 but for now, just panic */
+        janet_panicf("Undefined status code for process termination, %d.", status);
    }
    return status;
 }
@@ -529,7 +537,9 @@ static void janet_proc_wait_cb(JanetEVGenericMessage args) {
            JanetString s = janet_formatc("command failed with non-zero exit code %d", status);
            janet_cancel(args.fiber, janet_wrap_string(s));
        } else {
-            janet_schedule(args.fiber, janet_wrap_integer(status));
+            if (janet_fiber_can_resume(args.fiber)) {
+                janet_schedule(args.fiber, janet_wrap_integer(status));
+            }
        }
    }
 }
@@ -611,7 +621,11 @@ os_proc_wait_impl(JanetProc *proc) {

 JANET_CORE_FN(os_proc_wait,
              "(os/proc-wait proc)",
-              "Block until the subprocess completes. Returns the subprocess return code.") {
+              "Suspend the current fiber until the subprocess completes. Returns the subprocess return code. "
+              "os/proc-wait cannot be called twice on the same process. If `ev/with-deadline` cancels `os/proc-wait` "
+              "with an error or os/proc-wait is cancelled with any error caused by anything else, os/proc-wait still "
+              "finishes in the background. Only after os/proc-wait finishes, a process is cleaned up by the operating "
+              "system. Thus, a process becomes a zombie process if os/proc-wait is not called.") {
    janet_fixarity(argc, 1);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
 #ifdef JANET_EV
@@ -640,7 +654,7 @@ static const struct keyword_signal signal_keywords[] = {
 #ifdef SIGTERM
    {"term", SIGTERM},
 #endif
-#ifdef SIGARLM
+#ifdef SIGALRM
    {"alrm", SIGALRM},
 #endif
 #ifdef SIGHUP
@@ -722,10 +736,11 @@ static int get_signal_kw(const Janet *argv, int32_t n) {
 JANET_CORE_FN(os_proc_kill,
              "(os/proc-kill proc &opt wait signal)",
              "Kill a subprocess by sending SIGKILL to it on posix systems, or by closing the process "
-              "handle on windows. If `wait` is truthy, will wait for the process to finish and "
-              "returns the exit code. Otherwise, returns `proc`. If signal is specified send it instead."
-              "Signal keywords are named after their C counterparts but in lowercase with the leading "
-              "`SIG` stripped. Signals are ignored on windows.") {
+              "handle on windows. If os/proc-wait already finished for proc, os/proc-kill raises an error. After "
+              "sending signal to proc, if `wait` is truthy, will wait for the process to finish and return the exit "
+              "code by calling os/proc-wait. Otherwise, returns `proc`. If signal is specified, send it instead. "
+              "Signal keywords are named after their C counterparts but in lowercase with the leading `SIG` stripped. "
+              "Signals are ignored on windows.") {
    janet_arity(argc, 1, 3);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
    if (proc->flags & JANET_PROC_WAITED) {
@@ -764,8 +779,9 @@ JANET_CORE_FN(os_proc_kill,

 JANET_CORE_FN(os_proc_close,
              "(os/proc-close proc)",
-              "Wait on a process if it has not been waited on, and close pipes created by `os/spawn` "
-              "if they have not been closed. Returns nil.") {
+              "Close pipes created by `os/spawn` if they have not been closed. Then, if os/proc-wait was not already "
+              "called on proc, os/proc-wait is called on it, and it returns the exit code returned by os/proc-wait. "
+              "Otherwise, returns nil.") {
    janet_fixarity(argc, 1);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
 #ifdef JANET_EV
@@ -875,8 +891,9 @@ JANET_CORE_FN(os_sigaction,
    }
    struct sigaction action;
    sigset_t mask;
-    sigfillset(&mask);
+    sigaddset(&mask, sig);
    memset(&action, 0, sizeof(action));
+    action.sa_flags |= SA_RESTART;
    if (can_interrupt) {
 #ifdef JANET_NO_INTERPRETER_INTERRUPT
        janet_panic("interpreter interrupt not enabled");
@@ -1081,11 +1098,18 @@ static JanetFile *get_stdio_for_handle(JanetHandle handle, void *orig, int iswri
 }
 #endif

-static Janet os_execute_impl(int32_t argc, Janet *argv, int is_spawn) {
+typedef enum {
+    JANET_EXECUTE_EXECUTE,
+    JANET_EXECUTE_SPAWN,
+    JANET_EXECUTE_EXEC
+} JanetExecuteMode;
+
+static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS);
    janet_arity(argc, 1, 3);

    /* Get flags */
+    int is_spawn = mode == JANET_EXECUTE_SPAWN;
    uint64_t flags = 0;
    if (argc > 1) {
        flags = janet_getflags(argv, 1, "epxd");
@@ -1109,7 +1133,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_spawn) {
    int pipe_owner_flags = (is_spawn && (flags & 0x8)) ? JANET_PROC_ALLOW_ZOMBIE : 0;

    /* Get optional redirections */
-    if (argc > 2) {
+    if (argc > 2 && (mode != JANET_EXECUTE_EXEC)) {
        JanetDictView tab = janet_getdictionary(argv, 2);
        Janet maybe_stdin = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("in"));
        Janet maybe_stdout = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("out"));
@@ -1230,12 +1254,32 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, int is_spawn) {
     * of posix_spawn would modify the argv array passed in. */
    char *const *cargv = (char *const *)child_argv;

-    /* Use posix_spawn to spawn new process */
-
    if (use_environ) {
        janet_lock_environ();
    }

+    /* exec mode */
+    if (mode == JANET_EXECUTE_EXEC) {
+#ifdef JANET_WINDOWS
+        janet_panic("not supported on windows");
+#else
+        int status;
+        if (!use_environ) {
+            environ = envp;
+        }
+        do {
+            if (janet_flag_at(flags, 1)) {
+                status = execvp(cargv[0], cargv);
+            } else {
+                status = execv(cargv[0], cargv);
+            }
+        } while (status == -1 && errno == EINTR);
+        janet_panicf("%p: %s", cargv[0], strerror(errno ? errno : ENOENT));
+#endif
+    }
+
+    /* Use posix_spawn to spawn new process */
+
    /* Posix spawn setup */
    posix_spawn_file_actions_t actions;
    posix_spawn_file_actions_init(&actions);
@@ -1342,22 +1386,63 @@ JANET_CORE_FN(os_execute,
              "* :d - Don't try and terminate the process on garbage collection (allow spawning zombies).\n"
              "`env` is a table or struct mapping environment variables to values. It can also "
              "contain the keys :in, :out, and :err, which allow redirecting stdio in the subprocess. "
-              "These arguments should be core/file values. "
-              "Returns the exit status of the program.") {
-    return os_execute_impl(argc, argv, 0);
+              ":in, :out, and :err should be core/file values or core/stream values. core/file values and core/stream "
+              "values passed to :in, :out, and :err should be closed manually because os/execute doesn't close them. "
+              "Returns the exit code of the program.") {
+    return os_execute_impl(argc, argv, JANET_EXECUTE_EXECUTE);
 }

 JANET_CORE_FN(os_spawn,
              "(os/spawn args &opt flags env)",
              "Execute a program on the system and return a handle to the process. Otherwise, takes the "
-              "same arguments as `os/execute`. Does not wait for the process. "
-              "For each of the :in, :out, and :err keys to the `env` argument, one "
-              "can also pass in the keyword `:pipe` "
-              "to get streams for standard IO of the subprocess that can be read from and written to. "
-              "The returned value `proc` has the fields :in, :out, :err, :return-code, and "
-              "the additional field :pid on unix-like platforms. Use `(os/proc-wait proc)` to rejoin the "
-              "subprocess or `(os/proc-kill proc)`.") {
-    return os_execute_impl(argc, argv, 1);
+              "same arguments as `os/execute`. Does not wait for the process. For each of the :in, :out, and :err keys "
+              "of the `env` argument, one can also pass in the keyword `:pipe` to get streams for standard IO of the "
+              "subprocess that can be read from and written to. The returned value `proc` has the fields :in, :out, "
+              ":err, and the additional field :pid on unix-like platforms. `(os/proc-wait proc)` must be called to "
+              "rejoin the subprocess. After `(os/proc-wait proc)` finishes, proc gains a new field, :return-code. "
+              "If :x flag is passed to os/spawn, non-zero exit code will cause os/proc-wait to raise an error. "
+              "If pipe streams created with :pipe keyword are not closed in time, janet can run out of file "
+              "descriptors. They can be closed individually, or `os/proc-close` can close all pipe streams on proc. "
+              "If pipe streams aren't read before `os/proc-wait` finishes, then pipe buffers become full, and the "
+              "process cannot finish because the process cannot print more on pipe buffers which are already full. "
+              "If the process cannot finish, os/proc-wait cannot finish, either.") {
+    return os_execute_impl(argc, argv, JANET_EXECUTE_SPAWN);
+}
+
+JANET_CORE_FN(os_posix_exec,
+              "(os/posix-exec args &opt flags env)",
+              "Use the execvpe or execve system calls to replace the current process with an interface similar to os/execute. "
+              "Hoever, instead of creating a subprocess, the current process is replaced. Is not supported on windows, and "
+              "does not allow redirection of stdio.") {
+    return os_execute_impl(argc, argv, JANET_EXECUTE_EXEC);
+}
+
+JANET_CORE_FN(os_posix_fork,
+              "(os/posix-fork)",
+              "Make a `fork` system call and create a new process. Return nil if in the new process, otherwise a core/process object (as returned by os/spawn). "
+              "Not supported on all systems (POSIX only).") {
+    janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS);
+    janet_fixarity(argc, 0);
+    (void) argv;
+#ifdef JANET_WINDOWS
+    janet_panic("not supported");
+#else
+    pid_t result;
+    do {
+        result = fork();
+    } while (result == -1 && errno == EINTR);
+    if (result == -1) {
+        janet_panic(strerror(errno));
+    }
+    if (result) {
+        JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc));
+        memset(proc, 0, sizeof(JanetProc));
+        proc->pid = result;
+        proc->flags = JANET_PROC_ALLOW_ZOMBIE;
+        return janet_wrap_abstract(proc);
+    }
+    return janet_wrap_nil();
+#endif
 }

 #ifdef JANET_EV
@@ -1479,34 +1564,51 @@ JANET_CORE_FN(os_time,
 }

 JANET_CORE_FN(os_clock,
-              "(os/clock &opt source)",
-              "Return the number of whole + fractional seconds of the requested clock source.\n\n"
+              "(os/clock &opt source format)",
+              "Return the current time of the requested clock source.\n\n"
              "The `source` argument selects the clock source to use, when not specified the default "
              "is `:realtime`:\n"
              "- :realtime: Return the real (i.e., wall-clock) time. This clock is affected by discontinuous "
              "  jumps in the system time\n"
              "- :monotonic: Return the number of whole + fractional seconds since some fixed point in "
              "  time. The clock is guaranteed to be non-decreasing in real time.\n"
-              "- :cputime: Return the CPU time consumed by this process  (i.e. all threads in the process)\n") {
+              "- :cputime: Return the CPU time consumed by this process  (i.e. all threads in the process)\n"
+              "The `format` argument selects the type of output, when not specified the default is `:double`:\n"
+              "- :double: Return the number of seconds + fractional seconds as a double\n"
+              "- :int: Return the number of seconds as an integer\n"
+              "- :tuple: Return a 2 integer tuple [seconds, nanoseconds]\n") {
+    enum JanetTimeSource source;
    janet_sandbox_assert(JANET_SANDBOX_HRTIME);
-    janet_arity(argc, 0, 1);
-    enum JanetTimeSource source = JANET_TIME_REALTIME;
-    if (argc == 1) {
-        JanetKeyword sourcestr = janet_getkeyword(argv, 0);
-        if (janet_cstrcmp(sourcestr, "realtime") == 0) {
-            source = JANET_TIME_REALTIME;
-        } else if (janet_cstrcmp(sourcestr, "monotonic") == 0) {
-            source = JANET_TIME_MONOTONIC;
-        } else if (janet_cstrcmp(sourcestr, "cputime") == 0) {
-            source = JANET_TIME_CPUTIME;
-        } else {
-            janet_panicf("expected :realtime, :monotonic, or :cputime, got %v", argv[0]);
-        }
+    janet_arity(argc, 0, 2);
+
+    JanetKeyword sourcestr = janet_optkeyword(argv, argc, 0, (const uint8_t *) "realtime");
+    if (janet_cstrcmp(sourcestr, "realtime") == 0) {
+        source = JANET_TIME_REALTIME;
+    } else if (janet_cstrcmp(sourcestr, "monotonic") == 0) {
+        source = JANET_TIME_MONOTONIC;
+    } else if (janet_cstrcmp(sourcestr, "cputime") == 0) {
+        source = JANET_TIME_CPUTIME;
+    } else {
+        janet_panicf("expected :realtime, :monotonic, or :cputime, got %v", argv[0]);
    }
+
    struct timespec tv;
    if (janet_gettime(&tv, source)) janet_panic("could not get time");
-    double dtime = tv.tv_sec + (tv.tv_nsec / 1E9);
-    return janet_wrap_number(dtime);
+
+    JanetKeyword formatstr = janet_optkeyword(argv, argc, 1, (const uint8_t *) "double");
+    if (janet_cstrcmp(formatstr, "double") == 0) {
+        double dtime = tv.tv_sec + (tv.tv_nsec / 1E9);
+        return janet_wrap_number(dtime);
+    } else if (janet_cstrcmp(formatstr, "int") == 0) {
+        return janet_wrap_number(tv.tv_sec);
+    } else if (janet_cstrcmp(formatstr, "tuple") == 0) {
+        Janet tup[2] = {janet_wrap_integer(tv.tv_sec),
+                        janet_wrap_integer(tv.tv_nsec)
+                       };
+        return janet_wrap_tuple(janet_tuple_n(tup, 2));
+    } else {
+        janet_panicf("expected :double, :int, or :tuple, got %v", argv[1]);
+    }
 }

 JANET_CORE_FN(os_sleep,
@@ -2336,34 +2438,6 @@ JANET_CORE_FN(os_permission_int,
    return janet_wrap_integer(os_get_unix_mode(argv, 0));
 }

-JANET_CORE_FN(os_posix_fork,
-              "(os/posix-fork)",
-              "Make a `fork` system call and create a new process. Return nil if in the new process, otherwise a core/process object (as returned by os/spawn). "
-              "Not supported on all systems (POSIX only).") {
-    janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS);
-    janet_fixarity(argc, 0);
-    (void) argv;
-#ifdef JANET_WINDOWS
-    janet_panic("not supported");
-#else
-    pid_t result;
-    do {
-        result = fork();
-    } while (result == -1 && errno == EINTR);
-    if (result == -1) {
-        janet_panic(strerror(errno));
-    }
-    if (result) {
-        JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc));
-        memset(proc, 0, sizeof(JanetProc));
-        proc->pid = result;
-        proc->flags = JANET_PROC_ALLOW_ZOMBIE;
-        return janet_wrap_abstract(proc);
-    }
-    return janet_wrap_nil();
-#endif
-}
-
 #ifdef JANET_EV

 /*
@@ -2651,6 +2725,7 @@ void janet_lib_os(JanetTable *env) {
        JANET_CORE_REG("os/spawn", os_spawn),
        JANET_CORE_REG("os/shell", os_shell),
        JANET_CORE_REG("os/posix-fork", os_posix_fork),
+        JANET_CORE_REG("os/posix-exec", os_posix_exec),
        /* no need to sandbox process management if you can't create processes
         * (allows for limited functionality if use exposes C-functions to create specific processes) */
        JANET_CORE_REG("os/proc-wait", os_proc_wait),
--- a/src/core/peg.c
+++ b/src/core/peg.c
@@ -39,6 +39,10 @@
 typedef struct {
    const uint8_t *text_start;
    const uint8_t *text_end;
+    /* text_end can be restricted by some rules, but
+       outer_text_end will always contain the real end of
+       input, which we need to generate a line mapping */
+    const uint8_t *outer_text_end;
    const uint32_t *bytecode;
    const Janet *constants;
    JanetArray *captures;
@@ -114,12 +118,12 @@ static LineCol get_linecol_from_position(PegState *s, int32_t position) {
    /* Generate if not made yet */
    if (s->linemaplen < 0) {
        int32_t newline_count = 0;
-        for (const uint8_t *c = s->text_start; c < s->text_end; c++) {
+        for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) {
            if (*c == '\n') newline_count++;
        }
        int32_t *mem = janet_smalloc(sizeof(int32_t) * newline_count);
        size_t index = 0;
-        for (const uint8_t *c = s->text_start; c < s->text_end; c++) {
+        for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) {
            if (*c == '\n') mem[index++] = (int32_t)(c - s->text_start);
        }
        s->linemaplen = newline_count;
@@ -179,7 +183,7 @@ static const uint8_t *peg_rule(
    const uint32_t *rule,
    const uint8_t *text) {
 tail:
-    switch (*rule & 0x1F) {
+    switch (*rule) {
        default:
            janet_panic("unexpected opcode");
            return NULL;
@@ -482,6 +486,68 @@ tail:
            return result;
        }

+        case RULE_SUB: {
+            const uint8_t *text_start = text;
+            const uint32_t *rule_window = s->bytecode + rule[1];
+            const uint32_t *rule_subpattern = s->bytecode + rule[2];
+            down1(s);
+            const uint8_t *window_end = peg_rule(s, rule_window, text);
+            up1(s);
+            if (!window_end) {
+                return NULL;
+            }
+            const uint8_t *saved_end = s->text_end;
+            s->text_end = window_end;
+            down1(s);
+            const uint8_t *next_text = peg_rule(s, rule_subpattern, text_start);
+            up1(s);
+            s->text_end = saved_end;
+
+            if (!next_text) {
+                return NULL;
+            }
+
+            return window_end;
+        }
+
+        case RULE_SPLIT: {
+            const uint8_t *saved_end = s->text_end;
+            const uint32_t *rule_separator = s->bytecode + rule[1];
+            const uint32_t *rule_subpattern = s->bytecode + rule[2];
+
+            const uint8_t *separator_end = NULL;
+            do {
+                const uint8_t *text_start = text;
+                CapState cs = cap_save(s);
+                down1(s);
+                while (text <= s->text_end) {
+                    separator_end = peg_rule(s, rule_separator, text);
+                    cap_load(s, cs);
+                    if (separator_end) {
+                        break;
+                    }
+                    text++;
+                }
+                up1(s);
+
+                if (separator_end) {
+                    s->text_end = text;
+                    text = separator_end;
+                }
+
+                down1(s);
+                const uint8_t *subpattern_end = peg_rule(s, rule_subpattern, text_start);
+                up1(s);
+                s->text_end = saved_end;
+
+                if (!subpattern_end) {
+                    return NULL;
+                }
+            } while (separator_end);
+
+            return s->text_end;
+        }
+
        case RULE_REPLACE:
        case RULE_MATCHTIME: {
            uint32_t tag = rule[3];
@@ -1107,6 +1173,22 @@ static void spec_matchtime(Builder *b, int32_t argc, const Janet *argv) {
    emit_3(r, RULE_MATCHTIME, subrule, cindex, tag);
 }

+static void spec_sub(Builder *b, int32_t argc, const Janet *argv) {
+    peg_fixarity(b, argc, 2);
+    Reserve r = reserve(b, 3);
+    uint32_t subrule1 = peg_compile1(b, argv[0]);
+    uint32_t subrule2 = peg_compile1(b, argv[1]);
+    emit_2(r, RULE_SUB, subrule1, subrule2);
+}
+
+static void spec_split(Builder *b, int32_t argc, const Janet *argv) {
+    peg_fixarity(b, argc, 2);
+    Reserve r = reserve(b, 3);
+    uint32_t subrule1 = peg_compile1(b, argv[0]);
+    uint32_t subrule2 = peg_compile1(b, argv[1]);
+    emit_2(r, RULE_SPLIT, subrule1, subrule2);
+}
+
 #ifdef JANET_INT_TYPES
 #define JANET_MAX_READINT_WIDTH 8
 #else
@@ -1190,6 +1272,8 @@ static const SpecialPair peg_specials[] = {
    {"sequence", spec_sequence},
    {"set", spec_set},
    {"some", spec_some},
+    {"split", spec_split},
+    {"sub", spec_sub},
    {"thru", spec_thru},
    {"to", spec_to},
    {"uint", spec_uint_le},
@@ -1431,7 +1515,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
        uint32_t instr = bytecode[i];
        uint32_t *rule = bytecode + i;
        op_flags[i] |= 0x02;
-        switch (instr & 0x1F) {
+        switch (instr) {
            case RULE_LITERAL:
                i += 2 + ((rule[1] + 3) >> 2);
                break;
@@ -1524,6 +1608,15 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                op_flags[rule[1]] |= 0x01;
                i += 4;
                break;
+            case RULE_SUB:
+            case RULE_SPLIT:
+                /* [rule, rule] */
+                if (rule[1] >= blen) goto bad;
+                if (rule[2] >= blen) goto bad;
+                op_flags[rule[1]] |= 0x01;
+                op_flags[rule[2]] |= 0x01;
+                i += 3;
+                break;
            case RULE_ERROR:
            case RULE_DROP:
            case RULE_NOT:
@@ -1652,7 +1745,7 @@ typedef struct {
 static PegCall peg_cfun_init(int32_t argc, Janet *argv, int get_replace) {
    PegCall ret;
    int32_t min = get_replace ? 3 : 2;
-    janet_arity(argc, get_replace, -1);
+    janet_arity(argc, min, -1);
    if (janet_checktype(argv[0], JANET_ABSTRACT) &&
            janet_abstract_type(janet_unwrap_abstract(argv[0])) == &janet_peg_type) {
        ret.peg = janet_unwrap_abstract(argv[0]);
@@ -1677,6 +1770,7 @@ static PegCall peg_cfun_init(int32_t argc, Janet *argv, int get_replace) {
    ret.s.mode = PEG_MODE_NORMAL;
    ret.s.text_start = ret.bytes.bytes;
    ret.s.text_end = ret.bytes.bytes + ret.bytes.len;
+    ret.s.outer_text_end = ret.s.text_end;
    ret.s.depth = JANET_RECURSION_GUARD;
    ret.s.captures = janet_array(0);
    ret.s.tagged_captures = janet_array(0);
@@ -1771,7 +1865,7 @@ JANET_CORE_FN(cfun_peg_replace_all,
 }

 JANET_CORE_FN(cfun_peg_replace,
-              "(peg/replace peg repl text &opt start & args)",
+              "(peg/replace peg subst text &opt start & args)",
              "Replace first match of `peg` in `text` with `subst`, returning a new buffer. "
              "The peg does not need to make captures to do replacement. "
              "If `subst` is a function, it will be called with the "
--- a/src/core/pp.c
+++ b/src/core/pp.c
@@ -31,6 +31,7 @@
 #include <string.h>
 #include <ctype.h>
 #include <inttypes.h>
+#include <float.h>

 /* Implements a pretty printer for Janet. The pretty printer
 * is simple and not that flexible, but fast. */
@@ -38,11 +39,15 @@
 /* Temporary buffer size */
 #define BUFSIZE 64

+/* Preprocessor hacks */
+#define STR_HELPER(x) #x
+#define STR(x) STR_HELPER(x)
+
 static void number_to_string_b(JanetBuffer *buffer, double x) {
    janet_buffer_ensure(buffer, buffer->count + BUFSIZE, 2);
    const char *fmt = (x == floor(x) &&
                       x <= JANET_INTMAX_DOUBLE &&
-                       x >= JANET_INTMIN_DOUBLE) ? "%.0f" : "%g";
+                       x >= JANET_INTMIN_DOUBLE) ? "%.0f" : ("%." STR(DBL_DIG) "g");
    int count;
    if (x == 0.0) {
        /* Prevent printing of '-0' */
@@ -772,6 +777,8 @@ struct FmtMapping {
 /* Janet uses fixed width integer types for most things, so map
 * format specifiers to these fixed sizes */
 static const struct FmtMapping format_mappings[] = {
+    {'D', PRId64},
+    {'I', PRIi64},
    {'d', PRId64},
    {'i', PRIi64},
    {'o', PRIo64},
@@ -850,13 +857,19 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
            c = scanformat(c, form, width, precision);
            switch (*c++) {
                case 'c': {
-                    int n = va_arg(args, long);
+                    int n = va_arg(args, int);
                    nb = snprintf(item, MAX_ITEM, form, n);
                    break;
                }
                case 'd':
                case 'i': {
-                    int64_t n = va_arg(args, int);
+                    int64_t n = (int64_t) va_arg(args, int32_t);
+                    nb = snprintf(item, MAX_ITEM, form, n);
+                    break;
+                }
+                case 'D':
+                case 'I': {
+                    int64_t n = va_arg(args, int64_t);
                    nb = snprintf(item, MAX_ITEM, form, n);
                    break;
                }
@@ -864,7 +877,7 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
                case 'X':
                case 'o':
                case 'u': {
-                    uint64_t n = va_arg(args, unsigned int);
+                    uint64_t n = va_arg(args, uint64_t);
                    nb = snprintf(item, MAX_ITEM, form, n);
                    break;
                }
@@ -908,7 +921,7 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
                    janet_buffer_push_cstring(b, typestr(va_arg(args, Janet)));
                    break;
                case 'T': {
-                    int types = va_arg(args, long);
+                    int types = va_arg(args, int);
                    pushtypes(b, types);
                    break;
                }
@@ -1017,6 +1030,8 @@ void janet_buffer_format(
                                  janet_getinteger(argv, arg));
                    break;
                }
+                case 'D':
+                case 'I':
                case 'd':
                case 'i': {
                    int64_t n = janet_getinteger64(argv, arg);
--- a/src/core/run.c
+++ b/src/core/run.c
@@ -32,6 +32,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
    int errflags = 0, done = 0;
    int32_t index = 0;
    Janet ret = janet_wrap_nil();
+    JanetFiber *fiber = NULL;
    const uint8_t *where = sourcePath ? janet_cstring(sourcePath) : NULL;

    if (where) janet_gcroot(janet_wrap_string(where));
@@ -47,7 +48,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
            JanetCompileResult cres = janet_compile(form, env, where);
            if (cres.status == JANET_COMPILE_OK) {
                JanetFunction *f = janet_thunk(cres.funcdef);
-                JanetFiber *fiber = janet_fiber(f, 64, 0, NULL);
+                fiber = janet_fiber(f, 64, 0, NULL);
                fiber->env = env;
                JanetSignal status = janet_continue(fiber, janet_wrap_nil(), &ret);
                if (status != JANET_SIGNAL_OK && status != JANET_SIGNAL_EVENT) {
@@ -112,9 +113,14 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
 #ifdef JANET_EV
    /* Enter the event loop if we are not already in it */
    if (janet_vm.stackn == 0) {
-        janet_gcroot(ret);
+        if (fiber) {
+            janet_gcroot(janet_wrap_fiber(fiber));
+        }
        janet_loop();
-        janet_gcunroot(ret);
+        if (fiber) {
+            janet_gcunroot(janet_wrap_fiber(fiber));
+            ret = fiber->last_value;
+        }
    }
 #endif
    if (out) *out = ret;
--- a/src/core/specials.c
+++ b/src/core/specials.c
@@ -149,7 +149,7 @@ static int destructure(JanetCompiler *c,
                       JanetTable *attr) {
    switch (janet_type(left)) {
        default:
-            janetc_error(c, janet_formatc("unexpected type in destruction, got %v", left));
+            janetc_error(c, janet_formatc("unexpected type in destructuring, got %v", left));
            return 1;
        case JANET_SYMBOL:
            /* Leaf, assign right to left */
@@ -531,17 +531,11 @@ static JanetSlot janetc_def(JanetFopts opts, int32_t argn, const Janet *argv) {
 }

 /* 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) {
+static int janetc_check_nil_form(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;
@@ -601,10 +595,9 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {
    janetc_scope(&condscope, c, 0, "if");

    Janet condform = argv[0];
-    if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_EQ)) {
+    if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) {
        ifnjmp = JOP_JUMP_IF_NOT_NIL;
-    }
-    if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_NEQ)) {
+    } else if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) {
        ifnjmp = JOP_JUMP_IF_NIL;
    }

@@ -613,7 +606,11 @@ static JanetSlot janetc_if(JanetFopts opts, int32_t argn, const Janet *argv) {
    /* Check constant condition. */
    /* TODO: Use type info for more short circuits */
    if (cond.flags & JANET_SLOT_CONSTANT) {
-        if (!janet_truthy(cond.constant)) {
+        int swap_condition = 0;
+        if (ifnjmp == JOP_JUMP_IF_NOT && !janet_truthy(cond.constant)) swap_condition = 1;
+        if (ifnjmp == JOP_JUMP_IF_NIL && janet_checktype(cond.constant, JANET_NIL)) swap_condition = 1;
+        if (ifnjmp == JOP_JUMP_IF_NOT_NIL && !janet_checktype(cond.constant, JANET_NIL)) swap_condition = 1;
+        if (swap_condition) {
            /* Swap the true and false bodies */
            Janet temp = falsebody;
            falsebody = truebody;
@@ -808,12 +805,12 @@ static JanetSlot janetc_while(JanetFopts opts, int32_t argn, const Janet *argv)
     * 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)) {
+    if (janetc_check_nil_form(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_nil_form(condform, &condform, JANET_FUN_NEQ)) {
        is_notnil_form = 1;
        ifjmp = JOP_JUMP_IF_NOT_NIL;
        ifnjmp = JOP_JUMP_IF_NIL;
--- a/src/core/string.c
+++ b/src/core/string.c
@@ -549,8 +549,8 @@ JANET_CORE_FN(cfun_string_format,
              "- `a`, `A`: floating point number, formatted as a hexadecimal number.\n"
              "- `s`: formatted as a string, precision indicates padding and maximum length.\n"
              "- `t`: emit the type of the given value.\n"
-              "- `v`: format with (describe x)"
-              "- `V`: format with (string x)"
+              "- `v`: format with (describe x)\n"
+              "- `V`: format with (string x)\n"
              "- `j`: format to jdn (Janet data notation).\n"
              "\n"
              "The following conversion specifiers are used for \"pretty-printing\", where the upper-case "
--- a/src/core/symcache.c
+++ b/src/core/symcache.c
@@ -234,6 +234,7 @@ const uint8_t *janet_symbol_gen(void) {
    head->hash = hash;
    sym = (uint8_t *)(head->data);
    memcpy(sym, janet_vm.gensym_counter, sizeof(janet_vm.gensym_counter));
+    sym[head->length] = 0;
    janet_symcache_put((const uint8_t *)sym, bucket);
    return (const uint8_t *)sym;
 }
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -960,6 +960,7 @@ void arc4random_buf(void *buf, size_t nbytes);
 #endif

 int janet_cryptorand(uint8_t *out, size_t n) {
+#ifndef JANET_NO_CRYPTORAND
 #ifdef JANET_WINDOWS
    for (size_t i = 0; i < n; i += sizeof(unsigned int)) {
        unsigned int v;
@@ -971,7 +972,10 @@ int janet_cryptorand(uint8_t *out, size_t n) {
        }
    }
    return 0;
-#elif defined(JANET_LINUX) || defined(JANET_CYGWIN) || ( defined(JANET_APPLE) && !defined(MAC_OS_X_VERSION_10_7) )
+#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)
+    arc4random_buf(out, n);
+    return 0;
+#else
    /* We should be able to call getrandom on linux, but it doesn't seem
       to be uniformly supported on linux distros.
       On Mac, arc4random_buf wasn't available on until 10.7.
@@ -993,12 +997,10 @@ int janet_cryptorand(uint8_t *out, size_t n) {
    }
    RETRY_EINTR(rc, close(randfd));
    return 0;
-#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)
-    arc4random_buf(out, n);
-    return 0;
+#endif
 #else
-    (void) n;
    (void) out;
+    (void) n;
    return -1;
 #endif
 }
--- a/src/core/util.h
+++ b/src/core/util.h
@@ -49,11 +49,11 @@
 #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, "janet internal error at line %d in file %s: %s\n",\
        __LINE__,\
        __FILE__,\
        (m));\
-    exit(1);\
+    abort();\
 } while (0)
 #endif

--- a/src/include/janet.h
+++ b/src/include/janet.h
@@ -148,6 +148,12 @@ extern "C" {
 #define JANET_INTMIN_DOUBLE (-9007199254740992.0)
 #define JANET_INTMAX_INT64 9007199254740992
 #define JANET_INTMIN_INT64 (-9007199254740992)
+#ifdef JANET_64
+#define JANET_SIZEMAX JANET_INTMAX_INT64
+#else
+/* Avoid loop bounds issues */
+#define JANET_SIZEMAX (SIZE_MAX - 1)
+#endif

 /* Check emscripten */
 #ifdef __EMSCRIPTEN__
@@ -596,8 +602,7 @@ typedef enum {
    JANET_ASYNC_EVENT_READ = 6,
    JANET_ASYNC_EVENT_WRITE = 7,
    JANET_ASYNC_EVENT_COMPLETE = 8, /* Used on windows for IOCP */
-    JANET_ASYNC_EVENT_FAILED = 9, /* Used on windows for IOCP */
-    JANET_ASYNC_EVENT_USER = 10
+    JANET_ASYNC_EVENT_FAILED = 9 /* Used on windows for IOCP */
 } JanetAsyncEvent;

 typedef enum {
@@ -606,9 +611,7 @@ typedef enum {
    JANET_ASYNC_LISTEN_BOTH
 } JanetAsyncMode;

-/* Typedefs */
 typedef struct JanetStream JanetStream;
-typedef void (*JanetEVCallback)(JanetFiber *fiber, JanetAsyncEvent event);

 /* Wrapper around file descriptors and HANDLEs that can be polled. */
 struct JanetStream {
@@ -620,9 +623,24 @@ struct JanetStream {
    const void *methods; /* Methods for this stream */
 };

+typedef void (*JanetEVCallback)(JanetFiber *fiber, JanetAsyncEvent event);
+
+/* Start listening for events from a stream on the current root fiber. After
+ * calling this, users should call janet_await() before returning from the
+ * current C Function. This also will call janet_await.
+ * mode is which events to listen for, and callback is the function pointer to
+ * call when ever an event is sent from the event loop. state is an optional (can be NULL)
+ * pointer to data allocated with janet_malloc. This pointer will be passed to callback as
+ * fiber->ev_state. It will also be freed for you by the runtime when the event loop determines
+ * it can no longer be referenced. On windows, the contents of state MUST contained an OVERLAPPED struct. */
+JANET_API JANET_NO_RETURN void janet_async_start(JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state);
+
+/* Do not send any more events to the given callback. Call this after scheduling fiber to be resume
+ * or canceled. */
 JANET_API void janet_async_end(JanetFiber *fiber);
-JANET_API void *janet_async_start(JanetFiber *fiber, JanetStream *stream,
-                                  JanetAsyncMode mode, JanetEVCallback callback, size_t data_size);
+
+/* Needed for windows to mark a fiber as waiting for an IOCP completion event. Noop on other platforms. */
+JANET_API void janet_async_in_flight(JanetFiber *fiber);

 #endif

@@ -635,6 +653,7 @@ typedef int32_t JanetAtomicInt;
 #endif
 JANET_API JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x);
 JANET_API JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x);
+JANET_API JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x);

 /* We provide three possible implementations of Janets. The preferred
 * nanboxing approach, for 32 or 64 bits, and the standard C version. Code in the rest of the
@@ -952,25 +971,25 @@ struct JanetStackFrame {
 /* A dynamic array type. */
 struct JanetArray {
    JanetGCObject gc;
-    int32_t count;
-    int32_t capacity;
+    size_t count;
+    size_t capacity;
    Janet *data;
 };

 /* A byte buffer type. Used as a mutable string or string builder. */
 struct JanetBuffer {
    JanetGCObject gc;
-    int32_t count;
-    int32_t capacity;
+    size_t count;
+    size_t capacity;
    uint8_t *data;
 };

 /* A mutable associative data type. Backed by a hashtable. */
 struct JanetTable {
    JanetGCObject gc;
-    int32_t count;
-    int32_t capacity;
-    int32_t deleted;
+    size_t count;
+    size_t capacity;
+    size_t deleted;
    JanetKV *data;
    JanetTable *proto;
 };
@@ -984,7 +1003,7 @@ struct JanetKV {
 /* Prefix for a tuple */
 struct JanetTupleHead {
    JanetGCObject gc;
-    int32_t length;
+    size_t length;
    int32_t hash;
    int32_t sm_line;
    int32_t sm_column;
@@ -994,9 +1013,9 @@ struct JanetTupleHead {
 /* Prefix for a struct */
 struct JanetStructHead {
    JanetGCObject gc;
-    int32_t length;
+    size_t length;
+    size_t capacity;
    int32_t hash;
-    int32_t capacity;
    const JanetKV *proto;
    const JanetKV data[];
 };
@@ -1004,7 +1023,7 @@ struct JanetStructHead {
 /* Prefix for a string */
 struct JanetStringHead {
    JanetGCObject gc;
-    int32_t length;
+    size_t length;
    int32_t hash;
    const uint8_t data[];
 };
@@ -1188,18 +1207,18 @@ struct JanetMethod {

 struct JanetView {
    const Janet *items;
-    int32_t len;
+    size_t len;
 };

 struct JanetByteView {
    const uint8_t *bytes;
-    int32_t len;
+    size_t len;
 };

 struct JanetDictView {
    const JanetKV *kvs;
-    int32_t len;
-    int32_t cap;
+    size_t len;
+    size_t cap;
 };

 struct JanetRange {
@@ -1488,22 +1507,22 @@ JANET_API void janet_ev_post_event(JanetVM *vm, JanetCallback cb, JanetEVGeneric
 JANET_API void janet_ev_default_threaded_callback(JanetEVGenericMessage return_value);

 /* Read async from a stream */
-JANET_API void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
-JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
+JANET_NO_RETURN JANET_API void janet_ev_read(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
+JANET_NO_RETURN JANET_API void janet_ev_readchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes);
 #ifdef JANET_NET
-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_NO_RETURN JANET_API void janet_ev_recv(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_NO_RETURN JANET_API void janet_ev_recvchunk(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
+JANET_NO_RETURN JANET_API void janet_ev_recvfrom(JanetStream *stream, JanetBuffer *buf, int32_t nbytes, int flags);
 #endif

 /* Write async to a stream */
-JANET_API void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf);
-JANET_API void janet_ev_write_string(JanetStream *stream, JanetString str);
+JANET_NO_RETURN JANET_API void janet_ev_write_buffer(JanetStream *stream, JanetBuffer *buf);
+JANET_NO_RETURN JANET_API void janet_ev_write_string(JanetStream *stream, JanetString str);
 #ifdef JANET_NET
-JANET_API void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags);
-JANET_API void janet_ev_send_string(JanetStream *stream, JanetString str, int flags);
-JANET_API void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags);
-JANET_API void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags);
+JANET_NO_RETURN JANET_API void janet_ev_send_buffer(JanetStream *stream, JanetBuffer *buf, int flags);
+JANET_NO_RETURN JANET_API void janet_ev_send_string(JanetStream *stream, JanetString str, int flags);
+JANET_NO_RETURN JANET_API void janet_ev_sendto_buffer(JanetStream *stream, JanetBuffer *buf, void *dest, int flags);
+JANET_NO_RETURN JANET_API void janet_ev_sendto_string(JanetStream *stream, JanetString str, void *dest, int flags);
 #endif

 #endif
@@ -1563,17 +1582,17 @@ JANET_API JanetTable *janet_core_env(JanetTable *replacements);
 JANET_API JanetTable *janet_core_lookup_table(JanetTable *replacements);

 /* Execute strings */
-JANET_API int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out);
+JANET_API int janet_dobytes(JanetTable *env, const uint8_t *bytes, size_t len, const char *sourcePath, Janet *out);
 JANET_API int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out);

 /* Run the entrypoint of a wrapped program */
 JANET_API int janet_loop_fiber(JanetFiber *fiber);

 /* Number scanning */
-JANET_API int janet_scan_number(const uint8_t *str, int32_t len, double *out);
-JANET_API int janet_scan_number_base(const uint8_t *str, int32_t len, int32_t base, double *out);
-JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out);
-JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);
+JANET_API int janet_scan_number(const uint8_t *str, size_t len, double *out);
+JANET_API int janet_scan_number_base(const uint8_t *str, size_t len, int32_t base, double *out);
+JANET_API int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out);
+JANET_API int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out);

 /* Debugging */
 JANET_API void janet_debug_break(JanetFuncDef *def, int32_t pc);
@@ -1586,30 +1605,30 @@ JANET_API void janet_debug_find(
 extern JANET_API const JanetAbstractType janet_rng_type;
 JANET_API JanetRNG *janet_default_rng(void);
 JANET_API void janet_rng_seed(JanetRNG *rng, uint32_t seed);
-JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len);
+JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, size_t len);
 JANET_API uint32_t janet_rng_u32(JanetRNG *rng);
 JANET_API double janet_rng_double(JanetRNG *rng);

 /* Array functions */
-JANET_API JanetArray *janet_array(int32_t capacity);
-JANET_API JanetArray *janet_array_weak(int32_t capacity);
-JANET_API JanetArray *janet_array_n(const Janet *elements, int32_t n);
-JANET_API void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth);
-JANET_API void janet_array_setcount(JanetArray *array, int32_t count);
+JANET_API JanetArray *janet_array(size_t capacity);
+JANET_API JanetArray *janet_array_weak(size_t capacity);
+JANET_API JanetArray *janet_array_n(const Janet *elements, size_t n);
+JANET_API void janet_array_ensure(JanetArray *array, size_t capacity, int32_t growth);
+JANET_API void janet_array_setcount(JanetArray *array, size_t count);
 JANET_API void janet_array_push(JanetArray *array, Janet x);
 JANET_API Janet janet_array_pop(JanetArray *array);
 JANET_API Janet janet_array_peek(JanetArray *array);

 /* Buffer functions */
 #define JANET_BUFFER_FLAG_NO_REALLOC 0x10000
-JANET_API JanetBuffer *janet_buffer(int32_t capacity);
-JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity);
-JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count);
+JANET_API JanetBuffer *janet_buffer(size_t capacity);
+JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, size_t capacity);
+JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, size_t capacity, size_t count);
 JANET_API void janet_buffer_deinit(JanetBuffer *buffer);
-JANET_API void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth);
-JANET_API void janet_buffer_setcount(JanetBuffer *buffer, int32_t count);
-JANET_API void janet_buffer_extra(JanetBuffer *buffer, int32_t n);
-JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t len);
+JANET_API void janet_buffer_ensure(JanetBuffer *buffer, size_t capacity, size_t growth);
+JANET_API void janet_buffer_setcount(JanetBuffer *buffer, size_t count);
+JANET_API void janet_buffer_extra(JanetBuffer *buffer, size_t n);
+JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, size_t len);
 JANET_API void janet_buffer_push_string(JanetBuffer *buffer, JanetString string);
 JANET_API void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring);
 JANET_API void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t x);
@@ -1628,9 +1647,9 @@ JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x);
 #define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line)
 #define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column)
 #define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags)
-JANET_API Janet *janet_tuple_begin(int32_t length);
+JANET_API Janet *janet_tuple_begin(size_t length);
 JANET_API JanetTuple janet_tuple_end(Janet *tuple);
-JANET_API JanetTuple janet_tuple_n(const Janet *values, int32_t n);
+JANET_API JanetTuple janet_tuple_n(const Janet *values, size_t n);

 /* String/Symbol functions */
 #define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data)))
@@ -1673,7 +1692,7 @@ JANET_API JanetSymbol janet_symbol_gen(void);
 #define janet_struct_capacity(t) (janet_struct_head(t)->capacity)
 #define janet_struct_hash(t) (janet_struct_head(t)->hash)
 #define janet_struct_proto(t) (janet_struct_head(t)->proto)
-JANET_API JanetKV *janet_struct_begin(int32_t count);
+JANET_API JanetKV *janet_struct_begin(size_t count);
 JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value);
 JANET_API JanetStruct janet_struct_end(JanetKV *st);
 JANET_API Janet janet_struct_get(JanetStruct st, Janet key);
@@ -1683,9 +1702,9 @@ JANET_API JanetTable *janet_struct_to_table(JanetStruct st);
 JANET_API const JanetKV *janet_struct_find(JanetStruct st, Janet key);

 /* Table functions */
-JANET_API JanetTable *janet_table(int32_t capacity);
-JANET_API JanetTable *janet_table_init(JanetTable *table, int32_t capacity);
-JANET_API JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity);
+JANET_API JanetTable *janet_table(size_t capacity);
+JANET_API JanetTable *janet_table_init(JanetTable *table, size_t capacity);
+JANET_API JanetTable *janet_table_init_raw(JanetTable *table, size_t capacity);
 JANET_API void janet_table_deinit(JanetTable *table);
 JANET_API Janet janet_table_get(JanetTable *t, Janet key);
 JANET_API Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which);
@@ -1700,7 +1719,7 @@ JANET_API JanetTable *janet_table_clone(JanetTable *table);
 JANET_API void janet_table_clear(JanetTable *table);

 /* Fiber */
-JANET_API JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv);
+JANET_API JanetFiber *janet_fiber(JanetFunction *callee, size_t capacity, int32_t argc, const Janet *argv);
 JANET_API JanetFiber *janet_fiber_reset(JanetFiber *fiber, JanetFunction *callee, int32_t argc, const Janet *argv);
 JANET_API JanetFiberStatus janet_fiber_status(JanetFiber *fiber);
 JANET_API int janet_fiber_can_resume(JanetFiber *fiber);
@@ -1708,11 +1727,11 @@ JANET_API JanetFiber *janet_current_fiber(void);
 JANET_API JanetFiber *janet_root_fiber(void);

 /* Treat similar types through uniform interfaces for iteration */
-JANET_API int janet_indexed_view(Janet seq, const Janet **data, int32_t *len);
-JANET_API int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len);
-JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap);
-JANET_API Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key);
-JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv);
+JANET_API int janet_indexed_view(Janet seq, const Janet **data, size_t *len);
+JANET_API int janet_bytes_view(Janet str, const uint8_t **data, size_t *len);
+JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, size_t *len, size_t *cap);
+JANET_API Janet janet_dictionary_get(const JanetKV *data, size_t cap, Janet key);
+JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, size_t cap, const JanetKV *kv);

 /* Abstract */
 #define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data)))
@@ -1788,17 +1807,17 @@ JANET_API int janet_cstrcmp(JanetString str, const char *other);
 JANET_API Janet janet_in(Janet ds, Janet key);
 JANET_API Janet janet_get(Janet ds, Janet key);
 JANET_API Janet janet_next(Janet ds, Janet key);
-JANET_API Janet janet_getindex(Janet ds, int32_t index);
-JANET_API int32_t janet_length(Janet x);
+JANET_API Janet janet_getindex(Janet ds, size_t index);
+JANET_API size_t janet_length(Janet x);
 JANET_API Janet janet_lengthv(Janet x);
 JANET_API void janet_put(Janet ds, Janet key, Janet value);
-JANET_API void janet_putindex(Janet ds, int32_t index, Janet value);
+JANET_API void janet_putindex(Janet ds, size_t index, Janet value);
 #define janet_flag_at(F, I) ((F) & ((1ULL) << (I)))
 JANET_API Janet janet_wrap_number_safe(double x);
 JANET_API int janet_keyeq(Janet x, const char *cstring);
 JANET_API int janet_streq(Janet x, const char *cstring);
 JANET_API int janet_symeq(Janet x, const char *cstring);
-JANET_API int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer);
+JANET_API int32_t janet_sorted_keys(const JanetKV *dict, size_t cap, size_t *index_buffer);

 /* VM functions */
 JANET_API int janet_init(void);
@@ -2127,7 +2146,9 @@ typedef enum {
    RULE_LINE,         /* [tag] */
    RULE_COLUMN,       /* [tag] */
    RULE_UNREF,        /* [rule, tag] */
-    RULE_CAPTURE_NUM   /* [rule, tag] */
+    RULE_CAPTURE_NUM,  /* [rule, tag] */
+    RULE_SUB,          /* [rule, rule] */
+    RULE_SPLIT         /* [rule, rule] */
 } JanetPegOpcod;

 typedef struct {
@@ -2156,8 +2177,6 @@ JANET_API Janet janet_wrap_s64(int64_t x);
 JANET_API Janet janet_wrap_u64(uint64_t x);
 JANET_API int64_t janet_unwrap_s64(Janet x);
 JANET_API uint64_t janet_unwrap_u64(Janet x);
-JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out);
-JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);

 #endif

--- a/src/mainclient/shell.c
+++ b/src/mainclient/shell.c
@@ -502,10 +502,10 @@ static void kright(void) {
 }

 static void krightw(void) {
-    while (gbl_pos != gbl_len && !isspace(gbl_buf[gbl_pos])) {
+    while (gbl_pos != gbl_len && isspace(gbl_buf[gbl_pos])) {
        gbl_pos++;
    }
-    while (gbl_pos != gbl_len && isspace(gbl_buf[gbl_pos])) {
+    while (gbl_pos != gbl_len && !isspace(gbl_buf[gbl_pos])) {
        gbl_pos++;
    }
    refresh();
--- a/test/suite-asm.janet
+++ b/test/suite-asm.janet
@@ -51,5 +51,13 @@
 (def f (asm (disasm (fn [x] (fn [y] (+ x y))))))
 (assert (= ((f 10) 37) 47) "asm environment tables")

+# issue #1424
+(assert-no-error "arity > used slots (issue #1424)"
+                 (asm
+                   (disasm
+                     (fn []
+                       (def foo (fn [one two] one))
+                       (foo 100 200)))))
+
 (end-suite)

--- a/test/suite-boot.janet
+++ b/test/suite-boot.janet
@@ -241,6 +241,16 @@
  (assert (pos? (% x 4)) "generate in loop"))
 (assert (= gencount 75) "generate loop count")

+# more loop checks
+(assert (deep= (seq [i :range [0 10]] i) @[0 1 2 3 4 5 6 7 8 9]) "seq 1")
+(assert (deep= (seq [i :range [0 10 2]] i) @[0 2 4 6 8]) "seq 2")
+(assert (deep= (seq [i :range [10]] i) @[0 1 2 3 4 5 6 7 8 9]) "seq 3")
+(assert (deep= (seq [i :range-to [10]] i) @[0 1 2 3 4 5 6 7 8 9 10]) "seq 4")
+(def gen (generate [x :range-to [0 nil 2]] x))
+(assert (deep= (take 5 gen) @[0 2 4 6 8]) "generate nil limit")
+(def gen (generate [x :range [0 nil 2]] x))
+(assert (deep= (take 5 gen) @[0 2 4 6 8]) "generate nil limit 2")
+
 # Even and odd
 # ff163a5ae
 (assert (odd? 9) "odd? 1")
@@ -354,7 +364,7 @@
        "sort 5")
 (assert (<= ;(sort (map (fn [x] (math/random)) (range 1000)))) "sort 6")

-# #1283  
+# #1283
 (assert (deep=
          (partition 2 (generate [ i :in [:a :b :c :d :e]] i))
          '@[(:a :b) (:c :d) (:e)]))
@@ -945,10 +955,25 @@
 (defn case-4 [&]
  (def x (break (break (break)))))
 (bytecode-roundtrip case-4)
+(defn case-5 []
+  (def foo (fn [one two] one))
+  (foo 100 200))
+(bytecode-roundtrip case-5)

 # Debug bytecode of these functions
 # (pp (disasm case-1))
 # (pp (disasm case-2))
 # (pp (disasm case-3))

+# Regression #1330
+(defn regress-1330 [&]
+  (def a [1 2 3])
+  (def b [;a])
+  (identity a))
+(assert (= [1 2 3] (regress-1330)) "regression 1330")
+
+# Issue 1341
+(assert (= () '() (macex '())) "macex ()")
+(assert (= '[] (macex '[])) "macex []")
+
 (end-suite)
--- a/test/suite-buffer.janet
+++ b/test/suite-buffer.janet
@@ -77,6 +77,46 @@
 (buffer/push-string b5 "456" @"789")
 (assert (= "123456789" (string b5)) "buffer/push-buffer 2")

+(def buffer-uint16-be @"")
+(buffer/push-uint16 buffer-uint16-be :be 0x0102)
+(assert (= "\x01\x02" (string buffer-uint16-be)) "buffer/push-uint16 big endian")
+
+(def buffer-uint16-le @"")
+(buffer/push-uint16 buffer-uint16-le :le 0x0102)
+(assert (= "\x02\x01" (string buffer-uint16-le)) "buffer/push-uint16 little endian")
+
+(def buffer-uint16-negative @"")
+(buffer/push-uint16 buffer-uint16-negative :be -1)
+(assert (= "\xff\xff" (string buffer-uint16-negative)) "buffer/push-uint16 negative")
+
+(def buffer-uint32-be @"")
+(buffer/push-uint32 buffer-uint32-be :be 0x01020304)
+(assert (= "\x01\x02\x03\x04" (string buffer-uint32-be)) "buffer/push-uint32 big endian")
+
+(def buffer-uint32-le @"")
+(buffer/push-uint32 buffer-uint32-le :le 0x01020304)
+(assert (= "\x04\x03\x02\x01" (string buffer-uint32-le)) "buffer/push-uint32 little endian")
+
+(def buffer-uint32-negative @"")
+(buffer/push-uint32 buffer-uint32-negative :be -1)
+(assert (= "\xff\xff\xff\xff" (string buffer-uint32-negative)) "buffer/push-uint32 negative")
+
+(def buffer-float32-be @"")
+(buffer/push-float32 buffer-float32-be :be 1.234)
+(assert (= "\x3f\x9d\xf3\xb6" (string buffer-float32-be)) "buffer/push-float32 big endian")
+
+(def buffer-float32-le @"")
+(buffer/push-float32 buffer-float32-le :le 1.234)
+(assert (= "\xb6\xf3\x9d\x3f" (string buffer-float32-le)) "buffer/push-float32 little endian")
+
+(def buffer-float64-be @"")
+(buffer/push-float64 buffer-float64-be :be 1.234)
+(assert (= "\x3f\xf3\xbe\x76\xc8\xb4\x39\x58" (string buffer-float64-be)) "buffer/push-float64 big endian")
+
+(def buffer-float64-le @"")
+(buffer/push-float64 buffer-float64-le :le 1.234)
+(assert (= "\x58\x39\xb4\xc8\x76\xbe\xf3\x3f" (string buffer-float64-le)) "buffer/push-float64 little endian")
+
 # 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")
--- a/test/suite-ev.janet
+++ b/test/suite-ev.janet
@@ -21,6 +21,9 @@
 (import ./helper :prefix "" :exit true)
 (start-suite)

+(def test-port (os/getenv "JANET_TEST_PORT" "8761"))
+(def test-host (os/getenv "JANET_TEST_HOST" "127.0.0.1"))
+
 # Subprocess
 # 5e1a8c86f
 (def janet (dyn *executable*))
@@ -192,11 +195,11 @@
      (net/write stream b)
      (buffer/clear b)))

-  (def s (net/server "127.0.0.1" "8000" handler))
+  (def s (net/server test-host test-port handler))
  (assert s "made server 1")

  (defn test-echo [msg]
-    (with [conn (net/connect "127.0.0.1" "8000")]
+    (with [conn (net/connect test-host test-port)]
      (net/write conn msg)
      (def res (net/read conn 1024))
      (assert (= (string res) msg) (string "echo " msg))))
@@ -216,18 +219,18 @@
    # prevent immediate close
    (ev/read stream 1)
    (def [host port] (net/localname stream))
-    (assert (= host "127.0.0.1") "localname host server")
-    (assert (= port 8000) "localname port server")))
+    (assert (= host test-host) "localname host server")
+    (assert (= port (scan-number test-port)) "localname port server")))

 # Test localname and peername
 # 077bf5eba
 (repeat 10
-  (with [s (net/server "127.0.0.1" "8000" names-handler)]
+  (with [s (net/server test-host test-port names-handler)]
    (repeat 10
-      (with [conn (net/connect "127.0.0.1" "8000")]
+      (with [conn (net/connect test-host test-port)]
        (def [host port] (net/peername conn))
-        (assert (= host "127.0.0.1") "peername host client ")
-        (assert (= port 8000) "peername port client")
+        (assert (= host test-host) "peername host client ")
+        (assert (= port (scan-number test-port)) "peername port client")
        # let server close
        (ev/write conn " "))))
  (gccollect))
@@ -366,4 +369,10 @@
               (exec-slurp ;run janet "-e" "(print :hi)")))
          "exec-slurp 1"))

+# valgrind-able check for #1337
+(def superv (ev/chan 10))
+(def f (ev/go |(ev/sleep 1e9) nil superv))
+(ev/cancel f (gensym))
+(ev/take superv)
+
 (end-suite)
--- a/test/suite-os.janet
+++ b/test/suite-os.janet
@@ -96,11 +96,23 @@
  (assert (= (in buf 0) 0) "cryptorand doesn't overwrite buffer")
  (assert (= (length buf) 2) "cryptorand appends to buffer"))

+(assert-no-error "realtime clock" (os/clock))
+(assert-no-error "realtime clock" (os/clock nil))
+(assert-no-error "realtime clock" (os/clock nil nil))
+
 # 80db68210
 (assert-no-error "realtime clock" (os/clock :realtime))
 (assert-no-error "cputime clock" (os/clock :cputime))
 (assert-no-error "monotonic clock" (os/clock :monotonic))

+(assert-no-error "realtime clock double output" (os/clock nil :double))
+(assert-no-error "realtime clock int output" (os/clock nil :int))
+(assert-no-error "realtime clock tuple output" (os/clock nil :tuple))
+
+(assert-error "invalid clock" (os/clock :a))
+(assert-error "invalid output" (os/clock :realtime :b))
+(assert-error "invalid clock and output" (os/clock :a :b))
+
 (def before (os/clock :monotonic))
 (def after (os/clock :monotonic))
 (assert (>= after before) "monotonic clock is monotonic")
@@ -148,4 +160,3 @@
                               {:out dn :err dn})))

 (end-suite)
-
--- a/test/suite-peg.janet
+++ b/test/suite-peg.janet
@@ -263,6 +263,9 @@
 (marshpeg '(if-not "abcdf" 123))
 (marshpeg ~(cmt "abcdf" ,identity))
 (marshpeg '(group "abc"))
+(marshpeg '(sub "abcdf" "abc"))
+(marshpeg '(* (sub 1 1)))
+(marshpeg '(split "," (+ "a" "b" "c")))

 # Peg swallowing errors
 # 159651117
@@ -660,5 +663,98 @@
  (peg/match '(if (not (* (constant 7) "a")) "hello") "hello")
  @[]) "peg if not")

+(defn test [name peg input expected]
+  (assert (deep= (peg/match peg input) expected) name))
+
+(test "sub: matches the same input twice"
+  ~(sub "abcd" "abc")
+  "abcdef"
+  @[])
+
+(test "sub: second pattern cannot match more than the first pattern"
+  ~(sub "abcd" "abcde")
+  "abcdef"
+  nil)
+
+(test "sub: fails if first pattern fails"
+  ~(sub "x" "abc")
+  "abcdef"
+  nil)
+
+(test "sub: fails if second pattern fails"
+  ~(sub "abc" "x")
+  "abcdef"
+  nil)
+
+(test "sub: keeps captures from both patterns"
+  ~(sub '"abcd" '"abc")
+  "abcdef"
+  @["abcd" "abc"])
+
+(test "sub: second pattern can reference captures from first"
+  ~(* (constant 5 :tag) (sub (capture "abc" :tag) (backref :tag)))
+  "abcdef"
+  @[5 "abc" "abc"])
+
+(test "sub: second pattern can't see past what the first pattern matches"
+  ~(sub "abc" (* "abc" -1))
+  "abcdef"
+  @[])
+
+(test "sub: positions inside second match are still relative to the entire input"
+  ~(* "one\ntw" (sub "o" (* ($) (line) (column))))
+  "one\ntwo\nthree\n"
+  @[6 2 3])
+
+(test "sub: advances to the end of the first pattern's match"
+  ~(* (sub "abc" "ab") "d")
+  "abcdef"
+  @[])
+
+(test "split: basic functionality"
+  ~(split "," '1)
+  "a,b,c"
+  @["a" "b" "c"])
+
+(test "split: drops captures from separator pattern"
+  ~(split '"," '1)
+  "a,b,c"
+  @["a" "b" "c"])
+
+(test "split: can match empty subpatterns"
+  ~(split "," ':w*)
+  ",a,,bar,,,c,,"
+  @["" "a" "" "bar" "" "" "c" "" ""])
+
+(test "split: subpattern is limited to only text before the separator"
+  ~(split "," '(to -1))
+  "a,,bar,c"
+  @["a" "" "bar" "c"])
+
+(test "split: fails if any subpattern fails"
+  ~(split "," '"a")
+  "a,a,b"
+  nil)
+
+(test "split: separator does not have to match anything"
+  ~(split "x" '(to -1))
+  "a,a,b"
+  @["a,a,b"])
+
+(test "split: always consumes entire input"
+  ~(split 1 '"")
+  "abc"
+  @["" "" "" ""])
+
+(test "split: separator can be an arbitrary PEG"
+  ~(split :s+ '(to -1))
+  "a   b      c"
+  @["a" "b" "c"])
+
+(test "split: does not advance past the end of the input"
+  ~(* (split "," ':w+) 0)
+  "a,b,c"
+  @["a" "b" "c"])
+
 (end-suite)

--- a/test/suite-specials.janet
+++ b/test/suite-specials.janet
@@ -198,5 +198,9 @@

 (assert (= (test) '(1 ())) "issue #919")

-(end-suite)
+# Regression #1327
+(def x "A")
+(def x (if (= nil x) "B" x))
+(assert (= x "A"))

+(end-suite)
Author	SHA1	Message	Date
Calvin Rose	051a9793b9	Long way to go.	2024-04-15 17:40:32 -05:00
Calvin Rose	f92f3eb6fa	Address #1434 - add dynamic bindings for module state.	2024-04-15 16:20:13 -05:00
Calvin Rose	89e74dca3e	Update freebsd build	2024-04-15 16:02:34 -05:00
Calvin Rose	f2e86d2f8d	Merge pull request #1432 from wishdev/os/clock Add additional format options for os/clock	2024-04-15 07:34:02 -05:00
John W Higgins	623da131e5	os/clock docstring typos	2024-03-27 22:32:27 -07:00
John W Higgins	e89ec31ae5	Add additional format options for os/clock	2024-03-27 22:32:27 -07:00
Calvin Rose	68a6ed208e	Merge pull request #1430 from pepe/fix-win-clean Add exists test for dist directory on build command clean	2024-03-24 10:49:34 -07:00
Calvin Rose	c01b32c4f3	Merge pull request #1429 from pepe/prepare-134	2024-03-22 06:52:40 -07:00
Josef Pospíšil	ee11ff9da9	Move date and sort people	2024-03-22 07:54:23 +01:00
Josef Pospíšil	ed56d5d6ff	Add @llmII to docs	2024-03-20 10:40:30 +01:00
Josef Pospíšil	b317ab755c	One more commit	2024-03-20 10:34:30 +01:00
Josef Pospíšil	9819994999	Correct changelog	2024-03-20 10:32:13 +01:00
Josef Pospíšil	e9dbaa81d2	Add exists test on clean	2024-03-20 10:18:42 +01:00
Josef Pospíšil	9f9146ffae	Prepare for 1.34.0 release	2024-03-20 10:11:08 +01:00
Josef Pospíšil	9d9732af97	Update changelog for 1.34.0	2024-03-20 09:57:57 +01:00
Calvin Rose	ebb8fa9787	Merge pull request #1410 from sogaiu/ev-deadline-and-friends-doc-tweaks Doc tweaks for ev/deadline and ev/with-deadline	2024-03-12 06:18:40 -07:00
Calvin Rose	9e6abbf4d4	Fix asm roundtrip issue.	2024-03-10 09:07:11 -05:00
Calvin Rose	6032a6d658	Merge pull request #1414 from MaxGyver83/master Fix documentation of peg/replace	2024-02-24 11:06:16 -08:00
Max Schillinger	c29ab22e6d	Fix documentation of peg/replace	2024-02-23 12:46:45 +01:00
sogaiu	592ac4904c	Doc tweaks for ev/deadline and ev/with-deadline	2024-02-23 10:59:43 +09:00
Calvin Rose	03ae2ec153	Merge pull request #1394 from amano-kenji/master Improve documentation on subprocess API	2024-02-19 11:25:17 -08:00
Calvin Rose	3bc42d0d37	Only re-register when using poll.	2024-02-19 13:19:23 -06:00
Calvin Rose	12630d3e54	Register stream on unmarshal	2024-02-19 13:16:45 -06:00
Calvin Rose	c9897f99c3	Address #1405 - don't try and resume fibers that can't be resumed. FOr fibers that _can_ be resumed and then get cancelled, the sched_id will be incremented later prevent the spurious wake ups.	2024-02-19 08:37:49 -06:00
Calvin Rose	e66dc14b3a	Formatting.	2024-02-17 13:35:07 -06:00
Calvin Rose	7a2868c147	Fix macex1 to keep syntax location for all tuples - Address #1404	2024-02-17 13:34:23 -06:00
Calvin Rose	9e0daaee09	Address #1401 - restore if-let tail calls. Changes to avoid multiple macro expansions of the "false" branch caused a regression in this functionality.	2024-02-15 06:30:26 -06:00
Calvin Rose	c293c7de93	Merge pull request #1402 from sogaiu/each-body-before-set Swap set / body order for each (#1400)	2024-02-15 04:05:15 -08:00
Calvin Rose	49eb5f8563	Merge pull request #1403 from llmII/fix-os-proc-wait Fix: make `proc_get_status` compliant to OS documentation.	2024-02-15 04:01:09 -08:00
amano.kenji	674b375b2c	Improve documentation on subprocess API	2024-02-13 05:34:52 +00:00
llmII	7e94c091eb	Fix: os/proc-wait As discused over gitter, `WIFSIGNALED` macro must be checked before one uses the WTERMSIG macro. This change reflects that necessity and adds a final else clause which will panic if no status code could be determined.	2024-02-12 23:06:08 -06:00
sogaiu	5885ccba61	Swap set / body order for each (#1400 )	2024-02-13 11:12:18 +09:00
Calvin Rose	431ecd3d1a	Abort on assert failure instead of exit	2024-02-03 14:12:10 -06:00
Calvin Rose	f6df8ff935	Expose _exit to skip certain cleanup with os/exit	2024-02-03 14:12:10 -06:00
Calvin Rose	3fd70f0951	Update debug meson options.	2024-02-03 14:12:10 -06:00
Calvin Rose	bebb635d4f	Merge pull request #1392 from sogaiu/propagate-docstring-additions Add to propagate docstring (#1365)	2024-02-03 10:52:27 -08:00
sogaiu	354896bc4b	Add to propagate docstring (#1365 )	2024-02-03 15:48:19 +09:00
Calvin Rose	5ddefff27e	Merge pull request #1389 from sogaiu/fiber-last-value-doc-tweak	2024-02-02 08:42:48 -08:00
sogaiu	91827eef4f	Tweak fiber/last-value docstring	2024-02-02 19:06:56 +09:00
Calvin Rose	9c14c09962	Add explicit stdatomic config setting for #1374 There was some hacky workaround code for development versions of TCC that interfered with other compilers and technically was not legal c99.	2024-01-28 15:53:41 -06:00
Calvin Rose	e85a84171f	Revert local change that removes stdatomic.h	2024-01-28 07:58:22 -06:00
Calvin Rose	3a4f86c3d7	Make host and port configurable for suite-ev.janet	2024-01-28 07:56:59 -06:00
Calvin Rose	5e75963312	Merge pull request #1367 from sogaiu/debug-stacktrace-doc-tweak Tweak debug/stacktrace docstring (#1365)	2024-01-28 05:33:11 -08:00
Calvin Rose	184d9289b5	Merge pull request #1371 from pepe/destructuring-typo Fix typo in destructuring	2024-01-28 05:33:05 -08:00
Calvin Rose	b7ff9577c0	Merge pull request #1373 from sogaiu/module-expand-path-doc-suggestion Address #1370	2024-01-28 05:32:50 -08:00
sogaiu	942a1aaac6	Address #1370	2024-01-27 21:20:27 +09:00
Josef Pospíšil	69f0fe004d	Fix typo in destructuring	2024-01-26 14:36:56 +01:00
sogaiu	2a04347a42	Tweak debug/stacktrace docstring (#1365 )	2024-01-24 16:52:37 +09:00
Calvin Rose	1394f1a5c0	Merge pull request #1364 from sogaiu/module-expand-path-doc-tweak Cosmetically tweak module/expand-path docstring	2024-01-23 16:01:49 -08:00
sogaiu	cf4d19a8ea	Cosmetically tweak module/expand-path docstring	2024-01-22 22:16:14 +09:00
Calvin Rose	23b0fe9f8e	Merge pull request #1360 from pepe/patch-1	2024-01-17 11:51:59 -08:00
Josef Pospíšil	1ba718b15e	Update CHANGELOG.md	2024-01-17 13:58:00 +01:00
Calvin Rose	df5f79ff35	Merge pull request #1359 from pnelson/binary Add buffer/push-* sized int and float	2024-01-15 08:56:57 -08:00
Calvin Rose	6d7e8528ea	Merge pull request #1346 from ianthehenry/peg-split add a new (split) PEG special	2024-01-15 08:16:06 -08:00
Philip Nelson	197bb73a62	Add buffer/push-* sized int and float	2024-01-14 15:32:13 -08:00
Calvin Rose	f91e599451	Merge pull request #1351 from pepe/1.33	2024-01-07 13:30:08 -06:00
Josef Pospíšil	5b9aa9237c	Prepare for 1.33.0 release	2024-01-07 16:26:20 +01:00
Ian Henry	61f38fab37	add a new (split) PEG special This works similarly to string/split, but the separator is a PEG.	2024-01-05 22:02:52 -08:00
Calvin Rose	9142f38cbc	Fix #1341 .	2024-01-01 08:58:31 -06:00
Calvin Rose	e8ed961572	Merge pull request #1344 from ianthehenry/peg-sub-special Add a new (sub) PEG special	2023-12-31 18:40:47 -06:00
Calvin Rose	be11a2a1ad	Fix #1342	2023-12-31 18:36:55 -06:00
Ian Henry	ea75086300	add a new (sub) PEG special (sub) will first match one pattern, then match another pattern against the text that the first pattern advanced over.	2023-12-28 22:15:54 -08:00
Calvin Rose	9eeefbd79a	Merge pull request #1340 from sogaiu/string-format-doc-tweak	2023-12-20 09:10:26 -06:00
sogaiu	c573a98363	Cosmetically tweak string/format docstring	2023-12-19 18:33:47 +09:00
Calvin Rose	11d7af3f95	Work on addressing #1337 - fix valgrind case.	2023-12-18 08:56:27 -06:00
Calvin Rose	a10b4f61d8	Address #1337 (leet!). Changes a few scheduling details and adds a 0 byte explicitly to symbols created via gensym.	2023-12-16 16:15:46 -06:00
Calvin Rose	a0cb7514f1	Update Makefile for #1329 Add separate import library for libjanet.so and janet.exe with Mingw. This was causing issues with linking.	2023-12-09 10:11:15 -06:00
Calvin Rose	b066edc116	Merge pull request #1336 from pepe/peg-arity-typo	2023-12-07 11:31:13 -06:00
Josef Pospíšil	938f5a689e	Fix arity typo in peg	2023-12-07 14:08:03 +01:00
Calvin Rose	772f4c26e8	Merge pull request #1334 from iacore/fix-0 fix (doc next)	2023-12-02 17:28:32 -06:00
Locria Cyber	6b5d151beb	fix typo in (doc next)	2023-12-02 15:38:35 +00:00
Calvin Rose	a9176a77e6	Prevent bytecode optimization from remove mk* instructions. These instructions read from the stack, and therefor have side effects. Removing them without clearing the stack results in broken bytecode.	2023-11-22 08:18:23 -06:00
Calvin Rose	16f409c6a9	Typo for SIGALARM in os/proc-kill	2023-11-21 21:51:56 -06:00
Calvin Rose	9593c930de	Address #1326 in a dynamic way that is fairly conservative. Another optimization would be to keep track of immutable closure captures (vs. mutable closure captures) and always detach them.	2023-11-14 21:13:21 -06:00
Calvin Rose	56f33f514b	Fix regression #1327	2023-11-14 19:52:22 -06:00
Calvin Rose	1ccd544b94	Address #1326 - marshal_one_env w/ JANET_MARSHAL_UNSAFE. This allows uses the precise closure state capture when marshalling data between threads. This prevents accidental state capture when using ev/do-thread or similar with closures that reference the current state.	2023-11-10 15:36:45 -06:00
Calvin Rose	93c83a2ee2	Fix warnings w/ MSVC and format.	2023-11-10 15:02:10 -06:00
Calvin Rose	f459e32ada	Merge pull request #1325 from zevv/zevv-connect-cleanup net/ev: Cleaned up unused NetStateConnect, fixed janet_async_end() ev refcount	2023-11-10 15:01:43 -06:00
Ico Doornekamp	9b640c8e9c	net/ev: Cleaned up unused NetStateConnect, fixed janet_async_end() ev refcount	2023-11-10 20:34:17 +01:00
Calvin Rose	a3228f4997	Add changes and test cases for #1324	2023-11-09 11:18:03 -06:00
Calvin Rose	715eb69d92	Add more ipv6 feature detection.	2023-11-03 18:24:35 -05:00
Calvin Rose	df2d5cb3d3	Add ipv6, shared, and cryptorand options to meosn. Allows for builting with cosmopolitan, both with meson and Makefile. Use: CC=comsocc meson setup -Dipv6=false -Ddynamic_modules=false -Dshared=false -Dos_name=cosmopolitan to configure for cosmopolitan build.	2023-11-02 08:56:10 -05:00
Calvin Rose	3b189eab64	Fix #1321 , poll event loop CPU usage issue A stream may have a fiber attached for memory management purposes, but not actually be waiting on anything. Be more seletive with poll, which is not edge-triggered, to not poll for readiness on these streams.	2023-10-29 11:34:21 -05:00
Calvin Rose	609b629c22	Add support for atomic loads in Janet's atomic abstraction.	2023-10-21 10:40:57 -05:00
Calvin Rose	e74365fe38	Be a bit safer with reference counting. We might want to revisit some uses of refcounts in the ev module to be more efficient if we care about signal atomicity (where memory order isn't really important) or multithreading atomicity.	2023-10-21 09:55:00 -05:00
Calvin Rose	46b34833c2	Merge pull request #1314 from williewillus/pr1314 Use libc strlen in janet_buffer_push_cstring	2023-10-20 15:41:29 -07:00
Vincent Lee	045c80869d	Use libc strlen in janet_buffer_push_cstring Platform libc's often contains optimized assembly implementations of strlen, so take advantage of them here instead of doing a naive count.	2023-10-19 23:30:28 -07:00
Calvin Rose	2ea2e72ddd	Merge pull request #1313 from sogaiu/default-peg-grammar-additions Add more + and * keywords to default-peg-grammar	2023-10-19 19:26:10 -07:00
sogaiu	1b17e12fd6	Add more + and * keywords to default-peg-grammar	2023-10-19 18:45:20 +09:00
Calvin Rose	cc5beda0d2	Update patch release.	2023-10-15 14:33:43 -05:00
Calvin Rose	a363fd926d	Update CHANGELOG.md	2023-10-15 14:32:56 -05:00
Calvin Rose	21ebede529	Move posix-fork inside correct if-def Don't compile if processes are disabled.	2023-10-15 11:03:26 -05:00
Calvin Rose	15d67e9191	Merge pull request #1310 from Andriamanitra/patch-forward-word Change Alt-f in the REPL move to next end of word instead of beginning	2023-10-14 18:36:05 -07:00
Calvin Rose	b5996f5f02	Update for 1.32.0	2023-10-14 19:48:20 -05:00
Andriamanitra	83204dc293	Change Alt-f in the REPL move to next end of word instead of beginning	2023-10-14 14:21:16 +03:00
Calvin Rose	e3f4142d2a	Update result value from janet_do* functions.	2023-10-12 05:26:23 -05:00
Calvin Rose	f18ad36b1b	Rework #1306 - better default for pretty printing numbers. Not perfect for serialization, but a representation that plays well with both safe integers (z where abs(z) < 2^54) and non-integer floats.	2023-10-11 00:59:57 -05:00
Calvin Rose	cb25a2ecd6	Avoid using execvpe function.	2023-10-08 21:33:15 -05:00
Calvin Rose	741a5036e8	Add %D and %I for 64 bit formatting. Instead of breaking old code with changing %i and %d.	2023-10-08 21:23:03 -05:00
Calvin Rose	549ee95f3d	Add os/posix-exec (along os/posix-fork) Useful for old-style unix daemons, start up scripts, and so on. Easy to add on top of os/execute. May want to consider allowing the same IO redirection as os/execute and os/spawn. May also want to put both fork and exec behind a config switch since I suppose some systems may not support them, although I don't know of any concrete examples.	2023-10-08 21:03:08 -05:00
Calvin Rose	6ae81058aa	Be more consistent with va_arg types.	2023-10-08 19:09:35 -05:00
Calvin Rose	267c603824	Don't use full parallelism to avoid oom	2023-10-08 18:37:31 -05:00
Calvin Rose	a8f583a372	CMD isn't bash	2023-10-08 18:34:04 -05:00
Calvin Rose	2b5d90f73a	Disable amalgamation w/ mingw in CI due to memory limitations	2023-10-08 18:28:07 -05:00
Calvin Rose	4139e426fe	Refine interface for janet's new event loop. Infer the current root fiber and force user to allocate state for async events.	2023-10-08 18:25:46 -05:00