Inter

Address #1596 - Use atomic intrinsics to check allow_interrupt flag.
Use a relaxed memory order if possible to mitigate performance issues as much as possible. relaxed memory order should be sufficient.
2025-11-22 02:04:49 +00:00 · 2025-05-16 18:35:33 -05:00 · 2025-05-16 18:26:43 -05:00 · 2025-05-11 08:37:15 -05:00 · 2025-05-08 17:00:32 -05:00 · 2025-05-08 17:00:22 -05:00
102 changed files with 937 additions and 314 deletions
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -132,7 +132,7 @@ jobs:
    steps:
    - name: Checkout the repository
      uses: actions/checkout@master
-    - name: Do Qemu build and test
-      run: |
-        docker run --rm --privileged multiarch/qemu-user-static --reset -p yes
-        docker run --rm -v .:/janet --platform linux/s390x ubuntu bash -c "apt-get -y update && apt-get -y install git build-essential && cd /janet && make -j3 && make test"
+    - name: Enable qemu
+      run: docker run --privileged --rm tonistiigi/binfmt --install s390x
+    - name: Build and run on emulated architecture
+      run: docker run --rm -v .:/janet --platform linux/s390x alpine sh -c "apk update && apk add --no-interactive git build-base && cd /janet && make -j3 && make test"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,27 @@
 # Changelog
 All notable changes to this project will be documented in this file.

-## ??? - Unreleased
+## Unreleased - ???
+- Allow configuring `JANET_THREAD_LOCAL` during builds to allow multi-threading on unknown compilers.
+- Make `ffi/write` append to a buffer instead of insert at 0 by default.
+- Add `os/getpid` to get the current process id.
+- Add `:out` option to `os/spawn` to be able to redirect stderr to stdout with pipes.
+  Add `interrupt?` argument to `ev/deadline` to use VM interruptions.
+
+## 1.38.0 - 2025-03-18
+- Add `bundle/replace`
+- Add CLI flags for the `bundle/` module to install and manage bundles.
+- Improve `?` peg special termination behavior
+- Add IEEE hex floats to grammar.
+- Add buffer peg literal support
+- Improve `split` peg special edge case behavior
+- Add Arm64 .msi support
+- Add `no-reuse` argument to `net/listen` to disable reusing server sockets
 - Add `struct/rawget`
 - Fix `deep=` and `deep-not=` to better handle degenerate cases with mutable table keys
 - Long strings will now dedent on `\r\n` instead of just `\n`.
 - Add `ev/to-file` for synchronous resource operations
+- Improve `file/open` error message by including path

 ## 1.37.1 - 2024-12-05
 - Fix meson cross compilation
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2023 Calvin Rose and contributors
+Copyright (c) 2025 Calvin Rose and contributors

 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
--- a/18
+++ b/18
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -57,6 +57,7 @@ LDFLAGS?=-rdynamic
 LIBJANET_LDFLAGS?=$(LD_FLAGS)
 RUN:=$(RUN)

+
 COMMON_CFLAGS:=-std=c99 -Wall -Wextra -Isrc/include -Isrc/conf -fvisibility=hidden -fPIC
 BOOT_CFLAGS:=-DJANET_BOOTSTRAP -DJANET_BUILD=$(JANET_BUILD) -O0 $(COMMON_CFLAGS) -g
 BUILD_CFLAGS:=$(CFLAGS) $(COMMON_CFLAGS)
@@ -94,12 +95,18 @@ endif
 endif

 # Mingw
+MINGW_COMPILER=
 ifeq ($(findstring MINGW,$(UNAME)), MINGW)
+	MINGW_COMPILER=gcc
 	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
+	COMPILER_VERSION:=$(shell $(CC) --version)
+	ifeq ($(findstring clang,$(COMPILER_VERSION)), clang)
+		MINGW_COMPILER=clang
+	endif
 endif


@@ -206,9 +213,14 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################

 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.37.dylib
+SONAME=libjanet.1.38.dylib
 else
-SONAME=libjanet.so.1.37
+SONAME=libjanet.so.1.38
+endif
+
+ifeq ($(MINGW_COMPILER), clang)
+	SONAME=
+	SONAME_SETTER=
 endif

 build/c/shell.c: src/mainclient/shell.c
--- a/README.md
+++ b/README.md
@@ -165,6 +165,21 @@ make install-jpm-git

 Find out more about the available make targets by running `make help`.

+### Alpine Linux
+
+To build a statically-linked build of Janet, Alpine Linux + MUSL is a good combination. Janet can also
+be built inside a docker container or similar in this manner.
+
+```sh
+docker run -it --rm alpine /bin/ash
+$ apk add make gcc musl-dev git
+$ git clone https://github.com/janet-lang/janet.git
+$ cd janet
+$ make -j10
+$ make test
+$ make install
+```
+
 ### 32-bit Haiku

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

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

@rem Build the resources
 rc /nologo /fobuild\janet_win.res janet_win.rc
-@if not errorlevel 0 goto :BUILDFAIL
+@if errorlevel 1 goto :BUILDFAIL

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

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

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

--- a/meson.build
+++ b/meson.build
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Calvin Rose and contributors
+# Copyright (c) 2025 Calvin Rose and contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -20,7 +20,7 @@

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

 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -39,6 +39,15 @@ native_thread_dep = dependency('threads', native : true)
 # Deps
 m_dep = cc.find_library('m', required : false)
 dl_dep = cc.find_library('dl', required : false)
+
+# for MINGW/MSYS2
+native_ws2_dep = native_cc.find_library('ws2_32', required: false)
+native_psapi_dep = native_cc.find_library('psapi', required: false)
+native_wsock_dep = native_cc.find_library('wsock32', required: false)
+ws2_dep = cc.find_library('ws2_32', required: false)
+psapi_dep = cc.find_library('psapi', required: false)
+wsock_dep = cc.find_library('wsock32', required: false)
+
 android_spawn_dep = cc.find_library('android-spawn', required : false)
 thread_dep = dependency('threads')

@@ -96,6 +105,9 @@ endif
 if get_option('arch_name') != ''
  conf.set('JANET_ARCH_NAME', get_option('arch_name'))
 endif
+if get_option('thread_local_prefix') != ''
+  conf.set('JANET_THREAD_LOCAL', get_option('thread_local_prefix'))
+endif
 jconf = configure_file(output : 'janetconf.h',
  configuration : conf)

@@ -173,8 +185,8 @@ mainclient_src = [
  'src/mainclient/shell.c'
 ]

-janet_dependencies = [m_dep, dl_dep, android_spawn_dep]
-janet_native_dependencies = [native_m_dep, native_dl_dep, native_android_spawn_dep]
+janet_dependencies = [m_dep, dl_dep, android_spawn_dep, ws2_dep, psapi_dep, wsock_dep]
+janet_native_dependencies = [native_m_dep, native_dl_dep, native_android_spawn_dep, native_ws2_dep, native_psapi_dep, native_wsock_dep]
 if not get_option('single_threaded')
  janet_dependencies += thread_dep
  janet_native_dependencies += native_thread_dep
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -30,6 +30,7 @@ option('max_macro_expand', type : 'integer', min : 1, max : 8000, value : 200)
 option('stack_max', type : 'integer', min : 8096, max : 0x7fffffff, value : 0x7fffffff)

 option('arch_name', type : 'string', value: '')
+option('thread_local_prefix', type : 'string', value: '')
 option('os_name', type : 'string', value: '')
 option('shared', type : 'boolean', value: true)
 option('cryptorand', type : 'boolean', value: true)
--- a/src/boot/array_test.c
+++ b/src/boot/array_test.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/boot/boot.c
+++ b/src/boot/boot.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/boot/boot.janet
+++ b/src/boot/boot.janet
@@ -1,5 +1,5 @@
 # The core janet library
-# Copyright 2024 © Calvin Rose
+# Copyright 2025 © Calvin Rose

 ###
 ###
@@ -996,7 +996,7 @@

 (defn reduce2
  ``The 2-argument version of `reduce` that does not take an initialization value.
-  Instead, the first element of the array is used for initialization.``
+  Instead, the first element of the array is used for initialization. If `ind` is empty, will evaluate to nil.``
  [f ind]
  (var k (next ind))
  (if (= nil k) (break nil))
@@ -1084,16 +1084,29 @@
           (map-aggregator ,maptype ,res (,f x ;call-buffer)))))))

 (defn map
-  `Map a function over every value in a data structure and
-  return an array of the results.`
+  ```
+  Map a function `f` over every value in a data structure `ind`
+  and return an array of results, but only if no `inds` are
+  provided. Multiple data structures can be handled if each
+  `inds` is a data structure and `f` is a function of arity
+  one more than the number of `inds`.  The resulting array has
+  a length that is the shortest of `ind` and each of `inds`.
+  ```
  [f ind & inds]
  (def res @[])
  (map-template :map res f ind inds)
  res)

 (defn mapcat
-  ``Map a function over every element in an array or tuple and
-  use `array/concat` to concatenate the results.``
+  ```
+  Map a function `f` over every value in a data structure `ind`
+  and use `array/concat` to concatenate the results, but only if
+  no `inds` are provided. Multiple data structures can be handled
+  if each `inds` is a data structure and `f` is a function of
+  arity one more than the number of `inds`. Note that `f` is only
+  applied to values at indeces up to the largest index of the
+  shortest of `ind` and each of `inds`.
+  ```
  [f ind & inds]
  (def res @[])
  (map-template :mapcat res f ind inds)
@@ -1110,18 +1123,30 @@
  res)

 (defn count
-  ``Count the number of items in `ind` for which `(pred item)`
-  is true.``
+  ```
+  Count the number of values in a data structure `ind` for which
+  applying `pred` yields a truthy value, but only if no `inds` are
+  provided. Multiple data structures can be handled if each `inds`
+  is a data structure and `pred` is a function of arity one more
+  than the number of `inds`. Note that `pred` is only applied to
+  values at indeces up to the largest index of the shortest of
+  `ind` and each of `inds`.
+  ```
  [pred ind & inds]
  (var res 0)
  (map-template :count res pred ind inds)
  res)

 (defn keep
-  ``Given a predicate `pred`, return a new array containing the truthy results
-  of applying `pred` to each element in the indexed collection `ind`. This is
-  different from `filter` which returns an array of the original elements where
-  the predicate is truthy.``
+  ```
+  Given a predicate `pred`, return a new array containing the
+  truthy results of applying `pred` to each value in the data
+  structure `ind`, but only if no `inds` are provided. Multiple
+  data structures can be handled if each `inds` is a data
+  structure and `pred` is a function of arity one more than the
+  number of `inds`. The resulting array has a length that is no
+  longer than the shortest of `ind` and each of `inds`.
+  ```
  [pred ind & inds]
  (def res @[])
  (map-template :keep res pred ind inds)
@@ -1908,7 +1933,7 @@
    that will match any value without creating a binding.

  While a symbol pattern will ordinarily match any value, the pattern `(@ <sym>)`,
-  where <sym> is any symbol, will attempt to match `x` against a value
+  where `<sym>` is any symbol, will attempt to match `x` against a value
  already bound to `<sym>`, rather than matching and rebinding it.

  Any other value pattern will only match if it is equal to `x`.
@@ -2203,17 +2228,32 @@
  ret)

 (defn all
-  ``Returns true if `(pred item)` is truthy for every item in `ind`.
-  Otherwise, returns the first falsey result encountered.
-  Returns true if `ind` is empty.``
+  ```
+  Returns true if applying `pred` to every value in a data
+  structure `ind` results in only truthy values, but only if no
+  `inds` are provided. Multiple data structures can be handled
+  if each `inds` is a data structure and `pred` is a function
+  of arity one more than the number of `inds`. Returns the first
+  falsey result encountered. Note that `pred` is only called as
+  many times as the length of the shortest of `ind` and each of
+  `inds`. If `ind` or any of `inds` are empty, returns true.
+  ```
  [pred ind & inds]
  (var res true)
  (map-template :all res pred ind inds)
  res)

 (defn some
-  ``Returns nil if `(pred item)` is false or nil for every item in `ind`.
-  Otherwise, returns the first truthy result encountered.``
+  ```
+  Returns nil if applying `pred` to every value in a data
+  structure `ind` results in only falsey values, but only if no
+  `inds` are provided. Multiple data structures can be handled
+  if each `inds` is a data structure and `pred` is a function
+  of arity one more than the number of `inds`. Returns the first
+  truthy result encountered. Note that `pred` is only called as
+  many times as the length of the shortest of `ind` and each of
+  `inds`. If `ind` or any of `inds` are empty, returns nil.
+  ```
  [pred ind & inds]
  (var res nil)
  (map-template :some res pred ind inds)
@@ -2283,7 +2323,7 @@
            (def rawget (if (= tx :struct) struct/rawget table/rawget))
            (var ret false)
            (eachp [k v] x
-                (if (deep-not= (rawget y k) v) (break (set ret true))))
+              (if (deep-not= (rawget y k) v) (break (set ret true))))
            ret))
      (= tx :buffer) (not= 0 (- (length x) (length y)) (memcmp x y))
      (not= x y))))
