Test replacing CRITICAL_SECTION with SRWLOCK.

We use rw locks anyway, and it should be faster and smaller.

.builds/openbsd.yml

@@ -1,4 +1,4 @@
-image: openbsd/7.4
+image: openbsd/7.6
 sources:
 - https://git.sr.ht/~bakpakin/janet
 packages:

.github/workflows/test.yml

@@ -25,7 +25,7 @@ jobs:
     name: Build and test on Windows
     strategy:
       matrix:
-        os: [ windows-latest, windows-2019 ]
+        os: [ windows-latest, windows-2022 ]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout the repository
@@ -46,7 +46,7 @@ jobs:
     name: Build and test on Windows Minimal build
     strategy:
       matrix:
-        os: [ windows-2019 ]
+        os: [ windows-2022 ]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout the repository

CHANGELOG.md

@@ -2,9 +2,23 @@
 All notable changes to this project will be documented in this file.
 
 ## Unreleased - ???
+- Add `gcperthread` callback for abstract types. This lets threaded abstracts have a finalizer that is called per thread, as well as a global finalizer.
+- Add `JANET_DO_ERROR_*` flags to describe the return value of `janet_dobytes` and `janet_dostring`.
+
+## 1.39.1 - 2025-08-30
+- Add support for chdir in os/spawn on older macOS versions
+- Expose channels properly in C API
+
+## 1.39.0 - 2025-08-24
+- Various bug fixes
+- Add `net/socket`
+- Add support for illumos OS
+- Raise helpful errors for incorrect arguments to `import`.
+- 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`

Makefile

@@ -47,6 +47,7 @@ SPORK_TAG?=master
 HAS_SHARED?=1
 DEBUGGER=gdb
 SONAME_SETTER=-Wl,-soname,
+STRIPFLAGS=-x -S
 
 # For cross compilation
 HOSTCC?=$(CC)
@@ -54,7 +55,7 @@ HOSTAR?=$(AR)
 # Symbols are (optionally) removed later, keep -g as default!
 CFLAGS?=-O2 -g
 LDFLAGS?=-rdynamic
-LIBJANET_LDFLAGS?=$(LD_FLAGS)
+LIBJANET_LDFLAGS?=$(LDFLAGS)
 RUN:=$(RUN)
 
 
@@ -80,6 +81,12 @@ ifeq ($(UNAME), Darwin)
 	LDCONFIG:=true
 else ifeq ($(UNAME), Linux)
 	CLIBS:=$(CLIBS) -lrt -ldl
+else ifeq ($(UNAME), SunOS)
+	BUILD_CFLAGS+=-D__EXTENSIONS__ -DJANET_NO_NANBOX
+	BOOT_CFLAGS+=-D__EXTENSIONS__ -DJANET_NO_NANBOX
+	CLIBS:=-lsocket -lm
+	STRIPFLAGS=-x
+	LDCONFIG:=false
 endif
 
 # For other unix likes, add flags here!
@@ -213,9 +220,9 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################
 
 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.38.dylib
+SONAME=libjanet.1.40.dylib
 else
-SONAME=libjanet.so.1.38
+SONAME=libjanet.so.1.40
 endif
 
 ifeq ($(MINGW_COMPILER), clang)
@@ -289,7 +296,7 @@ build/janet-%.tar.gz: $(JANET_TARGET) \
 	README.md build/c/janet.c build/c/shell.c
 	mkdir -p build/$(JANET_DIST_DIR)/bin
 	cp $(JANET_TARGET) build/$(JANET_DIST_DIR)/bin/
-	strip -x -S 'build/$(JANET_DIST_DIR)/bin/janet'
+	strip $(STRIPFLAGS) 'build/$(JANET_DIST_DIR)/bin/janet'
 	mkdir -p build/$(JANET_DIST_DIR)/include
 	cp build/janet.h build/$(JANET_DIST_DIR)/include/
 	mkdir -p build/$(JANET_DIST_DIR)/lib/
@@ -336,7 +343,7 @@ build/janet.pc: $(JANET_TARGET)
 install: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.pc build/janet.h
 	mkdir -p '$(DESTDIR)$(BINDIR)'
 	cp $(JANET_TARGET) '$(DESTDIR)$(BINDIR)/janet'
-	strip -x -S '$(DESTDIR)$(BINDIR)/janet'
+	strip $(STRIPFLAGS) '$(DESTDIR)$(BINDIR)/janet'
 	mkdir -p '$(DESTDIR)$(INCLUDEDIR)/janet'
 	cp -r build/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet'
 	ln -sf ./janet/janet.h '$(DESTDIR)$(INCLUDEDIR)/janet.h'

README.md

@@ -213,6 +213,10 @@ gmake install-jpm-git
 NetBSD build instructions are the same as the FreeBSD build instructions.
 Alternatively, install the package directly with `pkgin install janet`.
 
+### illumos
+
+Building on illumos is exactly the same as building on FreeBSD.
+
 ### Windows
 
 1. Install [Visual Studio](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=Community&rel=15#) or [Visual Studio Build Tools](https://visualstudio.microsoft.com/thank-you-downloading-visual-studio/?sku=BuildTools&rel=15#).

build_win.bat

@@ -49,6 +49,7 @@ for %%f in (src\boot\*.c) do (
 )
 %JANET_LINK% /out:build\janet_boot.exe build\boot\*.obj
 @if errorlevel 1 goto :BUILDFAIL
+@rem note that there is no default sysroot being baked in
 build\janet_boot . > build\c\janet.c
 @if errorlevel 1 goto :BUILDFAIL
 

examples/abstract-unix-socket.janet

@@ -0,0 +1,6 @@
+# Linux only - uses abstract unix domain sockets
+(ev/spawn (net/server :unix "@abc123" (fn [conn] (print (:read conn 1024)) (:close conn))))
+(ev/sleep 1)
+(def s (net/connect :unix "@abc123" :stream))
+(:write s "hello")
+(:close s)

examples/sample-dep1/bundle/info.jdn

@@ -1,4 +1,4 @@
 @{
   :name "sample-dep1"
-  :dependencies ["sample-dep2"]
+  :dependencies [{:name "sample-dep2"}]
 }

janet.1

@@ -214,7 +214,7 @@ Don't execute a script, only compile it to check for errors. Useful for linting
 .BR \-m\ syspath
 Set the dynamic binding :syspath to the string syspath so that Janet will load system modules
 from a directory different than the default. The default is set when Janet is built, and defaults to
-/usr/local/lib/janet on Linux/Posix, and C:/Janet/Library on Windows. This option supersedes JANET_PATH.
+/usr/local/lib/janet on Linux/Posix. On Windows, there is no default value. This option supersedes JANET_PATH.
 
 .TP
 .BR \-c\ source\ output
@@ -255,8 +255,7 @@ and then arguments to the script.
 .RS
 The location to look for Janet libraries. This is the only environment variable Janet needs to
 find native and source code modules. If no JANET_PATH is set, Janet will look in
-the default location set at compile time. This should be a list of as well as a colon
-separate list of such directories.
+the default location set at compile time. This should be a colon-separated list of directory names on Linux/Posix, and a semicolon-separated list on Windows. Note that a typical setup (i.e. not NixOS / Guix) will only use a single directory.
 .RE
 
 .B JANET_PROFILE

meson.build

@@ -20,7 +20,7 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.38.0')
+  version : '1.40.0')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -105,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)
 
@@ -278,6 +281,7 @@ test_files = [
   'test/suite-corelib.janet',
   'test/suite-debug.janet',
   'test/suite-ev.janet',
+  'test/suite-ev2.janet',
   'test/suite-ffi.janet',
   'test/suite-filewatch.janet',
   'test/suite-inttypes.janet',

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)

src/boot/boot.janet

@@ -158,7 +158,7 @@
   ``Define an alias for a keyword that is used as a dynamic binding. The
   alias is a normal, lexically scoped binding that can be used instead of
   a keyword to prevent typos. `defdyn` does not set dynamic bindings or otherwise
-  replace `dyn` and `setdyn`. The alias _must_ start and end with the `*` character, usually
+  replace `dyn` and `setdyn`. The alias *must* start and end with the `*` character, usually
   called "earmuffs".``
   [alias & more]
   (assert (symbol? alias) "alias must be a symbol")
@@ -290,22 +290,6 @@
   (array/concat accum body)
   (tuple/slice accum 0))
 
-(defmacro try
-  ``Try something and catch errors. `body` is any expression,
-  and `catch` should be a form, the first element of which is a tuple. This tuple
-  should contain a binding for errors and an optional binding for
-  the fiber wrapping the body. Returns the result of `body` if no error,
-  or the result of `catch` if an error.``
-  [body catch]
-  (let [[[err fib]] catch
-        f (gensym)
-        r (gensym)]
-    ~(let [,f (,fiber/new (fn :try [] ,body) :ie)
-           ,r (,resume ,f)]
-       (if (,= (,fiber/status ,f) :error)
-         (do (def ,err ,r) ,(if fib ~(def ,fib ,f)) ,;(tuple/slice catch 1))
-         ,r))))
-
 (defmacro protect
   `Evaluate expressions, while capturing any errors. Evaluates to a tuple
   of two elements. The first element is true if successful, false if an