@@ -2345,17 +2385,11 @@

 (defmacro short-fn
  ```
-  Shorthand for `fn`. Arguments are given as `$n`, where `n` is the 0-indexed
-  argument of the function. `$` is also an alias for the first (index 0) argument.
-  The `$&` symbol will make the anonymous function variadic if it appears in the
-  body of the function, and can be combined with positional arguments.
-
-  Example usage:
-
-      (short-fn (+ $ $)) # A function that doubles its arguments.
-      (short-fn (string $0 $1)) # accepting multiple args.
-      |(+ $ $) # use pipe reader macro for terse function literals.
-      |(+ $&)  # variadic functions
+  Shorthand for `fn`. Arguments are given as `$n`, where `n` is the
+  0-indexed argument of the function. `$` is also an alias for the
+  first (index 0) argument. The `$&` symbol will make the anonymous
+  function variadic if it appears in the body of the function, and
+  can be combined with positional arguments.
  ```
  [arg &opt name]
  (var max-param-seen -1)
@@ -2540,7 +2574,7 @@
    * `:env` -- the environment to compile against - default is the current env

    * `:source` -- source path for better errors (use keywords for non-paths) - default
-      is :<anonymous>
+      is `:<anonymous>`

    * `:on-compile-error` -- callback when compilation fails - default is bad-compile

@@ -3883,8 +3917,8 @@
 (compwhen (dyn 'net/listen)
  (defn net/server
    "Start a server asynchronously with `net/listen` and `net/accept-loop`. Returns the new server stream."
-    [host port &opt handler type]
-    (def s (net/listen host port type))
+    [host port &opt handler type no-reuse]
+    (def s (net/listen host port type no-reuse))
    (if handler
      (ev/go (fn [] (net/accept-loop s handler))))
    s))
@@ -3990,7 +4024,7 @@

 (def- safe-forms {'defn true 'varfn true 'defn- true 'defmacro true 'defmacro- true
                  'def is-safe-def 'var is-safe-def 'def- is-safe-def 'var- is-safe-def
-                  'defglobal is-safe-def 'varglobal is-safe-def})
+                  'defglobal is-safe-def 'varglobal is-safe-def 'defdyn true})

 (def- importers {'import true 'import* true 'dofile true 'require true})
 (defn- use-2 [evaluator args]
@@ -4124,7 +4158,11 @@
    [manifest]
    (def bn (get manifest :name))
    (def manifest-name (get-manifest-filename bn))
-    (spit manifest-name (string/format "%j\n" manifest)))
+    (def b @"")
+    (buffer/format b "%j" manifest) # make sure it is valid jdn
+    (buffer/clear b)
+    (buffer/format b "%.99m\n" manifest)
+    (spit manifest-name b))

  (defn bundle/manifest
    "Get the manifest for a give installed bundle"
@@ -4143,7 +4181,7 @@
      (os/cd workdir)
      ([_] (print "cannot enter source directory " workdir " for bundle " bundle-name)))
    (defer (os/cd dir)
-      (def new-env (make-env (curenv)))
+      (def new-env (make-env))
      (put new-env *module-cache* @{})
      (put new-env *module-loading* @{})
      (put new-env *module-make-env* (fn make-bundle-env [&] (make-env new-env)))
@@ -4158,7 +4196,6 @@
    [module bundle-name hook & args]
    (def hookf (module/value module (symbol hook)))
    (unless hookf (break))
-    (def manifest (bundle/manifest bundle-name))
    (def dir (os/cwd))
    (os/cd (get module :workdir "."))
    (defer (os/cd dir)
@@ -4277,8 +4314,8 @@
    (assertf (not (string/check-set "\\/" bundle-name))
             "bundle name %v cannot contain path separators" bundle-name)
    (assert (next bundle-name) "cannot use empty bundle-name")
-    (assert (not (fexists (get-manifest-filename bundle-name)))
-            "bundle is already installed")
+    (assertf (not (fexists (get-manifest-filename bundle-name)))
+             "bundle %v is already installed" bundle-name)
    # Setup installed paths
    (prime-bundle-paths)
    (os/mkdir (bundle-dir bundle-name))
@@ -4317,6 +4354,9 @@
      (when check
        (do-hook module bundle-name :check man)))
    (print "installed " bundle-name)
+    (when (get man :has-bin-script)
+      (def binpath (string (dyn *syspath*) s "bin"))
+      (eprintf "executable scripts have been installed to %s" binpath))
    bundle-name)

  (defn- bundle/pack
@@ -4351,14 +4391,15 @@
      (spit install-hook b))
    dest-dir)

-  (defn bundle/reinstall
-    "Reinstall an existing bundle from the local source code."
-    [bundle-name &keys new-config]
+  (defn bundle/replace
+    "Reinstall an existing bundle from a new directory. Similar to bundle/reinstall,
+     but installs the replacement bundle from any directory. This is necesarry to replace a package without
+     breaking any dependencies."
+    [bundle-name path &keys new-config]
    (def manifest (bundle/manifest bundle-name))
-    (def path (get manifest :local-source))
    (def config (get manifest :config @{}))
    (def s (sep))
-    (assert (= :directory (os/stat path :mode)) "local source not available")
+    (assertf (= :directory (os/stat path :mode)) "local source %v not available" path)
    (def backup-dir (string (dyn *syspath*) s bundle-name ".backup"))
    (rmrf backup-dir)
    (def backup-bundle-source (bundle/pack bundle-name backup-dir true))
@@ -4371,6 +4412,14 @@
    (rmrf backup-bundle-source)
    bundle-name)

+  (defn bundle/reinstall
+    "Reinstall an existing bundle from the local source code."
+    [bundle-name &keys new-config]
+    (def manifest (bundle/manifest bundle-name))
+    (def path (get manifest :local-source))
+    (bundle/replace bundle-name path ;(kvs new-config))
+    bundle-name)
+
  (defn bundle/add-directory
    "Add a directory during the install process relative to `(dyn *syspath*)`"
    [manifest dest &opt chmod-mode]
@@ -4418,7 +4467,7 @@

  (defn bundle/add
    "Add files and directories during a bundle install relative to `(dyn *syspath*)`.
-     Added paths will be recorded in the bundle manifest such that they are properly tracked
+     Added files and directories will be recorded in the bundle manifest such that they are properly tracked
     and removed during an upgrade or uninstall."
    [manifest src &opt dest chmod-mode]
    (default dest src)
@@ -4434,13 +4483,17 @@
      (errorf "bad path %s - file is a %s" src mode)))

  (defn bundle/add-bin
-    `Shorthand for adding scripts during an install. Scripts will be installed to
-    (string (dyn *syspath*) "/bin") by default and will be set to be executable.`
+    ``
+    Shorthand for adding scripts during an install. Scripts will be installed to
+    `(string (dyn *syspath*) "/bin")` by default and will be set to be executable.
+    ``
    [manifest src &opt dest chmod-mode]
-    (default dest (last (string/split "/" src)))
+    (def s (sep))
+    (default dest (last (string/split s src)))
    (default chmod-mode 8r755)
-    (os/mkdir (string (dyn *syspath*) (sep) "bin"))
-    (bundle/add-file manifest src (string "bin" (sep) dest) chmod-mode))
+    (os/mkdir (string (dyn *syspath*) s "bin"))
+    (put manifest :has-bin-script true)
+    (bundle/add-file manifest src (string "bin" s dest) chmod-mode))

  (defn bundle/update-all
    "Reinstall all bundles"
@@ -4503,6 +4556,12 @@
   "-nocolor" "n"
   "-color" "N"
   "-library" "l"
+   "-install" "b"
+   "-reinstall" "B"
+   "-uninstall" "u"
+   "-update-all" "U"
+   "-list" "L"
+   "-prune" "P"
   "-lint-warn" "w"
   "-lint-error" "x"})

@@ -4513,7 +4572,7 @@

  (setdyn *args* args)

-  (var should-repl false)
+  (var should-repl nil)
  (var no-file true)
  (var quiet false)
  (var raw-stdin false)
@@ -4568,6 +4627,12 @@
               --library (-l) lib      : Use a module before processing more arguments
               --lint-warn (-w) level  : Set the lint warning level - default is "normal"
               --lint-error (-x) level : Set the lint error level - default is "none"
+               --install (-b) dirpath  : Install a bundle from a directory
+               --reinstall (-B) name   : Reinstall a bundle by bundle name
+               --uninstall (-u) name   : Uninstall a bundle by bundle name
+               --update-all (-U)       : Reinstall all installed bundles
+               --prune (-P)            : Uninstalled all bundles that are orphaned
+               --list (-L)             : List all installed bundles
               --                      : Stop handling options
             ```)
           (os/exit 0)
@@ -4612,6 +4677,30 @@
             ((thunk) ;subargs)
             (error (get thunk :error)))
           math/inf)
+     "b"
+     (compif (dyn 'bundle/install)
+       (fn [i &] (bundle/install (in args (+ i 1))) (set no-file false) (if (= nil should-repl) (set should-repl false)) 2)
+       (fn [i &] (eprint "--install not supported with reduced os") 2))
+     "B"
+     (compif (dyn 'bundle/reinstall)
+       (fn [i &] (bundle/reinstall (in args (+ i 1))) (set no-file false) (if (= nil should-repl) (set should-repl false)) 2)
+       (fn [i &] (eprint "--reinstall not supported with reduced os") 2))
+     "u"
+     (compif (dyn 'bundle/uninstall)
+       (fn [i &] (bundle/uninstall (in args (+ i 1))) (set no-file false) (if (= nil should-repl) (set should-repl false)) 2)
+       (fn [i &] (eprint "--uninstall not supported with reduced os") 2))
+     "P"
+     (compif (dyn 'bundle/prune)
+       (fn [i &] (bundle/prune) (set no-file false) (if (= nil should-repl) (set should-repl false)) 1)
+       (fn [i &] (eprint "--prune not supported with reduced os") 1))
+     "U"
+     (compif (dyn 'bundle/update-all)
+       (fn [i &] (bundle/update-all) (set no-file false) (if (= nil should-repl) (set should-repl false)) 1)
+       (fn [i &] (eprint "--update-all not supported with reduced os") 1))
+     "L"
+     (compif (dyn 'bundle/list)
+       (fn [i &] (each l (bundle/list) (print l)) (set no-file false) (if (= nil should-repl) (set should-repl false)) 1)
+       (fn [i &] (eprint "--list not supported with reduced os") 1))
     "d" (fn [&] (set debug-flag true) 1)
     "w" (fn [i &] (set warn-level (get-lint-level i)) 2)
     "x" (fn [i &] (set error-level (get-lint-level i)) 2)
--- a/src/boot/buffer_test.c
+++ b/src/boot/buffer_test.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/boot/number_test.c
+++ b/src/boot/number_test.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/boot/system_test.c
+++ b/src/boot/system_test.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/boot/table_test.c
+++ b/src/boot/table_test.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/conf/janetconf.h
+++ b/src/conf/janetconf.h
@@ -4,15 +4,16 @@
 #define JANETCONF_H

 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 37
-#define JANET_VERSION_PATCH 1
+#define JANET_VERSION_MINOR 38
+#define JANET_VERSION_PATCH 0
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.37.1"
+#define JANET_VERSION "1.38.0"

 /* #define JANET_BUILD "local" */

 /* These settings all affect linking, so use cautiously. */
 /* #define JANET_SINGLE_THREADED */
+/* #define JANET_THREAD_LOCAL _Thread_local */
 /* #define JANET_NO_DYNAMIC_MODULES */
 /* #define JANET_NO_NANBOX */
 /* #define JANET_API __attribute__((visibility ("default"))) */
--- a/src/core/abstract.c
+++ b/src/core/abstract.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/array.c
+++ b/src/core/array.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/asm.c
+++ b/src/core/asm.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/buffer.c
+++ b/src/core/buffer.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/bytecode.c
+++ b/src/core/bytecode.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/capi.c
+++ b/src/core/capi.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -64,6 +64,11 @@ void janet_signalv(JanetSignal sig, Janet message) {
    if (janet_vm.return_reg != NULL) {
        /* Should match logic in janet_call for coercing everything not ok to an error (no awaits, yields, etc.) */
        if (janet_vm.coerce_error && sig != JANET_SIGNAL_OK) {
+#ifdef JANET_EV
+            if (NULL != janet_vm.root_fiber && sig == JANET_SIGNAL_EVENT) {
+                janet_vm.root_fiber->sched_id++;
+            }
+#endif
            if (sig != JANET_SIGNAL_ERROR) {
                message = janet_wrap_string(janet_formatc("%v coerced from %s to error", message, janet_signal_names[sig]));
            }
@@ -584,6 +589,16 @@ JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) {
 #endif
 }

+JanetAtomicInt janet_atomic_load_relaxed(JanetAtomicInt volatile *x) {
+#ifdef _MSC_VER
+    return _InterlockedOr(x, 0);
+#elif defined(JANET_USE_STDATOMIC)
+    return atomic_load_explicit(x, memory_order_relaxed);
+#else
+    return __atomic_load_n(x, __ATOMIC_RELAXED);
+#endif
+}
+
 /* Some definitions for function-like macros */

 JANET_API JanetStructHead *(janet_struct_head)(JanetStruct st) {
--- a/src/core/cfuns.c
+++ b/src/core/cfuns.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/compile.c
+++ b/src/core/compile.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/compile.h
+++ b/src/core/compile.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/corelib.c
+++ b/src/core/corelib.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -1002,12 +1002,11 @@ static void make_apply(JanetTable *env) {
    janet_quick_asm(env, JANET_FUN_APPLY | JANET_FUNCDEF_FLAG_VARARG,
                    "apply", 1, 1, INT32_MAX, 6, apply_asm, sizeof(apply_asm),
                    JDOC("(apply f & args)\n\n"
-         "Applies a function to a variable number of arguments. Each element in args "
-         "is used as an argument to f, except the last element in args, which is expected to "
-         "be an array-like. Each element in this last argument is then also pushed as an argument to "
-         "f. For example:\n\n"
-         "\t(apply + 1000 (range 10))\n\n"
-         "sums the first 10 integers and 1000."));
+         "Applies a function f to a variable number of arguments. Each "
+         "element in args is used as an argument to f, except the last "
+         "element in args, which is expected to be an array or a tuple. "
+         "Each element in this last argument is then also pushed as an "
+         "argument to f."));
 }

 static const uint32_t error_asm[] = {
--- a/src/core/debug.c
+++ b/src/core/debug.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/emit.c
+++ b/src/core/emit.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/emit.h
+++ b/src/core/emit.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/ev.c
+++ b/src/core/ev.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -112,6 +112,13 @@ typedef struct {
    JanetHandle write_pipe;
 } JanetEVThreadInit;

+/* Structure used to initialize threads that run timeouts */
+typedef struct {
+    double sec;
+    JanetVM *vm;
+    JanetFiber *fiber;
+} JanetThreadedTimeout;
+
 #define JANET_MAX_Q_CAPACITY 0x7FFFFFF

 static void janet_q_init(JanetQueue *q) {
@@ -346,21 +353,22 @@ JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod

 static void janet_stream_close_impl(JanetStream *stream) {
    stream->flags |= JANET_STREAM_CLOSED;
+    int canclose = !(stream->flags & JANET_STREAM_NOT_CLOSEABLE);
 #ifdef JANET_WINDOWS
    if (stream->handle != INVALID_HANDLE_VALUE) {
 #ifdef JANET_NET
        if (stream->flags & JANET_STREAM_SOCKET) {
-            closesocket((SOCKET) stream->handle);
+            if (canclose) closesocket((SOCKET) stream->handle);
        } else
 #endif
        {
-            CloseHandle(stream->handle);
+            if (canclose) CloseHandle(stream->handle);
        }
        stream->handle = INVALID_HANDLE_VALUE;
    }
 #else
    if (stream->handle != -1) {
-        close(stream->handle);
+        if (canclose) close(stream->handle);
        stream->handle = -1;
 #ifdef JANET_EV_POLL
        uint32_t i = stream->index;
@@ -623,6 +631,7 @@ void janet_addtimeout(double sec) {
    to.curr_fiber = NULL;
    to.sched_id = fiber->sched_id;
    to.is_error = 1;
+    to.has_worker = 0;
    add_timeout(to);
 }

@@ -635,9 +644,68 @@ void janet_addtimeout_nil(double sec) {
    to.curr_fiber = NULL;
    to.sched_id = fiber->sched_id;
    to.is_error = 0;
+    to.has_worker = 0;
    add_timeout(to);
 }

+#ifdef JANET_WINDOWS
+static VOID CALLBACK janet_timeout_stop(ULONG_PTR ptr) {
+    UNREFERENCED_PARAMETER(ptr);
+    ExitThread(0);
+}
+#elif JANET_ANDROID
+static void janet_timeout_stop(int sig_num) {
+    if (sig_num == SIGUSR1) {
+        pthread_exit(0);
+    }
+}
+#endif
+
+static void janet_timeout_cb(JanetEVGenericMessage msg) {
+    (void) msg;
+    janet_interpreter_interrupt_handled(&janet_vm);
+}
+
+#ifdef JANET_WINDOWS
+static DWORD WINAPI janet_timeout_body(LPVOID ptr) {
+    JanetThreadedTimeout tto = *(JanetThreadedTimeout *)ptr;
+    janet_free(ptr);
+    SleepEx((DWORD)(tto.sec * 1000), TRUE);
+    if (janet_fiber_can_resume(tto.fiber)) {
+        janet_interpreter_interrupt(tto.vm);
+        JanetEVGenericMessage msg = {0};
+        janet_ev_post_event(tto.vm, janet_timeout_cb, msg);
+    }
+    return 0;
+}
+#else
+static void *janet_timeout_body(void *ptr) {
+#ifdef JANET_ANDROID
+    struct sigaction action;
+    memset(&action, 0, sizeof(action));
+    sigemptyset(&action.sa_mask);
+    action.sa_flags = 0;
+    action.sa_handler = &janet_timeout_stop;
+    sigaction(SIGUSR1, &action, NULL);
+#endif
+    JanetThreadedTimeout tto = *(JanetThreadedTimeout *)ptr;
+    janet_free(ptr);
+    struct timespec ts;
+    ts.tv_sec = (time_t) tto.sec;
+    ts.tv_nsec = (tto.sec <= UINT32_MAX)
+                 ? (long)((tto.sec - ((uint32_t)tto.sec)) * 1000000000)
+                 : 0;
+    nanosleep(&ts, &ts);
+    if (janet_fiber_can_resume(tto.fiber)) {
+        janet_interpreter_interrupt(tto.vm);
+        JanetEVGenericMessage msg = {0};
+        janet_ev_post_event(tto.vm, janet_timeout_cb, msg);
+    }
+    return NULL;
+}
+#endif
+
+
 void janet_ev_inc_refcount(void) {
    janet_atomic_inc(&janet_vm.listener_count);
 }
@@ -1037,6 +1105,9 @@ JANET_CORE_FN(cfun_channel_push,
              "Returns the channel if the write succeeded, nil otherwise.") {
    janet_fixarity(argc, 2);
    JanetChannel *channel = janet_getchannel(argv, 0);
+    if (janet_vm.coerce_error) {
+        janet_panic("cannot give to channel inside janet_call");
+    }
    if (janet_channel_push(channel, argv[1], 0)) {
        janet_await();
    }
@@ -1049,6 +1120,9 @@ JANET_CORE_FN(cfun_channel_pop,
    janet_fixarity(argc, 1);
    JanetChannel *channel = janet_getchannel(argv, 0);
    Janet item;
+    if (janet_vm.coerce_error) {
+        janet_panic("cannot take from channel inside janet_call");
+    }
    if (janet_channel_pop(channel, &item, 0)) {
        janet_schedule(janet_vm.root_fiber, item);
    }
@@ -1085,6 +1159,10 @@ JANET_CORE_FN(cfun_channel_choice,
    int32_t len;
    const Janet *data;

+    if (janet_vm.coerce_error) {
+        janet_panic("cannot select from channel inside janet_call");
+    }
+
    /* Check channels for immediate reads and writes */
    for (int32_t i = 0; i < argc; i++) {
        if (janet_indexed_view(argv[i], &data, &len) && len == 2) {
@@ -1379,7 +1457,7 @@ JanetFiber *janet_loop1(void) {
    /* Run scheduled fibers unless interrupts need to be handled. */
    while (janet_vm.spawn.head != janet_vm.spawn.tail) {
        /* Don't run until all interrupts have been marked as handled by calling janet_interpreter_interrupt_handled */
-        if (janet_vm.auto_suspend) break;
+        if (janet_atomic_load_relaxed(&janet_vm.auto_suspend)) break;
        JanetTask task = {NULL, janet_wrap_nil(), JANET_SIGNAL_OK, 0};
        janet_q_pop(&janet_vm.spawn, &task, sizeof(task));
        if (task.fiber->gc.flags & JANET_FIBER_EV_FLAG_SUSPENDED) janet_ev_dec_refcount();
@@ -1421,6 +1499,21 @@ JanetFiber *janet_loop1(void) {
        while ((has_timeout = peek_timeout(&to))) {
            if (to.curr_fiber != NULL) {
                if (!janet_fiber_can_resume(to.curr_fiber)) {
+                    if (to.has_worker) {
+#ifdef JANET_WINDOWS
+                        QueueUserAPC(janet_timeout_stop, to.worker, 0);
+                        WaitForSingleObject(to.worker, INFINITE);
+                        CloseHandle(to.worker);
+#else
+#ifdef JANET_ANDROID
+                        pthread_kill(to.worker, SIGUSR1);
+#else
+                        pthread_cancel(to.worker);
+#endif
+                        void *res;
+                        pthread_join(to.worker, &res);
+#endif
+                    }
                    janet_table_remove(&janet_vm.active_tasks, janet_wrap_fiber(to.curr_fiber));
                    pop_timeout(0);
                    continue;
@@ -1789,6 +1882,22 @@ void janet_stream_edge_triggered(JanetStream *stream) {
 }

 void janet_stream_level_triggered(JanetStream *stream) {
+    /* On macos, we seem to need to delete any registered events before re-registering without
+     * EV_CLEAR, otherwise the new event will still have EV_CLEAR set erroneously. This could be a
+     * kernel bug, but unfortunately the specification is vague here, esp. in regards to where and when
+     * EV_CLEAR is set automatically. */
+    struct kevent kevs[2];
+    int length = 0;
+    if (stream->flags & (JANET_STREAM_READABLE | JANET_STREAM_ACCEPTABLE)) {
+        EV_SETx(&kevs[length++], stream->handle, EVFILT_READ, EV_DELETE, 0, 0, stream);
+    }
+    if (stream->flags & JANET_STREAM_WRITABLE) {
+        EV_SETx(&kevs[length++], stream->handle, EVFILT_WRITE, EV_DELETE, 0, 0, stream);
+    }
+    int status;
+    do {
+        status = kevent(janet_vm.kq, kevs, length, NULL, 0, NULL);
+    } while (status == -1 && errno == EINTR);
    janet_register_stream_impl(stream, 0);
 }

@@ -2906,7 +3015,8 @@ static JanetEVGenericMessage janet_go_thread_subr(JanetEVGenericMessage args) {
            uint32_t count1;
            memcpy(&count1, nextbytes, sizeof(count1));
            size_t count = (size_t) count1;
-            if (count > (endbytes - nextbytes) * sizeof(JanetCFunRegistry)) {
+            /* Use division to avoid overflowing size_t */
+            if (count > (endbytes - nextbytes - sizeof(count1)) / sizeof(JanetCFunRegistry)) {
                janet_panic("thread message invalid");
            }
            janet_vm.registry_count = count;
@@ -3077,26 +3187,57 @@ JANET_CORE_FN(cfun_ev_sleep,
 }

 JANET_CORE_FN(cfun_ev_deadline,
-              "(ev/deadline sec &opt tocancel tocheck)",
-              "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);
+              "(ev/deadline sec &opt tocancel tocheck intr?)",
+              "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, must be a fiber. "
+              "Returns `tocancel` immediately. If `interrupt?` is set to true, will create a "
+              "background thread to try to interrupt the VM if the timeout expires.") {
+    janet_arity(argc, 1, 4);
    double sec = janet_getnumber(argv, 0);
+    sec = (sec < 0) ? 0 : sec;
    JanetFiber *tocancel = janet_optfiber(argv, argc, 1, janet_vm.root_fiber);
    JanetFiber *tocheck = janet_optfiber(argv, argc, 2, janet_vm.fiber);
+    int use_interrupt = janet_optboolean(argv, argc, 3, 0);
    JanetTimeout to;
    to.when = ts_delta(ts_now(), sec);
    to.fiber = tocancel;
    to.curr_fiber = tocheck;
    to.is_error = 0;
    to.sched_id = to.fiber->sched_id;
+    if (use_interrupt) {
+#ifdef JANET_ANDROID
+        janet_sandbox_assert(JANET_SANDBOX_SIGNAL);
+#endif
+        JanetThreadedTimeout *tto = janet_malloc(sizeof(JanetThreadedTimeout));
+        if (NULL == tto) {
+            JANET_OUT_OF_MEMORY;
+        }
+        tto->sec = sec;
+        tto->vm = &janet_vm;
+        tto->fiber = tocheck;
+#ifdef JANET_WINDOWS
+        HANDLE worker = CreateThread(NULL, 0, janet_timeout_body, tto, 0, NULL);
+        if (NULL == worker) {
+            janet_free(tto);
+            janet_panic("failed to create thread");
+        }
+#else
+        pthread_t worker;
+        int err = pthread_create(&worker, NULL, janet_timeout_body, tto);
+        if (err) {
+            janet_free(tto);
+            janet_panicf("%s", janet_strerror(err));
+        }
+        janet_assert(!pthread_detach(worker), "pthread_detach");
+#endif
+        to.has_worker = 1;
+        to.worker = worker;
+    } else {
+        to.has_worker = 0;
+    }
    add_timeout(to);
    return janet_wrap_fiber(tocancel);
 }
--- a/src/core/features.h
+++ b/src/core/features.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/ffi.c
+++ b/src/core/ffi.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -1686,7 +1686,7 @@ JANET_CORE_FN(cfun_ffi_buffer_write,
    JanetFFIType type = decode_ffi_type(argv[0]);
    uint32_t el_size = (uint32_t) type_size(type);
    JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, el_size);
-    int32_t index = janet_optnat(argv, argc, 3, 0);
+    int32_t index = janet_optnat(argv, argc, 3, buffer->count);
    int32_t old_count = buffer->count;
    if (index > old_count) janet_panic("index out of bounds");
    buffer->count = index;
--- a/src/core/fiber.c
+++ b/src/core/fiber.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/fiber.h
+++ b/src/core/fiber.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/filewatch.c
+++ b/src/core/filewatch.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -599,33 +599,33 @@ JANET_CORE_FN(cfun_filewatch_make,
 JANET_CORE_FN(cfun_filewatch_add,
              "(filewatch/add watcher path &opt flags)",
              "Add a path to the watcher. Available flags depend on the current OS, and are as follows:\n\n"
-              "Windows/MINGW (flags correspond to FILE_NOTIFY_CHANGE_* flags in win32 documentation):\n\n"
+              "Windows/MINGW (flags correspond to `FILE_NOTIFY_CHANGE_*` flags in win32 documentation):\n\n"
              "* `:all` - trigger an event for all of the below triggers.\n\n"
-              "* `:attributes` - FILE_NOTIFY_CHANGE_ATTRIBUTES\n\n"
-              "* `:creation` - FILE_NOTIFY_CHANGE_CREATION\n\n"
-              "* `:dir-name` - FILE_NOTIFY_CHANGE_DIR_NAME\n\n"
-              "* `:last-access` - FILE_NOTIFY_CHANGE_LAST_ACCESS\n\n"
-              "* `:last-write` - FILE_NOTIFY_CHANGE_LAST_WRITE\n\n"
-              "* `:security` - FILE_NOTIFY_CHANGE_SECURITY\n\n"
-              "* `:size` - FILE_NOTIFY_CHANGE_SIZE\n\n"
+              "* `:attributes` - `FILE_NOTIFY_CHANGE_ATTRIBUTES`\n\n"
+              "* `:creation` - `FILE_NOTIFY_CHANGE_CREATION`\n\n"
+              "* `:dir-name` - `FILE_NOTIFY_CHANGE_DIR_NAME`\n\n"
+              "* `:last-access` - `FILE_NOTIFY_CHANGE_LAST_ACCESS`\n\n"
+              "* `:last-write` - `FILE_NOTIFY_CHANGE_LAST_WRITE`\n\n"
+              "* `:security` - `FILE_NOTIFY_CHANGE_SECURITY`\n\n"
+              "* `:size` - `FILE_NOTIFY_CHANGE_SIZE`\n\n"
              "* `:recursive` - watch subdirectories recursively\n\n"
-              "Linux (flags correspond to IN_* flags from <sys/inotify.h>):\n\n"
-              "* `:access` - IN_ACCESS\n\n"
-              "* `:all` - IN_ALL_EVENTS\n\n"
-              "* `:attrib` - IN_ATTRIB\n\n"
-              "* `:close-nowrite` - IN_CLOSE_NOWRITE\n\n"
-              "* `:close-write` - IN_CLOSE_WRITE\n\n"
-              "* `:create` - IN_CREATE\n\n"
-              "* `:delete` - IN_DELETE\n\n"
-              "* `:delete-self` - IN_DELETE_SELF\n\n"
-              "* `:ignored` - IN_IGNORED\n\n"
-              "* `:modify` - IN_MODIFY\n\n"
-              "* `:move-self` - IN_MOVE_SELF\n\n"
-              "* `:moved-from` - IN_MOVED_FROM\n\n"
-              "* `:moved-to` - IN_MOVED_TO\n\n"
-              "* `:open` - IN_OPEN\n\n"
-              "* `:q-overflow` - IN_Q_OVERFLOW\n\n"
-              "* `:unmount` - IN_UNMOUNT\n\n\n"
+              "Linux (flags correspond to `IN_*` flags from <sys/inotify.h>):\n\n"
+              "* `:access` - `IN_ACCESS`\n\n"
+              "* `:all` - `IN_ALL_EVENTS`\n\n"
+              "* `:attrib` - `IN_ATTRIB`\n\n"
+              "* `:close-nowrite` - `IN_CLOSE_NOWRITE`\n\n"
+              "* `:close-write` - `IN_CLOSE_WRITE`\n\n"
+              "* `:create` - `IN_CREATE`\n\n"
+              "* `:delete` - `IN_DELETE`\n\n"
+              "* `:delete-self` - `IN_DELETE_SELF`\n\n"
+              "* `:ignored` - `IN_IGNORED`\n\n"
+              "* `:modify` - `IN_MODIFY`\n\n"
+              "* `:move-self` - `IN_MOVE_SELF`\n\n"
+              "* `:moved-from` - `IN_MOVED_FROM`\n\n"
+              "* `:moved-to` - `IN_MOVED_TO`\n\n"
+              "* `:open` - `IN_OPEN`\n\n"
+              "* `:q-overflow` - `IN_Q_OVERFLOW`\n\n"
+              "* `:unmount` - `IN_UNMOUNT`\n\n\n"
              "On Windows, events will have the following possible types:\n\n"
              "* `:unknown`\n\n"
              "* `:added`\n\n"
--- a/src/core/gc.c
+++ b/src/core/gc.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/gc.h
+++ b/src/core/gc.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/inttypes.c
+++ b/src/core/inttypes.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose & contributors
+* Copyright (c) 2025 Calvin Rose & contributors
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/io.c
+++ b/src/core/io.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/marsh.c
+++ b/src/core/marsh.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/math.c
+++ b/src/core/math.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/net.c
+++ b/src/core/net.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose and contributors.
+* Copyright (c) 2025 Calvin Rose and contributors.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -554,7 +554,10 @@ JANET_CORE_FN(cfun_net_connect,
    int err = WSAGetLastError();
    freeaddrinfo(ai);
 #else
-    int status = connect(sock, addr, addrlen);
+    int status;
+    do {
+        status = connect(sock, addr, addrlen);
+    } while (status == -1 && errno == EINTR);
    int err = errno;
    if (is_unix) {
        janet_free(ai);
@@ -578,17 +581,21 @@ JANET_CORE_FN(cfun_net_connect,
    net_sched_connect(stream);
 }

-static const char *serverify_socket(JSock sfd, int reuse) {
+static const char *serverify_socket(JSock sfd, int reuse_addr, int reuse_port) {
    /* Set various socket options */
    int enable = 1;
-    if (reuse) {
+    if (reuse_addr) {
        if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (char *) &enable, sizeof(int)) < 0) {
            return "setsockopt(SO_REUSEADDR) failed";
        }
+    }
+    if (reuse_port) {
 #ifdef SO_REUSEPORT
        if (setsockopt(sfd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0) {
            return "setsockopt(SO_REUSEPORT) failed";
        }
+#else
+        (void) reuse_port;
 #endif
    }
    janet_net_socknoblock(sfd);
@@ -650,7 +657,7 @@ JANET_CORE_FN(cfun_net_listen,
              "The type parameter specifies the type of network connection, either "
              "a :stream (usually tcp), or :datagram (usually udp). If not specified, the default is "
              ":stream. The host and port arguments are the same as in net/address. The last boolean parameter `no-reuse` will "
-              "disable the use of SO_REUSEADDR and SO_REUSEPORT when creating a server on some operating systems.") {
+              "disable the use of `SO_REUSEADDR` and `SO_REUSEPORT` when creating a server on some operating systems.") {
    janet_sandbox_assert(JANET_SANDBOX_NET_LISTEN);
    janet_arity(argc, 2, 4);

@@ -668,7 +675,7 @@ JANET_CORE_FN(cfun_net_listen,
            janet_free(ai);
            janet_panicf("could not create socket: %V", janet_ev_lasterr());
        }
-        const char *err = serverify_socket(sfd, reuse);
+        const char *err = serverify_socket(sfd, reuse, 0);
        if (NULL != err || bind(sfd, (struct sockaddr *)ai, sizeof(struct sockaddr_un))) {
            JSOCKCLOSE(sfd);
            janet_free(ai);
@@ -691,7 +698,7 @@ JANET_CORE_FN(cfun_net_listen,
            sfd = socket(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol);
 #endif
            if (!JSOCKVALID(sfd)) continue;
-            const char *err = serverify_socket(sfd, reuse);
+            const char *err = serverify_socket(sfd, reuse, reuse);
            if (NULL != err) {
                JSOCKCLOSE(sfd);
                continue;
--- a/src/core/os.c
+++ b/src/core/os.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose and contributors.
+* Copyright (c) 2025 Calvin Rose and contributors.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -55,6 +55,7 @@
 #include <sys/utime.h>
 #include <io.h>
 #include <process.h>
+#define JANET_SPAWN_CHDIR
 #else
 #include <spawn.h>
 #include <utime.h>
@@ -73,6 +74,20 @@ extern char **environ;
 #endif
 #endif

+/* Detect availability of posix_spawn_file_actions_addchdir_np. Since
+ * this doesn't seem to follow any standard, just a common extension, we
+ * must enumerate supported systems for availability. Define JANET_SPAWN_NO_CHDIR
+ * to disable this. */
+#ifndef JANET_SPAWN_NO_CHDIR
+#ifdef __GLIBC__
+#define JANET_SPAWN_CHDIR
+#elif defined(JANET_APPLE) /* Some older versions may not work here. */
+#define JANET_SPAWN_CHDIR
+#elif defined(__FreeBSD__) /* Not all BSDs work, for example openBSD doesn't seem to support this */
+#define JANET_SPAWN_CHDIR
+#endif
+#endif
+
 /* Not POSIX, but all Unixes but Solaris have this function. */
 #if defined(JANET_POSIX) && !defined(__sun)
 time_t timegm(struct tm *tm);
@@ -541,11 +556,12 @@ static void janet_proc_wait_cb(JanetEVGenericMessage args) {
        proc->flags &= ~JANET_PROC_WAITING;
        janet_gcunroot(janet_wrap_abstract(proc));
        janet_gcunroot(janet_wrap_fiber(args.fiber));
-        if ((status != 0) && (proc->flags & JANET_PROC_ERROR_NONZERO)) {
-            JanetString s = janet_formatc("command failed with non-zero exit code %d", status);
-            janet_cancel(args.fiber, janet_wrap_string(s));
-        } else {
-            if (janet_fiber_can_resume(args.fiber)) {
+        uint32_t sched_id = (uint32_t) args.argi;
+        if (janet_fiber_can_resume(args.fiber) && args.fiber->sched_id == sched_id) {
+            if ((status != 0) && (proc->flags & JANET_PROC_ERROR_NONZERO)) {
+                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));
            }
        }
@@ -603,6 +619,7 @@ os_proc_wait_impl(JanetProc *proc) {
    memset(&targs, 0, sizeof(targs));
    targs.argp = proc;
    targs.fiber = janet_root_fiber();
+    targs.argi = (uint32_t) targs.fiber->sched_id;
    janet_gcroot(janet_wrap_abstract(proc));
    janet_gcroot(janet_wrap_fiber(targs.fiber));
    janet_ev_threaded_call(janet_proc_wait_subr, targs, janet_proc_wait_cb);
@@ -629,16 +646,15 @@ os_proc_wait_impl(JanetProc *proc) {

 JANET_CORE_FN(os_proc_wait,
              "(os/proc-wait proc)",
-              "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.") {
+              "Suspend the current fiber until the subprocess `proc` completes. Once `proc` "
+              "completes, return the exit code of `proc`. If called more than once on the same "
+              "core/process value, will raise an error. When creating subprocesses using "
+              "`os/spawn`, this function should be called on the returned value to avoid zombie "
+              "processes.") {
    janet_fixarity(argc, 1);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
 #ifdef JANET_EV
    os_proc_wait_impl(proc);
-    return janet_wrap_nil();
 #else
    return os_proc_wait_impl(proc);
 #endif
@@ -743,12 +759,13 @@ 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 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.") {
+              "Kill the subprocess `proc` by sending SIGKILL to it on POSIX systems, or by closing "
+              "the process handle on Windows. If `proc` has already completed, raise an error. If "
+              "`wait` is truthy, will wait for `proc` to complete and return the exit code (this "
+              "will raise an error if `proc` is being waited for). Otherwise, return `proc`. If "
+              "`signal` is provided, send it instead of SIGKILL. Signal keywords are named after "
+              "their C counterparts but in lowercase with the leading SIG stripped. `signal` is "
+              "ignored on Windows.") {
    janet_arity(argc, 1, 3);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
    if (proc->flags & JANET_PROC_WAITED) {
@@ -776,7 +793,6 @@ JANET_CORE_FN(os_proc_kill,
    if (argc > 1 && janet_truthy(argv[1])) {
 #ifdef JANET_EV
        os_proc_wait_impl(proc);
-        return janet_wrap_nil();
 #else
        return os_proc_wait_impl(proc);
 #endif
@@ -787,9 +803,9 @@ JANET_CORE_FN(os_proc_kill,

 JANET_CORE_FN(os_proc_close,
              "(os/proc-close proc)",
-              "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.") {
+              "Close pipes created for subprocess `proc` by `os/spawn` if they have not been "
+              "closed. Then, if `proc` is not being waited for, wait. If this function waits, when "
+              "`proc` completes, return the exit code of `proc`. Otherwise, return nil.") {
    janet_fixarity(argc, 1);
    JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
 #ifdef JANET_EV
@@ -807,12 +823,24 @@ JANET_CORE_FN(os_proc_close,
    }
 #ifdef JANET_EV
    os_proc_wait_impl(proc);
-    return janet_wrap_nil();
 #else
    return os_proc_wait_impl(proc);
 #endif
 }

+JANET_CORE_FN(os_proc_getpid,
+              "(os/getpid)",
+              "Get the process ID of the current process.") {
+    janet_sandbox_assert(JANET_SANDBOX_SUBPROCESS);
+    janet_fixarity(argc, 0);
+    (void) argv;
+#ifdef JANET_WINDOWS
+    return janet_wrap_number((double) _getpid());
+#else
+    return janet_wrap_number((double) getpid());
+#endif
+}
+
 static void swap_handles(JanetHandle *handles) {
    JanetHandle temp = handles[0];
    handles[0] = handles[1];
@@ -1137,6 +1165,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    JanetAbstract orig_in = NULL, orig_out = NULL, orig_err = NULL;
    JanetHandle new_in = JANET_HANDLE_NONE, new_out = JANET_HANDLE_NONE, new_err = JANET_HANDLE_NONE;
    JanetHandle pipe_in = JANET_HANDLE_NONE, pipe_out = JANET_HANDLE_NONE, pipe_err = JANET_HANDLE_NONE;
+    int stderr_is_stdout = 0;
    int pipe_errflag = 0; /* Track errors setting up pipes */
    int pipe_owner_flags = (is_spawn && (flags & 0x8)) ? JANET_PROC_ALLOW_ZOMBIE : 0;

@@ -1161,11 +1190,28 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
        if (is_spawn && janet_keyeq(maybe_stderr, "pipe")) {
            new_err = make_pipes(&pipe_err, 0, &pipe_errflag);
            pipe_owner_flags |= JANET_PROC_OWNS_STDERR;
+        } else if (is_spawn && janet_keyeq(maybe_stderr, "out")) {
+            stderr_is_stdout = 1;
        } else if (!janet_checktype(maybe_stderr, JANET_NIL)) {
            new_err = janet_getjstream(&maybe_stderr, 0, &orig_err);
        }
    }

+    /* Optional working directory. Available for both os/execute and os/spawn. */
+    const char *chdir_path = NULL;
+    if (argc > 2) {
+        JanetDictView tab = janet_getdictionary(argv, 2);
+        Janet workdir = janet_dictionary_get(tab.kvs, tab.cap, janet_ckeywordv("cd"));
+        if (janet_checktype(workdir, JANET_STRING)) {
+            chdir_path = (const char *) janet_unwrap_string(workdir);
+#ifndef JANET_SPAWN_CHDIR
+            janet_panicf(":cd argument not supported on this system - %s", chdir_path);
+#endif
+        } else if (!janet_checktype(workdir, JANET_NIL)) {
+            janet_panicf("expected string for :cd argumnet, got %v", workdir);
+        }
+    }
+
    /* Clean up if any of the pipes have any issues */
    if (pipe_errflag) {
        if (pipe_in != JANET_HANDLE_NONE) close_handle(pipe_in);
@@ -1180,6 +1226,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    SECURITY_ATTRIBUTES saAttr;
    PROCESS_INFORMATION processInfo;
    STARTUPINFO startupInfo;
+    LPCSTR lpCurrentDirectory = NULL;
    memset(&saAttr, 0, sizeof(saAttr));
    memset(&processInfo, 0, sizeof(processInfo));
    memset(&startupInfo, 0, sizeof(startupInfo));
@@ -1196,6 +1243,10 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    }
    const char *path = (const char *) janet_unwrap_string(exargs.items[0]);

+    if (chdir_path != NULL) {
+        lpCurrentDirectory = chdir_path;
+    }
+
    /* Do IO redirection */

    if (pipe_in != JANET_HANDLE_NONE) {
@@ -1203,7 +1254,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    } else if (new_in != JANET_HANDLE_NONE) {
        startupInfo.hStdInput = new_in;
    } else {
-        startupInfo.hStdInput = (HANDLE) _get_osfhandle(0);
+        startupInfo.hStdInput = (HANDLE) _get_osfhandle(_fileno(stdin));
    }

    if (pipe_out != JANET_HANDLE_NONE) {
@@ -1211,15 +1262,17 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    } else if (new_out != JANET_HANDLE_NONE) {
        startupInfo.hStdOutput = new_out;
    } else {
-        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(1);
+        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(_fileno(stdout));
    }

    if (pipe_err != JANET_HANDLE_NONE) {
        startupInfo.hStdError = pipe_err;
    } else if (new_err != NULL) {
        startupInfo.hStdError = new_err;
+    } else if (stderr_is_stdout) {
+        startupInfo.hStdError = startupInfo.hStdOutput;
    } else {
-        startupInfo.hStdError = (HANDLE) _get_osfhandle(2);
+        startupInfo.hStdError = (HANDLE) _get_osfhandle(_fileno(stderr));
    }

    int cp_failed = 0;
@@ -1230,7 +1283,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
                       TRUE, /* handle inheritance */
                       0, /* flags */
                       use_environ ? NULL : envp, /* pass in environment */
-                       NULL, /* use parents starting directory */
+                       lpCurrentDirectory,
                       &startupInfo,
                       &processInfo)) {
        cp_failed = 1;
@@ -1268,9 +1321,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {

    /* exec mode */
    if (mode == JANET_EXECUTE_EXEC) {
-#ifdef JANET_WINDOWS
-        janet_panic("not supported on windows");
-#else
        int status;
        if (!use_environ) {
            environ = envp;
@@ -1283,7 +1333,6 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
            }
        } while (status == -1 && errno == EINTR);
        janet_panicf("%p: %s", cargv[0], janet_strerror(errno ? errno : ENOENT));
-#endif
    }

    /* Use posix_spawn to spawn new process */
@@ -1291,6 +1340,15 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    /* Posix spawn setup */
    posix_spawn_file_actions_t actions;
    posix_spawn_file_actions_init(&actions);
+#ifdef JANET_SPAWN_CHDIR
+    if (chdir_path != NULL) {
+#ifdef JANET_SPAWN_CHDIR_NO_NP
+        posix_spawn_file_actions_addchdir(&actions, chdir_path);
+#else
+        posix_spawn_file_actions_addchdir_np(&actions, chdir_path);
+#endif
+    }
+#endif
    if (pipe_in != JANET_HANDLE_NONE) {
        posix_spawn_file_actions_adddup2(&actions, pipe_in, 0);
        posix_spawn_file_actions_addclose(&actions, pipe_in);
@@ -1313,6 +1371,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
    } else if (new_err != JANET_HANDLE_NONE && new_err != 2) {
        posix_spawn_file_actions_adddup2(&actions, new_err, 2);
        posix_spawn_file_actions_addclose(&actions, new_err);
+    } else if (stderr_is_stdout) {
+        posix_spawn_file_actions_adddup2(&actions, 1, 2);
    }

    pid_t pid;
@@ -1384,45 +1444,57 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {

 JANET_CORE_FN(os_execute,
              "(os/execute args &opt flags env)",
-              "Execute a program on the system and pass it string arguments. `flags` "
-              "is a keyword that modifies how the program will execute.\n"
-              "* :e - enables passing an environment to the program. Without :e, the "
+              "Execute a program on the system and return the exit code. `args` is an array/tuple "
+              "of strings. The first string is the name of the program and the remainder are "
+              "arguments passed to the program. `flags` is a keyword made from the following "
+              "characters that modifies how the program executes:\n"
+              "* :e - enables passing an environment to the program. Without 'e', the "
              "current environment is inherited.\n"
-              "* :p - allows searching the current PATH for the binary to execute. "
-              "Without this flag, binaries must use absolute paths.\n"
-              "* :x - raise error if exit code is non-zero.\n"
-              "* :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. "
-              ":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.") {
+              "* :p - allows searching the current PATH for the program to execute. "
+              "Without this flag, the first element of `args` must be an absolute path.\n"
+              "* :x - raises error if exit code is non-zero.\n"
+              "* :d - prevents the garbage collector terminating the program (if still running) "
+              "and calling the equivalent of `os/proc-wait` (allows zombie processes).\n"
+              "`env` is a table/struct mapping environment variables to values. It can also "
+              "contain the keys :in, :out, and :err, which allow redirecting stdio in the "
+              "subprocess. :in, :out, and :err should be core/file or core/stream values. "
+              "If core/stream values are used, the caller is responsible for ensuring pipes do not "
+              "cause the program to block and deadlock.") {
    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 "
-              "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.") {
+              "Execute a program on the system and return a core/process value representing the "
+              "spawned subprocess. Takes the same arguments as `os/execute` but does not wait for "
+              "the subprocess to complete. Unlike `os/execute`, the value `:pipe` can be used for "
+              ":in, :out and :err keys in `env`. If used, the returned core/process will have a "
+              "writable stream in the :in field and readable streams in the :out and :err fields. "
+              "On non-Windows systems, the subprocess PID will be in the :pid field. The caller is "
+              "responsible for waiting on the process (e.g. by calling `os/proc-wait` on the "
+              "returned core/process value) to avoid creating zombie process. After the subprocess "
+              "completes, the exit value is in the :return-code field. If `flags` includes 'x', a "
+              "non-zero exit code will cause a waiting fiber to raise an error. The use of "
+              "`:pipe` may fail if there are too many active file descriptors. The caller is "
+              "responsible for closing pipes created by `:pipe` (either individually or using "
+              "`os/proc-close`). Similar to `os/execute`, the caller is responsible for ensuring "
+              "pipes do not cause the program to block and deadlock. As a special case, the stream passed to `:err` "
+              "can be the keyword `:out` to redirect stderr to stdout in the subprocess.") {
    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. "
-              "However, instead of creating a subprocess, the current process is replaced. Is not supported on windows, and "
+              "However, instead of creating a subprocess, the current process is replaced. Is not supported on Windows, and "
              "does not allow redirection of stdio.") {
+#ifdef JANET_WINDOWS
+    (void) argc;
+    (void) argv;
+    janet_panic("not supported on Windows");
+#else
    return os_execute_impl(argc, argv, JANET_EXECUTE_EXEC);
+#endif
 }

 JANET_CORE_FN(os_posix_fork,
@@ -1433,7 +1505,7 @@ JANET_CORE_FN(os_posix_fork,
    janet_fixarity(argc, 0);
    (void) argv;
 #ifdef JANET_WINDOWS
-    janet_panic("not supported");
+    janet_panic("not supported on Windows");
 #else
    pid_t result;
    do {
@@ -1880,7 +1952,6 @@ JANET_CORE_FN(os_mktime,
        /* utc time */
 #ifdef JANET_NO_UTC_MKTIME
        janet_panic("os/mktime UTC not supported on this platform");
-        return janet_wrap_nil();
 #else
        t = timegm(&t_info);
 #endif
@@ -1947,8 +2018,7 @@ JANET_CORE_FN(os_link,
 #ifdef JANET_WINDOWS
    (void) argc;
    (void) argv;
-    janet_panic("os/link not supported on Windows");
-    return janet_wrap_nil();
+    janet_panic("not supported on Windows");
 #else
    const char *oldpath = janet_getcstring(argv, 0);
    const char *newpath = janet_getcstring(argv, 1);
@@ -1966,8 +2036,7 @@ JANET_CORE_FN(os_symlink,
 #ifdef JANET_WINDOWS
    (void) argc;
    (void) argv;
-    janet_panic("os/symlink not supported on Windows");
-    return janet_wrap_nil();
+    janet_panic("not supported on Windows");
 #else
    const char *oldpath = janet_getcstring(argv, 0);
    const char *newpath = janet_getcstring(argv, 1);
@@ -2069,8 +2138,7 @@ JANET_CORE_FN(os_readlink,
 #ifdef JANET_WINDOWS
    (void) argc;
    (void) argv;
-    janet_panic("os/readlink not supported on Windows");
-    return janet_wrap_nil();
+    janet_panic("not supported on Windows");
 #else
    static char buffer[PATH_MAX];
    const char *path = janet_getcstring(argv, 0);
@@ -2326,7 +2394,6 @@ static Janet os_stat_or_lstat(int do_lstat, int32_t argc, Janet *argv) {
            return sg->fn(&st);
        }
        janet_panicf("unexpected keyword %v", janet_wrap_keyword(key));
-        return janet_wrap_nil();
    }
 }

@@ -2795,6 +2862,7 @@ void janet_lib_os(JanetTable *env) {
        JANET_CORE_REG("os/proc-wait", os_proc_wait),
        JANET_CORE_REG("os/proc-kill", os_proc_kill),
        JANET_CORE_REG("os/proc-close", os_proc_close),
+        JANET_CORE_REG("os/getpid", os_proc_getpid),
 #endif

        /* high resolution timers */
--- a/src/core/parse.c
+++ b/src/core/parse.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/peg.c
+++ b/src/core/peg.c
@@ -342,7 +342,7 @@ tail:
            while (captured < hi) {
                CapState cs2 = cap_save(s);
                next_text = peg_rule(s, rule_a, text);
-                if (!next_text || next_text == text) {
+                if (!next_text || ((next_text == text) && (hi == UINT32_MAX))) {
                    cap_load(s, cs2);
                    break;
                }
@@ -544,6 +544,42 @@ tail:
            return window_end;
        }

+        case RULE_TIL: {
+            const uint32_t *rule_terminus = s->bytecode + rule[1];
+            const uint32_t *rule_subpattern = s->bytecode + rule[2];
+
+            const uint8_t *terminus_start = text;
+            const uint8_t *terminus_end = NULL;
+            down1(s);
+            while (terminus_start <= s->text_end) {
+                CapState cs2 = cap_save(s);
+                terminus_end = peg_rule(s, rule_terminus, terminus_start);
+                cap_load(s, cs2);
+                if (terminus_end) {
+                    break;
+                }
+                terminus_start++;
+            }
+            up1(s);
+
+            if (!terminus_end) {
+                return NULL;
+            }
+
+            const uint8_t *saved_end = s->text_end;
+            s->text_end = terminus_start;
+            down1(s);
+            const uint8_t *matched = peg_rule(s, rule_subpattern, text);
+            up1(s);
+            s->text_end = saved_end;
+
+            if (!matched) {
+                return NULL;
+            }
+
+            return terminus_end;
+        }
+
        case RULE_SPLIT: {
            const uint8_t *saved_end = s->text_end;
            const uint32_t *rule_separator = s->bytecode + rule[1];
@@ -1230,6 +1266,14 @@ static void spec_sub(Builder *b, int32_t argc, const Janet *argv) {
    emit_2(r, RULE_SUB, subrule1, subrule2);
 }

+static void spec_til(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_TIL, subrule1, subrule2);
+}
+
 static void spec_split(Builder *b, int32_t argc, const Janet *argv) {
    peg_fixarity(b, argc, 2);
    Reserve r = reserve(b, 3);
@@ -1326,6 +1370,7 @@ static const SpecialPair peg_specials[] = {
    {"split", spec_split},
    {"sub", spec_sub},
    {"thru", spec_thru},
+    {"til", spec_til},
    {"to", spec_to},
    {"uint", spec_uint_le},
    {"uint-be", spec_uint_be},
@@ -1665,6 +1710,7 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                i += 4;
                break;
            case RULE_SUB:
+            case RULE_TIL:
            case RULE_SPLIT:
                /* [rule, rule] */
                if (rule[1] >= blen) goto bad;
--- a/src/core/pp.c
+++ b/src/core/pp.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/regalloc.c
+++ b/src/core/regalloc.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/regalloc.h
+++ b/src/core/regalloc.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/run.c
+++ b/src/core/run.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/specials.c
+++ b/src/core/specials.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/state.c
+++ b/src/core/state.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/state.h
+++ b/src/core/state.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -27,7 +27,9 @@
 #include <stdint.h>

 #ifdef JANET_EV
-#ifndef JANET_WINDOWS
+#ifdef JANET_WINDOWS
+#include <windows.h>
+#else
 #include <pthread.h>
 #endif
 #endif
@@ -53,13 +55,21 @@ typedef struct {
    void *data;
 } JanetQueue;

+#ifdef JANET_EV
 typedef struct {
    JanetTimestamp when;
    JanetFiber *fiber;
    JanetFiber *curr_fiber;
    uint32_t sched_id;
    int is_error;
+    int has_worker;
+#ifdef JANET_WINDOWS
+    HANDLE worker;
+#else
+    pthread_t worker;
+#endif
 } JanetTimeout;
+#endif

 /* Registry table for C functions - contains metadata that can
 * be looked up by cfunction pointer. All strings here are pointing to
--- a/src/core/string.c
+++ b/src/core/string.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/strtod.c
+++ b/src/core/strtod.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/struct.c
+++ b/src/core/struct.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/symcache.c
+++ b/src/core/symcache.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/symcache.h
+++ b/src/core/symcache.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/table.c
+++ b/src/core/table.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/tuple.c
+++ b/src/core/tuple.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/util.c
+++ b/src/core/util.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/util.h
+++ b/src/core/util.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -205,9 +205,9 @@ int janet_make_pipe(JanetHandle handles[2], int mode);
 #ifdef JANET_FILEWATCH
 void janet_lib_filewatch(JanetTable *env);
 #endif
+#endif
 #ifdef JANET_FFI
 void janet_lib_ffi(JanetTable *env);
 #endif
-#endif

 #endif
--- a/src/core/value.c
+++ b/src/core/value.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/vector.c
+++ b/src/core/vector.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/vector.h
+++ b/src/core/vector.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/core/vm.c
+++ b/src/core/vm.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -115,7 +115,7 @@
 #define vm_maybe_auto_suspend(COND)
 #else
 #define vm_maybe_auto_suspend(COND) do { \
-    if ((COND) && janet_vm.auto_suspend) { \
+    if ((COND) && janet_atomic_load_relaxed(&janet_vm.auto_suspend)) { \
        fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \
        vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \
    } \
@@ -798,14 +798,14 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
    vm_pcnext();

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

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

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

@@ -1388,6 +1388,11 @@ Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {

    if (signal != JANET_SIGNAL_OK) {
        /* Should match logic in janet_signalv */
+#ifdef JANET_EV
+        if (janet_vm.root_fiber != NULL && signal == JANET_SIGNAL_EVENT) {
+            janet_vm.root_fiber->sched_id++;
+        }
+#endif
        if (signal != JANET_SIGNAL_ERROR) {
            *janet_vm.return_reg = janet_wrap_string(janet_formatc("%v coerced from %s to error", *janet_vm.return_reg, janet_signal_names[signal]));
        }
--- a/src/core/wrap.c
+++ b/src/core/wrap.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/src/include/janet.h
+++ b/src/include/janet.h
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
@@ -67,6 +67,11 @@ extern "C" {
 #define JANET_LINUX 1
 #endif

+/* Check for Android */
+#ifdef __ANDROID__
+#define JANET_ANDROID 1
+#endif
+
 /* Check for Cygwin */
 #if defined(__CYGWIN__)
 #define JANET_CYGWIN 1
@@ -165,14 +170,12 @@ extern "C" {
 /* Also enable the thread library only if not single-threaded */
 #ifdef JANET_SINGLE_THREADED
 #define JANET_THREAD_LOCAL
-#undef JANET_THREADS
-#elif defined(__GNUC__)
+#elif !(defined(JANET_THREAD_LOCAL)) && defined(__GNUC__)
 #define JANET_THREAD_LOCAL __thread
-#elif defined(_MSC_BUILD)
+#elif !(defined(JANET_THREAD_LOCAL)) && defined(_MSC_BUILD)
 #define JANET_THREAD_LOCAL __declspec(thread)
-#else
+#elif !(defined(JANET_THREAD_LOCAL))
 #define JANET_THREAD_LOCAL
-#undef JANET_THREADS
 #endif

 /* Enable or disable dynamic module loading. Enabled by default. */
@@ -591,6 +594,7 @@ typedef void *JanetAbstract;
 #define JANET_STREAM_WRITABLE 0x400
 #define JANET_STREAM_ACCEPTABLE 0x800
 #define JANET_STREAM_UDPSERVER 0x1000
+#define JANET_STREAM_NOT_CLOSEABLE 0x2000
 #define JANET_STREAM_TOCLOSE 0x10000

 typedef enum {
@@ -663,6 +667,7 @@ typedef int32_t JanetAtomicInt;
 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);
+JANET_API JanetAtomicInt janet_atomic_load_relaxed(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
@@ -2182,6 +2187,7 @@ typedef enum {
    RULE_UNREF,        /* [rule, tag] */
    RULE_CAPTURE_NUM,  /* [rule, tag] */
    RULE_SUB,          /* [rule, rule] */
+    RULE_TIL,          /* [rule, rule] */
    RULE_SPLIT,        /* [rule, rule] */
    RULE_NTH,          /* [nth, rule, tag] */
    RULE_ONLY_TAGS,    /* [rule] */
--- a/src/mainclient/shell.c
+++ b/src/mainclient/shell.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/test/amalg/main.c
+++ b/test/amalg/main.c
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Calvin Rose
+* Copyright (c) 2025 Calvin Rose
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
--- a/test/suite-array.janet
+++ b/test/suite-array.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-asm.janet
+++ b/test/suite-asm.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-boot.janet
+++ b/test/suite-boot.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-buffer.janet
+++ b/test/suite-buffer.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-bundle.janet
+++ b/test/suite-bundle.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-capi.janet
+++ b/test/suite-capi.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-cfuns.janet
+++ b/test/suite-cfuns.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-compile.janet
+++ b/test/suite-compile.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-corelib.janet
+++ b/test/suite-corelib.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-debug.janet
+++ b/test/suite-debug.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-ev.janet
+++ b/test/suite-ev.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose & contributors
+# Copyright (c) 2025 Calvin Rose & contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -199,7 +199,7 @@
  (assert s "made server 1")

  (defn test-echo [msg]
-    (with [conn (net/connect test-host test-port)]
+    (with [conn (assert (net/connect test-host test-port))]
      (net/write conn msg)
      (def res (net/read conn 1024))
      (assert (= (string res) msg) (string "echo " msg))))
@@ -213,6 +213,7 @@

 # Test on both server and client
 # 504411e
+(var iterations 0)
 (defn names-handler
  [stream]
  (defer (:close stream)
@@ -220,21 +221,26 @@
    (ev/read stream 1)
    (def [host port] (net/localname stream))
    (assert (= host test-host) "localname host server")
-    (assert (= port (scan-number test-port)) "localname port server")))
+    (assert (= port (scan-number test-port)) "localname port server")
+    (++ iterations)
+    (ev/write stream " ")))

 # Test localname and peername
 # 077bf5eba
 (repeat 10
  (with [s (net/server test-host test-port names-handler)]
    (repeat 10
-      (with [conn (net/connect test-host test-port)]
+      (with [conn (assert (net/connect test-host test-port))]
        (def [host port] (net/peername conn))
        (assert (= host test-host) "peername host client ")
        (assert (= port (scan-number test-port)) "peername port client")
-        # let server close
-        (ev/write conn " "))))
+        (++ iterations)
+        (ev/write conn " ")
+        (ev/read conn 1))))
  (gccollect))

+(assert (= iterations 200) "localname and peername not enough checks")
+
 # Create pipe
 # 12f09ad2d
 (var pipe-counter 0)
@@ -422,17 +428,11 @@
  (assert (= result text) (string/format "expected %v, got %v" text result)))

 # Now do our telnet chat
-(def bob (net/connect test-host test-port :stream))
+(def bob (assert (net/connect test-host test-port :stream)))
 (expect-read bob "Whats your name?\n")
-(if (= :mingw (os/which))
-  (net/write bob "bob")
-  (do
-    (def fbob (ev/to-file bob))
-    (file/write fbob "bob")
-    (file/flush fbob)
-    (:close fbob)))
+(net/write bob "bob")
 (expect-read bob "Welcome bob\n")
-(def alice (net/connect test-host test-port))
+(def alice (assert (net/connect test-host test-port)))
 (expect-read alice "Whats your name?\n")
 (net/write alice "alice")
 (expect-read alice "Welcome alice\n")
@@ -446,7 +446,7 @@
 (expect-read bob "[alice]:hi\n")

 # Ted joins the chat server
-(def ted (net/connect test-host test-port))
+(def ted (assert (net/connect test-host test-port)))
 (expect-read ted "Whats your name?\n")
 (net/write ted "ted")
 (expect-read ted "Welcome ted\n")
@@ -476,6 +476,14 @@
 (:close chat-server)

 # Issue #1531
+(defn sleep-print [x] (ev/sleep 0) (print x))
+(protect (with-dyns [*out* sleep-print] (prin :foo)))
+(defn level-trigger-handling [conn &] (:close conn))
+(def s (assert (net/server test-host test-port level-trigger-handling)))
+(def c (assert (net/connect test-host test-port)))
+(:close s)
+
+# Issue #1531 no. 2
 (def c (ev/chan 0))
 (ev/spawn (while (def x (ev/take c))))
 (defn print-to-chan [x] (ev/give c x))
@@ -484,4 +492,79 @@
                (pp :foo)))
 (ev/chan-close c)

+# soreuseport on unix domain sockets
+(compwhen (or (= :macos (os/which)) (= :linux (os/which)))
+  (assert-no-error "unix-domain socket reuseaddr"
+                   (let [uds-path "./unix-domain-socket"]
+                     (defer (os/rm uds-path)
+                       (let [s (net/listen :unix uds-path :stream)]
+                         (:close s))))))
+
+# net/accept-loop level triggering
+(gccollect)
+(def maxconn 50)
+(var connect-count 0)
+(defn level-trigger-handling
+  [conn &]
+  (with [conn conn]
+    (ev/write conn (ev/read conn 4096))
+    (++ connect-count)))
+(def s (assert (net/server test-host test-port level-trigger-handling)))
+(def cons @[])
+(repeat maxconn (array/push cons (assert (net/connect test-host test-port))))
+(assert (= maxconn (length cons)))
+(defn do-connect [i]
+  (with [c (get cons i)]
+    (ev/write c "abc123")
+    (ev/read c 4096)))
+(for i 0 maxconn (ev/spawn (do-connect i)))
+(ev/sleep 0.1)
+(assert (= maxconn connect-count))
+(:close s)
+
+# Cancel os/proc-wait with ev/deadline
+(let [p (os/spawn [;run janet "-e" "(os/sleep 4)"] :p)]
+  (var terminated-normally false)
+  (assert-error "deadline expired"
+                (ev/with-deadline 0.01
+                  (os/proc-wait p)
+                  (print "uhoh")
+                  (set terminated-normally true)))
+  (assert (not terminated-normally) "early termination failure")
+  # Without this kill, janet will wait the full 4 seconds for the subprocess to complete before exiting.
+  (assert-no-error "kill proc after wait failed" (os/proc-kill p)))
+
+# Cancel os/proc-wait with ev/deadline 2
+(let [p (os/spawn [;run janet "-e" "(os/sleep 0.1)"] :p)]
+  (var terminated-normally false)
+  (assert-error "deadline expired"
+                (ev/with-deadline 0.05
+                  (os/proc-wait p)
+                  (print "uhoh")
+                  (set terminated-normally true)))
+  (assert (not terminated-normally) "early termination failure 2")
+  (ev/sleep 0.15)
+  (assert (not terminated-normally) "early termination failure 3"))
+
+(let [f (coro (forever :foo))]
+  (ev/deadline 0.01 nil f true)
+  (assert-error "deadline expired" (resume f)))
+
+# Use :err :stdout
+(def- subproc-code '(do (eprint "hi") (eflush) (print "there") (flush)))
+(defn ev/slurp
+  [f &opt buf]
+  (default buf @"")
+  (if (ev/read f 0x10000 buf)
+    (ev/slurp f buf)
+    buf))
+(def p (os/spawn [;run janet "-e" (string/format "%j" subproc-code)] :px {:out :pipe :err :out}))
+(def [exit-code data]
+  (ev/gather
+    (os/proc-wait p)
+    (ev/slurp (p :out))))
+(def data (string/replace-all "\r" "" data))
+(assert (zero? exit-code) "subprocess ran")
+(assert (= data "hi\nthere\n") "output is correct")
+
 (end-suite)
--- a/test/suite-ffi.janet
+++ b/test/suite-ffi.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose & contributors
+# Copyright (c) 2025 Calvin Rose & contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -55,4 +55,11 @@
 (compwhen has-ffi
  (assert-error "bad struct issue #1512" (ffi/struct :void)))

+(compwhen has-ffi
+  (def buf @"")
+  (ffi/write :u8 10 buf)
+  (assert (= 1 (length buf)))
+  (ffi/write :u8 10 buf)
+  (assert (= 2 (length buf))))
+
 (end-suite)
--- a/test/suite-filewatch.janet
+++ b/test/suite-filewatch.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2024 Calvin Rose & contributors
+# Copyright (c) 2025 Calvin Rose & contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-inttypes.janet
+++ b/test/suite-inttypes.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose & contributors
+# Copyright (c) 2025 Calvin Rose & contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-io.janet
+++ b/test/suite-io.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose & contributors
+# Copyright (c) 2025 Calvin Rose & contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-marsh.janet
+++ b/test/suite-marsh.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-math.janet
+++ b/test/suite-math.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-os.janet
+++ b/test/suite-os.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-parse.janet
+++ b/test/suite-parse.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-peg.janet
+++ b/test/suite-peg.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
@@ -713,6 +713,41 @@
  "abcdef"
  @[])

+(test "til: basic matching"
+  ~(til "d" "abc")
+  "abcdef"
+  @[])
+
+(test "til: second pattern can't see past the first occurrence of first pattern"
+  ~(til "d" (* "abc" -1))
+  "abcdef"
+  @[])
+
+(test "til: fails if first pattern fails"
+  ~(til "x" "abc")
+  "abcdef"
+  nil)
+
+(test "til: fails if second pattern fails"
+  ~(til "abc" "x")
+  "abcdef"
+  nil)
+
+(test "til: discards captures from initial pattern"
+  ~(til '"d" '"abc")
+  "abcdef"
+  @["abc"])
+
+(test "til: positions inside second match are still relative to the entire input"
+  ~(* "one\ntw" (til 0 (* ($) (line) (column))))
+  "one\ntwo\nthree\n"
+  @[6 2 3])
+
+(test "til: advances to the end of the first pattern's first occurrence"
+  ~(* (til "d" "ab") "e")
+  "abcdef"
+  @[])
+
 (test "split: basic functionality"
  ~(split "," '1)
  "a,b,c"
@@ -789,5 +824,16 @@
      "abc123"
      @["abc123"])

+# Issue 1554 - 0-width match termination behavior
+(test "issue 1554 case 1" '(any (> '1)) "abc" @[])
+(test "issue 1554 case 2" '(any (? (> '1))) "abc" @[])
+(test "issue 1554 case 3" '(any (> (? '1))) "abc" @[])
+(test "issue 1554 case 4" '(* "a" (> '1)) "abc" @["b"])
+(test "issue 1554 case 5" '(* "a" (? (> '1))) "abc" @["b"])
+(test "issue 1554 case 6" '(* "a" (> (? '1))) "abc" @["b"])
+(test "issue 1554 case 7" '(between 0 2 (> '1)) "abc" @["a" "a"])
+(test "issue 1554 case 8" '(between 2 3 (? (> '1))) "abc" @["a" "a" "a"])
+(test "issue 1554 case 9" '(between 0 0 (> (? '1))) "abc" @[])
+
 (end-suite)

--- a/test/suite-pp.janet
+++ b/test/suite-pp.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose & contributors
+# Copyright (c) 2025 Calvin Rose & contributors
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-specials.janet
+++ b/test/suite-specials.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-string.janet
+++ b/test/suite-string.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-strtod.janet
+++ b/test/suite-strtod.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-struct.janet
+++ b/test/suite-struct.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-symcache.janet
+++ b/test/suite-symcache.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-table.janet
+++ b/test/suite-table.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-tuple.janet
+++ b/test/suite-tuple.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-unknown.janet
+++ b/test/suite-unknown.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-value.janet
+++ b/test/suite-value.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/test/suite-vm.janet
+++ b/test/suite-vm.janet
@@ -1,4 +1,4 @@
-# Copyright (c) 2023 Calvin Rose
+# Copyright (c) 2025 Calvin Rose
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Calvin Rose	c5b3da1ffe	Inter	2025-05-16 18:35:33 -05:00
Calvin Rose	a8e2c8e5b8	Address #1596 - Use atomic intrinsics to check allow_interrupt flag. Use a relaxed memory order if possible to mitigate performance issues as much as possible. relaxed memory order should be sufficient.	2025-05-16 18:26:43 -05:00
Calvin Rose	3d3e880f52	Allow configuration of JANET_THREAD_LOCAL. Address #1595 This is to better allow configuration on various, unknown compilers. Previously, we hardcoded how thread local storage was specified for a few different compilers, but we were not following and C standard. In C11, there is a standardized storage specifier _Thread_local for this storage class, however this is now deprecated in various C++ compilers for a new keyword, confusingly. Janet also does not claim to require the C11 standard, so for maximum flexibilty, the storage specifier must be specified at configure time.	2025-05-11 08:37:15 -05:00
Calvin Rose	bef8ba5e06	Merge pull request #1594 from sogaiu/tweak-docstrings Tweak docstrings for better handling	2025-05-08 17:00:32 -05:00
Calvin Rose	523639362c	Merge pull request #1593 from agent-kilo/thread-message-size-check Try to fix cfun registry size check for cross-thread messages	2025-05-08 17:00:22 -05:00
sogaiu	4b6d5e5671	Tweak docstrings for better handling	2025-05-02 18:54:18 +09:00
Agent Kilo	a695454dae	Try to fix cfun registry size check for cross-thread messages	2025-04-28 17:00:23 +08:00
Calvin Rose	f2eaa5dee8	Remove ev/to-stream. The function has more problems than initially expected, both on Posix systems and on Windows. Given all the caveats, it is probably best not to include. Any function that can obtain files can use os/open instead. The standard FILE objects also will not work anyway, and different operating systems have different work arounds.	2025-04-18 18:20:27 -07:00
Calvin Rose	b27c830d90	Use win32 DuplicatHandle instead of _dup There are constraints when using the posix API on win32 that aren't present with normal win32.	2025-04-11 21:36:08 -05:00
Calvin Rose	92a852f2df	Add ev/to-stream. This function is symmetrical to ev/to-file and can convert a blocking file to a stream (with caveats).	2025-04-11 21:10:49 -05:00
Calvin Rose	647e218bed	make format	2025-04-09 20:39:23 -05:00
Calvin Rose	5ebe945ffd	Merge pull request #1582 from pyrmont/bugfix.termux-pthread_cancel Fix absence of pthread_cancel in Android	2025-04-09 20:16:57 -05:00
Michael Camilleri	6254fffad0	Update changelog to include change to `ev/deadline`	2025-04-09 10:40:19 +09:00
Michael Camilleri	5705b2f6c7	Fix absence of pthread_cancel in Android	2025-04-09 10:37:46 +09:00
Calvin Rose	90a33bc88a	Add some systems that support addchdir.	2025-04-07 21:12:28 -05:00
Calvin Rose	1ba077c87d	Add ifdefs for various platforms to check for the support of addchdir. This will need to be expanded but should support most modern systems.	2025-04-07 21:12:28 -05:00
Calvin Rose	34629ae314	Fix signature on windows.	2025-04-07 21:12:28 -05:00
Calvin Rose	3edc4f35b2	Add `:cd` argument to os/execute and os/spawn.	2025-04-07 21:12:28 -05:00
Calvin Rose	06d01c099f	Merge pull request #1581 from sogaiu/fix-mapcat-and-keep-docstrings Fix mapcat and keep docstrings	2025-04-07 21:11:14 -05:00
sogaiu	d493eaf485	Fix mapcat and keep docstrings	2025-04-06 20:48:52 +09:00
Calvin Rose	332f123abe	Replace if not errorlevel 0 with if errorlevel 1 The former is just bad syntax.	2025-04-05 20:59:45 -05:00
Calvin Rose	38e841fc5c	Get rid of test error.	2025-04-05 20:52:47 -05:00
Calvin Rose	e8187fdee5	Fix windows build	2025-04-05 20:26:57 -05:00
Calvin Rose	2fedb67cb3	formatting	2025-04-05 17:32:07 -05:00
Calvin Rose	bdab93c999	Add `{:err :out}` option to os/spawn. This special case in the os/spawn interface allows easily redirecting both stderr and stdout to the same pipe.	2025-04-05 17:30:46 -05:00
Calvin Rose	a9ff8b388f	Add os/getpid	2025-04-05 16:20:17 -05:00
Calvin Rose	b12dfd784e	Merge pull request #1578 from sogaiu/tweak-some-docstrings Tweak doc for mapcat, count, keep, all, some	2025-04-04 21:45:09 -05:00
sogaiu	e2cc8f2965	Tweak doc for mapcat, count, keep, all, some	2025-04-05 10:42:04 +09:00
Calvin Rose	17524d2ed3	Merge pull request #1577 from sogaiu/cleanup-unix-domain-socket Remove unix domain socket after test	2025-04-04 07:11:42 -05:00
sogaiu	d2ee4aa074	Remove unix domain socket after test	2025-04-04 20:22:10 +09:00
Calvin Rose	363e32d455	Adopt docstring from #1574	2025-04-03 20:52:40 -05:00
Calvin Rose	31920e574d	Add explicit Alpine Linux directions. Statically linking Janet is quite useful, especially for users who want to use jpm and janet-pm to build standalone binaries.	2025-04-01 19:47:03 -05:00
Calvin Rose	cf714ed591	Notify user when script is installed during a bundle installation. Lets user know what to add to PATH.	2025-04-01 18:52:23 -05:00
Calvin Rose	b458404b41	Update ffi/write to append to a buffer by default.	2025-03-28 10:00:40 -05:00
Calvin Rose	707463a645	Merge pull request #1575 from pyrmont/feature.ev-interrupt2 Expand scope of code that works with `ev/deadline` again	2025-03-26 09:42:51 -05:00
Michael Camilleri	eac37ab869	Avoid leaking memory used for JanetThreadedTimeout struct	2025-03-25 22:02:53 +09:00
Michael Camilleri	a24e5b1eaa	Prevent deadline timeout being less than zero	2025-03-25 21:41:59 +09:00
Michael Camilleri	09ac85b1b9	Move janet_timeout_* function definitions before first use	2025-03-25 21:15:28 +09:00
Michael Camilleri	87c1eab7d4	Define JanetTimeout only if event loop enabled	2025-03-25 21:14:21 +09:00
Michael Camilleri	5a29a28c11	Include <windows.h> in state.h	2025-03-25 20:34:45 +09:00
Michael Camilleri	2ed186664f	Support using a background thread to monitor deadlines	2025-03-25 20:27:44 +09:00
Calvin Rose	73334f3485	Prepare for 1.38.0 release.	2025-03-18 21:14:45 -05:00
Calvin Rose	a5b8da8d67	Merge pull request #1572 from tsujamin/janet-ffi-define-fix Remove janet_lib_ffi() dependency on JANET_EV	2025-03-18 19:12:44 -07:00
Benjamin Roberts	e8cccfced5	Remove janet_lib_ffi() dependency on JANET_EV	2025-03-18 10:54:18 -04:00
Calvin Rose	88984f7ffb	Add bundle/replace Slight generalization of bundle/reinstall to allow inplace upgrades of a bundle without reinstalling all dependent bundles as well.	2025-03-17 17:58:40 -05:00
Calvin Rose	182170b3be	Make installed manifests nicer to work with.	2025-03-16 20:39:16 -05:00
Calvin Rose	f92412841b	Merge pull request #1569 from sogaiu/vm-bug-1566	2025-03-12 21:13:49 -07:00
sogaiu	18c00e89da	Fix vm bugs from #1566	2025-03-13 11:43:43 +09:00
Calvin Rose	7c38a55a9a	Merge pull request #1568 from rwtolbert/msys2_mingw_build_fix Update Makefile and meson to build with msys2 gcc and clang	2025-03-10 17:56:00 -07:00
Bob Tolbert	a15916ec9c	Update Makefile and meson to build with msys2 gcc and clang	2025-03-10 10:13:36 -05:00
Calvin Rose	3583d4c92f	Fix defdyn in flychecking.	2025-03-08 20:03:02 -06:00
Calvin Rose	a456c67a7b	Merge pull request #1564 from pyrmont/bugfix.qemu-segfault Use Alpine Linux as base image for s390x testing	2025-03-05 05:52:20 -08:00
Michael Camilleri	6e226e4073	Use sh rather than bash on Alpine Linux	2025-03-04 15:19:44 +09:00
Michael Camilleri	d23e6614b1	Use Alpine Linux as the base image rather than Ubuntu	2025-03-04 15:17:07 +09:00
Michael Camilleri	ab6afa72fd	Use simpler base image	2025-03-04 15:01:25 +09:00
Calvin Rose	9538b8a77c	Merge pull request #1562 from pyrmont/bugfix.subprocess-cleanup Improve subprocess-related docstrings and functions	2025-03-03 18:47:59 -08:00
Calvin Rose	36d3804dd2	Merge pull request #1563 from pyrmont/bugfix.copyright-dates Add script to update copyright dates	2025-03-03 18:47:38 -08:00
Michael Camilleri	a34b8ea68f	Update older dates to 2025	2025-03-04 11:32:15 +09:00
Michael Camilleri	55c10f98bb	Check more file extensions	2025-03-04 11:31:56 +09:00
Michael Camilleri	4b5a2a14c0	Update year in copyright disclaimer to 2025	2025-03-04 11:24:09 +09:00
Michael Camilleri	665705d06d	Add Janet script to update copyright disclaimer	2025-03-04 11:23:26 +09:00
Michael Camilleri	cc8cd4bace	Use uraimo GitHub action for s390x testing	2025-03-04 09:14:05 +09:00
Michael Camilleri	8f8b6ed001	Remove note on cancellation and tidy up wording	2025-03-03 23:28:37 +09:00
Calvin Rose	aa9efee868	Expose bundle operations in the CLI. Bundle installation is a fairly natural command on the command line.	2025-03-03 08:14:09 -06:00
Calvin Rose	e0a0e2ed42	Prevent multi-scheduling with os/proc-wait. (address #1562 )	2025-03-02 10:44:15 -06:00
Michael Camilleri	39f5c539d7	Clarify wording of docstrings further	2025-03-02 13:25:14 +09:00
Michael Camilleri	1b6437a4f8	Remove unnecessary returns	2025-03-02 08:30:51 +09:00
Michael Camilleri	c62c1a58f0	Reword documentation relating to subprocess creation	2025-03-02 08:29:32 +09:00
Calvin Rose	3441bcbd69	Add more cases for checking coerce error. Channel operations inside a janet_call could wreak more havoc later, when scheduled fibers are shooting off when they shouldn't be. The easiest way to prevent this is simply check that we are not inside janet_call before doing channel operations. We also get nicer error messages this way.	2025-02-16 10:40:38 -06:00
Calvin Rose	2e6001316a	Work on bug #1556	2025-02-16 09:09:33 -06:00
Calvin Rose	53bcc15207	Merge pull request #1557 from sogaiu/update-changelog-2025-02 Update CHANGELOG.md	2025-02-09 23:22:45 -08:00
sogaiu	dd609bb1bb	Update CHANGELOG.md	2025-02-08 14:29:22 +09:00
Calvin Rose	5c56c7fa91	Formatting in peg.c	2025-02-07 21:05:28 -06:00
Calvin Rose	9a892363a3	Address issue #1558 Don't attempt SO_REUSEPORT on unix domain sockets since it doesn't make sense and may cause a failure to bind without extra effort by the programmer.	2025-02-07 21:05:07 -06:00
Calvin Rose	5f550ea5d4	Merge pull request #1555 from sogaiu/tweak-apply-short-fn-docstrings Tweak apply and short-fn docstrings	2025-02-06 16:44:45 -08:00
sogaiu	1b6cc023a5	Tweak apply and short-fn docstrings	2025-02-06 22:35:59 +09:00
Calvin Rose	410f8d69bc	Merge pull request #1528 from ianthehenry/til-peg-special add (til) PEG special	2025-02-03 19:07:08 -08:00
Calvin Rose	6da44bdb6a	Get rid of early termination rule in all finite loops.	2025-02-03 07:36:00 -06:00
Calvin Rose	d30fd27575	Address #1554 - capture first 0-width match in repeating rules and optionals. This fixes some undesirable interplay between lookaheads and looping (repeating) rules where lookaheads caused the loop to immediately terminate _and_ discard any captures. This change adds an exception if there is a 0-width match at the first iteration of the loop, in which case captures will be kept, although the loop will still be terminated (any further iteration of the loop would possibly cause an infinite loop). This allows optionals to work as expected when combined with lookahead. There is also a question of whether or not optional should be implemented as separate rule rather than as `(between 0 1 subrule)`.	2025-02-02 20:34:36 -06:00
Calvin Rose	1b278fc657	Update reduce2 documentation to fix issue #1545	2025-02-01 17:31:55 -06:00
Ian Henry	952906279c	add (til) PEG special (til sep subpattern) is a specialized (sub) that behaves like (sub (to sep) subpattern), but advances over the input like (thru sep).	2024-12-04 21:17:10 -08:00