@@ -352,6 +336,23 @@
                         (tuple 'if $fi $fi ret))))))
   ret)
 
+(defmacro try
+  ``Try something and catch errors. `body` is any expression,
+  and `catch` should be a form, the first element of which is a tuple. This tuple
+  should contain a binding for errors and an optional binding for
+  the fiber wrapping the body. Returns the result of `body` if no error,
+  or the result of `catch` if an error.``
+  [body catch]
+  (assert (and (not (empty? catch)) (indexed? (catch 0))) "the first element of `catch` must be a tuple or array")
+  (let [[err fib] (catch 0)
+        r (or err (gensym))
+        f (or fib (gensym))]
+    ~(let [,f (,fiber/new (fn :try [] ,body) :ie)
+           ,r (,resume ,f)]
+       (if (,= (,fiber/status ,f) :error)
+         (do ,;(tuple/slice catch 1))
+         ,r))))
+
 (defmacro with-syms
   "Evaluates `body` with each symbol in `syms` bound to a generated, unique symbol."
   [syms & body]
@@ -1103,8 +1104,9 @@
   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`. The resulting array
-  has a length that is the shortest of `ind` and each of `inds`.
+  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 @[])
@@ -1143,8 +1145,8 @@
   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 the
-  shortest of `ind` and each of `inds`.
+  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 @[])
@@ -1932,7 +1934,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`.
@@ -2573,7 +2575,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
 
@@ -3179,12 +3181,17 @@
   use the name of the module as a prefix. One can also use "`:export true`"
   to re-export the imported symbols. If "`:exit true`" is given as an argument,
   any errors encountered at the top level in the module will cause `(os/exit 1)`
-  to be called. Dynamic bindings will NOT be imported. Use :fresh to bypass the
-  module cache. Use `:only [foo bar baz]` to only import select bindings into the
-  current environment.``
+  to be called. Dynamic bindings will NOT be imported. Use :fresh with a truthy
+  value to bypass the module cache. Use `:only [foo bar baz]` to only import
+  select bindings into the current environment.``
   [path & args]
+  (assertf (even? (length args)) "args should have even length: %n" args)
   (def ps (partition 2 args))
-  (def argm (mapcat (fn [[k v]] [k (case k :as (string v) :only ~(quote ,v) v)]) ps))
+  (def argm
+    (mapcat (fn [[k v]]
+              (assertf (keyword? k) "expected keyword, got %s: %n" (type k) k)
+              [k (case k :as (string v) :only ~(quote ,v) v)])
+            ps))
   (tuple import* (string path) ;argm))
 
 (defmacro use
@@ -3247,12 +3254,10 @@
   # Terminal codes for emission/tokenization
   (def delimiters
     (if has-color
-      {:underline ["\e[4m" "\e[24m"]
-       :code ["\e[97m" "\e[39m"]
+      {:code ["\e[97m" "\e[39m"]
        :italics ["\e[4m" "\e[24m"]
        :bold ["\e[1m" "\e[22m"]}
-      {:underline ["_" "_"]
-       :code ["`" "`"]
+      {:code ["`" "`"]
        :italics ["*" "*"]
        :bold ["**" "**"]}))
   (def modes @{})
@@ -3383,7 +3388,6 @@
           (= b (chr `\`)) (do
                             (++ token-length)
                             (buffer/push token (get line (++ i))))
-          (= b (chr "_")) (delim :underline)
           (= b (chr "*"))
           (if (= (chr "*") (get line (+ i 1)))
             (do (++ i)
@@ -3915,8 +3919,14 @@
 
 (compwhen (dyn 'net/listen)
   (defn net/server
-    "Start a server asynchronously with `net/listen` and `net/accept-loop`. Returns the new server stream."
+    ``
+    Starts a server with `net/listen`. Runs `net/accept-loop` asynchronously if
+    `handler` is set and `type` is `:stream` (the default). It is invalid to set
+    `handler` if `type` is `:datagram`. Returns the new server stream.
+    ``
     [host port &opt handler type no-reuse]
+    (assert (not (and (= type :datagram) handler))
+            "handler not supported for :datagram servers")
     (def s (net/listen host port type no-reuse))
     (if handler
       (ev/go (fn [] (net/accept-loop s handler))))
@@ -4295,20 +4305,14 @@
     "Install a bundle from the local filesystem. The name of the bundle will be inferred from the bundle, or passed as a parameter :name in `config`."
     [path &keys config]
     (def path (bundle-rpath path))
-    (def clean (get config :clean))
-    (def check (get config :check))
     (def s (sep))
-    # Check meta file for dependencies and default name
-    (def infofile-pre-1 (string path s "bundle" s "info.jdn"))
-    (def infofile-pre (if (fexists infofile-pre-1) infofile-pre-1 (string path s "info.jdn"))) # allow for alias
-    (var default-bundle-name nil)
-    (when (os/stat infofile-pre :mode)
-      (def info (-> infofile-pre slurp parse))
-      (def deps (get info :dependencies @[]))
-      (set default-bundle-name (get info :name))
-      (def missing (seq [d :in deps :when (not (bundle/installed? d))] (string d)))
-      (when (next missing) (errorf "missing dependencies %s" (string/join missing ", "))))
-    (def bundle-name (get config :name default-bundle-name))
+    # Detect bundle name
+    (def infofile-src1 (string path s "bundle" s "info.jdn"))
+    (def infofile-src2 (string path s "info.jdn"))
+    (def infofile-src (cond (fexists infofile-src1) infofile-src1
+                            (fexists infofile-src2) infofile-src2))
+    (def info (-?> infofile-src slurp parse))
+    (def bundle-name (get config :name (get info :name)))
     (assertf bundle-name "unable to infer bundle name for %v, use :name argument" path)
     (assertf (not (string/check-set "\\/" bundle-name))
              "bundle name %v cannot contain path separators" bundle-name)
@@ -4318,28 +4322,32 @@
     # Setup installed paths
     (prime-bundle-paths)
     (os/mkdir (bundle-dir bundle-name))
-    # Aliases for common bundle/ files
-    (def bundle.janet (string path s "bundle.janet"))
-    (when (fexists bundle.janet) (copyfile bundle.janet (bundle-file bundle-name "init.janet")))
-    (when (fexists infofile-pre) (copyfile infofile-pre (bundle-file bundle-name "info.jdn")))
+    # Copy infofile
+    (def infofile-dest (bundle-file bundle-name "info.jdn"))
+    (when infofile-src (copyfile infofile-src infofile-dest))
+    # Copy aliased initfile
+    (def initfile-alias (string path s "bundle.janet"))
+    (def initfile-dest (bundle-file bundle-name "init.janet"))
+    (when (fexists initfile-alias) (copyfile initfile-alias initfile-dest))
     # Copy some files into the new location unconditionally
     (def implicit-sources (string path s "bundle"))
     (when (= :directory (os/stat implicit-sources :mode))
       (copyrf implicit-sources (bundle-dir bundle-name)))
     (def man @{:name bundle-name :local-source path :files @[]})
     (merge-into man config)
-    (def infofile (bundle-file bundle-name "info.jdn"))
-    (put man :auto-remove (get config :auto-remove))
     (sync-manifest man)
     (edefer (do (print "installation error, uninstalling") (bundle/uninstall bundle-name))
-      (when (os/stat infofile :mode)
-        (def info (-> infofile slurp parse))
-        (def deps (get info :dependencies @[]))
+      (when (os/stat infofile-dest :mode)
+        (def info (-> infofile-dest slurp parse))
+        (def deps (seq [d :in (get info :dependencies @[])]
+                   (string (if (dictionary? d) (get d :name) d))))
         (def missing (filter (complement bundle/installed?) deps))
         (when (next missing)
           (error (string "missing dependencies " (string/join missing ", "))))
         (put man :dependencies deps)
         (put man :info info))
+      (def clean (get config :clean))
+      (def check (get config :check))
       (def module (get-bundle-module bundle-name))
       (def all-hooks (seq [[k v] :pairs module :when (symbol? k) :unless (get v :private)] (keyword k)))
       (put man :hooks all-hooks)
@@ -4482,8 +4490,10 @@
       (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]
     (def s (sep))
     (default dest (last (string/split s src)))
@@ -4628,7 +4638,7 @@
                --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
+               --prune (-P)            : Uninstall all bundles that are orphaned
                --list (-L)             : List all installed bundles
                --                      : Stop handling options
              ```)

src/conf/janetconf.h

@@ -4,15 +4,16 @@
 #define JANETCONF_H
 
 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 38
+#define JANET_VERSION_MINOR 40
 #define JANET_VERSION_PATCH 0
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.38.0"
+#define JANET_VERSION "1.40.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"))) */

src/core/abstract.c

@@ -88,7 +88,7 @@ void *janet_abstract_threaded(const JanetAbstractType *atype, size_t size) {
 #ifdef JANET_WINDOWS
 
 size_t janet_os_mutex_size(void) {
-    return sizeof(CRITICAL_SECTION);
+    return sizeof(SRWLOCK);
 }
 
 size_t janet_os_rwlock_size(void) {
@@ -96,20 +96,20 @@ size_t janet_os_rwlock_size(void) {
 }
 
 void janet_os_mutex_init(JanetOSMutex *mutex) {
-    InitializeCriticalSection((CRITICAL_SECTION *) mutex);
+    InitializeSRWLock((PSRWLOCK) mutex);
 }
 
 void janet_os_mutex_deinit(JanetOSMutex *mutex) {
-    DeleteCriticalSection((CRITICAL_SECTION *) mutex);
+    /* no op? */
+    (void) mutex;
 }
 
 void janet_os_mutex_lock(JanetOSMutex *mutex) {
-    EnterCriticalSection((CRITICAL_SECTION *) mutex);
+    AcquireSRWLockExclusive((PSRWLOCK) mutex);
 }
 
 void janet_os_mutex_unlock(JanetOSMutex *mutex) {
-    /* error handling? May want to keep counter */
-    LeaveCriticalSection((CRITICAL_SECTION *) mutex);
+    ReleaseSRWLockExclusive((PSRWLOCK) mutex);
 }
 
 void janet_os_rwlock_init(JanetOSRWLock *rwlock) {

src/core/capi.c

@@ -589,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) {

src/core/corelib.c

@@ -66,7 +66,7 @@ JanetModule janet_native(const char *name, const uint8_t **error) {
     JanetBuildConfig modconf = getter();
     JanetBuildConfig host = janet_config_current();
     if (host.major != modconf.major ||
-            host.minor < modconf.minor ||
+            host.minor != modconf.minor ||
             host.bits != modconf.bits) {
         char errbuf[128];
         snprintf(errbuf, sizeof(errbuf), "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x)",
@@ -653,22 +653,15 @@ JANET_CORE_FN(janet_core_check_int,
               "(int? x)",
               "Check if x can be exactly represented as a 32 bit signed two's complement integer.") {
     janet_fixarity(argc, 1);
-    if (!janet_checktype(argv[0], JANET_NUMBER)) goto ret_false;
-    double num = janet_unwrap_number(argv[0]);
-    return janet_wrap_boolean(num == (double)((int32_t)num));
-ret_false:
-    return janet_wrap_false();
+    return janet_wrap_boolean(janet_checkint(argv[0]));
 }
 
 JANET_CORE_FN(janet_core_check_nat,
               "(nat? x)",
               "Check if x can be exactly represented as a non-negative 32 bit signed two's complement integer.") {
     janet_fixarity(argc, 1);
-    if (!janet_checktype(argv[0], JANET_NUMBER)) goto ret_false;
-    double num = janet_unwrap_number(argv[0]);
-    return janet_wrap_boolean(num >= 0 && (num == (double)((int32_t)num)));
-ret_false:
-    return janet_wrap_false();
+    if (!janet_checkint(argv[0])) return janet_wrap_false();
+    return janet_wrap_boolean(janet_unwrap_integer(argv[0]) >= 0);
 }
 
 JANET_CORE_FN(janet_core_is_bytes,

src/core/ev.c

@@ -83,7 +83,7 @@ struct JanetChannel {
     int closed;
     int is_threaded;
 #ifdef JANET_WINDOWS
-    CRITICAL_SECTION lock;
+    SRWLOCK lock;
 #else
     pthread_mutex_t lock;
 #endif
@@ -353,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;
@@ -603,8 +604,44 @@ void janet_ev_init_common(void) {
 #endif
 }
 
+#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 handle_timeout_worker(JanetTimeout to, int cancel) {
+    if (!to.has_worker) return;
+#ifdef JANET_WINDOWS
+    (void) cancel;
+    QueueUserAPC(janet_timeout_stop, to.worker, 0);
+    WaitForSingleObject(to.worker, INFINITE);
+    CloseHandle(to.worker);
+#else
+#ifdef JANET_ANDROID
+    if (cancel) janet_assert(!pthread_kill(to.worker, SIGUSR1), "pthread_kill");
+#else
+    if (cancel) janet_assert(!pthread_cancel(to.worker), "pthread_cancel");
+#endif
+    void *res = NULL;
+    janet_assert(!pthread_join(to.worker, &res), "pthread_join");
+#endif
+}
+
 /* Common deinit code */
 void janet_ev_deinit_common(void) {
+    JanetTimeout to;
+    while (peek_timeout(&to)) {
+        handle_timeout_worker(to, 1);
+        pop_timeout(0);
+    }
     janet_q_deinit(&janet_vm.spawn);
     janet_free(janet_vm.tq);
     janet_table_deinit(&janet_vm.threaded_abstracts);
@@ -647,13 +684,6 @@ void janet_addtimeout_nil(double sec) {
     add_timeout(to);
 }
 
-#ifdef JANET_WINDOWS
-static VOID CALLBACK janet_timeout_stop(ULONG_PTR ptr) {
-    UNREFERENCED_PARAMETER(ptr);
-    ExitThread(0);
-}
-#endif
-
 static void janet_timeout_cb(JanetEVGenericMessage msg) {
     (void) msg;
     janet_interpreter_interrupt_handled(&janet_vm);
@@ -664,15 +694,21 @@ 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);
-    }
+    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;
@@ -681,11 +717,9 @@ static void *janet_timeout_body(void *ptr) {
                  ? (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);
-    }
+    janet_interpreter_interrupt(tto.vm);
+    JanetEVGenericMessage msg = {0};
+    janet_ev_post_event(tto.vm, janet_timeout_cb, msg);
     return NULL;
 }
 #endif
@@ -805,6 +839,34 @@ static int janet_chanat_gc(void *p, size_t s) {
     return 0;
 }
 
+static void janet_chanat_remove_vmref(JanetQueue *fq) {
+    JanetChannelPending *pending = fq->data;
+    if (fq->head <= fq->tail) {
+        for (int32_t i = fq->head; i < fq->tail; i++) {
+            if (pending[i].thread == &janet_vm) pending[i].thread = NULL;
+        }
+    } else {
+        for (int32_t i = fq->head; i < fq->capacity; i++) {
+            if (pending[i].thread == &janet_vm) pending[i].thread = NULL;
+        }
+        for (int32_t i = 0; i < fq->tail; i++) {
+            if (pending[i].thread == &janet_vm) pending[i].thread = NULL;
+        }
+    }
+}
+
+static int janet_chanat_gcperthread(void *p, size_t s) {
+    (void) s;
+    JanetChannel *chan = p;
+    janet_chan_lock(chan);
+    /* Make sure that the internals of the threaded channel no longer reference _this_ thread. Replace
+     * those references with NULL. */
+    janet_chanat_remove_vmref(&chan->read_pending);
+    janet_chanat_remove_vmref(&chan->write_pending);
+    janet_chan_unlock(chan);
+    return 0;
+}
+
 static void janet_chanat_mark_fq(JanetQueue *fq) {
     JanetChannelPending *pending = fq->data;
     if (fq->head <= fq->tail) {
@@ -887,8 +949,9 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
         int is_read = (mode == JANET_CP_MODE_CHOICE_READ) || (mode == JANET_CP_MODE_READ);
         if (is_read) {
             JanetChannelPending reader;
-            if (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) {
+            while (!janet_q_pop(&channel->read_pending, &reader, sizeof(reader))) {
                 JanetVM *vm = reader.thread;
+                if (!vm) continue;
                 JanetEVGenericMessage msg;
                 msg.tag = reader.mode;
                 msg.fiber = reader.fiber;
@@ -896,11 +959,13 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
                 msg.argp = channel;
                 msg.argj = x;
                 janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+                break;
             }
         } else {
             JanetChannelPending writer;
-            if (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) {
+            while (!janet_q_pop(&channel->write_pending, &writer, sizeof(writer))) {
                 JanetVM *vm = writer.thread;
+                if (!vm) continue;
                 JanetEVGenericMessage msg;
                 msg.tag = writer.mode;
                 msg.fiber = writer.fiber;
@@ -908,6 +973,7 @@ static void janet_thread_chan_cb(JanetEVGenericMessage msg) {
                 msg.argp = channel;
                 msg.argj = janet_wrap_nil();
                 janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+                break;
             }
         }
     }
@@ -971,7 +1037,9 @@ static int janet_channel_push_with_lock(JanetChannel *channel, Janet x, int mode
             msg.argi = (int32_t) reader.sched_id;
             msg.argp = channel;
             msg.argj = x;
-            janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+            if (vm) {
+                janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+            }
         } else {
             if (reader.mode == JANET_CP_MODE_CHOICE_READ) {
                 janet_schedule(reader.fiber, make_read_result(channel, x));
@@ -1026,7 +1094,9 @@ static int janet_channel_pop_with_lock(JanetChannel *channel, Janet *item, int i
             msg.argi = (int32_t) writer.sched_id;
             msg.argp = channel;
             msg.argj = janet_wrap_nil();
-            janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+            if (vm) {
+                janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+            }
         } else {
             if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) {
                 janet_schedule(writer.fiber, make_write_result(channel));
@@ -1290,7 +1360,9 @@ JANET_CORE_FN(cfun_channel_close,
                 msg.tag = JANET_CP_MODE_CLOSE;
                 msg.argi = (int32_t) writer.sched_id;
                 msg.argj = janet_wrap_nil();
-                janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+                if (vm) {
+                    janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+                }
             } else {
                 if (janet_fiber_can_resume(writer.fiber)) {
                     if (writer.mode == JANET_CP_MODE_CHOICE_WRITE) {
@@ -1311,7 +1383,9 @@ JANET_CORE_FN(cfun_channel_close,
                 msg.tag = JANET_CP_MODE_CLOSE;
                 msg.argi = (int32_t) reader.sched_id;
                 msg.argj = janet_wrap_nil();
-                janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+                if (vm) {
+                    janet_ev_post_event(vm, janet_thread_chan_cb, msg);
+                }
             } else {
                 if (janet_fiber_can_resume(reader.fiber)) {
                     if (reader.mode == JANET_CP_MODE_CHOICE_READ) {
@@ -1404,7 +1478,10 @@ const JanetAbstractType janet_channel_type = {
     NULL, /* compare */
     NULL, /* hash */
     janet_chanat_next,
-    JANET_ATEND_NEXT
+    NULL, /* call */
+    NULL, /* length */
+    NULL, /* bytes */
+    janet_chanat_gcperthread
 };
 
 /* Main event loop */
@@ -1437,12 +1514,13 @@ JanetFiber *janet_loop1(void) {
                 }
             }
         }
+        handle_timeout_worker(to, 0);
     }
 
     /* 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();
@@ -1484,23 +1562,14 @@ 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
-                        pthread_cancel(to.worker);
-                        void *res;
-                        pthread_join(to.worker, &res);
-#endif
-                    }
-                    janet_table_remove(&janet_vm.active_tasks, janet_wrap_fiber(to.curr_fiber));
                     pop_timeout(0);
+                    janet_table_remove(&janet_vm.active_tasks, janet_wrap_fiber(to.curr_fiber));
+                    handle_timeout_worker(to, 1);
                     continue;
                 }
             } else if (to.fiber->sched_id != to.sched_id) {
                 pop_timeout(0);
+                handle_timeout_worker(to, 1);
                 continue;
             }
             break;
@@ -1665,7 +1734,7 @@ void janet_stream_level_triggered(JanetStream *stream) {
 
 static JanetTimestamp ts_now(void) {
     struct timespec now;
-    janet_assert(-1 != clock_gettime(CLOCK_MONOTONIC, &now), "failed to get time");
+    janet_assert(-1 != janet_gettime(&now, JANET_TIME_MONOTONIC), "failed to get time");
     uint64_t res = 1000 * now.tv_sec;
     res += now.tv_nsec / 1000000;
     return res;
@@ -1823,7 +1892,7 @@ JanetTimestamp to_interval(const JanetTimestamp ts) {
 
 static JanetTimestamp ts_now(void) {
     struct timespec now;
-    janet_assert(-1 != clock_gettime(CLOCK_MONOTONIC, &now), "failed to get time");
+    janet_assert(-1 != janet_gettime(&now, JANET_TIME_MONOTONIC), "failed to get time");
     uint64_t res = 1000 * now.tv_sec;
     res += now.tv_nsec / 1000000;
     return res;
@@ -1977,7 +2046,7 @@ void janet_ev_deinit(void) {
 
 static JanetTimestamp ts_now(void) {
     struct timespec now;
-    janet_assert(-1 != clock_gettime(CLOCK_REALTIME, &now), "failed to get time");
+    janet_assert(-1 != janet_gettime(&now, JANET_TIME_MONOTONIC), "failed to get time");
     uint64_t res = 1000 * now.tv_sec;
     res += now.tv_nsec / 1000000;
     return res;
@@ -2149,7 +2218,7 @@ void janet_ev_post_event(JanetVM *vm, JanetCallback cb, JanetEVGenericMessage ms
     event.cb = cb;
     int fd = vm->selfpipe[1];
     /* handle a bit of back pressure before giving up. */
-    int tries = 4;
+    int tries = 20;
     while (tries > 0) {
         int status;
         do {
@@ -2996,7 +3065,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;
@@ -3154,6 +3224,7 @@ JANET_NO_RETURN void janet_sleep_await(double sec) {
     to.is_error = 0;
     to.sched_id = to.fiber->sched_id;
     to.curr_fiber = NULL;
+    to.has_worker = 0;
     add_timeout(to);
     janet_await();
 }
@@ -3188,6 +3259,9 @@ JANET_CORE_FN(cfun_ev_deadline,
     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;
@@ -3505,8 +3579,6 @@ void janet_lib_ev(JanetTable *env) {
     janet_register_abstract_type(&janet_channel_type);
     janet_register_abstract_type(&janet_mutex_type);
     janet_register_abstract_type(&janet_rwlock_type);
-
-    janet_lib_filewatch(env);
 }
 
 #endif

src/core/filewatch.c

@@ -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"
@@ -633,7 +633,7 @@ JANET_CORE_FN(cfun_filewatch_add,
               "* `:modified`\n\n"
               "* `:renamed-old`\n\n"
               "* `:renamed-new`\n\n"
-              "On Linux, events will a `:type` corresponding to the possible flags, excluding `:all`.\n"
+              "On Linux, events will have a `:type` corresponding to the possible flags, excluding `:all`.\n"
               "") {
     janet_arity(argc, 2, -1);
     JanetWatcher *watcher = janet_getabstract(argv, 0, &janet_filewatch_at);

src/core/gc.c

@@ -346,6 +346,9 @@ static void janet_deinit_block(JanetGCObject *mem) {
             break;
         case JANET_MEMORY_ABSTRACT: {
             JanetAbstractHead *head = (JanetAbstractHead *)mem;
+            if (head->type->gcperthread) {
+                janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed");
+            }
             if (head->type->gc) {
                 janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
             }
@@ -497,9 +500,12 @@ void janet_sweep() {
             /* If not visited... */
             if (!janet_truthy(items[i].value)) {
                 void *abst = janet_unwrap_abstract(items[i].key);
+                JanetAbstractHead *head = janet_abstract_head(abst);
+                if (head->type->gcperthread) {
+                    janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed");
+                }
                 if (0 == janet_abstract_decref(abst)) {
                     /* Run finalizer */
-                    JanetAbstractHead *head = janet_abstract_head(abst);
                     if (head->type->gc) {
                         janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
                     }
@@ -672,8 +678,11 @@ void janet_clear_memory(void) {
     for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
         if (janet_checktype(items[i].key, JANET_ABSTRACT)) {
             void *abst = janet_unwrap_abstract(items[i].key);
+            JanetAbstractHead *head = janet_abstract_head(abst);
+            if (head->type->gcperthread) {
+                janet_assert(!head->type->gcperthread(head->data, head->size), "per-thread finalizer failed");
+            }
             if (0 == janet_abstract_decref(abst)) {
-                JanetAbstractHead *head = janet_abstract_head(abst);
                 if (head->type->gc) {
                     janet_assert(!head->type->gc(head->data, head->size), "finalizer failed");
                 }

src/core/net.c

@@ -341,7 +341,7 @@ static int janet_get_sockettype(Janet *argv, int32_t argc, int32_t n) {
 /* Needs argc >= offset + 2 */
 /* For unix paths, just rertuns a single sockaddr and sets *is_unix to 1,
  * otherwise 0. Also, ignores is_bind when is a unix socket. */
-static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int socktype, int passive, int *is_unix) {
+static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int socktype, int passive, int *is_unix, socklen_t *sizeout) {
     /* Unix socket support - not yet supported on windows. */
 #ifndef JANET_WINDOWS
     if (janet_keyeq(argv[offset], "unix")) {
@@ -352,15 +352,14 @@ static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int sock
         }
         saddr->sun_family = AF_UNIX;
         size_t path_size = sizeof(saddr->sun_path);
+        snprintf(saddr->sun_path, path_size, "%s", path);
+        *sizeout = sizeof(struct sockaddr_un);
 #ifdef JANET_LINUX
         if (path[0] == '@') {
             saddr->sun_path[0] = '\0';
-            snprintf(saddr->sun_path + 1, path_size - 1, "%s", path + 1);
-        } else
-#endif
-        {
-            snprintf(saddr->sun_path, path_size, "%s", path);
+            *sizeout = offsetof(struct sockaddr_un, sun_path) + janet_string_length(path);
         }
+#endif
         *is_unix = 1;
         return (struct addrinfo *) saddr;
     }
@@ -385,6 +384,11 @@ static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int sock
         janet_panicf("could not get address info: %s", gai_strerror(status));
     }
     *is_unix = 0;
+#ifdef JANET_WINDOWS
+    *sizeout = 0;
+#else
+    *sizeout = sizeof(struct sockaddr_un);
+#endif
     return ai;
 }
 
@@ -405,12 +409,13 @@ JANET_CORE_FN(cfun_net_sockaddr,
     int socktype = janet_get_sockettype(argv, argc, 2);
     int is_unix = 0;
     int make_arr = (argc >= 3 && janet_truthy(argv[3]));
-    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix);
+    socklen_t addrsize = 0;
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix, &addrsize);
 #ifndef JANET_WINDOWS
     /* no unix domain socket support on windows yet */
     if (is_unix) {
-        void *abst = janet_abstract(&janet_address_type, sizeof(struct sockaddr_un));
-        memcpy(abst, ai, sizeof(struct sockaddr_un));
+        void *abst = janet_abstract(&janet_address_type, addrsize);
+        memcpy(abst, ai, addrsize);
         Janet ret = janet_wrap_abstract(abst);
         return make_arr ? janet_wrap_array(janet_array_n(&ret, 1)) : ret;
     }
@@ -461,7 +466,8 @@ JANET_CORE_FN(cfun_net_connect,
     }
 
     /* Where we're connecting to */
-    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix);
+    socklen_t addrlen = 0;
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix, &addrlen);
 
     /* Check if we're binding address */
     struct addrinfo *binding = NULL;
@@ -486,7 +492,6 @@ JANET_CORE_FN(cfun_net_connect,
     /* Create socket */
     JSock sock = JSOCKDEFAULT;
     void *addr = NULL;
-    socklen_t addrlen = 0;
 #ifndef JANET_WINDOWS
     if (is_unix) {
         sock = socket(AF_UNIX, socktype | JSOCKFLAGS, 0);
@@ -496,7 +501,6 @@ JANET_CORE_FN(cfun_net_connect,
             janet_panicf("could not create socket: %V", v);
         }
         addr = (void *) ai;
-        addrlen = sizeof(struct sockaddr_un);
     } else
 #endif
     {
@@ -543,7 +547,9 @@ JANET_CORE_FN(cfun_net_connect,
     }
 
     /* Wrap socket in abstract type JanetStream */
-    JanetStream *stream = make_stream(sock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE);
+    uint32_t udp_flag = 0;
+    if (socktype == SOCK_DGRAM) udp_flag = JANET_STREAM_UDPSERVER;
+    JanetStream *stream = make_stream(sock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE | udp_flag);
 
     /* Set up the socket for non-blocking IO before connecting */
     janet_net_socknoblock(sock);
@@ -581,6 +587,56 @@ JANET_CORE_FN(cfun_net_connect,
     net_sched_connect(stream);
 }
 
+JANET_CORE_FN(cfun_net_socket,
+              "(net/socket &opt type)",
+              "Creates a new unbound socket. Type is an optional keyword, "
+              "either a :stream (usually tcp), or :datagram (usually udp). The default is :stream.") {
+    janet_arity(argc, 0, 1);
+
+    int socktype = janet_get_sockettype(argv, argc, 0);
+
+    /* Create socket */
+    JSock sfd = JSOCKDEFAULT;
+    struct addrinfo *ai = NULL;
+    struct addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_UNSPEC;
+    hints.ai_socktype = socktype;
+    hints.ai_flags = 0;
+    int status = getaddrinfo(NULL, "0", &hints, &ai);
+    if (status) {
+        janet_panicf("could not get address info: %s", gai_strerror(status));
+    }
+
+    struct addrinfo *rp = NULL;
+    for (rp = ai; rp != NULL; rp = rp->ai_next) {
+#ifdef JANET_WINDOWS
+        sfd = WSASocketW(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol, NULL, 0, WSA_FLAG_OVERLAPPED);
+#else
+        sfd = socket(rp->ai_family, rp->ai_socktype | JSOCKFLAGS, rp->ai_protocol);
+#endif
+        if (JSOCKVALID(sfd)) {
+            break;
+        }
+    }
+    freeaddrinfo(ai);
+
+    if (!JSOCKVALID(sfd)) {
+        Janet v = janet_ev_lasterr();
+        janet_panicf("could not create socket: %V", v);
+    }
+
+    /* Wrap socket in abstract type JanetStream */
+    uint32_t udp_flag = 0;
+    if (socktype == SOCK_DGRAM) udp_flag = JANET_STREAM_UDPSERVER;
+    JanetStream *stream = make_stream(sfd, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE | udp_flag);
+
+    /* Set up the socket for non-blocking IO */
+    janet_net_socknoblock(sfd);
+
+    return janet_wrap_abstract(stream);
+}
+
 static const char *serverify_socket(JSock sfd, int reuse_addr, int reuse_port) {
     /* Set various socket options */
     int enable = 1;
@@ -657,14 +713,15 @@ 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);
 
     /* Get host, port, and handler*/
     int socktype = janet_get_sockettype(argv, argc, 2);
     int is_unix = 0;
-    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 1, &is_unix);
+    socklen_t addrlen = 0;
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 1, &is_unix, &addrlen);
     int reuse = !(argc >= 4 && janet_truthy(argv[3]));
 
     JSock sfd = JSOCKDEFAULT;
@@ -676,7 +733,7 @@ JANET_CORE_FN(cfun_net_listen,
             janet_panicf("could not create socket: %V", janet_ev_lasterr());
         }
         const char *err = serverify_socket(sfd, reuse, 0);
-        if (NULL != err || bind(sfd, (struct sockaddr *)ai, sizeof(struct sockaddr_un))) {
+        if (NULL != err || bind(sfd, (struct sockaddr *)ai, addrlen)) {
             JSOCKCLOSE(sfd);
             janet_free(ai);
             if (err) {
@@ -1078,6 +1135,7 @@ void janet_lib_net(JanetTable *env) {
     JanetRegExt net_cfuns[] = {
         JANET_CORE_REG("net/address", cfun_net_sockaddr),
         JANET_CORE_REG("net/listen", cfun_net_listen),
+        JANET_CORE_REG("net/socket", cfun_net_socket),
         JANET_CORE_REG("net/accept", cfun_stream_accept),
         JANET_CORE_REG("net/accept-loop", cfun_stream_accept_loop),
         JANET_CORE_REG("net/read", cfun_stream_read),

src/core/os.c

@@ -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>
@@ -65,6 +66,7 @@
 #ifdef JANET_APPLE
 #include <crt_externs.h>
 #define environ (*_NSGetEnviron())
+#include <AvailabilityMacros.h>
 #else
 extern char **environ;
 #endif
@@ -73,6 +75,26 @@ 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)
+/* The posix_spawn_file_actions_addchdir_np function
+ * has only been implemented since macOS 10.15 */
+#if defined(MAC_OS_X_VERSION_10_15) && (MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_15)
+#define JANET_SPAWN_CHDIR
+#else
+#define JANET_SPAWN_NO_CHDIR
+#endif
+#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);
@@ -158,6 +180,8 @@ JANET_CORE_FN(os_which,
     return janet_ckeywordv("dragonfly");
 #elif defined(JANET_BSD)
     return janet_ckeywordv("bsd");
+#elif defined(JANET_ILLUMOS)
+    return janet_ckeywordv("illumos");
 #else
     return janet_ckeywordv("posix");
 #endif
@@ -297,6 +321,13 @@ JANET_CORE_FN(os_cpu_count,
         return dflt;
     }
     return janet_wrap_integer(result);
+#elif defined(JANET_ILLUMOS)
+    (void) dflt;
+    long result = sysconf(_SC_NPROCESSORS_CONF);
+    if (result < 0) {
+        return dflt;
+    }
+    return janet_wrap_integer(result);
 #else
     return dflt;
 #endif
@@ -1182,6 +1213,21 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
         }
     }
 
+    /* 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);
@@ -1196,6 +1242,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));
@@ -1212,6 +1259,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) {
@@ -1219,7 +1270,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) {
@@ -1227,7 +1278,7 @@ 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) {
@@ -1237,7 +1288,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     } 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;
@@ -1248,7 +1299,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;
@@ -1305,6 +1356,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);
@@ -2819,6 +2879,9 @@ void janet_lib_os(JanetTable *env) {
         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),
+#ifdef JANET_EV
+        JANET_CORE_REG("os/sigaction", os_sigaction),
+#endif
 #endif
 
         /* high resolution timers */
@@ -2827,7 +2890,6 @@ void janet_lib_os(JanetTable *env) {
 #ifdef JANET_EV
         JANET_CORE_REG("os/open", os_open), /* fs read and write */
         JANET_CORE_REG("os/pipe", os_pipe),
-        JANET_CORE_REG("os/sigaction", os_sigaction),
 #endif
 #endif
         JANET_REG_END

src/core/pp.c

@@ -1060,19 +1060,11 @@ void janet_buffer_format(
                     break;
                 }
                 case 's': {
-                    JanetByteView bytes = janet_getbytes(argv, arg);
-                    const uint8_t *s = bytes.bytes;
-                    int32_t l = bytes.len;
+                    const char *s = janet_getcbytes(argv, arg);
                     if (form[2] == '\0')
-                        janet_buffer_push_bytes(b, s, l);
+                        janet_buffer_push_cstring(b, s);
                     else {
-                        if (l != (int32_t) strlen((const char *) s))
-                            janet_panic("string contains zeros");
-                        if (!strchr(form, '.') && l >= 100) {
-                            janet_panic("no precision and string is too long to be formatted");
-                        } else {
-                            nb = snprintf(item, MAX_ITEM, form, s);
-                        }
+                        nb = snprintf(item, MAX_ITEM, form, s);
                     }
                     break;
                 }

src/core/run.c

@@ -26,7 +26,8 @@
 #include "state.h"
 #endif
 
-/* Run a string */
+/* Run a string of code. The return value is a set of error flags, JANET_DO_ERROR_RUNTIME, JANET_DO_ERROR_COMPILE, and JANET_DOR_ERROR_PARSE if
+ * any errors were encountered in those phases. More information is printed to stderr. */
 int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out) {
     JanetParser *parser;
     int errflags = 0, done = 0;
@@ -55,7 +56,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                 JanetSignal status = janet_continue(fiber, janet_wrap_nil(), &ret);
                 if (status != JANET_SIGNAL_OK && status != JANET_SIGNAL_EVENT) {
                     janet_stacktrace_ext(fiber, ret, "");
-                    errflags |= 0x01;
+                    errflags |= JANET_DO_ERROR_RUNTIME;
                     done = 1;
                 }
             } else {
@@ -75,7 +76,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                     janet_eprintf("%s:%d:%d: compile error: %s\n", sourcePath,
                                   line, col, (const char *)cres.error);
                 }
-                errflags |= 0x02;
+                errflags |= JANET_DO_ERROR_COMPILE;
                 done = 1;
             }
         }
@@ -89,7 +90,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
                 break;
             case JANET_PARSE_ERROR: {
                 const char *e = janet_parser_error(parser);
-                errflags |= 0x04;
+                errflags |= JANET_DO_ERROR_PARSE;
                 ret = janet_cstringv(e);
                 int32_t line = (int32_t) parser->line;
                 int32_t col = (int32_t) parser->column;

src/core/state.h

@@ -23,8 +23,11 @@
 #ifndef JANET_STATE_H_defined
 #define JANET_STATE_H_defined
 
+#ifndef JANET_AMALG
+#include "features.h"
 #include <janet.h>
 #include <stdint.h>
+#endif
 
 #ifdef JANET_EV
 #ifdef JANET_WINDOWS

src/core/util.c

@@ -931,27 +931,24 @@ int janet_gettime(struct timespec *spec, enum JanetTimeSource source) {
 #include <mach/clock.h>
 #include <mach/mach.h>
 int janet_gettime(struct timespec *spec, enum JanetTimeSource source) {
-    if (source == JANET_TIME_REALTIME) {
+    if (source == JANET_TIME_CPUTIME) {
+        clock_t tmp = clock();
+        spec->tv_sec = tmp / CLOCKS_PER_SEC;
+        spec->tv_nsec = ((tmp - (spec->tv_sec * CLOCKS_PER_SEC)) * 1000000000) / CLOCKS_PER_SEC;
+    } else {
         clock_serv_t cclock;
         mach_timespec_t mts;
-        host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+        clock_id_t cid = CALENDAR_CLOCK;
+        if (source == JANET_TIME_REALTIME) {
+            cid = CALENDAR_CLOCK;
+        } else if (source == JANET_TIME_MONOTONIC) {
+            cid = SYSTEM_CLOCK;
+        }
+        host_get_clock_service(mach_host_self(), cid, &cclock);
         clock_get_time(cclock, &mts);
         mach_port_deallocate(mach_task_self(), cclock);
         spec->tv_sec = mts.tv_sec;
         spec->tv_nsec = mts.tv_nsec;
-    } else if (source == JANET_TIME_MONOTONIC) {
-        clock_serv_t cclock;
-        int nsecs;
-        mach_msg_type_number_t count;
-        host_get_clock_service(mach_host_self(), clock, &cclock);
-        clock_get_attributes(cclock, CLOCK_GET_TIME_RES, (clock_attr_t)&nsecs, &count);
-        mach_port_deallocate(mach_task_self(), cclock);
-        clock_getres(CLOCK_MONOTONIC, spec);
-    }
-    if (source == JANET_TIME_CPUTIME) {
-        clock_t tmp = clock();
-        spec->tv_sec = tmp;
-        spec->tv_nsec = (tmp - spec->tv_sec) * 1.0e9;
     }
     return 0;
 }

src/core/vm.c

@@ -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()); \
     } \

src/include/janet.h

@@ -67,11 +67,21 @@ 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
 #endif
 
+/* Check for Illumos */
+#if defined(__illumos__)
+#define JANET_ILLUMOS 1
+#endif
+
 /* Check Unix */
 #if defined(_AIX) \
     || defined(__APPLE__) /* Darwin */ \
@@ -157,7 +167,7 @@ extern "C" {
 #endif
 
 /* Check sun */
-#ifdef __sun
+#if defined(__sun) && !defined(JANET_ILLUMOS)
 #define JANET_NO_UTC_MKTIME
 #endif
 
@@ -165,14 +175,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 +599,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 +672,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
@@ -1178,6 +1188,7 @@ struct JanetAbstractType {
     Janet(*call)(void *p, int32_t argc, Janet *argv);
     size_t (*length)(void *p, size_t len);
     JanetByteView(*bytes)(void *p, size_t len);
+    int (*gcperthread)(void *data, size_t len);
 };
 
 /* Some macros to let us add extra types to JanetAbstract types without
@@ -1197,7 +1208,8 @@ struct JanetAbstractType {
 #define JANET_ATEND_NEXT        NULL,JANET_ATEND_CALL
 #define JANET_ATEND_CALL        NULL,JANET_ATEND_LENGTH
 #define JANET_ATEND_LENGTH      NULL,JANET_ATEND_BYTES
-#define JANET_ATEND_BYTES
+#define JANET_ATEND_BYTES       NULL,JANET_ATEND_GCPERTHREAD
+#define JANET_ATEND_GCPERTHREAD
 
 struct JanetReg {
     const char *name;
@@ -1455,10 +1467,10 @@ JANET_API int32_t janet_abstract_incref(void *abst);
 JANET_API int32_t janet_abstract_decref(void *abst);
 
 /* Expose channel utilities */
-JanetChannel *janet_channel_make(uint32_t limit);
-JanetChannel *janet_channel_make_threaded(uint32_t limit);
-JanetChannel *janet_getchannel(const Janet *argv, int32_t n);
-JanetChannel *janet_optchannel(const Janet *argv, int32_t argc, int32_t n, JanetChannel *dflt);
+JANET_API JanetChannel *janet_channel_make(uint32_t limit);
+JANET_API JanetChannel *janet_channel_make_threaded(uint32_t limit);
+JANET_API JanetChannel *janet_getchannel(const Janet *argv, int32_t n);
+JANET_API JanetChannel *janet_optchannel(const Janet *argv, int32_t argc, int32_t n, JanetChannel *dflt);
 JANET_API int janet_channel_give(JanetChannel *channel, Janet x);
 JANET_API int janet_channel_take(JanetChannel *channel, Janet *out);
 
@@ -1606,6 +1618,9 @@ JANET_API JanetTable *janet_core_env(JanetTable *replacements);
 JANET_API JanetTable *janet_core_lookup_table(JanetTable *replacements);
 
 /* Execute strings */
+#define JANET_DO_ERROR_RUNTIME 0x01
+#define JANET_DO_ERROR_COMPILE 0x02
+#define JANET_DO_ERROR_PARSE 0x04
 JANET_API int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char *sourcePath, Janet *out);
 JANET_API int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out);
 

test/suite-boot.janet

@@ -865,6 +865,13 @@
 (assert (deep= ~(,import* "a" :as "b" :fresh maybe)
                (macex '(import a :as b :fresh maybe))) "import macro 2")
 
+# 2af3f21d
+(assert-error "import macro 2" (macex '(import a :fresh)))
+(assert-error "import macro 3" (macex '(import a :as b :fresh)))
+(assert-error "import macro 4" (macex '(import b "notakeyword" value)))
+(assert (deep= ~(,import* "a" :fresh nil)
+               (macex '(import a :fresh nil))) "import macro 5")
+
 # #477 walk preserving bracket type
 # 0a1d902f4
 (assert (= :brackets (tuple/type (postwalk identity '[])))

test/suite-ev.janet

@@ -106,6 +106,8 @@
       (calc-2 "(+ 9 10 11 12)"))
     @[10 26 42]) "parallel subprocesses 2")
 
+# (print "file piping")
+
 # File piping
 # a1cc5ca04
 (assert-no-error "file writing 1"
@@ -225,6 +227,8 @@
     (++ iterations)
     (ev/write stream " ")))
 
+# (print "local name / peer name testing")
+
 # Test localname and peername
 # 077bf5eba
 (repeat 10
@@ -407,6 +411,8 @@
         (while (def msg (ev/read connection 100))
           (broadcast name (string msg)))))))
 
+# (print "chat app testing")
+
 # Now launch the chat server
 (def chat-server (net/listen test-host test-port))
 (ev/spawn
@@ -500,6 +506,8 @@
                        (let [s (net/listen :unix uds-path :stream)]
                          (:close s))))))
 
+# (print "accept loop testing")
+
 # net/accept-loop level triggering
 (gccollect)
 (def maxconn 50)
@@ -522,6 +530,8 @@
 (assert (= maxconn connect-count))
 (:close s)
 
+# (print "running deadline tests...")
+
 # Cancel os/proc-wait with ev/deadline
 (let [p (os/spawn [;run janet "-e" "(os/sleep 4)"] :p)]
   (var terminated-normally false)
@@ -546,9 +556,35 @@
   (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)))
+# Deadline with interrupt
+(defmacro with-deadline2
+  ``
+  Create a fiber to execute `body`, schedule the event loop to cancel
+  the task (root fiber) associated with `body`'s fiber, and start
+  `body`'s fiber by resuming it.
+
+  The event loop will try to cancel the root fiber if `body`'s fiber
+  has not completed after at least `sec` seconds.
+
+  `sec` is a number that can have a fractional part.
+  ``
+  [sec & body]
+  (with-syms [f]
+    ~(let [,f (coro ,;body)]
+       (,ev/deadline ,sec nil ,f true)
+       (,resume ,f))))
+
+(for i 0 10
+  # (print "deadline 1 iteration " i)
+  (assert (= :done (with-deadline2 10
+                     (ev/sleep 0.01)
+                     :done)) "deadline with interrupt exits normally"))
+
+(for i 0 10
+  # (print "deadline 2 iteration " i)
+  (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)))

test/suite-ev2.janet

@@ -0,0 +1,58 @@
+# 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
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+
+(import ./helper :prefix "" :exit true)
+(start-suite)
+
+# Issue #1629
+(def thread-channel (ev/thread-chan 100))
+(def super (ev/thread-chan 10))
+(defn worker []
+  (while true
+    (def item (ev/take thread-channel))
+    (when (= item :deadline)
+      (ev/deadline 0.1 nil (fiber/current) true))))
+(ev/thread worker nil :n super)
+(ev/give thread-channel :item)
+(ev/sleep 0.05)
+(ev/give thread-channel :item)
+(ev/sleep 0.05)
+(ev/give thread-channel :deadline)
+(ev/sleep 0.05)
+(ev/give thread-channel :item)
+(ev/sleep 0.05)
+(ev/give thread-channel :item)
+(ev/sleep 0.15)
+(assert (deep= '(:error "deadline expired" nil) (ev/take super)) "deadline expirataion")
+
+# Another variant
+(def thread-channel (ev/thread-chan 100))
+(def super (ev/thread-chan 10))
+(defn worker []
+  (while true
+    (def item (ev/take thread-channel))
+    (when (= item :deadline)
+      (ev/deadline 0.1))))
+(ev/thread worker nil :n super)
+(ev/give thread-channel :deadline)
+(ev/sleep 0.2)
+(assert (deep= '(:error "deadline expired" nil) (ev/take super)) "deadline expirataion")
+
+(end-suite)

test/suite-string.janet

@@ -136,5 +136,8 @@
         "keyword slice")
 (assert (= 'symbol (symbol/slice "some_symbol_slice" 5 11)) "symbol slice")
 
+# Check string formatting, #1600
+(assert (= "" (string/format "%.99s" @"")) "string/format %s buffer")
+
 (end-suite)
 

tools/msi/janet.wxs

@@ -37,6 +37,12 @@
 			 Version="$(var.Version)"
 			 Manufacturer="$(var.Manufacturer)"
 			 UpgradeCode="$(var.UpgradeCode)">
+       <!--
+         perUser means destination will be under user's %AppData% directory,
+         not Program Files or similar.
+
+         see: https://learn.microsoft.com/en-us/windows/win32/msi/installation-context
+       -->
         <Package Compressed="yes"
 				 InstallScope="perUser"
 				 Manufacturer="$(var.Manufacturer)"