Update src/core/string.c

Co-authored-by: John W Higgins <wishdev@gmail.com>

.builds/linux.yml

@@ -19,8 +19,3 @@ tasks:
     ninja
     ninja test
     sudo ninja install
-- meson_min: |
-    cd janet
-    meson setup build_meson_min --buildtype=release -Dsingle_threaded=true -Dnanbox=false -Ddynamic_modules=false -Ddocstrings=false -Dnet=false -Dsourcemaps=false -Dpeg=false -Dassembler=false -Dint_types=false -Dreduced_os=true -Dffi=false
-    cd build_meson_min
-    ninja

.builds/openbsd.yml

@@ -1,4 +1,4 @@
-image: openbsd/7.7
+image: openbsd/latest
 sources:
 - https://git.sr.ht/~bakpakin/janet
 packages:
@@ -10,6 +10,7 @@ tasks:
     gmake
     gmake test
     doas gmake install
+    gmake test-install
     doas gmake uninstall
 - meson_min: |
     cd janet

.github/cosmo/build

@@ -1,38 +0,0 @@
-#!/bin/sh
-set -eux
-
-COSMO_DIR="/sc/cosmocc"
-
-# build x86_64
-X86_64_CC="/sc/cosmocc/bin/x86_64-unknown-cosmo-cc"
-X86_64_AR="/sc/cosmocc/bin/x86_64-unknown-cosmo-ar"
-mkdir -p /sc/cosmocc/x86_64
-make -j CC="$X86_64_CC" AR="$X86_64_AR" HAS_SHARED=0 JANET_NO_AMALG=1
-cp build/janet /sc/cosmocc/x86_64/janet
-make clean
-
-# build aarch64
-AARCH64_CC="/sc/cosmocc/bin/aarch64-unknown-cosmo-cc"
-AARCH64_AR="/sc/cosmocc/bin/aarch64-unknown-cosmo-ar"
-mkdir -p /sc/cosmocc/aarch64
-make -j CC="$AARCH64_CC" AR="$AARCH64_AR" HAS_SHARED=0 JANET_NO_AMALG=1
-cp build/janet /sc/cosmocc/aarch64/janet
-make clean
-
-# fat binary
-apefat () {
-    OUTPUT="$1"
-    OLDNAME_X86_64="$(basename -- "$2")"
-    OLDNAME_AARCH64="$(basename -- "$3")"
-    TARG_FOLD="$(dirname "$OUTPUT")"
-    "$COSMO_DIR/bin/apelink" -l "$COSMO_DIR/bin/ape-x86_64.elf" \
-        -l "$COSMO_DIR/bin/ape-aarch64.elf" \
-        -M "$COSMO_DIR/bin/ape-m1.c" \
-        -o "$OUTPUT" \
-        "$2" \
-        "$3"
-    cp "$2" "$TARG_FOLD/$OLDNAME_X86_64.x86_64"
-    cp "$3" "$TARG_FOLD/$OLDNAME_AARCH64.aarch64"
-}
-
-apefat /sc/cosmocc/janet.com /sc/cosmocc/x86_64/janet /sc/cosmocc/aarch64/janet

.github/cosmo/setup

@@ -1,21 +0,0 @@
-#!/bin/sh
-set -e
-
-sudo apt update
-sudo apt-get install -y ca-certificates libssl-dev\
-    qemu qemu-utils qemu-user-static\
-    texinfo groff\
-    cmake ninja-build bison zip\
-    pkg-config build-essential autoconf re2c
-
-# download cosmocc
-cd /sc
-wget https://github.com/jart/cosmopolitan/releases/download/3.3.3/cosmocc-3.3.3.zip
-mkdir -p cosmocc
-cd cosmocc
-unzip ../cosmocc-3.3.3.zip
-
-# register
-cd /sc/cosmocc
-sudo cp ./bin/ape-x86_64.elf /usr/bin/ape
-sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"

.github/workflows/codeql.yml

@@ -27,16 +27,15 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v2
         with:
           languages: ${{ matrix.language }}
           queries: +security-and-quality
-          tools: linked
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v3
+        uses: github/codeql-action/autobuild@v2
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v2
         with:
           category: "/language:${{ matrix.language }}"

.github/workflows/release.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-latest, macos-13 ]
+        os: [ ubuntu-latest, macos-latest ]
     steps:
       - name: Checkout the repository
         uses: actions/checkout@master
@@ -39,35 +39,6 @@ jobs:
             build/c/janet.c
             build/c/shell.c
 
-  release-arm:
-    permissions:
-      contents: write  # for softprops/action-gh-release to create GitHub release
-    name: Build release binaries
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ macos-latest ]
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@master
-      - name: Set the version
-        run: echo "version=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
-      - name: Set the platform
-        run: echo "platform=$(tr '[A-Z]' '[a-z]' <<< $RUNNER_OS)" >> $GITHUB_ENV
-      - name: Compile the project
-        run: make clean && make
-      - name: Build the artifact
-        run: JANET_DIST_DIR=janet-${{ env.version }}-${{ env.platform }} make build/janet-${{ env.version }}-${{ env.platform }}-aarch64.tar.gz
-      - name: Draft the release
-        uses: softprops/action-gh-release@v1
-        with:
-          draft: true
-          files: |
-            build/*.gz
-            build/janet.h
-            build/c/janet.c
-            build/c/shell.c
-
   release-windows:
     permissions:
       contents: write  # for softprops/action-gh-release to create GitHub release
@@ -89,30 +60,3 @@ jobs:
             ./dist/*.zip
             ./*.zip
             ./*.msi
-
-  release-cosmo:
-    permissions:
-      contents: write  # for softprops/action-gh-release to create GitHub release
-    name: Build release binaries for Cosmo
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@master
-      - name: create build folder
-        run: |
-          sudo mkdir -p /sc
-          sudo chmod -R 0777 /sc
-      - name: setup Cosmopolitan Libc
-        run: bash ./.github/cosmo/setup
-      - name: Set the version
-        run: echo "version=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_ENV
-      - name: Set the platform
-        run: echo "platform=cosmo" >> $GITHUB_ENV
-      - name: build Janet APE binary
-        run: bash ./.github/cosmo/build
-      - name: push binary to github
-        uses: softprops/action-gh-release@v1
-        with:
-          draft: true
-          files: |
-            /sc/cosmocc/janet.com

.github/workflows/test.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ ubuntu-latest, macos-latest, macos-13 ]
+        os: [ ubuntu-latest, macos-latest ]
     steps:
       - name: Checkout the repository
         uses: actions/checkout@master
@@ -23,10 +23,7 @@ jobs:
 
   test-windows:
     name: Build and test on Windows
-    strategy:
-      matrix:
-        os: [ windows-latest, windows-2022 ]
-    runs-on: ${{ matrix.os }}
+    runs-on: windows-latest
     steps:
       - name: Checkout the repository
         uses: actions/checkout@master
@@ -38,61 +35,28 @@ jobs:
       - name: Test the project
         shell: cmd
         run: build_win test
-      - name: Test installer build
-        shell: cmd
-        run: build_win dist
-
-  test-windows-min:
-    name: Build and test on Windows Minimal build
-    strategy:
-      matrix:
-        os: [ windows-2022 ]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@master
-      - name: Setup MSVC
-        uses: ilammy/msvc-dev-cmd@v1
-      - name: Setup Python
-        uses: actions/setup-python@v2
-        with:
-          python-version: '3.x'
-      - name: Install Python Dependencies
-        run: pip install meson ninja
-      - name: Build
-        shell: cmd
-        run: |
-          meson setup build_meson_min --buildtype=release -Dsingle_threaded=true -Dnanbox=false -Ddynamic_modules=false -Ddocstrings=false -Dnet=false -Dsourcemaps=false -Dpeg=false -Dassembler=false -Dint_types=false -Dreduced_os=true -Dffi=false
-          cd build_meson_min
-          ninja
 
   test-mingw:
-    name: Build on Windows with Mingw
+    name: Build on Windows with Mingw (no test yet)
     runs-on: windows-latest
     defaults:
       run:
         shell: msys2 {0}
-    strategy:
-      matrix:
-        msystem: [ UCRT64, CLANG64 ]
     steps:
       - name: Checkout the repository
         uses: actions/checkout@master
       - name: Setup Mingw
         uses: msys2/setup-msys2@v2
         with:
-          msystem: ${{ matrix.msystem }}
+          msystem: UCRT64
           update: true
           install: >-
             base-devel
             git
             gcc
-      - name: Build
+      - name: Build the project
         shell: cmd
-        run: make -j4 CC=gcc
-      - name: Test
-        shell: cmd
-        run: make -j4 CC=gcc test
+        run: make -j4 CC=gcc JANET_NO_AMALG=1
 
   test-mingw-linux:
     name: Build and test with Mingw on Linux + Wine
@@ -109,7 +73,7 @@ jobs:
       - name: Compile the project
         run: make clean && make CC=x86_64-w64-mingw32-gcc LD=x86_64-w64-mingw32-gcc UNAME=MINGW RUN=wine
       - name: Test the project
-        run: make test UNAME=MINGW RUN=wine VERBOSE=1
+        run: make test UNAME=MINGW RUN=wine
 
   test-arm-linux:
     name: Build and test ARM32 cross compilation
@@ -122,17 +86,6 @@ jobs:
           sudo apt-get update
           sudo apt-get install gcc-arm-linux-gnueabi qemu-user
       - name: Compile the project
-        run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" CC=arm-linux-gnueabi-gcc LD=arm-linux-gnueabi-gcc
+        run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" CC=arm-linux-gnueabi-gcc LD=arm-linux-gnueabi-gcc 
       - name: Test the project
-        run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" SUBRUN="qemu-arm -L /usr/arm-linux-gnueabi/" test VERBOSE=1
-
-  test-s390x-linux:
-    name: Build and test s390x in qemu
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout the repository
-      uses: actions/checkout@master
-    - 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"
+        run: make RUN="qemu-arm -L /usr/arm-linux-gnueabi/" SUBRUN="qemu-arm -L /usr/arm-linux-gnueabi/" test

.gitignore

@@ -48,8 +48,6 @@ janet.wasm
 # Generated files
 *.gen.h
 *.gen.c
-*.tmp
-temp.*
 
 # Generate test files
 *.out
@@ -128,9 +126,6 @@ vgcore.*
 *.idb
 *.pdb
 
-# GGov
-*.gcov
-
 # Kernel Module Compile Results
 *.mod*
 *.cmd
@@ -139,9 +134,6 @@ Module.symvers
 Mkfile.old
 dkms.conf
 
-# Coverage files
-*.cov
-
 # End of https://www.gitignore.io/api/c
 
 # Created by https://www.gitignore.io/api/cmake

CHANGELOG.md

@@ -1,93 +1,6 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
-## 1.40.0 - 2025-11-15
-- Add `os/posix-chroot`
-- Fix `ev/deadline` with interrupt race condition bug on Windows.
-- Improve `flycheck` by allowing functions and macros to define their own flycheck behavior via the metadata `:flycheck`.
-- Add `*flychecking*` dynamic binding to check if inside flycheck evalutation
-- 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`
-- 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
-- Update timeout documentation for networking APIs: timeouts raise errors and do not return nil.
-- Add `janet_addtimeout_nil(double sec);` to the C API.
-- Change string hashing.
-- Fix string equality bug.
-- Add `assertf`
-- Change how JANET_PROFILE is loaded to allow more easily customizing the environment.
-- Add `*repl-prompt*` dynamic binding to allow customizing the built in repl.
-- Add multiple path support in the `JANET_PATH` environment variables. This lets
-  user more easily import modules from many directories.
-- Add `nth` and `only-tags` PEG specials to select from sub-captures while
-  dropping the rest.
-
-## 1.36.0 - 2024-09-07
-- Improve error messages in `bundle/add*` functions.
-- Add CI testing and verify tests pass on the s390x architecture.
-- Save `:source-form` in environment entries when `*debug*` is set.
-- Add experimental `filewatch/` module for listening to file system changes on Linux and Windows.
-- Add `bundle/who-is` to query which bundle a file on disk was installed by.
-- Add `geomean` function
-- Add `:R` and `:W` flags to `os/pipe` to create blocking pipes on Posix and Windows systems.
-  These streams cannot be directly read to and written from, but can be passed to subprocesses.
-- Add `array/join`
-- Add `tuple/join`
-- Add `bundle/add-bin` to make installing scripts easier. This also establishes a packaging convention for it.
-- Fix marshalling weak tables and weak arrays.
-- Fix bug in `ev/` module that could accidentally close sockets on accident.
-- Expose C functions for constructing weak tables in janet.h
-- Let range take non-integer values.
-
-## 1.35.2 - 2024-06-16
-- Fix some documentation typos.
-- Allow using `:only` in import without quoting.
-
-## 1.35.0 - 2024-06-15
-- Add `:only` argument to `import` to allow for easier control over imported bindings.
-- Add extra optional `env` argument to `eval` and `eval-string`.
-- Allow naming function literals with a keyword. This allows better stacktraces for macros without
-  accidentally adding new bindings.
-- Add `bundle/` module for managing packages within Janet. This should replace the jpm packaging
-  format eventually and is much simpler and amenable to more complicated builds.
-- Add macros `ev/with-lock`, `ev/with-rlock`, and `ev/with-wlock` for using mutexes and rwlocks.
-- Add `with-env`
-- Add *module-make-env* dynamic binding
-- Add buffer/format-at
-- Add long form command line options for readable CLI usage
-- Fix bug with `net/accept-loop` that would sometimes miss connections.
-
 ## 1.34.0 - 2024-03-22
 - Add a new (split) PEG special by @ianthehenry
 - Add buffer/push-* sized int and float by @pnelson
@@ -187,7 +100,7 @@ All notable changes to this project will be documented in this file.
   See http://no-color.org/
 - Disallow using `(splice x)` in contexts where it doesn't make sense rather than silently coercing to `x`.
   Instead, raise a compiler error.
-- Change the names of `:user8` and `:user9` signals to `:interrupt` and `:await`
+- Change the names of `:user8` and `:user9` sigals to `:interrupt` and `:await`
 - Change the names of `:user8` and `:user9` fiber statuses to `:interrupted` and `:suspended`.
 - Add `ev/all-tasks` to see all currently suspended fibers.
 - Add `keep-syntax` and `keep-syntax!` functions to make writing macros easier.
@@ -358,7 +271,7 @@ All notable changes to this project will be documented in this file.
 - Add the ability to close channels with `ev/chan-close` (or `:close`).
 - Add threaded channels with `ev/thread-chan`.
 - Add `JANET_FN` and `JANET_REG` macros to more easily define C functions that export their source mapping information.
-- Add `janet_interpreter_interrupt` and `janet_loop1_interrupt` to interrupt the interpreter while running.
+- Add `janet_interpreter_interupt` and `janet_loop1_interrupt` to interrupt the interpreter while running.
 - Add `table/clear`
 - Add build option to disable the threading library without disabling all threads.
 - Remove JPM from the main Janet distribution. Instead, JPM must be installed
@@ -412,7 +325,7 @@ saving and restoring the entire VM state.
 - Sort keys in pretty printing output.
 
 ## 1.15.3 - 2021-02-28
-- Fix a fiber bug that occurred in deeply nested fibers
+- Fix a fiber bug that occured in deeply nested fibers
 - Add `unref` combinator to pegs.
 - Small docstring changes.
 
@@ -562,13 +475,13 @@ saving and restoring the entire VM state.
 - Add `symbol/slice`
 - Add `keyword/slice`
 - Allow cross compilation with Makefile.
-- Change `compare-primitive` to `cmp` and make it more efficient.
+- Change `compare-primitve` to `cmp` and make it more efficient.
 - Add `reverse!` for reversing an array or buffer in place.
 - `janet_dobytes` and `janet_dostring` return parse errors in \*out
 - Add `repeat` macro for iterating something n times.
 - Add `eachy` (each yield) macro for iterating a fiber.
 - Fix `:generate` verb in loop macro to accept non symbols as bindings.
-- Add `:h`, `:h+`, and `:h*` in `default-peg-grammar` for hexadecimal digits.
+- Add `:h`, `:h+`, and `:h*` in `default-peg-grammar` for hexidecimal digits.
 - Fix `%j` formatter to print numbers precisely (using the `%.17g` format string to printf).
 
 ## 1.10.1 - 2020-06-18

CONTRIBUTING.md

@@ -61,7 +61,7 @@ ensure a consistent code style for C.
 
 ## Janet style
 
-All janet code in the project should be formatted similar to the code in src/boot/boot.janet.
+All janet code in the project should be formatted similar to the code in core.janet.
 The auto formatting from janet.vim will work well.
 
 ## Typo Fixing and One-Line changes

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2025 Calvin Rose and contributors
+Copyright (c) 2023 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

Makefile

@@ -1,4 +1,4 @@
-# Copyright (c) 2025 Calvin Rose
+# Copyright (c) 2023 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
@@ -43,11 +43,9 @@ JANET_DIST_DIR?=janet-dist
 JANET_BOOT_FLAGS:=. JANET_PATH '$(JANET_PATH)'
 JANET_TARGET_OBJECTS=build/janet.o build/shell.o
 JPM_TAG?=master
-SPORK_TAG?=master
 HAS_SHARED?=1
 DEBUGGER=gdb
 SONAME_SETTER=-Wl,-soname,
-STRIPFLAGS=-x -S
 
 # For cross compilation
 HOSTCC?=$(CC)
@@ -55,10 +53,9 @@ HOSTAR?=$(AR)
 # Symbols are (optionally) removed later, keep -g as default!
 CFLAGS?=-O2 -g
 LDFLAGS?=-rdynamic
-LIBJANET_LDFLAGS?=$(LDFLAGS)
+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)
@@ -81,12 +78,6 @@ 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!
@@ -102,18 +93,12 @@ 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
 
 
@@ -154,7 +139,6 @@ JANET_CORE_SOURCES=src/core/abstract.c \
 				   src/core/ev.c \
 				   src/core/ffi.c \
 				   src/core/fiber.c \
-				   src/core/filewatch.c \
 				   src/core/gc.c \
 				   src/core/inttypes.c \
 				   src/core/io.c \
@@ -220,14 +204,9 @@ build/%.bin.o: src/%.c $(JANET_HEADERS) $(JANET_LOCAL_HEADERS) Makefile
 ########################
 
 ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.40.dylib
+SONAME=libjanet.1.34.dylib
 else
-SONAME=libjanet.so.1.40
-endif
-
-ifeq ($(MINGW_COMPILER), clang)
-	SONAME=
-	SONAME_SETTER=
+SONAME=libjanet.so.1.34
 endif
 
 build/c/shell.c: src/mainclient/shell.c
@@ -261,7 +240,6 @@ $(JANET_STATIC_LIBRARY): $(JANET_TARGET_OBJECTS)
 # Testing assumes HOSTCC=CC
 
 TEST_SCRIPTS=$(wildcard test/suite*.janet)
-EXAMPLE_SCRIPTS=$(wildcard examples/*.janet)
 
 repl: $(JANET_TARGET)
 	$(RUN) ./$(JANET_TARGET)
@@ -269,26 +247,21 @@ repl: $(JANET_TARGET)
 debug: $(JANET_TARGET)
 	$(DEBUGGER) ./$(JANET_TARGET)
 
-VALGRIND_COMMAND=$(RUN) valgrind --leak-check=full --quiet
-CALLGRIND_COMMAND=$(RUN) valgrind --tool=callgrind
+VALGRIND_COMMAND=valgrind --leak-check=full --quiet
 
 valgrind: $(JANET_TARGET)
 	$(VALGRIND_COMMAND) ./$(JANET_TARGET)
 
-test: $(JANET_TARGET) $(TEST_SCRIPTS) $(EXAMPLE_SCRIPTS)
+test: $(JANET_TARGET) $(TEST_PROGRAMS)
 	for f in test/suite*.janet; do $(RUN) ./$(JANET_TARGET) "$$f" || exit; done
 	for f in examples/*.janet; do $(RUN) ./$(JANET_TARGET) -k "$$f"; done
 
-valtest: $(JANET_TARGET) $(TEST_SCRIPTS) $(EXAMPLE_SCRIPTS)
+valtest: $(JANET_TARGET) $(TEST_PROGRAMS)
 	for f in test/suite*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
-	for f in examples/*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) -k "$$f"; done
+	for f in examples/*.janet; do ./$(JANET_TARGET) -k "$$f"; done
 
 callgrind: $(JANET_TARGET)
-	$(CALLGRIND_COMMAND) ./$(JANET_TARGET)
-
-calltest: $(JANET_TARGET) $(TEST_SCRIPTS) $(EXAMPLE_SCRIPTS)
-	for f in test/suite*.janet; do $(CALLGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
-	for f in examples/*.janet; do $(CALLGRIND_COMMAND) ./$(JANET_TARGET) -k "$$f"; done
+	for f in test/suite*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
 
 ########################
 ##### Distribution #####
@@ -302,7 +275,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 $(STRIPFLAGS) 'build/$(JANET_DIST_DIR)/bin/janet'
+	strip -x -S 'build/$(JANET_DIST_DIR)/bin/janet'
 	mkdir -p build/$(JANET_DIST_DIR)/include
 	cp build/janet.h build/$(JANET_DIST_DIR)/include/
 	mkdir -p build/$(JANET_DIST_DIR)/lib/
@@ -349,7 +322,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 $(STRIPFLAGS) '$(DESTDIR)$(BINDIR)/janet'
+	strip -x -S '$(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'
@@ -385,12 +358,6 @@ install-jpm-git: $(JANET_TARGET)
 		JANET_LIBPATH='$(LIBDIR)' \
 		$(RUN) ../../$(JANET_TARGET) ./bootstrap.janet
 
-install-spork-git: $(JANET_TARGET)
-	mkdir -p build
-	rm -rf build/spork
-	git clone --depth=1 --branch='$(SPORK_TAG)' https://github.com/janet-lang/spork.git build/spork
-	$(JANET_TARGET) -e '(bundle/install "build/spork")'
-
 uninstall:
 	-rm '$(DESTDIR)$(BINDIR)/janet'
 	-rm -rf '$(DESTDIR)$(INCLUDEDIR)/janet'
@@ -419,6 +386,9 @@ clean:
 	-rm -rf build vgcore.* callgrind.*
 	-rm -rf test/install/build test/install/modpath
 
+test-install:
+	echo "JPM has been removed from default install."
+
 help:
 	@echo
 	@echo 'Janet: A Dynamic Language & Bytecode VM'
@@ -430,8 +400,7 @@ help:
 	@echo '   make test       Test a built Janet'
 	@echo '   make valgrind   Assess Janet with Valgrind'
 	@echo '   make callgrind  Assess Janet with Valgrind, using Callgrind'
-	@echo '   make valtest    Run the test suite and examples with Valgrind to check for memory leaks'
-	@echo '   make calltest   Run the test suite and examples with Callgrind'
+	@echo '   make valtest    Run the test suite with Valgrind to check for memory leaks'
 	@echo '   make dist       Create a distribution tarball'
 	@echo '   make docs       Generate documentation'
 	@echo '   make debug      Run janet with GDB or LLDB'
@@ -441,9 +410,6 @@ help:
 	@echo "   make format     Format Janet's own source files"
 	@echo '   make grammar    Generate a TextMate language grammar'
 	@echo
-	@echo '   make install-jpm-git   Install jpm into the current filesystem'
-	@echo '   make install-spork-git Install spork into the current filesystem'
-	@echo
 
-.PHONY: clean install install-jpm-git install-spork-git repl debug valgrind test \
-	valtest callgrind callgrind-test dist uninstall docs grammar format help compile-commands
+.PHONY: clean install repl debug valgrind test \
+	valtest dist uninstall docs grammar format help compile-commands

README.md

@@ -1,4 +1,4 @@
-[![Join the chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://janet.zulipchat.com)
+[![Join the chat](https://badges.gitter.im/janet-language/community.svg)](https://gitter.im/janet-language/community)
  
 [![builds.sr.ht status](https://builds.sr.ht/~bakpakin/janet/commits/master/freebsd.yml.svg)](https://builds.sr.ht/~bakpakin/janet/commits/master/freebsd.yml?)
 [![builds.sr.ht status](https://builds.sr.ht/~bakpakin/janet/commits/master/openbsd.yml.svg)](https://builds.sr.ht/~bakpakin/janet/commits/master/openbsd.yml?)
@@ -18,6 +18,9 @@ to run script files. This client program is separate from the core runtime, so
 Janet can be embedded in other programs. Try Janet in your browser at
 <https://janet-lang.org>.
 
+If you'd like to financially support the ongoing development of Janet, consider
+[sponsoring its primary author](https://github.com/sponsors/bakpakin) through GitHub.
+
 <br>
 
 ## Examples
@@ -165,21 +168,6 @@ 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,
@@ -213,10 +201,6 @@ 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#).
@@ -226,7 +210,7 @@ Building on illumos is exactly the same as building on FreeBSD.
 
 To build an `.msi` installer executable, in addition to the above steps, you will have to:
 
-5. Install, or otherwise add to your PATH the [WiX 3.14 Toolset](https://github.com/wixtoolset/wix3/releases).
+5. Install, or otherwise add to your PATH the [WiX 3.11 Toolset](https://github.com/wixtoolset/wix3/releases).
 6. Run `build_win dist`.
 
 Now you should have an `.msi`. You can run `build_win install` to install the `.msi`, or execute the file itself.
@@ -269,10 +253,8 @@ Emacs, and Atom each have syntax packages for the Janet language, though.
 
 ## Installation
 
-If you just want to try out the language, you don't need to install anything.
-In this case you can also move the `janet` executable wherever you want on
-your system and run it.  However, for a fuller setup, please see the
-[Introduction](https://janet-lang.org/docs/index.html) for more details.
+See the [Introduction](https://janet-lang.org/docs/index.html) for more details. If you just want
+to try out the language, you don't need to install anything. You can also move the `janet` executable wherever you want on your system and run it.
 
 ## Usage
 
@@ -333,7 +315,8 @@ See the [Embedding Section](https://janet-lang.org/capi/embedding.html) on the w
 
 ## Discussion
 
-Feel free to ask questions and join the discussion on the [Janet Zulip Instance](https://janet.zulipchat.com/)
+Feel free to ask questions and join the discussion on the [Janet Gitter channel](https://gitter.im/janet-language/community).
+Gitter provides Matrix and IRC bridges as well.
 
 ## FAQ
 

build_win.bat

@@ -41,35 +41,32 @@ if not exist build\boot mkdir build\boot
 @rem Build the bootstrap interpreter
 for %%f in (src\core\*.c) do (
     %JANET_COMPILE% /DJANET_BOOTSTRAP /Fobuild\boot\%%~nf.obj %%f
-    @if errorlevel 1 goto :BUILDFAIL
+    @if not errorlevel 0 goto :BUILDFAIL
 )
 for %%f in (src\boot\*.c) do (
     %JANET_COMPILE% /DJANET_BOOTSTRAP /Fobuild\boot\%%~nf.obj %%f
-    @if errorlevel 1 goto :BUILDFAIL
+    @if not errorlevel 0 goto :BUILDFAIL
 )
 %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
+@if not errorlevel 0 goto :BUILDFAIL
 build\janet_boot . > build\c\janet.c
-@if errorlevel 1 goto :BUILDFAIL
 
 @rem Build the sources
 %JANET_COMPILE% /Fobuild\janet.obj build\c\janet.c
-@if errorlevel 1 goto :BUILDFAIL
+@if not errorlevel 0 goto :BUILDFAIL
 %JANET_COMPILE% /Fobuild\shell.obj src\mainclient\shell.c
-@if errorlevel 1 goto :BUILDFAIL
+@if not errorlevel 0 goto :BUILDFAIL
 
 @rem Build the resources
 rc /nologo /fobuild\janet_win.res janet_win.rc
-@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 errorlevel 1 goto :BUILDFAIL
+@if not errorlevel 0 goto :BUILDFAIL
 
 @rem Build static library (libjanet.lib)
 %JANET_LINK_STATIC% /out:build\libjanet.lib build\janet.obj
-@if errorlevel 1 goto :BUILDFAIL
+@if not errorlevel 0 goto :BUILDFAIL
 
 echo === Successfully built janet.exe for Windows ===
 echo === Run 'build_win test' to run tests. ==
@@ -92,7 +89,7 @@ exit /b 0
 
 @rem Clean build artifacts
 :CLEAN
-del *.exe *.lib *.exp *.msi *.wixpdb
+del *.exe *.lib *.exp
 rd /s /q build
 if exist dist (
     rd /s /q dist
@@ -103,7 +100,7 @@ exit /b 0
 :TEST
 for %%f in (test/suite*.janet) do (
     janet.exe test\%%f
-    @if errorlevel 1 goto TESTFAIL
+    @if not errorlevel 0 goto TESTFAIL
 )
 exit /b 0
 
@@ -122,6 +119,7 @@ copy README.md dist\README.md
 
 copy janet.lib dist\janet.lib
 copy janet.exp dist\janet.exp
+copy janet.def dist\janet.def
 
 janet.exe tools\patch-header.janet src\include\janet.h src\conf\janetconf.h build\janet.h
 copy build\janet.h dist\janet.h
@@ -139,18 +137,11 @@ if defined APPVEYOR_REPO_TAG_NAME (
     set RELEASE_VERSION=%JANET_VERSION%
 )
 if defined CI (
-    set WIXBIN="%WIX%bin\"
-    echo WIXBIN = %WIXBIN%
+    set WIXBIN="c:\Program Files (x86)\WiX Toolset v3.11\bin\"
 ) else (
     set WIXBIN=
 )
-
-set WIXARCH=%BUILDARCH%
-if "%WIXARCH%"=="aarch64" (
-    set WIXARCH=arm64
-)
-
-%WIXBIN%candle.exe tools\msi\janet.wxs -arch %WIXARCH% -out build\
+%WIXBIN%candle.exe tools\msi\janet.wxs -arch %BUILDARCH% -out build\
 %WIXBIN%light.exe "-sice:ICE38" -b tools\msi -ext WixUIExtension build\janet.wixobj -out janet-%RELEASE_VERSION%-windows-%BUILDARCH%-installer.msi
 exit /b 0
 

examples/abstract-unix-socket.janet

@@ -1,6 +0,0 @@
-# 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/chatserver.janet

@@ -1,35 +0,0 @@
-(def conmap @{})
-
-(defn broadcast [em msg]
-  (eachk par conmap
-         (if (not= par em)
-           (if-let [tar (get conmap par)]
-             (net/write tar (string/format "[%s]:%s" em msg))))))
-
-(defn handler
-  [connection]
-  (print "connection: " connection)
-  (net/write connection "Whats your name?\n")
-  (def name (string/trim (string (ev/read connection 100))))
-  (print name " connected")
-  (if (get conmap name)
-    (do
-      (net/write connection "Name already taken!")
-      (:close connection))
-    (do
-      (put conmap name connection)
-      (net/write connection (string/format "Welcome %s\n" name))
-      (defer (do
-               (put conmap name nil)
-               (:close connection))
-        (while (def msg (ev/read connection 100))
-          (broadcast name (string msg)))
-        (print name " disconnected")))))
-
-(defn main [& args]
-  (printf "STARTING SERVER...")
-  (flush)
-  (def my-server (net/listen "127.0.0.1" "8000"))
-  (forever
-   (def connection (net/accept my-server))
-   (ev/call handler connection)))

examples/ffi/so.c

@@ -35,11 +35,6 @@ typedef struct {
     int c;
 } intintint;
 
-typedef struct {
-    uint64_t a;
-    uint64_t b;
-} uint64pair;
-
 typedef struct {
     int64_t a;
     int64_t b;
@@ -208,20 +203,3 @@ EXPORTER
 int sixints_fn_3(SixInts s, int x) {
     return x + s.u + s.v + s.w + s.x + s.y + s.z;
 }
-
-EXPORTER
-intint stack_spill_fn(uint8_t a, uint8_t b, uint8_t c, uint8_t d,
-                      uint8_t e, uint8_t f, uint8_t g, uint8_t h,
-                      float i, float j, float k, float l,
-                      float m, float n, float o, float p,
-                      float s1, int8_t s2, uint8_t s3, double s4, uint8_t s5, intint s6) {
-    return (intint) {
-        (a | b | c | d | e | f | g | h) + (i + j + k + l + m + n + o + p),
-        s1 *s6.a + s2 *s6.b + s3 *s4 *s5
-    };
-}
-
-EXPORTER
-double stack_spill_fn_2(uint64pair a, uint64pair b, uint64pair c, int8_t d, uint64pair e, int8_t f) {
-    return (double)(a.a * c.a + a.b * c.b + b.a * e.a) * f - (double)(b.b * e.b) + d;
-}

examples/ffi/test.janet

@@ -8,13 +8,11 @@
 
 (if is-windows
   (os/execute ["cl.exe" "/nologo" "/LD" ffi/source-loc "/link" "/DLL" (string "/OUT:" ffi/loc)] :px)
-  (os/execute ["cc" ffi/source-loc "-g" "-shared" "-o" ffi/loc] :px))
+  (os/execute ["cc" ffi/source-loc "-shared" "-o" ffi/loc] :px))
 
 (ffi/context ffi/loc)
 
-(def intint (ffi/struct :int :int))
 (def intintint (ffi/struct :int :int :int))
-(def uint64pair (ffi/struct :u64 :u64))
 (def big (ffi/struct :s64 :s64 :s64))
 (def split (ffi/struct :int :int :float :float))
 (def split-flip (ffi/struct :float :float :int :int))
@@ -57,14 +55,6 @@
 (ffi/defbind sixints-fn six-ints [])
 (ffi/defbind sixints-fn-2 :int [x :int s six-ints])
 (ffi/defbind sixints-fn-3 :int [s six-ints x :int])
-(ffi/defbind stack-spill-fn intint
-             [a :u8 b :u8 c :u8 d :u8
-              e :u8 f :u8 g :u8 h :u8
-              i :float j :float k :float l :float
-              m :float n :float o :float p :float
-              s1 :float s2 :s8 s3 :u8 s4 :double s5 :u8 s6 intint])
-(ffi/defbind stack-spill-fn-2 :double [a uint64pair b uint64pair c uint64pair d :s8 e uint64pair f :s8])
-(ffi/defbind-alias int-fn int-fn-aliased :int [a :int b :int])
 
 #
 # Struct reading and writing
@@ -129,7 +119,6 @@
 (tracev (return-struct 42))
 (tracev (double-lots 1 2 3 4 5 6 700 800 9 10))
 (tracev (struct-big 11 99.5))
-(tracev (int-fn-aliased 10 20))
 
 (assert (= [10 10 12 12] (split-ret-fn 10 12)))
 (assert (= [12 12 10 10] (split-flip-ret-fn 10 12)))
@@ -141,10 +130,5 @@
 (assert (= 21 (math/round (double-many 1 2 3 4 5 6.01))))
 (assert (= 19 (double-lots 1 2 3 4 5 6 7 8 9 10)))
 (assert (= 204 (float-fn 8 4 17)))
-(assert (= [0 38534415] (stack-spill-fn
-                          0 0 0 0 0 0 0 0
-                          0 0 0 0 0 0 0 0
-                          1.5 -32 196 65536.5 3 [-15 32])))
-(assert (= -2806 (stack-spill-fn-2 [2 3] [5 7] [9 11] -19 [13 17] -23)))
 
 (print "Done.")

examples/numarray/numarray.c

@@ -70,7 +70,7 @@ void num_array_put(void *p, Janet key, Janet value) {
     if (!janet_checktype(value, JANET_NUMBER))
         janet_panic("expected number value");
 
-    index = (size_t)janet_unwrap_integer(key);
+    index = janet_unwrap_size(key);
     if (index < array->size) {
         array->data[index] = janet_unwrap_number(value);
     }
@@ -96,7 +96,7 @@ int num_array_get(void *p, Janet key, Janet *out) {
         return janet_getmethod(janet_unwrap_keyword(key), methods, out);
     if (!janet_checkint(key))
         janet_panic("expected integer key");
-    index = (size_t)janet_unwrap_integer(key);
+    index = janet_unwrap_size(key);
     if (index >= array->size) {
         return 0;
     } else {

examples/sample-bad-bundle1/info.jdn

@@ -1,3 +0,0 @@
-@{
-  :name "sample-bad-bundle1"
-}

examples/sample-bad-bundle2/badmod.janet

@@ -1 +0,0 @@
-(def abc 123)

examples/sample-bad-bundle2/bundle.janet

@@ -1,7 +0,0 @@
-(defn install
-  [manifest &]
-  (bundle/add-file manifest "badmod.janet"))
-
-(defn check
-  [&]
-  (error "Check failed!"))

examples/sample-bad-bundle2/info.jdn

@@ -1,3 +0,0 @@
-@{
-  :name "sample-bad-bundle2"
-}

examples/sample-bundle-aliases/aliases-mod.janet

@@ -1 +0,0 @@
-(defn fun [x] (range x))

examples/sample-bundle-aliases/bundle.janet

@@ -1,3 +0,0 @@
-(defn install
-  [manifest &]
-  (bundle/add-file manifest "aliases-mod.janet"))

examples/sample-bundle-aliases/info.jdn

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

examples/sample-bundle/bundle/info.jdn

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

examples/sample-bundle/bundle/init.janet

@@ -1,3 +0,0 @@
-(defn install
-  [manifest &]
-  (bundle/add-file manifest "mymod.janet"))

examples/sample-bundle/mymod.janet

@@ -1,7 +0,0 @@
-(import dep1)
-(import dep2)
-
-(defn myfn
-  [x]
-  (def y (dep2/function x))
-  (dep1/function y))

examples/sample-dep1/bundle/info.jdn

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

examples/sample-dep1/bundle/init.janet

@@ -1,3 +0,0 @@
-(defn install
-  [manifest &]
-  (bundle/add-file manifest "dep1.janet"))

examples/sample-dep1/dep1.janet

@@ -1,3 +0,0 @@
-(defn function
-  [x]
-  (+ x x))

examples/sample-dep2/bundle/info.jdn

@@ -1,3 +0,0 @@
-@{
-  :name "sample-dep2"
-}

examples/sample-dep2/bundle/init.janet

@@ -1,3 +0,0 @@
-(defn install
-  [manifest &]
-  (bundle/add-file manifest "dep2.janet"))

examples/sample-dep2/dep2.janet

@@ -1,3 +0,0 @@
-(defn function
-  [x]
-  (* x x))

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. On Windows, there is no default value. This option supersedes JANET_PATH.
+/usr/local/lib/janet on Linux/Posix, and C:/Janet/Library on Windows. This option supersedes JANET_PATH.
 
 .TP
 .BR \-c\ source\ output
@@ -255,7 +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 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.
+the default location set at compile time.
 .RE
 
 .B JANET_PROFILE

meson.build

@@ -1,4 +1,4 @@
-# Copyright (c) 2025 Calvin Rose and contributors
+# Copyright (c) 2023 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,34 +20,16 @@
 
 project('janet', 'c',
   default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false', 'default_library=both'],
-  version : '1.40.0')
+  version : '1.34.0')
 
 # Global settings
 janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
 header_path = join_paths(get_option('prefix'), get_option('includedir'), 'janet')
 
-# Compilers
+# Link math library on all systems
 cc = meson.get_compiler('c')
-native_cc = meson.get_compiler('c', native : true)
-
-# Native deps
-native_m_dep = native_cc.find_library('m', required : false)
-native_dl_dep = native_cc.find_library('dl', required : false)
-native_android_spawn_dep = native_cc.find_library('android-spawn', required : false)
-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')
 
@@ -97,7 +79,6 @@ conf.set('JANET_EV_NO_KQUEUE', not get_option('kqueue'))
 conf.set('JANET_NO_INTERPRETER_INTERRUPT', not get_option('interpreter_interrupt'))
 conf.set('JANET_NO_FFI', not get_option('ffi'))
 conf.set('JANET_NO_FFI_JIT', not get_option('ffi_jit'))
-conf.set('JANET_NO_FILEWATCH', not get_option('filewatch'))
 conf.set('JANET_NO_CRYPTORAND', not get_option('cryptorand'))
 if get_option('os_name') != ''
   conf.set('JANET_OS_NAME', get_option('os_name'))
@@ -105,9 +86,6 @@ 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)
 
@@ -144,7 +122,6 @@ core_src = [
   'src/core/ev.c',
   'src/core/ffi.c',
   'src/core/fiber.c',
-  'src/core/filewatch.c',
   'src/core/gc.c',
   'src/core/inttypes.c',
   'src/core/io.c',
@@ -185,18 +162,11 @@ mainclient_src = [
   'src/mainclient/shell.c'
 ]
 
-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
-endif
-
 # Build boot binary
 janet_boot = executable('janet-boot', core_src, boot_src,
   include_directories : incdir,
   c_args : '-DJANET_BOOTSTRAP',
-  dependencies : janet_native_dependencies,
+  dependencies : [m_dep, dl_dep, thread_dep, android_spawn_dep],
   native : true)
 
 # Build janet.c
@@ -209,6 +179,11 @@ janetc = custom_target('janetc',
     'JANET_PATH', janet_path
   ])
 
+janet_dependencies = [m_dep, dl_dep, android_spawn_dep]
+if not get_option('single_threaded')
+  janet_dependencies += thread_dep
+endif
+
 # Allow building with no shared library
 if cc.has_argument('-fvisibility=hidden')
   lib_cflags = ['-fvisibility=hidden']
@@ -254,7 +229,7 @@ if meson.is_cross_build()
   endif
   janet_nativeclient = executable('janet-native', janetc, mainclient_src,
     include_directories : incdir,
-    dependencies : janet_native_dependencies,
+    dependencies : janet_dependencies,
     c_args : extra_native_cflags,
     native : true)
 else
@@ -274,16 +249,13 @@ test_files = [
   'test/suite-asm.janet',
   'test/suite-boot.janet',
   'test/suite-buffer.janet',
-  'test/suite-bundle.janet',
   'test/suite-capi.janet',
   'test/suite-cfuns.janet',
   'test/suite-compile.janet',
   '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',
   'test/suite-io.janet',
   'test/suite-marsh.janet',
@@ -298,7 +270,6 @@ test_files = [
   'test/suite-struct.janet',
   'test/suite-symcache.janet',
   'test/suite-table.janet',
-  'test/suite-tuple.janet',
   'test/suite-unknown.janet',
   'test/suite-value.janet',
   'test/suite-vm.janet'

meson_options.txt

@@ -22,7 +22,6 @@ option('kqueue', type : 'boolean', value : true)
 option('interpreter_interrupt', type : 'boolean', value : true)
 option('ffi', type : 'boolean', value : true)
 option('ffi_jit', type : 'boolean', value : true)
-option('filewatch', type : 'boolean', value : true)
 
 option('recursion_guard', type : 'integer', min : 10, max : 8000, value : 1024)
 option('max_proto_depth', type : 'integer', min : 10, max : 8000, value : 200)
@@ -30,7 +29,6 @@ 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/array_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -26,8 +26,6 @@
 #include "tests.h"
 
 int array_test() {
-
-    int i;
     JanetArray *array1, *array2;
 
     array1 = janet_array(10);
@@ -53,7 +51,7 @@ int array_test() {
     janet_array_push(array2, janet_cstringv("six"));
     janet_array_push(array2, janet_cstringv("seven"));
 
-    for (i = 0; i < array2->count; i++) {
+    for (size_t i = 0; i < array2->count; i++) {
         assert(janet_equals(array1->data[i], array2->data[i]));
     }
 

src/boot/boot.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -104,7 +104,7 @@ int main(int argc, const char **argv) {
     }
     fclose(boot_file);
 
-    status = janet_dobytes(env, boot_buffer, (int32_t) boot_size, boot_filename, NULL);
+    status = janet_dobytes(env, boot_buffer, boot_size, boot_filename, NULL);
     janet_free(boot_buffer);
 
     /* Deinitialize vm */

src/boot/buffer_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -26,8 +26,6 @@
 #include "tests.h"
 
 int buffer_test() {
-
-    int i;
     JanetBuffer *buffer1, *buffer2;
 
     buffer1 = janet_buffer(100);
@@ -54,7 +52,7 @@ int buffer_test() {
     assert(buffer1->capacity >= buffer1->count);
     assert(buffer2->capacity >= buffer2->count);
 
-    for (i = 0; i < buffer1->count; i++) {
+    for (size_t i = 0; i < buffer1->count; i++) {
         assert(buffer1->data[i] == buffer2->data[i]);
     }
 

src/boot/number_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -38,7 +38,7 @@ static void test_valid_str(const char *str) {
     double cnum, jnum;
     jnum = 0.0;
     cnum = atof(str);
-    err = janet_scan_number((const uint8_t *) str, (int32_t) strlen(str), &jnum);
+    err = janet_scan_number((const uint8_t *) str, strlen(str), &jnum);
     assert(!err);
     assert(cnum == jnum);
 }

src/boot/system_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -22,7 +22,7 @@
 
 #include <janet.h>
 #include <assert.h>
-#include <string.h>
+#include <stdio.h>
 #include <math.h>
 
 #include "tests.h"
@@ -35,11 +35,6 @@ int system_test() {
     assert(sizeof(void *) == 8);
 #endif
 
-    /* Check the version defines are self consistent */
-    char version_combined[256];
-    sprintf(version_combined, "%d.%d.%d%s", JANET_VERSION_MAJOR, JANET_VERSION_MINOR, JANET_VERSION_PATCH, JANET_VERSION_EXTRA);
-    assert(!strcmp(JANET_VERSION, version_combined));
-
     /* Reflexive testing and nanbox testing */
     assert(janet_equals(janet_wrap_nil(), janet_wrap_nil()));
     assert(janet_equals(janet_wrap_false(), janet_wrap_false()));

src/boot/table_test.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/conf/janetconf.h

@@ -4,16 +4,15 @@
 #define JANETCONF_H
 
 #define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 40
+#define JANET_VERSION_MINOR 34
 #define JANET_VERSION_PATCH 0
 #define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.40.0"
+#define JANET_VERSION "1.34.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"))) */
@@ -30,7 +29,6 @@
 /* #define JANET_NO_NET */
 /* #define JANET_NO_INT_TYPES */
 /* #define JANET_NO_EV */
-/* #define JANET_NO_FILEWATCH */
 /* #define JANET_NO_REALPATH */
 /* #define JANET_NO_SYMLINKS */
 /* #define JANET_NO_UMASK */

src/core/abstract.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/array.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -30,11 +30,11 @@
 
 #include <string.h>
 
-static void janet_array_impl(JanetArray *array, int32_t capacity) {
+static void janet_array_impl(JanetArray *array, size_t capacity) {
     Janet *data = NULL;
     if (capacity > 0) {
         janet_vm.next_collection += capacity * sizeof(Janet);
-        data = (Janet *) janet_malloc(sizeof(Janet) * (size_t) capacity);
+        data = (Janet *) janet_malloc(sizeof(Janet) * capacity);
         if (NULL == data) {
             JANET_OUT_OF_MEMORY;
         }
@@ -45,25 +45,25 @@ static void janet_array_impl(JanetArray *array, int32_t capacity) {
 }
 
 /* Creates a new array */
-JanetArray *janet_array(int32_t capacity) {
+JanetArray *janet_array(size_t capacity) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     janet_array_impl(array, capacity);
     return array;
 }
 
 /* Creates a new array with weak references */
-JanetArray *janet_array_weak(int32_t capacity) {
+JanetArray *janet_array_weak(size_t capacity) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY_WEAK, sizeof(JanetArray));
     janet_array_impl(array, capacity);
     return array;
 }
 
 /* Creates a new array from n elements. */
-JanetArray *janet_array_n(const Janet *elements, int32_t n) {
+JanetArray *janet_array_n(const Janet *elements, size_t n) {
     JanetArray *array = janet_gcalloc(JANET_MEMORY_ARRAY, sizeof(JanetArray));
     array->capacity = n;
     array->count = n;
-    array->data = janet_malloc(sizeof(Janet) * (size_t) n);
+    array->data = janet_malloc(sizeof(Janet) * n);
     if (!array->data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -72,13 +72,13 @@ JanetArray *janet_array_n(const Janet *elements, int32_t n) {
 }
 
 /* Ensure the array has enough capacity for elements */
-void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
+void janet_array_ensure(JanetArray *array, size_t capacity, size_t growth) {
     Janet *newData;
     Janet *old = array->data;
     if (capacity <= array->capacity) return;
-    int64_t new_capacity = ((int64_t) capacity) * growth;
-    if (new_capacity > INT32_MAX) new_capacity = INT32_MAX;
-    capacity = (int32_t) new_capacity;
+    size_t new_capacity = (capacity) * growth;
+    if (new_capacity > JANET_INTMAX_SIZE) new_capacity = JANET_INTMAX_SIZE;
+    capacity = new_capacity;
     newData = janet_realloc(old, capacity * sizeof(Janet));
     if (NULL == newData) {
         JANET_OUT_OF_MEMORY;
@@ -89,11 +89,9 @@ void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth) {
 }
 
 /* Set the count of an array. Extend with nil if needed. */
-void janet_array_setcount(JanetArray *array, int32_t count) {
-    if (count < 0)
-        return;
+void janet_array_setcount(JanetArray *array, size_t count) {
     if (count > array->count) {
-        int32_t i;
+        size_t i;
         janet_array_ensure(array, count, 1);
         for (i = array->count; i < count; i++) {
             array->data[i] = janet_wrap_nil();
@@ -104,10 +102,10 @@ void janet_array_setcount(JanetArray *array, int32_t count) {
 
 /* Push a value to the top of the array */
 void janet_array_push(JanetArray *array, Janet x) {
-    if (array->count == INT32_MAX) {
+    if (array->count == JANET_INTMAX_SIZE) {
         janet_panic("array overflow");
     }
-    int32_t newcount = array->count + 1;
+    size_t newcount = array->count + 1;
     janet_array_ensure(array, newcount, 2);
     array->data[array->count] = x;
     array->count = newcount;
@@ -138,7 +136,7 @@ JANET_CORE_FN(cfun_array_new,
               "Creates a new empty array with a pre-allocated capacity. The same as "
               "`(array)` but can be more efficient if the maximum size of an array is known.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     JanetArray *array = janet_array(cap);
     return janet_wrap_array(array);
 }
@@ -147,7 +145,7 @@ JANET_CORE_FN(cfun_array_weak,
               "(array/weak capacity)",
               "Creates a new empty array with a pre-allocated capacity and support for weak references. Similar to `array/new`.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     JanetArray *array = janet_array_weak(cap);
     return janet_wrap_array(array);
 }
@@ -156,10 +154,10 @@ JANET_CORE_FN(cfun_array_new_filled,
               "(array/new-filled count &opt value)",
               "Creates a new array of `count` elements, all set to `value`, which defaults to nil. Returns the new array.") {
     janet_arity(argc, 1, 2);
-    int32_t count = janet_getnat(argv, 0);
+    size_t count = janet_getsize(argv, 0);
     Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
     JanetArray *array = janet_array(count);
-    for (int32_t i = 0; i < count; i++) {
+    for (size_t i = 0; i < count; i++) {
         array->data[i] = x;
     }
     array->count = count;
@@ -173,7 +171,7 @@ JANET_CORE_FN(cfun_array_fill,
     janet_arity(argc, 1, 2);
     JanetArray *array = janet_getarray(argv, 0);
     Janet x = (argc == 2) ? argv[1] : janet_wrap_nil();
-    for (int32_t i = 0; i < array->count; i++) {
+    for (size_t i = 0; i < array->count; i++) {
         array->data[i] = x;
     }
     return argv[0];
@@ -201,10 +199,10 @@ JANET_CORE_FN(cfun_array_push,
               "Push all the elements of xs to the end of an array. Modifies the input array and returns it.") {
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    if (INT32_MAX - argc + 1 <= array->count) {
+    if ((size_t) JANET_INTMAX_SIZE - argc + 1 <= array->count) {
         janet_panic("array overflow");
     }
-    int32_t newcount = array->count - 1 + argc;
+    size_t newcount = array->count - 1 + argc;
     janet_array_ensure(array, newcount, 2);
     if (argc > 1) memcpy(array->data + array->count, argv + 1, (size_t)(argc - 1) * sizeof(Janet));
     array->count = newcount;
@@ -219,8 +217,8 @@ JANET_CORE_FN(cfun_array_ensure,
               "Otherwise, the backing memory will be reallocated so that there is enough space.") {
     janet_fixarity(argc, 3);
     JanetArray *array = janet_getarray(argv, 0);
-    int32_t newcount = janet_getinteger(argv, 1);
-    int32_t growth = janet_getinteger(argv, 2);
+    size_t newcount = janet_getsize(argv, 1);
+    size_t growth = janet_getsize(argv, 2);
     if (newcount < 1) janet_panic("expected positive integer");
     janet_array_ensure(array, newcount, growth);
     return argv[0];
@@ -248,21 +246,20 @@ JANET_CORE_FN(cfun_array_concat,
               "which must be an array. If any of the parts are arrays or tuples, their elements will "
               "be inserted into the array. Otherwise, each part in `parts` will be appended to `arr` in order. "
               "Return the modified array `arr`.") {
-    int32_t i;
     janet_arity(argc, 1, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    for (i = 1; i < argc; i++) {
+    for (int32_t i = 1; i < argc; i++) {
         switch (janet_type(argv[i])) {
             default:
                 janet_array_push(array, argv[i]);
                 break;
             case JANET_ARRAY:
             case JANET_TUPLE: {
-                int32_t j, len = 0;
+                size_t j, len = 0;
                 const Janet *vals = NULL;
                 janet_indexed_view(argv[i], &vals, &len);
                 if (array->data == vals) {
-                    int32_t newcount = array->count + len;
+                    size_t newcount = array->count + len;
                     janet_array_ensure(array, newcount, 2);
                     janet_indexed_view(argv[i], &vals, &len);
                 }
@@ -275,31 +272,6 @@ JANET_CORE_FN(cfun_array_concat,
     return janet_wrap_array(array);
 }
 
-JANET_CORE_FN(cfun_array_join,
-              "(array/join arr & parts)",
-              "Join a variable number of arrays and tuples into the first argument, "
-              "which must be an array. "
-              "Return the modified array `arr`.") {
-    int32_t i;
-    janet_arity(argc, 1, -1);
-    JanetArray *array = janet_getarray(argv, 0);
-    for (i = 1; i < argc; i++) {
-        int32_t j, len = 0;
-        const Janet *vals = NULL;
-        if (!janet_indexed_view(argv[i], &vals, &len)) {
-            janet_panicf("expected indexed type for argument %d, got %v", i, argv[i]);
-        }
-        if (array->data == vals) {
-            int32_t newcount = array->count + len;
-            janet_array_ensure(array, newcount, 2);
-            janet_indexed_view(argv[i], &vals, &len);
-        }
-        for (j = 0; j < len; j++)
-            janet_array_push(array, vals[j]);
-    }
-    return janet_wrap_array(array);
-}
-
 JANET_CORE_FN(cfun_array_insert,
               "(array/insert arr at & xs)",
               "Insert all `xs` into array `arr` at index `at`. `at` should be an integer between "
@@ -309,15 +281,15 @@ JANET_CORE_FN(cfun_array_insert,
     size_t chunksize, restsize;
     janet_arity(argc, 2, -1);
     JanetArray *array = janet_getarray(argv, 0);
-    int32_t at = janet_getinteger(argv, 1);
+    ssize_t at = janet_getssize(argv, 1);
     if (at < 0) {
         at = array->count + at + 1;
     }
-    if (at < 0 || at > array->count)
-        janet_panicf("insertion index %d out of range [0,%d]", at, array->count);
+    if (at < 0 || (size_t) at > array->count)
+      janet_panicf("insertion index %d out of range [0,%d]", at, array->count);
     chunksize = (argc - 2) * sizeof(Janet);
     restsize = (array->count - at) * sizeof(Janet);
-    if (INT32_MAX - (argc - 2) < array->count) {
+    if ((size_t) JANET_INTMAX_SIZE - (argc - 2) < array->count) {
         janet_panic("array overflow");
     }
     janet_array_ensure(array, array->count + argc - 2, 2);
@@ -339,17 +311,15 @@ JANET_CORE_FN(cfun_array_remove,
               "Returns the array.") {
     janet_arity(argc, 2, 3);
     JanetArray *array = janet_getarray(argv, 0);
-    int32_t at = janet_getinteger(argv, 1);
-    int32_t n = 1;
+    ssize_t at = janet_getssize(argv, 1);
+    size_t n = 1;
     if (at < 0) {
         at = array->count + at;
     }
-    if (at < 0 || at > array->count)
+    if (at < 0 || (size_t) at > array->count)
         janet_panicf("removal index %d out of range [0,%d]", at, array->count);
     if (argc == 3) {
-        n = janet_getinteger(argv, 2);
-        if (n < 0)
-            janet_panicf("expected non-negative integer for argument n, got %v", argv[2]);
+        n = janet_getsize(argv, 2);
     }
     if (at + n > array->count) {
         n = array->count - at;
@@ -410,7 +380,6 @@ void janet_lib_array(JanetTable *env) {
         JANET_CORE_REG("array/remove", cfun_array_remove),
         JANET_CORE_REG("array/trim", cfun_array_trim),
         JANET_CORE_REG("array/clear", cfun_array_clear),
-        JANET_CORE_REG("array/join", cfun_array_join),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, array_cfuns);

src/core/asm.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -282,7 +282,7 @@ static int32_t doarg_1(
         case JANET_TUPLE: {
             const Janet *t = janet_unwrap_tuple(x);
             if (argtype == JANET_OAT_TYPE) {
-                int32_t i = 0;
+                size_t i = 0;
                 ret = 0;
                 for (i = 0; i < janet_tuple_length(t); i++) {
                     ret |= doarg_1(a, JANET_OAT_SIMPLETYPE, t[i]);
@@ -492,7 +492,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     JanetAssembler a;
     Janet s = source;
     JanetFuncDef *def;
-    int32_t count, i;
+    size_t count, i;
     const Janet *arr;
     Janet x;
     (void) flags;
@@ -578,8 +578,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
             Janet v = arr[i];
             if (janet_checktype(v, JANET_TUPLE)) {
                 const Janet *t = janet_unwrap_tuple(v);
-                int32_t j;
-                for (j = 0; j < janet_tuple_length(t); j++) {
+                for (size_t j = 0; j < janet_tuple_length(t); j++) {
                     if (!janet_checktype(t[j], JANET_SYMBOL))
                         janet_asm_error(&a, "slot names must be symbols");
                     janet_table_put(&a.slots, t[j], janet_wrap_integer(i));
@@ -596,7 +595,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     x = janet_get1(s, janet_ckeywordv("constants"));
     if (janet_indexed_view(x, &arr, &count)) {
         def->constants_length = count;
-        def->constants = janet_malloc(sizeof(Janet) * (size_t) count);
+        def->constants = janet_malloc(sizeof(Janet) * count);
         if (NULL == def->constants) {
             JANET_OUT_OF_MEMORY;
         }
@@ -615,8 +614,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         x = janet_get1(s, janet_ckeywordv("defs"));
     }
     if (janet_indexed_view(x, &arr, &count)) {
-        int32_t i;
-        for (i = 0; i < count; i++) {
+        for (size_t i = 0; i < count; i++) {
             JanetAssembleResult subres;
             Janet subname;
             int32_t newlen;
@@ -701,7 +699,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
     /* Check for source mapping */
     x = janet_get1(s, janet_ckeywordv("sourcemap"));
     if (janet_indexed_view(x, &arr, &count)) {
-        janet_asm_assert(&a, count == def->bytecode_length, "sourcemap must have the same length as the bytecode");
+        janet_asm_assert(&a, count == (size_t) def->bytecode_length, "sourcemap must have the same length as the bytecode");
         def->sourcemap = janet_malloc(sizeof(JanetSourceMapping) * (size_t) count);
         if (NULL == def->sourcemap) {
             JANET_OUT_OF_MEMORY;
@@ -775,7 +773,7 @@ static JanetAssembleResult janet_asm1(JanetAssembler *parent, Janet source, int
         if (def->environments_length) {
             def->environments = janet_realloc(def->environments, def->environments_length * sizeof(int32_t));
         }
-        for (int32_t i = 0; i < count; i++) {
+        for (size_t i = 0; i < count; i++) {
             if (!janet_checkint(arr[i])) {
                 janet_asm_error(&a, "expected integer");
             }

src/core/buffer.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -36,11 +36,13 @@ static void janet_buffer_can_realloc(JanetBuffer *buffer) {
 }
 
 /* Initialize a buffer */
-static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity) {
+static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, size_t capacity) {
     uint8_t *data = NULL;
     if (capacity < 4) capacity = 4;
+    if (capacity > JANET_INTMAX_SIZE)
+      capacity = JANET_INTMAX_SIZE;
     janet_gcpressure(capacity);
-    data = janet_malloc(sizeof(uint8_t) * (size_t) capacity);
+    data = janet_malloc(sizeof(uint8_t) * capacity);
     if (NULL == data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -51,7 +53,7 @@ static JanetBuffer *janet_buffer_init_impl(JanetBuffer *buffer, int32_t capacity
 }
 
 /* Initialize a buffer */
-JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) {
+JanetBuffer *janet_buffer_init(JanetBuffer *buffer, size_t capacity) {
     janet_buffer_init_impl(buffer, capacity);
     buffer->gc.data.next = NULL;
     buffer->gc.flags = JANET_MEM_DISABLED;
@@ -59,8 +61,7 @@ JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity) {
 }
 
 /* Initialize an unmanaged buffer */
-JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count) {
-    if (count < 0) janet_panic("count < 0");
+JanetBuffer *janet_pointer_buffer_unsafe(void *memory, size_t capacity, size_t count) {
     if (capacity < count) janet_panic("capacity < count");
     JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer));
     buffer->gc.flags |= JANET_BUFFER_FLAG_NO_REALLOC;
@@ -78,21 +79,21 @@ void janet_buffer_deinit(JanetBuffer *buffer) {
 }
 
 /* Initialize a buffer */
-JanetBuffer *janet_buffer(int32_t capacity) {
+JanetBuffer *janet_buffer(size_t capacity) {
     JanetBuffer *buffer = janet_gcalloc(JANET_MEMORY_BUFFER, sizeof(JanetBuffer));
     return janet_buffer_init_impl(buffer, capacity);
 }
 
 /* Ensure that the buffer has enough internal capacity */
-void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth) {
+void janet_buffer_ensure(JanetBuffer *buffer, size_t capacity, size_t growth) {
     uint8_t *new_data;
     uint8_t *old = buffer->data;
     if (capacity <= buffer->capacity) return;
     janet_buffer_can_realloc(buffer);
-    int64_t big_capacity = ((int64_t) capacity) * growth;
-    capacity = big_capacity > INT32_MAX ? INT32_MAX : (int32_t) big_capacity;
+    uint64_t big_capacity = (uint64_t) capacity*growth;
+    capacity = big_capacity > JANET_INTMAX_SIZE ? JANET_INTMAX_SIZE : (size_t) big_capacity;
     janet_gcpressure(capacity - buffer->capacity);
-    new_data = janet_realloc(old, (size_t) capacity * sizeof(uint8_t));
+    new_data = janet_realloc(old, capacity * sizeof(uint8_t));
     if (NULL == new_data) {
         JANET_OUT_OF_MEMORY;
     }
@@ -101,11 +102,9 @@ void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth)
 }
 
 /* Ensure that the buffer has enough internal capacity */
-void janet_buffer_setcount(JanetBuffer *buffer, int32_t count) {
-    if (count < 0)
-        return;
+void janet_buffer_setcount(JanetBuffer *buffer, size_t count) {
     if (count > buffer->count) {
-        int32_t oldcount = buffer->count;
+        size_t oldcount = buffer->count;
         janet_buffer_ensure(buffer, count, 1);
         memset(buffer->data + oldcount, 0, count - oldcount);
     }
@@ -114,15 +113,15 @@ void janet_buffer_setcount(JanetBuffer *buffer, int32_t count) {
 
 /* Adds capacity for enough extra bytes to the buffer. Ensures that the
  * next n bytes pushed to the buffer will not cause a reallocation */
-void janet_buffer_extra(JanetBuffer *buffer, int32_t n) {
+void janet_buffer_extra(JanetBuffer *buffer, size_t n) {
     /* Check for buffer overflow */
-    if ((int64_t)n + buffer->count > INT32_MAX) {
+    if ((int64_t)n + buffer->count > JANET_INTMAX_SIZE) {
         janet_panic("buffer overflow");
     }
-    int32_t new_size = buffer->count + n;
+    size_t new_size = buffer->count + n;
     if (new_size > buffer->capacity) {
         janet_buffer_can_realloc(buffer);
-        int32_t new_capacity = (new_size > (INT32_MAX / 2)) ? INT32_MAX : (new_size * 2);
+        size_t new_capacity = (new_size > (JANET_INTMAX_SIZE / 2)) ? JANET_INTMAX_SIZE : (new_size * 2);
         uint8_t *new_data = janet_realloc(buffer->data, new_capacity * sizeof(uint8_t));
         janet_gcpressure(new_capacity - buffer->capacity);
         if (NULL == new_data) {
@@ -135,12 +134,12 @@ void janet_buffer_extra(JanetBuffer *buffer, int32_t n) {
 
 /* Push a cstring to buffer */
 void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) {
-    int32_t len = (int32_t) strlen(cstring);
+    size_t len = strlen(cstring);
     janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len);
 }
 
 /* Push multiple bytes into the buffer */
-void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t length) {
+void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, size_t length) {
     if (0 == length) return;
     janet_buffer_extra(buffer, length);
     memcpy(buffer->data + buffer->count, string, length);
@@ -197,7 +196,7 @@ JANET_CORE_FN(cfun_buffer_new,
               "Creates a new, empty buffer with enough backing memory for `capacity` bytes. "
               "Returns a new buffer of length 0.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getinteger(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     JanetBuffer *buffer = janet_buffer(cap);
     return janet_wrap_buffer(buffer);
 }
@@ -207,8 +206,7 @@ JANET_CORE_FN(cfun_buffer_new_filled,
               "Creates a new buffer of length `count` filled with `byte`. By default, `byte` is 0. "
               "Returns the new buffer.") {
     janet_arity(argc, 1, 2);
-    int32_t count = janet_getinteger(argv, 0);
-    if (count < 0) count = 0;
+    size_t count = janet_getsize(argv, 0);
     int32_t byte = 0;
     if (argc == 2) {
         byte = janet_getinteger(argv, 1) & 0xFF;
@@ -224,10 +222,9 @@ JANET_CORE_FN(cfun_buffer_frombytes,
               "(buffer/from-bytes & byte-vals)",
               "Creates a buffer from integer parameters with byte values. All integers "
               "will be coerced to the range of 1 byte 0-255.") {
-    int32_t i;
     JanetBuffer *buffer = janet_buffer(argc);
-    for (i = 0; i < argc; i++) {
-        int32_t c = janet_getinteger(argv, i);
+    for (int32_t i = 0; i < argc; i++) {
+        size_t c = janet_getsize(argv, i);
         buffer->data[i] = c & 0xFF;
     }
     buffer->count = argc;
@@ -258,7 +255,7 @@ JANET_CORE_FN(cfun_buffer_trim,
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     janet_buffer_can_realloc(buffer);
     if (buffer->count < buffer->capacity) {
-        int32_t newcap = buffer->count > 4 ? buffer->count : 4;
+        size_t newcap = buffer->count > 4 ? buffer->count : 4;
         uint8_t *newData = janet_realloc(buffer->data, newcap);
         if (NULL == newData) {
             JANET_OUT_OF_MEMORY;
@@ -273,10 +270,9 @@ JANET_CORE_FN(cfun_buffer_u8,
               "(buffer/push-byte buffer & xs)",
               "Append bytes to a buffer. Will expand the buffer as necessary. "
               "Returns the modified buffer. Will throw an error if the buffer overflows.") {
-    int32_t i;
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (i = 1; i < argc; i++) {
+    for (int32_t i = 1; i < argc; i++) {
         janet_buffer_push_u8(buffer, (uint8_t)(janet_getinteger(argv, i) & 0xFF));
     }
     return argv[0];
@@ -287,10 +283,9 @@ JANET_CORE_FN(cfun_buffer_word,
               "Append machine words to a buffer. The 4 bytes of the integer are appended "
               "in twos complement, little endian order, unsigned for all x. Returns the modified buffer. Will "
               "throw an error if the buffer overflows.") {
-    int32_t i;
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (i = 1; i < argc; i++) {
+    for (int32_t i = 1; i < argc; i++) {
         double number = janet_getnumber(argv, i);
         uint32_t word = (uint32_t) number;
         if (word != number)
@@ -306,10 +301,9 @@ JANET_CORE_FN(cfun_buffer_chars,
               "Will accept any of strings, keywords, symbols, and buffers. "
               "Returns the modified buffer. "
               "Will throw an error if the buffer overflows.") {
-    int32_t i;
     janet_arity(argc, 1, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    for (i = 1; i < argc; i++) {
+    for (int32_t i = 1; i < argc; i++) {
         JanetByteView view = janet_getbytes(argv, i);
         if (view.bytes == buffer->data) {
             janet_buffer_ensure(buffer, buffer->count + view.len, 2);
@@ -371,15 +365,17 @@ JANET_CORE_FN(cfun_buffer_push_uint16,
     janet_fixarity(argc, 3);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int reverse = should_reverse_bytes(argv, 1);
-    uint16_t data = janet_getuinteger16(argv, 2);
-    uint8_t bytes[sizeof(data)];
-    memcpy(bytes, &data, sizeof(bytes));
+    union {
+        uint16_t data;
+        uint8_t bytes[2];
+    } u;
+    u.data = (uint16_t) janet_getinteger(argv, 2);
     if (reverse) {
-        uint8_t temp = bytes[1];
-        bytes[1] = bytes[0];
-        bytes[0] = temp;
+        uint8_t temp = u.bytes[1];
+        u.bytes[1] = u.bytes[0];
+        u.bytes[0] = temp;
     }
-    janet_buffer_push_bytes(buffer, bytes, sizeof(bytes));
+    janet_buffer_push_u16(buffer, *(uint16_t *) u.bytes);
     return argv[0];
 }
 
@@ -390,12 +386,14 @@ JANET_CORE_FN(cfun_buffer_push_uint32,
     janet_fixarity(argc, 3);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int reverse = should_reverse_bytes(argv, 1);
-    uint32_t data = janet_getuinteger(argv, 2);
-    uint8_t bytes[sizeof(data)];
-    memcpy(bytes, &data, sizeof(bytes));
+    union {
+        uint32_t data;
+        uint8_t bytes[4];
+    } u;
+    u.data = (uint32_t) janet_getinteger(argv, 2);
     if (reverse)
-        reverse_u32(bytes);
-    janet_buffer_push_bytes(buffer, bytes, sizeof(bytes));
+        reverse_u32(u.bytes);
+    janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes);
     return argv[0];
 }
 
@@ -406,12 +404,14 @@ JANET_CORE_FN(cfun_buffer_push_uint64,
     janet_fixarity(argc, 3);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int reverse = should_reverse_bytes(argv, 1);
-    uint64_t data = janet_getuinteger64(argv, 2);
-    uint8_t bytes[sizeof(data)];
-    memcpy(bytes, &data, sizeof(bytes));
+    union {
+        uint64_t data;
+        uint8_t bytes[8];
+    } u;
+    u.data = (uint64_t) janet_getuinteger64(argv, 2);
     if (reverse)
-        reverse_u64(bytes);
-    janet_buffer_push_bytes(buffer, bytes, sizeof(bytes));
+        reverse_u64(u.bytes);
+    janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes);
     return argv[0];
 }
 
@@ -422,12 +422,14 @@ JANET_CORE_FN(cfun_buffer_push_float32,
     janet_fixarity(argc, 3);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int reverse = should_reverse_bytes(argv, 1);
-    float data = (float) janet_getnumber(argv, 2);
-    uint8_t bytes[sizeof(data)];
-    memcpy(bytes, &data, sizeof(bytes));
+    union {
+        float data;
+        uint8_t bytes[4];
+    } u;
+    u.data = (float) janet_getnumber(argv, 2);
     if (reverse)
-        reverse_u32(bytes);
-    janet_buffer_push_bytes(buffer, bytes, sizeof(bytes));
+        reverse_u32(u.bytes);
+    janet_buffer_push_u32(buffer, *(uint32_t *) u.bytes);
     return argv[0];
 }
 
@@ -438,12 +440,14 @@ JANET_CORE_FN(cfun_buffer_push_float64,
     janet_fixarity(argc, 3);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     int reverse = should_reverse_bytes(argv, 1);
-    double data = janet_getnumber(argv, 2);
-    uint8_t bytes[sizeof(data)];
-    memcpy(bytes, &data, sizeof(bytes));
+    union {
+        double data;
+        uint8_t bytes[8];
+    } u;
+    u.data = janet_getnumber(argv, 2);
     if (reverse)
-        reverse_u64(bytes);
-    janet_buffer_push_bytes(buffer, bytes, sizeof(bytes));
+        reverse_u64(u.bytes);
+    janet_buffer_push_u64(buffer, *(uint64_t *) u.bytes);
     return argv[0];
 }
 
@@ -468,9 +472,9 @@ JANET_CORE_FN(cfun_buffer_push_at,
               " at index `index`.") {
     janet_arity(argc, 2, -1);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    int32_t index = janet_getinteger(argv, 1);
-    int32_t old_count = buffer->count;
-    if (index < 0 || index > old_count) {
+    size_t index = janet_getsize(argv, 1);
+    size_t old_count = buffer->count;
+    if (index > old_count) {
         janet_panicf("index out of range [0, %d)", old_count);
     }
     buffer->count = index;
@@ -509,8 +513,7 @@ JANET_CORE_FN(cfun_buffer_popn,
               "Removes the last `n` bytes from the buffer. Returns the modified buffer.") {
     janet_fixarity(argc, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    int32_t n = janet_getinteger(argv, 1);
-    if (n < 0) janet_panic("n must be non-negative");
+    size_t n = janet_getsize(argv, 1);
     if (buffer->count < n) {
         buffer->count = 0;
     } else {
@@ -534,17 +537,17 @@ JANET_CORE_FN(cfun_buffer_slice,
     return janet_wrap_buffer(buffer);
 }
 
-static void bitloc(int32_t argc, Janet *argv, JanetBuffer **b, int32_t *index, int *bit) {
+static void bitloc(int32_t argc, Janet *argv, JanetBuffer **b, size_t *index, int *bit) {
     janet_fixarity(argc, 2);
     JanetBuffer *buffer = janet_getbuffer(argv, 0);
     double x = janet_getnumber(argv, 1);
     int64_t bitindex = (int64_t) x;
     int64_t byteindex = bitindex >> 3;
     int which_bit = bitindex & 7;
-    if (bitindex != x || bitindex < 0 || byteindex >= buffer->count)
+    if (bitindex != x || bitindex < 0 || (size_t) byteindex >= buffer->count)
         janet_panicf("invalid bit index %v", argv[1]);
     *b = buffer;
-    *index = (int32_t) byteindex;
+    *index = (size_t) byteindex;
     *bit = which_bit;
 }
 
@@ -552,7 +555,7 @@ JANET_CORE_FN(cfun_buffer_bitset,
               "(buffer/bit-set buffer index)",
               "Sets the bit at the given bit-index. Returns the buffer.") {
     int bit;
-    int32_t index;
+    size_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     buffer->data[index] |= 1 << bit;
@@ -563,7 +566,7 @@ JANET_CORE_FN(cfun_buffer_bitclear,
               "(buffer/bit-clear buffer index)",
               "Clears the bit at the given bit-index. Returns the buffer.") {
     int bit;
-    int32_t index;
+    size_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     buffer->data[index] &= ~(1 << bit);
@@ -574,7 +577,7 @@ JANET_CORE_FN(cfun_buffer_bitget,
               "(buffer/bit buffer index)",
               "Gets the bit at the given bit-index. Returns true if the bit is set, false if not.") {
     int bit;
-    int32_t index;
+    size_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     return janet_wrap_boolean(buffer->data[index] & (1 << bit));
@@ -584,7 +587,7 @@ JANET_CORE_FN(cfun_buffer_bittoggle,
               "(buffer/bit-toggle buffer index)",
               "Toggles the bit at the given bit index in buffer. Returns the buffer.") {
     int bit;
-    int32_t index;
+    size_t index;
     JanetBuffer *buffer;
     bitloc(argc, argv, &buffer, &index, &bit);
     buffer->data[index] ^= (1 << bit);
@@ -600,26 +603,25 @@ JANET_CORE_FN(cfun_buffer_blit,
     JanetBuffer *dest = janet_getbuffer(argv, 0);
     JanetByteView src = janet_getbytes(argv, 1);
     int same_buf = src.bytes == dest->data;
-    int32_t offset_dest = 0;
-    int32_t offset_src = 0;
+    size_t offset_dest = 0;
+    size_t offset_src = 0;
     if (argc > 2 && !janet_checktype(argv[2], JANET_NIL))
         offset_dest = janet_gethalfrange(argv, 2, dest->count, "dest-start");
     if (argc > 3 && !janet_checktype(argv[3], JANET_NIL))
         offset_src = janet_gethalfrange(argv, 3, src.len, "src-start");
-    int32_t length_src;
+    size_t length_src;
     if (argc > 4) {
-        int32_t src_end = src.len;
+        size_t src_end = src.len;
         if (!janet_checktype(argv[4], JANET_NIL))
             src_end = janet_gethalfrange(argv, 4, src.len, "src-end");
         length_src = src_end - offset_src;
-        if (length_src < 0) length_src = 0;
     } else {
         length_src = src.len - offset_src;
     }
-    int64_t last = (int64_t) offset_dest + length_src;
-    if (last > INT32_MAX)
+    size_t last = offset_dest + length_src;
+    if (last > JANET_INTMAX_SIZE)
         janet_panic("buffer blit out of range");
-    int32_t last32 = (int32_t) last;
+    size_t last32 = (size_t) last;
     janet_buffer_ensure(dest, last32, 2);
     if (last32 > dest->count) dest->count = last32;
     if (length_src) {
@@ -645,27 +647,6 @@ JANET_CORE_FN(cfun_buffer_format,
     return argv[0];
 }
 
-JANET_CORE_FN(cfun_buffer_format_at,
-              "(buffer/format-at buffer at format & args)",
-              "Snprintf like functionality for printing values into a buffer. Returns "
-              "the modified buffer.") {
-    janet_arity(argc, 2, -1);
-    JanetBuffer *buffer = janet_getbuffer(argv, 0);
-    int32_t at = janet_getinteger(argv, 1);
-    if (at < 0) {
-        at += buffer->count + 1;
-    }
-    if (at > buffer->count || at < 0) janet_panicf("expected index at to be in range [0, %d), got %d", buffer->count, at);
-    int32_t oldcount = buffer->count;
-    buffer->count = at;
-    const char *strfrmt = (const char *) janet_getstring(argv, 2);
-    janet_buffer_format(buffer, strfrmt, 2, argc, argv);
-    if (buffer->count < oldcount) {
-        buffer->count = oldcount;
-    }
-    return argv[0];
-}
-
 void janet_lib_buffer(JanetTable *env) {
     JanetRegExt buffer_cfuns[] = {
         JANET_CORE_REG("buffer/new", cfun_buffer_new),
@@ -692,7 +673,6 @@ void janet_lib_buffer(JanetTable *env) {
         JANET_CORE_REG("buffer/bit-toggle", cfun_buffer_bittoggle),
         JANET_CORE_REG("buffer/blit", cfun_buffer_blit),
         JANET_CORE_REG("buffer/format", cfun_buffer_format),
-        JANET_CORE_REG("buffer/format-at", cfun_buffer_format_at),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, buffer_cfuns);

src/core/bytecode.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -140,7 +140,7 @@ void janet_bytecode_remove_noops(JanetFuncDef *def) {
                 /* relative pc is in DS field of instruction */
                 old_jump_target = i + (((int32_t)instr) >> 8);
                 new_jump_target = pc_map[old_jump_target];
-                instr += (uint32_t)(new_jump_target - old_jump_target + (i - j)) << 8;
+                instr += (new_jump_target - old_jump_target + (i - j)) << 8;
                 break;
             case JOP_JUMP_IF:
             case JOP_JUMP_IF_NIL:
@@ -149,7 +149,7 @@ void janet_bytecode_remove_noops(JanetFuncDef *def) {
                 /* relative pc is in ES field of instruction */
                 old_jump_target = i + (((int32_t)instr) >> 16);
                 new_jump_target = pc_map[old_jump_target];
-                instr += (uint32_t)(new_jump_target - old_jump_target + (i - j)) << 16;
+                instr += (new_jump_target - old_jump_target + (i - j)) << 16;
                 break;
             default:
                 break;

src/core/capi.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -25,18 +25,15 @@
 #include <janet.h>
 #include "state.h"
 #include "fiber.h"
-#include "util.h"
 #endif
 
 #ifndef JANET_SINGLE_THREADED
 #ifndef JANET_WINDOWS
 #include <pthread.h>
-#endif
-#endif
-
-#ifdef JANET_WINDOWS
+#else
 #include <windows.h>
 #endif
+#endif
 
 #ifdef JANET_USE_STDATOMIC
 #include <stdatomic.h>
@@ -62,18 +59,6 @@ JANET_NO_RETURN static void janet_top_level_signal(const char *msg) {
 
 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]));
-            }
-            sig = JANET_SIGNAL_ERROR;
-        }
         *janet_vm.return_reg = message;
         if (NULL != janet_vm.fiber) {
             janet_vm.fiber->flags |= JANET_FIBER_DID_LONGJUMP;
@@ -153,7 +138,7 @@ type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, type dflt) { \
 }
 
 #define DEFINE_OPTLEN(name, NAME, type) \
-type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len) { \
+type janet_opt##name(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len) { \
     if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {\
         return janet_##name(dflt_len); \
     }\
@@ -247,19 +232,19 @@ const char *janet_getcbytes(const Janet *argv, int32_t n) {
             char *new_string = janet_smalloc(b->count + 1);
             memcpy(new_string, b->data, b->count);
             new_string[b->count] = 0;
-            if (strlen(new_string) != (size_t) b->count) goto badzeros;
+            if (strlen(new_string) != b->count) goto badzeros;
             return new_string;
         } else {
             /* Ensure trailing 0 */
             janet_buffer_push_u8(b, 0);
             b->count--;
-            if (strlen((char *)b->data) != (size_t) b->count) goto badzeros;
+            if (strlen((char *)b->data) != b->count) goto badzeros;
             return (const char *) b->data;
         }
     }
     JanetByteView view = janet_getbytes(argv, n);
     const char *cstr = (const char *)view.bytes;
-    if (strlen(cstr) != (size_t) view.len) goto badzeros;
+    if (strlen(cstr) != view.len) goto badzeros;
     return cstr;
 
 badzeros:
@@ -318,28 +303,11 @@ int32_t janet_getinteger(const Janet *argv, int32_t n) {
 uint32_t janet_getuinteger(const Janet *argv, int32_t n) {
     Janet x = argv[n];
     if (!janet_checkuint(x)) {
-        janet_panicf("bad slot #%d, expected 32 bit unsigned integer, got %v", n, x);
+        janet_panicf("bad slot #%d, expected 32 bit signed integer, got %v", n, x);
     }
-    return (uint32_t) janet_unwrap_number(x);
+    return janet_unwrap_integer(x);
 }
 
-int16_t janet_getinteger16(const Janet *argv, int32_t n) {
-    Janet x = argv[n];
-    if (!janet_checkint16(x)) {
-        janet_panicf("bad slot #%d, expected 16 bit signed integer, got %v", n, x);
-    }
-    return (int16_t) janet_unwrap_number(x);
-}
-
-uint16_t janet_getuinteger16(const Janet *argv, int32_t n) {
-    Janet x = argv[n];
-    if (!janet_checkuint16(x)) {
-        janet_panicf("bad slot #%d, expected 16 bit unsigned integer, got %v", n, x);
-    }
-    return (uint16_t) janet_unwrap_number(x);
-}
-
-
 int64_t janet_getinteger64(const Janet *argv, int32_t n) {
 #ifdef JANET_INT_TYPES
     return janet_unwrap_s64(argv[n]);
@@ -369,39 +337,47 @@ size_t janet_getsize(const Janet *argv, int32_t n) {
     if (!janet_checksize(x)) {
         janet_panicf("bad slot #%d, expected size, got %v", n, x);
     }
-    return (size_t) janet_unwrap_number(x);
+    return janet_unwrap_size(x);
 }
 
-int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which) {
-    int32_t raw = janet_getinteger(argv, n);
-    int32_t not_raw = raw;
+ssize_t janet_getssize(const Janet *argv, int32_t n) {
+    Janet x = argv[n];
+    if (!janet_checkssize(x)) {
+        janet_panicf("bad slot #%d, expected ssize, got %v", n, x);
+    }
+    return janet_unwrap_ssize(x);
+}
+
+size_t janet_gethalfrange(const Janet *argv, int32_t n, size_t length, const char *which) {
+    ssize_t raw = janet_getssize(argv, n);
+    ssize_t not_raw = raw;
     if (not_raw < 0) not_raw += length + 1;
-    if (not_raw < 0 || not_raw > length)
+    if (not_raw < 0 || (size_t) not_raw > length)
         janet_panicf("%s index %d out of range [%d,%d]", which, (int64_t) raw, -(int64_t)length - 1, (int64_t) length);
-    return not_raw;
+    return (size_t) not_raw;
 }
 
-int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) {
+size_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, size_t length) {
     if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
         return 0;
     }
     return janet_gethalfrange(argv, n, length, "start");
 }
 
-int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length) {
+size_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, size_t length) {
     if (n >= argc || janet_checktype(argv[n], JANET_NIL)) {
         return length;
     }
     return janet_gethalfrange(argv, n, length, "end");
 }
 
-int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which) {
-    int32_t raw = janet_getinteger(argv, n);
-    int32_t not_raw = raw;
+size_t janet_getargindex(const Janet *argv, int32_t n, size_t length, const char *which) {
+    ssize_t raw = janet_getssize(argv, n);
+    ssize_t not_raw = raw;
     if (not_raw < 0) not_raw += length;
-    if (not_raw < 0 || not_raw > length)
+    if (not_raw < 0 || (size_t) not_raw > length)
         janet_panicf("%s index %d out of range [%d,%d)", which, (int64_t)raw, -(int64_t)length, (int64_t)length);
-    return not_raw;
+    return (size_t) not_raw;
 }
 
 JanetView janet_getindexed(const Janet *argv, int32_t n) {
@@ -446,7 +422,7 @@ void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *a
 JanetRange janet_getslice(int32_t argc, const Janet *argv) {
     janet_arity(argc, 1, 3);
     JanetRange range;
-    int32_t length = janet_length(argv[0]);
+    size_t length = janet_length(argv[0]);
     range.start = janet_getstartrange(argv, argc, 1, length);
     range.end = janet_getendrange(argv, argc, 2, length);
     if (range.end < range.start)
@@ -478,43 +454,16 @@ void janet_setdyn(const char *name, Janet value) {
     }
 }
 
-/* Create a function that when called, returns X. Trivial in Janet, a pain in C. */
-JanetFunction *janet_thunk_delay(Janet x) {
-    static const uint32_t bytecode[] = {
-        JOP_LOAD_CONSTANT,
-        JOP_RETURN
-    };
-    JanetFuncDef *def = janet_funcdef_alloc();
-    def->arity = 0;
-    def->min_arity = 0;
-    def->max_arity = INT32_MAX;
-    def->flags = JANET_FUNCDEF_FLAG_VARARG;
-    def->slotcount = 1;
-    def->bytecode = janet_malloc(sizeof(bytecode));
-    def->bytecode_length = (int32_t)(sizeof(bytecode) / sizeof(uint32_t));
-    def->constants = janet_malloc(sizeof(Janet));
-    def->constants_length = 1;
-    def->name = NULL;
-    if (!def->bytecode || !def->constants) {
-        JANET_OUT_OF_MEMORY;
-    }
-    def->constants[0] = x;
-    memcpy(def->bytecode, bytecode, sizeof(bytecode));
-    janet_def_addflags(def);
-    /* janet_verify(def); */
-    return janet_thunk(def);
-}
-
 uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags) {
     uint64_t ret = 0;
     const uint8_t *keyw = janet_getkeyword(argv, n);
-    int32_t klen = janet_string_length(keyw);
-    int32_t flen = (int32_t) strlen(flags);
+    size_t klen = janet_string_length(keyw);
+    size_t flen = strlen(flags);
     if (flen > 64) {
         flen = 64;
     }
-    for (int32_t j = 0; j < klen; j++) {
-        for (int32_t i = 0; i < flen; i++) {
+    for (size_t j = 0; j < klen; j++) {
+        for (size_t i = 0; i < flen; i++) {
             if (((uint8_t) flags[i]) == keyw[j]) {
                 ret |= 1ULL << i;
                 goto found;
@@ -551,6 +500,12 @@ size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt) {
     return janet_getsize(argv, n);
 }
 
+ssize_t janet_optssize(const Janet *argv, int32_t argc, int32_t n, ssize_t dflt) {
+    if (argc <= n) return dflt;
+    if (janet_checktype(argv[n], JANET_NIL)) return dflt;
+    return janet_getssize(argv, n);
+}
+
 void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, void *dflt) {
     if (argc <= n) return dflt;
     if (janet_checktype(argv[n], JANET_NIL)) return dflt;
@@ -560,8 +515,8 @@ void *janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetA
 /* Atomic refcounts */
 
 JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) {
-#ifdef _MSC_VER
-    return _InterlockedIncrement(x);
+#ifdef JANET_WINDOWS
+    return InterlockedIncrement(x);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_fetch_add_explicit(x, 1, memory_order_relaxed) + 1;
 #else
@@ -570,8 +525,8 @@ JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x) {
 }
 
 JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x) {
-#ifdef _MSC_VER
-    return _InterlockedDecrement(x);
+#ifdef JANET_WINDOWS
+    return InterlockedDecrement(x);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_fetch_add_explicit(x, -1, memory_order_acq_rel) - 1;
 #else
@@ -580,8 +535,8 @@ JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x) {
 }
 
 JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) {
-#ifdef _MSC_VER
-    return _InterlockedOr(x, 0);
+#ifdef JANET_WINDOWS
+    return InterlockedOr(x, 0);
 #elif defined(JANET_USE_STDATOMIC)
     return atomic_load_explicit(x, memory_order_acquire);
 #else
@@ -589,16 +544,6 @@ 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/cfuns.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/compile.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -418,12 +418,11 @@ JanetSlot janetc_gettarget(JanetFopts opts) {
 }
 
 /* Get a bunch of slots for function arguments */
-JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len) {
-    int32_t i;
+JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, size_t len) {
     JanetSlot *ret = NULL;
     JanetFopts subopts = janetc_fopts_default(c);
     subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE;
-    for (i = 0; i < len; i++) {
+    for (size_t i = 0; i < len; i++) {
         janet_v_push(ret, janetc_value(subopts, vals[i]));
     }
     return ret;
@@ -435,9 +434,9 @@ JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds) {
     JanetFopts subopts = janetc_fopts_default(c);
     subopts.flags |= JANET_FOPTS_ACCEPT_SPLICE;
     const JanetKV *kvs = NULL;
-    int32_t cap = 0, len = 0;
+    size_t cap = 0, len = 0;
     janet_dictionary_view(ds, &kvs, &len, &cap);
-    for (int32_t i = 0; i < cap; i++) {
+    for (size_t i = 0; i < cap; i++) {
         if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
         janet_v_push(ret, janetc_value(subopts, kvs[i].key));
         janet_v_push(ret, janetc_value(subopts, kvs[i].value));
@@ -934,7 +933,7 @@ JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c) {
         int32_t slotchunks = (def->slotcount + 31) >> 5;
         /* numchunks is min of slotchunks and scope->ua.count */
         int32_t numchunks = slotchunks > scope->ua.count ? scope->ua.count : slotchunks;
-        uint32_t *chunks = janet_calloc(slotchunks, sizeof(uint32_t));
+        uint32_t *chunks = janet_calloc(sizeof(uint32_t), slotchunks);
         if (NULL == chunks) {
             JANET_OUT_OF_MEMORY;
         }
@@ -1056,7 +1055,7 @@ JanetCompileResult janet_compile_lint(Janet source,
 
     if (c.result.status == JANET_COMPILE_OK) {
         JanetFuncDef *def = janetc_pop_funcdef(&c);
-        def->name = janet_cstring("thunk");
+        def->name = janet_cstring("_thunk");
         janet_def_addflags(def);
         c.result.funcdef = def;
     } else {

src/core/compile.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -232,7 +232,7 @@ void janetc_throwaway(JanetFopts opts, Janet x);
 JanetSlot janetc_gettarget(JanetFopts opts);
 
 /* Get a bunch of slots for function arguments */
-JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, int32_t len);
+JanetSlot *janetc_toslots(JanetCompiler *c, const Janet *vals, size_t len);
 
 /* Get a bunch of slots for function arguments */
 JanetSlot *janetc_toslotskv(JanetCompiler *c, Janet ds);
@@ -262,7 +262,7 @@ void janetc_popscope(JanetCompiler *c);
 void janetc_popscope_keepslot(JanetCompiler *c, JanetSlot retslot);
 JanetFuncDef *janetc_pop_funcdef(JanetCompiler *c);
 
-/* Create a destroy slot */
+/* Create a destory slots */
 JanetSlot janetc_cslot(Janet x);
 
 /* Search for a symbol */

src/core/corelib.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -66,18 +66,18 @@ 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)",
-                 host.major,
-                 host.minor,
-                 host.patch,
-                 host.bits,
-                 modconf.major,
-                 modconf.minor,
-                 modconf.patch,
-                 modconf.bits);
+        sprintf(errbuf, "config mismatch - host %d.%.d.%d(%.4x) vs. module %d.%d.%d(%.4x)",
+                host.major,
+                host.minor,
+                host.patch,
+                host.bits,
+                modconf.major,
+                modconf.minor,
+                modconf.patch,
+                modconf.bits);
         *error = janet_cstring(errbuf);
         return NULL;
     }
@@ -92,7 +92,7 @@ static const char *janet_dyncstring(const char *name, const char *dflt) {
     }
     const uint8_t *jstr = janet_unwrap_string(x);
     const char *cstr = (const char *)jstr;
-    if (strlen(cstr) != (size_t) janet_string_length(jstr)) {
+    if (strlen(cstr) != janet_string_length(jstr)) {
         janet_panicf("string %v contains embedded 0s", x);
     }
     return cstr;
@@ -432,39 +432,27 @@ JANET_CORE_FN(janet_core_range,
               "With one argument, returns a range [0, end). With two arguments, returns "
               "a range [start, end). With three, returns a range with optional step size.") {
     janet_arity(argc, 1, 3);
-    double start = 0, stop = 0, step = 1, count = 0;
+    int32_t start = 0, stop = 0, step = 1, count = 0;
     if (argc == 3) {
-        start = janet_getnumber(argv, 0);
-        stop = janet_getnumber(argv, 1);
-        step = janet_getnumber(argv, 2);
-        count = (step > 0) ? (stop - start) / step :
-                ((step < 0) ? (stop - start) / step : 0);
+        start = janet_getinteger(argv, 0);
+        stop = janet_getinteger(argv, 1);
+        step = janet_getinteger(argv, 2);
+        count = (step > 0) ? (stop - start - 1) / step + 1 :
+                ((step < 0) ? (stop - start + 1) / step + 1 : 0);
     } else if (argc == 2) {
-        start = janet_getnumber(argv, 0);
-        stop = janet_getnumber(argv, 1);
+        start = janet_getinteger(argv, 0);
+        stop = janet_getinteger(argv, 1);
         count = stop - start;
     } else {
-        stop = janet_getnumber(argv, 0);
+        stop = janet_getinteger(argv, 0);
         count = stop;
     }
     count = (count > 0) ? count : 0;
-    int32_t int_count;
-    janet_assert(count >= 0, "bad range code");
-    if (count > (double) INT32_MAX) {
-        janet_panicf("range is too large, %f elements", count);
-    } else {
-        int_count = (int32_t) ceil(count);
+    JanetArray *array = janet_array(count);
+    for (int32_t i = 0; i < count; i++) {
+        array->data[i] = janet_wrap_number(start + i * step);
     }
-    if (step > 0.0) {
-        janet_assert(start + int_count * step >= stop, "bad range code");
-    } else {
-        janet_assert(start + int_count * step <= stop, "bad range code");
-    }
-    JanetArray *array = janet_array(int_count);
-    for (int32_t i = 0; i < int_count; i++) {
-        array->data[i] = janet_wrap_number((double) start + (double) i * step);
-    }
-    array->count = int_count;
+    array->count = count;
     return janet_wrap_array(array);
 }
 
@@ -653,15 +641,22 @@ 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);
-    return janet_wrap_boolean(janet_checkint(argv[0]));
+    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();
 }
 
 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_checkint(argv[0])) return janet_wrap_false();
-    return janet_wrap_boolean(janet_unwrap_integer(argv[0]) >= 0);
+    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();
 }
 
 JANET_CORE_FN(janet_core_is_bytes,
@@ -694,15 +689,7 @@ JANET_CORE_FN(janet_core_is_lengthable,
 
 JANET_CORE_FN(janet_core_signal,
               "(signal what x)",
-              "Raise a signal with payload x. `what` can be an integer\n"
-              "from 0 through 7 indicating user(0-7), or one of:\n\n"
-              "* :ok\n"
-              "* :error\n"
-              "* :debug\n"
-              "* :yield\n"
-              "* :user(0-7)\n"
-              "* :interrupt\n"
-              "* :await") {
+              "Raise a signal with payload x. ") {
     janet_arity(argc, 1, 2);
     Janet payload = argc == 2 ? argv[1] : janet_wrap_nil();
     if (janet_checkint(argv[0])) {
@@ -731,12 +718,12 @@ JANET_CORE_FN(janet_core_memcmp,
     janet_arity(argc, 2, 5);
     JanetByteView a = janet_getbytes(argv, 0);
     JanetByteView b = janet_getbytes(argv, 1);
-    int32_t len = janet_optnat(argv, argc, 2, a.len < b.len ? a.len : b.len);
-    int32_t offset_a = janet_optnat(argv, argc, 3, 0);
-    int32_t offset_b = janet_optnat(argv, argc, 4, 0);
+    size_t len = janet_optsize(argv, argc, 2, a.len < b.len ? a.len : b.len);
+    size_t offset_a = janet_optsize(argv, argc, 3, 0);
+    size_t offset_b = janet_optsize(argv, argc, 4, 0);
     if (offset_a + len > a.len) janet_panicf("invalid offset-a: %d", offset_a);
     if (offset_b + len > b.len) janet_panicf("invalid offset-b: %d", offset_b);
-    return janet_wrap_integer(memcmp(a.bytes + offset_a, b.bytes + offset_b, (size_t) len));
+    return janet_wrap_integer(memcmp(a.bytes + offset_a, b.bytes + offset_b, len));
 }
 
 typedef struct SandboxOption {
@@ -746,7 +733,6 @@ typedef struct SandboxOption {
 
 static const SandboxOption sandbox_options[] = {
     {"all", JANET_SANDBOX_ALL},
-    {"chroot", JANET_SANDBOX_CHROOT},
     {"env", JANET_SANDBOX_ENV},
     {"ffi", JANET_SANDBOX_FFI},
     {"ffi-define", JANET_SANDBOX_FFI_DEFINE},
@@ -772,7 +758,6 @@ JANET_CORE_FN(janet_core_sandbox,
               "Disable feature sets to prevent the interpreter from using certain system resources. "
               "Once a feature is disabled, there is no way to re-enable it. Capabilities can be:\n\n"
               "* :all - disallow all (except IO to stdout, stderr, and stdin)\n"
-              "* :chroot - disallow calling `os/posix-chroot`\n"
               "* :env - disallow reading and write env variables\n"
               "* :ffi - disallow FFI (recommended if disabling anything else)\n"
               "* :ffi-define - disallow loading new FFI modules and binding new functions\n"
@@ -991,17 +976,18 @@ static void make_apply(JanetTable *env) {
         /* Push the array */
         S(JOP_PUSH_ARRAY, 5),
 
-        /* Call the function */
+        /* Call the funciton */
         S(JOP_TAILCALL, 0)
     };
     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 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."));
+                         "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."));
 }
 
 static const uint32_t error_asm[] = {
@@ -1135,9 +1121,6 @@ static void janet_load_libs(JanetTable *env) {
 #endif
 #ifdef JANET_EV
     janet_lib_ev(env);
-#ifdef JANET_FILEWATCH
-    janet_lib_filewatch(env);
-#endif
 #endif
 #ifdef JANET_NET
     janet_lib_net(env);
@@ -1154,82 +1137,82 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     janet_quick_asm(env, JANET_FUN_CMP,
                     "cmp", 2, 2, 2, 2, cmp_asm, sizeof(cmp_asm),
                     JDOC("(cmp x y)\n\n"
-         "Returns -1 if x is strictly less than y, 1 if y is strictly greater "
-         "than x, and 0 otherwise. To return 0, x and y must be the exact same type."));
+                         "Returns -1 if x is strictly less than y, 1 if y is strictly greater "
+                         "than x, and 0 otherwise. To return 0, x and y must be the exact same type."));
     janet_quick_asm(env, JANET_FUN_NEXT,
                     "next", 2, 1, 2, 2, next_asm, sizeof(next_asm),
                     JDOC("(next ds &opt key)\n\n"
-         "Gets the next key in a data structure. Can be used to iterate through "
-         "the keys of a data structure in an unspecified order. Keys are guaranteed "
-         "to be seen only once per iteration if the data structure is not mutated "
-         "during iteration. If key is nil, next returns the first key. If next "
-         "returns nil, there are no more keys to iterate through."));
+                         "Gets the next key in a data structure. Can be used to iterate through "
+                         "the keys of a data structure in an unspecified order. Keys are guaranteed "
+                         "to be seen only once per iteration if the data structure is not mutated "
+                         "during iteration. If key is nil, next returns the first key. If next "
+                         "returns nil, there are no more keys to iterate through."));
     janet_quick_asm(env, JANET_FUN_PROP,
                     "propagate", 2, 2, 2, 2, propagate_asm, sizeof(propagate_asm),
                     JDOC("(propagate x fiber)\n\n"
-         "Propagate a signal from a fiber to the current fiber and "
-         "set the last value of the current fiber to `x`.  The signal "
-         "value is then available as the status of the current fiber. "
-         "The resulting stack trace from the current fiber will include "
-         "frames from fiber. If fiber is in a state that can be resumed, "
-         "resuming the current fiber will first resume `fiber`. "
-         "This function can be used to re-raise an error without losing "
-         "the original stack trace."));
+                         "Propagate a signal from a fiber to the current fiber and "
+                         "set the last value of the current fiber to `x`.  The signal "
+                         "value is then available as the status of the current fiber. "
+                         "The resulting stack trace from the current fiber will include "
+                         "frames from fiber. If fiber is in a state that can be resumed, "
+                         "resuming the current fiber will first resume `fiber`. "
+                         "This function can be used to re-raise an error without losing "
+                         "the original stack trace."));
     janet_quick_asm(env, JANET_FUN_DEBUG,
                     "debug", 1, 0, 1, 1, debug_asm, sizeof(debug_asm),
                     JDOC("(debug &opt x)\n\n"
-         "Throws a debug signal that can be caught by a parent fiber and used to inspect "
-         "the running state of the current fiber. Returns the value passed in by resume."));
+                         "Throws a debug signal that can be caught by a parent fiber and used to inspect "
+                         "the running state of the current fiber. Returns the value passed in by resume."));
     janet_quick_asm(env, JANET_FUN_ERROR,
                     "error", 1, 1, 1, 1, error_asm, sizeof(error_asm),
                     JDOC("(error e)\n\n"
-         "Throws an error e that can be caught and handled by a parent fiber."));
+                         "Throws an error e that can be caught and handled by a parent fiber."));
     janet_quick_asm(env, JANET_FUN_YIELD,
                     "yield", 1, 0, 1, 2, yield_asm, sizeof(yield_asm),
                     JDOC("(yield &opt x)\n\n"
-         "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
-         "another thread resumes it. The fiber will then resume, and the last yield call will "
-         "return the value that was passed to resume."));
+                         "Yield a value to a parent fiber. When a fiber yields, its execution is paused until "
+                         "another thread resumes it. The fiber will then resume, and the last yield call will "
+                         "return the value that was passed to resume."));
     janet_quick_asm(env, JANET_FUN_CANCEL,
                     "cancel", 2, 2, 2, 2, cancel_asm, sizeof(cancel_asm),
                     JDOC("(cancel fiber err)\n\n"
-         "Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. "
-         "Returns the same result as resume."));
+                         "Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. "
+                         "Returns the same result as resume."));
     janet_quick_asm(env, JANET_FUN_RESUME,
                     "resume", 2, 1, 2, 2, resume_asm, sizeof(resume_asm),
                     JDOC("(resume fiber &opt x)\n\n"
-         "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
-         "will be returned to the last yield in the case of a pending fiber, or the argument to "
-         "the dispatch function in the case of a new fiber. Returns either the return result of "
-         "the fiber's dispatch function, or the value from the next yield call in fiber."));
+                         "Resume a new or suspended fiber and optionally pass in a value to the fiber that "
+                         "will be returned to the last yield in the case of a pending fiber, or the argument to "
+                         "the dispatch function in the case of a new fiber. Returns either the return result of "
+                         "the fiber's dispatch function, or the value from the next yield call in fiber."));
     janet_quick_asm(env, JANET_FUN_IN,
                     "in", 3, 2, 3, 4, in_asm, sizeof(in_asm),
                     JDOC("(in ds key &opt dflt)\n\n"
-         "Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, "
-         "strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, "
-         "and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can "
-         "take any value as a key except nil and will return nil or dflt if not found."));
+                         "Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, "
+                         "strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, "
+                         "and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can "
+                         "take any value as a key except nil and will return nil or dflt if not found."));
     janet_quick_asm(env, JANET_FUN_GET,
                     "get", 3, 2, 3, 4, get_asm, sizeof(in_asm),
                     JDOC("(get ds key &opt dflt)\n\n"
-         "Get the value mapped to key in data structure ds, and return dflt or nil if not found. "
-         "Similar to in, but will not throw an error if the key is invalid for the data structure "
-         "unless the data structure is an abstract type. In that case, the abstract type getter may throw "
-         "an error."));
+                         "Get the value mapped to key in data structure ds, and return dflt or nil if not found. "
+                         "Similar to in, but will not throw an error if the key is invalid for the data structure "
+                         "unless the data structure is an abstract type. In that case, the abstract type getter may throw "
+                         "an error."));
     janet_quick_asm(env, JANET_FUN_PUT,
                     "put", 3, 3, 3, 3, put_asm, sizeof(put_asm),
                     JDOC("(put ds key value)\n\n"
-         "Associate a key with a value in any mutable associative data structure. Indexed data structures "
-         "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
-         "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
-         "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
-         "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
-         "a value nil into a table will remove the key from the table. Returns the data structure ds."));
+                         "Associate a key with a value in any mutable associative data structure. Indexed data structures "
+                         "(arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds "
+                         "value is provided. In an array, extra space will be filled with nils, and in a buffer, extra "
+                         "space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype "
+                         "will hide the association defined by the prototype, but will not mutate the prototype table. Putting "
+                         "a value nil into a table will remove the key from the table. Returns the data structure ds."));
     janet_quick_asm(env, JANET_FUN_LENGTH,
                     "length", 1, 1, 1, 1, length_asm, sizeof(length_asm),
                     JDOC("(length ds)\n\n"
-         "Returns the length or count of a data structure in constant time as an integer. For "
-         "structs and tables, returns the number of key-value pairs in the data structure."));
+                         "Returns the length or count of a data structure in constant time as an integer. For "
+                         "structs and tables, returns the number of key-value pairs in the data structure."));
     janet_quick_asm(env, JANET_FUN_BNOT,
                     "bnot", 1, 1, 1, 1, bnot_asm, sizeof(bnot_asm),
                     JDOC("(bnot x)\n\nReturns the bit-wise inverse of integer x."));
@@ -1238,74 +1221,74 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     /* Variadic ops */
     templatize_varop(env, JANET_FUN_ADD, "+", 0, 0, JOP_ADD,
                      JDOC("(+ & xs)\n\n"
-         "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0."));
+                          "Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0."));
     templatize_varop(env, JANET_FUN_SUBTRACT, "-", 0, 0, JOP_SUBTRACT,
                      JDOC("(- & xs)\n\n"
-         "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
-         "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
-         "the rest of the elements."));
+                          "Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the "
+                          "negative value of that element. Otherwise, returns the first element in xs minus the sum of "
+                          "the rest of the elements."));
     templatize_varop(env, JANET_FUN_MULTIPLY, "*", 1, 1, JOP_MULTIPLY,
                      JDOC("(* & xs)\n\n"
-         "Returns the product of all elements in xs. If xs is empty, returns 1."));
+                          "Returns the product of all elements in xs. If xs is empty, returns 1."));
     templatize_varop(env, JANET_FUN_DIVIDE, "/", 1, 1, JOP_DIVIDE,
                      JDOC("(/ & xs)\n\n"
-         "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
-         "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
-         "values."));
+                          "Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns "
+                          "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
+                          "values."));
     templatize_varop(env, JANET_FUN_DIVIDE_FLOOR, "div", 1, 1, JOP_DIVIDE_FLOOR,
                      JDOC("(div & xs)\n\n"
-         "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns "
-         "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
-         "values."));
+                          "Returns the floored division of xs. If xs is empty, returns 1. If xs has one value x, returns "
+                          "the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining "
+                          "values."));
     templatize_varop(env, JANET_FUN_MODULO, "mod", 0, 1, JOP_MODULO,
                      JDOC("(mod & xs)\n\n"
-         "Returns the result of applying the modulo operator on the first value of xs with each remaining value. "
-         "`(mod x 0)` is defined to be `x`."));
+                          "Returns the result of applying the modulo operator on the first value of xs with each remaining value. "
+                          "`(mod x 0)` is defined to be `x`."));
     templatize_varop(env, JANET_FUN_REMAINDER, "%", 0, 1, JOP_REMAINDER,
                      JDOC("(% & xs)\n\n"
-         "Returns the remainder of dividing the first value of xs by each remaining value."));
+                          "Returns the remainder of dividing the first value of xs by each remaining value."));
     templatize_varop(env, JANET_FUN_BAND, "band", -1, -1, JOP_BAND,
                      JDOC("(band & xs)\n\n"
-         "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
+                          "Returns the bit-wise and of all values in xs. Each x in xs must be an integer."));
     templatize_varop(env, JANET_FUN_BOR, "bor", 0, 0, JOP_BOR,
                      JDOC("(bor & xs)\n\n"
-         "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
+                          "Returns the bit-wise or of all values in xs. Each x in xs must be an integer."));
     templatize_varop(env, JANET_FUN_BXOR, "bxor", 0, 0, JOP_BXOR,
                      JDOC("(bxor & xs)\n\n"
-         "Returns the bit-wise xor of all values in xs. Each in xs must be an integer."));
+                          "Returns the bit-wise xor of all values in xs. Each in xs must be an integer."));
     templatize_varop(env, JANET_FUN_LSHIFT, "blshift", 1, 1, JOP_SHIFT_LEFT,
                      JDOC("(blshift x & shifts)\n\n"
-         "Returns the value of x bit shifted left by the sum of all values in shifts. x "
-         "and each element in shift must be an integer."));
+                          "Returns the value of x bit shifted left by the sum of all values in shifts. x "
+                          "and each element in shift must be an integer."));
     templatize_varop(env, JANET_FUN_RSHIFT, "brshift", 1, 1, JOP_SHIFT_RIGHT,
                      JDOC("(brshift x & shifts)\n\n"
-         "Returns the value of x bit shifted right by the sum of all values in shifts. x "
-         "and each element in shift must be an integer."));
+                          "Returns the value of x bit shifted right by the sum of all values in shifts. x "
+                          "and each element in shift must be an integer."));
     templatize_varop(env, JANET_FUN_RSHIFTU, "brushift", 1, 1, JOP_SHIFT_RIGHT_UNSIGNED,
                      JDOC("(brushift x & shifts)\n\n"
-         "Returns the value of x bit shifted right by the sum of all values in shifts. x "
-         "and each element in shift must be an integer. The sign of x is not preserved, so "
-         "for positive shifts the return value will always be positive."));
+                          "Returns the value of x bit shifted right by the sum of all values in shifts. x "
+                          "and each element in shift must be an integer. The sign of x is not preserved, so "
+                          "for positive shifts the return value will always be positive."));
 
     /* Variadic comparators */
     templatize_comparator(env, JANET_FUN_GT, ">", 0, JOP_GREATER_THAN,
                           JDOC("(> & xs)\n\n"
-         "Check if xs is in descending order. Returns a boolean."));
+                               "Check if xs is in descending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_LT, "<", 0, JOP_LESS_THAN,
                           JDOC("(< & xs)\n\n"
-         "Check if xs is in ascending order. Returns a boolean."));
+                               "Check if xs is in ascending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_GTE, ">=", 0, JOP_GREATER_THAN_EQUAL,
                           JDOC("(>= & xs)\n\n"
-         "Check if xs is in non-ascending order. Returns a boolean."));
+                               "Check if xs is in non-ascending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_LTE, "<=", 0, JOP_LESS_THAN_EQUAL,
                           JDOC("(<= & xs)\n\n"
-         "Check if xs is in non-descending order. Returns a boolean."));
+                               "Check if xs is in non-descending order. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_EQ, "=", 0, JOP_EQUALS,
                           JDOC("(= & xs)\n\n"
-         "Check if all values in xs are equal. Returns a boolean."));
+                               "Check if all values in xs are equal. Returns a boolean."));
     templatize_comparator(env, JANET_FUN_NEQ, "not=", 1, JOP_EQUALS,
                           JDOC("(not= & xs)\n\n"
-         "Check if any values in xs are not equal. Returns a boolean."));
+                               "Check if any values in xs are not equal. Returns a boolean."));
 
     /* Platform detection */
     janet_def(env, "janet/version", janet_cstringv(JANET_VERSION),
@@ -1314,7 +1297,7 @@ JanetTable *janet_core_env(JanetTable *replacements) {
               JDOC("The build identifier of the running janet program."));
     janet_def(env, "janet/config-bits", janet_wrap_integer(JANET_CURRENT_CONFIG_BITS),
               JDOC("The flag set of config options from janetconf.h which is used to check "
-         "if native modules are compatible with the host program."));
+                   "if native modules are compatible with the host program."));
 
     /* Allow references to the environment */
     janet_def(env, "root-env", janet_wrap_table(env),
@@ -1356,7 +1339,7 @@ JanetTable *janet_core_env(JanetTable *replacements) {
     janet_resolve(env, janet_csymbol("make-image-dict"), &midv);
     JanetTable *lid = janet_unwrap_table(lidv);
     JanetTable *mid = janet_unwrap_table(midv);
-    for (int32_t i = 0; i < lid->capacity; i++) {
+    for (size_t i = 0; i < lid->capacity; i++) {
         const JanetKV *kv = lid->data + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
             janet_table_put(mid, kv->value, kv->key);
@@ -1374,7 +1357,7 @@ JanetTable *janet_core_lookup_table(JanetTable *replacements) {
 
     /* Add replacements */
     if (replacements != NULL) {
-        for (int32_t i = 0; i < replacements->capacity; i++) {
+        for (size_t i = 0; i < replacements->capacity; i++) {
             JanetKV kv = replacements->data[i];
             if (!janet_checktype(kv.key, JANET_NIL)) {
                 janet_table_put(dict, kv.key, kv.value);

src/core/debug.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -102,7 +102,7 @@ void janet_stacktrace(JanetFiber *fiber, Janet err) {
 }
 
 /* Error reporting. This can be emulated from within Janet, but for
- * consistency with the top level code it is defined once. */
+ * consitency with the top level code it is defined once. */
 void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
 
     int32_t fi;
@@ -164,7 +164,7 @@ void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
                 }
             }
             if (frame->flags & JANET_STACKFRAME_TAILCALL)
-                janet_eprintf(" (tail call)");
+                janet_eprintf(" (tailcall)");
             if (frame->func && frame->pc) {
                 int32_t off = (int32_t)(frame->pc - def->bytecode);
                 if (def->sourcemap) {
@@ -180,11 +180,6 @@ void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *prefix) {
                 }
             }
             janet_eprintf("\n");
-            /* Print fiber points optionally. Clutters traces but provides info
-            if (i <= 0 && fi > 0) {
-                janet_eprintf("  in parent fiber\n");
-            }
-            */
         }
     }
 

src/core/emit.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/emit.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/features.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -76,6 +76,4 @@
 #define __BSD_VISIBLE 1
 #endif
 
-#define _FILE_OFFSET_BITS 64
-
 #endif

src/core/ffi.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -56,9 +56,6 @@
 #if (defined(__x86_64__) || defined(_M_X64)) && !defined(JANET_WINDOWS)
 #define JANET_FFI_SYSV64_ENABLED
 #endif
-#if (defined(__aarch64__) || defined(_M_ARM64)) && !defined(JANET_WINDOWS)
-#define JANET_FFI_AAPCS64_ENABLED
-#endif
 
 typedef struct JanetFFIType JanetFFIType;
 typedef struct JanetFFIStruct JanetFFIStruct;
@@ -110,7 +107,7 @@ static const JanetFFIPrimInfo janet_ffi_type_info[] = {
 struct JanetFFIType {
     JanetFFIStruct *st;
     JanetFFIPrimType prim;
-    int32_t array_count;
+    ssize_t array_count;
 };
 
 typedef struct {
@@ -143,13 +140,7 @@ typedef enum {
     JANET_WIN64_REGISTER,
     JANET_WIN64_STACK,
     JANET_WIN64_REGISTER_REF,
-    JANET_WIN64_STACK_REF,
-    JANET_AAPCS64_GENERAL,
-    JANET_AAPCS64_SSE,
-    JANET_AAPCS64_GENERAL_REF,
-    JANET_AAPCS64_STACK,
-    JANET_AAPCS64_STACK_REF,
-    JANET_AAPCS64_NONE
+    JANET_WIN64_STACK_REF
 } JanetFFIWordSpec;
 
 /* Describe how each Janet argument is interpreted in terms of machine words
@@ -164,16 +155,13 @@ typedef struct {
 typedef enum {
     JANET_FFI_CC_NONE,
     JANET_FFI_CC_SYSV_64,
-    JANET_FFI_CC_WIN_64,
-    JANET_FFI_CC_AAPCS64
+    JANET_FFI_CC_WIN_64
 } JanetFFICallingConvention;
 
 #ifdef JANET_FFI_WIN64_ENABLED
 #define JANET_FFI_CC_DEFAULT JANET_FFI_CC_WIN_64
 #elif defined(JANET_FFI_SYSV64_ENABLED)
 #define JANET_FFI_CC_DEFAULT JANET_FFI_CC_SYSV_64
-#elif defined(JANET_FFI_AAPCS64_ENABLED)
-#define JANET_FFI_CC_DEFAULT JANET_FFI_CC_AAPCS64
 #else
 #define JANET_FFI_CC_DEFAULT JANET_FFI_CC_NONE
 #endif
@@ -313,9 +301,6 @@ static JanetFFICallingConvention decode_ffi_cc(const uint8_t *name) {
 #endif
 #ifdef JANET_FFI_SYSV64_ENABLED
     if (!janet_cstrcmp(name, "sysv64")) return JANET_FFI_CC_SYSV_64;
-#endif
-#ifdef JANET_FFI_AAPCS64_ENABLED
-    if (!janet_cstrcmp(name, "aapcs64")) return JANET_FFI_CC_AAPCS64;
 #endif
     if (!janet_cstrcmp(name, "default")) return JANET_FFI_CC_DEFAULT;
     janet_panicf("unknown calling convention %s", name);
@@ -400,7 +385,7 @@ static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) {
 
     JanetFFIStruct *st = janet_abstract(&janet_struct_type,
                                         sizeof(JanetFFIStruct) + argc * sizeof(JanetFFIStructMember));
-    st->field_count = 0;
+    st->field_count = member_count;
     st->size = 0;
     st->align = 1;
     if (argc == 0) {
@@ -418,13 +403,12 @@ static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) {
         st->fields[i].type = decode_ffi_type(argv[j]);
         size_t el_size = type_size(st->fields[i].type);
         size_t el_align = type_align(st->fields[i].type);
-        if (el_align <= 0) janet_panicf("bad field type %V", argv[j]);
         if (all_packed || pack_one) {
             if (st->size % el_align != 0) is_aligned = 0;
             st->fields[i].offset = st->size;
             st->size += (uint32_t) el_size;
         } else {
-            if (el_align > st->align) st->align = (uint32_t) el_align;
+            if (el_align > (size_t) st->align) st->align = (uint32_t) el_align;
             st->fields[i].offset = (uint32_t)(((st->size + el_align - 1) / el_align) * el_align);
             st->size = (uint32_t)(el_size + st->fields[i].offset);
         }
@@ -434,7 +418,6 @@ static JanetFFIStruct *build_struct_type(int32_t argc, const Janet *argv) {
     st->size += (st->align - 1);
     st->size /= st->align;
     st->size *= st->align;
-    st->field_count = member_count;
     return st;
 }
 
@@ -449,13 +432,13 @@ static JanetFFIType decode_ffi_type(Janet x) {
         ret.st = janet_unwrap_abstract(x);
         return ret;
     }
-    int32_t len;
+    size_t len;
     const Janet *els;
     if (janet_indexed_view(x, &els, &len)) {
         if (janet_checktype(x, JANET_ARRAY)) {
             if (len != 2 && len != 1) janet_panicf("array type must be of form @[type count], got %v", x);
             ret = decode_ffi_type(els[0]);
-            int32_t array_count = len == 1 ? 0 : janet_getnat(els, 1);
+            ssize_t array_count = len == 1 ? 0 : janet_getssize(els, 1);
             ret.array_count = array_count;
         } else {
             ret.st = build_struct_type(len, els);
@@ -492,7 +475,7 @@ JANET_CORE_FN(cfun_ffi_align,
 static void *janet_ffi_getpointer(const Janet *argv, int32_t n) {
     switch (janet_type(argv[n])) {
         default:
-            janet_panicf("bad slot #%d, expected ffi pointer convertible type, got %v", n, argv[n]);
+            janet_panicf("bad slot #%d, expected ffi pointer convertable type, got %v", n, argv[n]);
         case JANET_POINTER:
         case JANET_STRING:
         case JANET_KEYWORD:
@@ -535,11 +518,11 @@ static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFI
         el_type.array_count = -1;
         size_t el_size = type_size(el_type);
         JanetView els = janet_getindexed(argv, n);
-        if (els.len != type.array_count) {
+        if (els.len != (size_t) type.array_count) {
             janet_panicf("bad array length, expected %d, got %d", type.array_count, els.len);
         }
         char *cursor = to;
-        for (int32_t i = 0; i < els.len; i++) {
+        for (size_t i = 0; i < els.len; i++) {
             janet_ffi_write_one(cursor, els.items, i, el_type, recur - 1);
             cursor += el_size;
         }
@@ -558,7 +541,7 @@ static void janet_ffi_write_one(void *to, const Janet *argv, int32_t n, JanetFFI
                 janet_panicf("wrong number of fields in struct, expected %d, got %d",
                              (int32_t) st->field_count, els.len);
             }
-            for (int32_t i = 0; i < els.len; i++) {
+            for (size_t i = 0; i < els.len; i++) {
                 JanetFFIType tp = st->fields[i].type;
                 janet_ffi_write_one((char *) to + st->fields[i].offset, els.items, i, tp, recur - 1);
             }
@@ -780,101 +763,6 @@ static JanetFFIWordSpec sysv64_classify(JanetFFIType type) {
 }
 #endif
 
-#ifdef JANET_FFI_AAPCS64_ENABLED
-/* Procedure Call Standard for the Arm® 64-bit Architecture (AArch64) 2023Q3 – October 6, 2023
- * See section 6.8.2 Parameter passing rules.
- * https://github.com/ARM-software/abi-aa/releases/download/2023Q3/aapcs64.pdf
- *
- * Additional documentation needed for Apple platforms.
- * https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms */
-
-#define JANET_FFI_AAPCS64_FORCE_STACK_ALIGN(ptr, alignment) (ptr = ((ptr) + ((alignment) - 1)) & ~((alignment) - 1))
-#if !defined(JANET_APPLE)
-#define JANET_FFI_AAPCS64_STACK_ALIGN(ptr, alignment) ((void) alignment, JANET_FFI_AAPCS64_FORCE_STACK_ALIGN(ptr, 8))
-#else
-#define JANET_FFI_AAPCS64_STACK_ALIGN(ptr, alignment) JANET_FFI_AAPCS64_FORCE_STACK_ALIGN(ptr, alignment)
-#endif
-
-typedef struct {
-    uint64_t a;
-    uint64_t b;
-} Aapcs64Variant1ReturnGeneral;
-
-typedef struct {
-    double a;
-    double b;
-    double c;
-    double d;
-} Aapcs64Variant2ReturnSse;
-
-/* Workaround for passing a return value pointer through x8.
- * Limits struct returns to 128 bytes. */
-typedef struct {
-    uint64_t a;
-    uint64_t b;
-    uint64_t c;
-    uint64_t d;
-    uint64_t e;
-    uint64_t f;
-    uint64_t g;
-    uint64_t h;
-    uint64_t i;
-    uint64_t j;
-    uint64_t k;
-    uint64_t l;
-    uint64_t m;
-    uint64_t n;
-    uint64_t o;
-    uint64_t p;
-} Aapcs64Variant3ReturnPointer;
-
-static JanetFFIWordSpec aapcs64_classify(JanetFFIType type) {
-    switch (type.prim) {
-        case JANET_FFI_TYPE_PTR:
-        case JANET_FFI_TYPE_STRING:
-        case JANET_FFI_TYPE_BOOL:
-        case JANET_FFI_TYPE_INT8:
-        case JANET_FFI_TYPE_INT16:
-        case JANET_FFI_TYPE_INT32:
-        case JANET_FFI_TYPE_INT64:
-        case JANET_FFI_TYPE_UINT8:
-        case JANET_FFI_TYPE_UINT16:
-        case JANET_FFI_TYPE_UINT32:
-        case JANET_FFI_TYPE_UINT64:
-            return JANET_AAPCS64_GENERAL;
-        case JANET_FFI_TYPE_DOUBLE:
-        case JANET_FFI_TYPE_FLOAT:
-            return JANET_AAPCS64_SSE;
-        case JANET_FFI_TYPE_STRUCT: {
-            JanetFFIStruct *st = type.st;
-            if (st->field_count <= 4 && aapcs64_classify(st->fields[0].type) == JANET_AAPCS64_SSE) {
-                bool is_hfa = true;
-                for (uint32_t i = 1; i < st->field_count; i++) {
-                    if (st->fields[0].type.prim != st->fields[i].type.prim) {
-                        is_hfa = false;
-                        break;
-                    }
-                }
-                if (is_hfa) {
-                    return JANET_AAPCS64_SSE;
-                }
-            }
-
-            if (type_size(type) > 16) {
-                return JANET_AAPCS64_GENERAL_REF;
-            }
-
-            return JANET_AAPCS64_GENERAL;
-        }
-        case JANET_FFI_TYPE_VOID:
-            return JANET_AAPCS64_NONE;
-        default:
-            janet_panic("nyi");
-            return JANET_AAPCS64_NONE;
-    }
-}
-#endif
-
 JANET_CORE_FN(cfun_ffi_signature,
               "(ffi/signature calling-convention ret-type & arg-types)",
               "Create a function signature object that can be used to make calls "
@@ -1072,96 +960,6 @@ JANET_CORE_FN(cfun_ffi_signature,
         }
         break;
 #endif
-
-#ifdef JANET_FFI_AAPCS64_ENABLED
-        case JANET_FFI_CC_AAPCS64: {
-            uint32_t next_general_reg = 0;
-            uint32_t next_fp_reg = 0;
-            uint32_t stack_offset = 0;
-            uint32_t ref_stack_offset = 0;
-
-            JanetFFIWordSpec ret_spec = aapcs64_classify(ret_type);
-            ret.spec = ret_spec;
-            if (ret_spec == JANET_AAPCS64_SSE) {
-                variant = 1;
-            } else if (ret_spec == JANET_AAPCS64_GENERAL_REF) {
-                if (type_size(ret_type) > sizeof(Aapcs64Variant3ReturnPointer)) {
-                    janet_panic("return value bigger than supported");
-                }
-                variant = 2;
-            } else {
-                variant = 0;
-            }
-
-            for (uint32_t i = 0; i < arg_count; i++) {
-                mappings[i].type = decode_ffi_type(argv[i + 2]);
-                mappings[i].spec = aapcs64_classify(mappings[i].type);
-                size_t arg_size = type_size(mappings[i].type);
-
-                switch (mappings[i].spec) {
-                    case JANET_AAPCS64_GENERAL: {
-                        bool arg_is_struct = mappings[i].type.prim == JANET_FFI_TYPE_STRUCT;
-                        uint32_t needed_registers = (arg_size + 7) / 8;
-                        if (next_general_reg + needed_registers <= 8) {
-                            mappings[i].offset = next_general_reg;
-                            next_general_reg += needed_registers;
-                        } else {
-                            size_t arg_align = arg_is_struct ? 8 : type_align(mappings[i].type);
-                            mappings[i].spec = JANET_AAPCS64_STACK;
-                            mappings[i].offset = JANET_FFI_AAPCS64_STACK_ALIGN(stack_offset, arg_align);
-#if !defined(JANET_APPLE)
-                            stack_offset += arg_size > 8 ? arg_size : 8;
-#else
-                            stack_offset += arg_size;
-#endif
-                            next_general_reg = 8;
-                        }
-                        break;
-                    }
-                    case JANET_AAPCS64_GENERAL_REF:
-                        if (next_general_reg < 8) {
-                            mappings[i].offset = next_general_reg++;
-                        } else {
-                            mappings[i].spec = JANET_AAPCS64_STACK_REF;
-                            mappings[i].offset = JANET_FFI_AAPCS64_STACK_ALIGN(stack_offset, 8);
-                            stack_offset += 8;
-                        }
-                        mappings[i].offset2 = JANET_FFI_AAPCS64_FORCE_STACK_ALIGN(ref_stack_offset, 8);
-                        ref_stack_offset += arg_size;
-                        break;
-                    case JANET_AAPCS64_SSE: {
-                        uint32_t needed_registers = (arg_size + 7) / 8;
-                        if (next_fp_reg + needed_registers <= 8) {
-                            mappings[i].offset = next_fp_reg;
-                            next_fp_reg += needed_registers;
-                        } else {
-                            mappings[i].spec = JANET_AAPCS64_STACK;
-                            mappings[i].offset = JANET_FFI_AAPCS64_STACK_ALIGN(stack_offset, 8);
-#if !defined(JANET_APPLE)
-                            stack_offset += 8;
-#else
-                            stack_offset += arg_size;
-#endif
-                        }
-                        break;
-                    }
-                    default:
-                        janet_panic("nyi");
-                }
-            }
-
-            stack_offset = (stack_offset + 15) & ~0xFUL;
-            ref_stack_offset = (ref_stack_offset + 15) & ~0xFUL;
-            stack_count = stack_offset + ref_stack_offset;
-
-            for (uint32_t i = 0; i < arg_count; i++) {
-                if (mappings[i].spec == JANET_AAPCS64_GENERAL_REF || mappings[i].spec == JANET_AAPCS64_STACK_REF) {
-                    mappings[i].offset2 = stack_offset + mappings[i].offset2;
-                }
-            }
-        }
-        break;
-#endif
     }
 
     /* Create signature abstract value */
@@ -1496,99 +1294,6 @@ static Janet janet_ffi_win64(JanetFFISignature *signature, void *function_pointe
 
 #endif
 
-#ifdef JANET_FFI_AAPCS64_ENABLED
-
-static void janet_ffi_aapcs64_standard_callback(void *ctx, void *userdata) {
-    janet_ffi_trampoline(ctx, userdata);
-}
-
-typedef Aapcs64Variant1ReturnGeneral janet_aapcs64_variant_1(uint64_t x0, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5, uint64_t x6, uint64_t x7,
-        double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7);
-typedef Aapcs64Variant2ReturnSse janet_aapcs64_variant_2(uint64_t x0, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5, uint64_t x6, uint64_t x7,
-        double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7);
-typedef Aapcs64Variant3ReturnPointer janet_aapcs64_variant_3(uint64_t x0, uint64_t x1, uint64_t x2, uint64_t x3, uint64_t x4, uint64_t x5, uint64_t x6, uint64_t x7,
-        double v0, double v1, double v2, double v3, double v4, double v5, double v6, double v7);
-
-
-static Janet janet_ffi_aapcs64(JanetFFISignature *signature, void *function_pointer, const Janet *argv) {
-    union {
-        Aapcs64Variant1ReturnGeneral general_return;
-        Aapcs64Variant2ReturnSse sse_return;
-        Aapcs64Variant3ReturnPointer pointer_return;
-    } retu;
-    uint64_t regs[8];
-    double fp_regs[8];
-    void *ret_mem = &retu.general_return;
-
-    /* Apple's stack values do not need to be 8-byte aligned,
-     * thus all stack offsets refer to actual byte positions. */
-    uint8_t *stack = alloca(signature->stack_count);
-#if defined(JANET_APPLE)
-    /* Values must be zero-extended by the caller instead of the callee. */
-    memset(stack, 0, signature->stack_count);
-#endif
-    for (uint32_t i = 0; i < signature->arg_count; i++) {
-        int32_t n = i + 2;
-        JanetFFIMapping arg = signature->args[i];
-        void *to = NULL;
-
-        switch (arg.spec) {
-            case JANET_AAPCS64_GENERAL:
-                to = regs + arg.offset;
-                break;
-            case JANET_AAPCS64_GENERAL_REF:
-                to = stack + arg.offset2;
-                regs[arg.offset] = (uint64_t) to;
-                break;
-            case JANET_AAPCS64_SSE:
-                to = fp_regs + arg.offset;
-                break;
-            case JANET_AAPCS64_STACK:
-                to = stack + arg.offset;
-                break;
-            case JANET_AAPCS64_STACK_REF:
-                to = stack + arg.offset2;
-                uint64_t *ptr = (uint64_t *) stack + arg.offset;
-                *ptr = (uint64_t) to;
-                break;
-            default:
-                janet_panic("nyi");
-        }
-
-        if (to) {
-            janet_ffi_write_one(to, argv, n, arg.type, JANET_FFI_MAX_RECUR);
-        }
-    }
-
-    switch (signature->variant) {
-        case 0:
-            retu.general_return = ((janet_aapcs64_variant_1 *)(function_pointer))(
-                                      regs[0], regs[1], regs[2], regs[3],
-                                      regs[4], regs[5], regs[6], regs[7],
-                                      fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3],
-                                      fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]);
-            break;
-        case 1:
-            retu.sse_return = ((janet_aapcs64_variant_2 *)(function_pointer))(
-                                  regs[0], regs[1], regs[2], regs[3],
-                                  regs[4], regs[5], regs[6], regs[7],
-                                  fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3],
-                                  fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]);
-            break;
-        case 2: {
-            retu.pointer_return = ((janet_aapcs64_variant_3 *)(function_pointer))(
-                                      regs[0], regs[1], regs[2], regs[3],
-                                      regs[4], regs[5], regs[6], regs[7],
-                                      fp_regs[0], fp_regs[1], fp_regs[2], fp_regs[3],
-                                      fp_regs[4], fp_regs[5], fp_regs[6], fp_regs[7]);
-        }
-    }
-
-    return janet_ffi_read_one(ret_mem, signature->ret.type, JANET_FFI_MAX_RECUR);
-}
-
-#endif
-
 /* Allocate executable memory chunks in sizes of a page. Ideally we would keep
  * an allocator around so that multiple JIT allocations would point to the same
  * region but it isn't really worth it. */
@@ -1603,7 +1308,7 @@ JANET_CORE_FN(cfun_ffi_jitfn,
     JanetByteView bytes = janet_getbytes(argv, 0);
 
     /* Quick hack to align to page boundary, we should query OS. FIXME */
-    size_t alloc_size = ((size_t) bytes.len + FFI_PAGE_MASK) & ~FFI_PAGE_MASK;
+    size_t alloc_size = (bytes.len + FFI_PAGE_MASK) & ~FFI_PAGE_MASK;
 
 #ifdef JANET_FFI_JIT
 #ifdef JANET_EV
@@ -1668,10 +1373,6 @@ JANET_CORE_FN(cfun_ffi_call,
 #ifdef JANET_FFI_SYSV64_ENABLED
         case JANET_FFI_CC_SYSV_64:
             return janet_ffi_sysv64(signature, function_pointer, argv);
-#endif
-#ifdef JANET_FFI_AAPCS64_ENABLED
-        case JANET_FFI_CC_AAPCS64:
-            return janet_ffi_aapcs64(signature, function_pointer, argv);
 #endif
     }
 }
@@ -1684,10 +1385,10 @@ JANET_CORE_FN(cfun_ffi_buffer_write,
     janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
     janet_arity(argc, 2, 4);
     JanetFFIType type = decode_ffi_type(argv[0]);
-    uint32_t el_size = (uint32_t) type_size(type);
+    size_t el_size = type_size(type);
     JanetBuffer *buffer = janet_optbuffer(argv, argc, 2, el_size);
-    int32_t index = janet_optnat(argv, argc, 3, buffer->count);
-    int32_t old_count = buffer->count;
+    size_t index = janet_optsize(argv, argc, 3, 0);
+    size_t old_count = buffer->count;
     if (index > old_count) janet_panic("index out of bounds");
     buffer->count = index;
     janet_buffer_extra(buffer, el_size);
@@ -1707,14 +1408,14 @@ JANET_CORE_FN(cfun_ffi_buffer_read,
     janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
     janet_arity(argc, 2, 3);
     JanetFFIType type = decode_ffi_type(argv[0]);
-    size_t offset = (size_t) janet_optnat(argv, argc, 2, 0);
+    size_t offset = janet_optsize(argv, argc, 2, 0);
     if (janet_checktype(argv[1], JANET_POINTER)) {
         uint8_t *ptr = janet_unwrap_pointer(argv[1]);
         return janet_ffi_read_one(ptr + offset, type, JANET_FFI_MAX_RECUR);
     } else {
         size_t el_size = type_size(type);
         JanetByteView bytes = janet_getbytes(argv, 1);
-        if ((size_t) bytes.len < offset + el_size) janet_panic("read out of range");
+        if (bytes.len < offset + el_size) janet_panic("read out of range");
         return janet_ffi_read_one(bytes.bytes + offset, type, JANET_FFI_MAX_RECUR);
     }
 }
@@ -1741,10 +1442,6 @@ JANET_CORE_FN(cfun_ffi_get_callback_trampoline,
 #ifdef JANET_FFI_SYSV64_ENABLED
         case JANET_FFI_CC_SYSV_64:
             return janet_wrap_pointer(janet_ffi_sysv64_standard_callback);
-#endif
-#ifdef JANET_FFI_AAPCS64_ENABLED
-        case JANET_FFI_CC_AAPCS64:
-            return janet_wrap_pointer(janet_ffi_aapcs64_standard_callback);
 #endif
     }
 }
@@ -1826,8 +1523,8 @@ JANET_CORE_FN(cfun_ffi_pointer_buffer,
     janet_sandbox_assert(JANET_SANDBOX_FFI_USE);
     janet_arity(argc, 2, 4);
     void *pointer = janet_getpointer(argv, 0);
-    int32_t capacity = janet_getnat(argv, 1);
-    int32_t count = janet_optnat(argv, argc, 2, 0);
+    size_t capacity = janet_getsize(argv, 1);
+    size_t count = janet_optsize(argv, argc, 2, 0);
     int64_t offset = janet_optinteger64(argv, argc, 3, 0);
     uint8_t *offset_pointer = ((uint8_t *) pointer) + offset;
     return janet_wrap_buffer(janet_pointer_buffer_unsafe(offset_pointer, capacity, count));
@@ -1864,9 +1561,6 @@ JANET_CORE_FN(cfun_ffi_supported_calling_conventions,
 #endif
 #ifdef JANET_FFI_SYSV64_ENABLED
     janet_array_push(array, janet_ckeywordv("sysv64"));
-#endif
-#ifdef JANET_FFI_AAPCS64_ENABLED
-    janet_array_push(array, janet_ckeywordv("aapcs64"));
 #endif
     janet_array_push(array, janet_ckeywordv("none"));
     return janet_wrap_array(array);

src/core/fiber.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -48,7 +48,7 @@ static void fiber_reset(JanetFiber *fiber) {
     janet_fiber_set_status(fiber, JANET_STATUS_NEW);
 }
 
-static JanetFiber *fiber_alloc(int32_t capacity) {
+static JanetFiber *fiber_alloc(size_t capacity) {
     Janet *data;
     JanetFiber *fiber = janet_gcalloc(JANET_MEMORY_FIBER, sizeof(JanetFiber));
     if (capacity < 32) {
@@ -196,7 +196,7 @@ int janet_fiber_funcframe(JanetFiber *fiber, JanetFunction *func) {
     int32_t oldframe = fiber->frame;
     int32_t nextframe = fiber->stackstart;
     int32_t nextstacktop = nextframe + func->def->slotcount + JANET_FRAME_SIZE;
-    int32_t next_arity = fiber->stacktop - fiber->stackstart;
+    int32_t next_arity = (int32_t) fiber->stacktop - fiber->stackstart;
 
     /* Check strict arity before messing with state */
     if (next_arity < func->def->min_arity) return 1;
@@ -331,7 +331,7 @@ int janet_fiber_funcframe_tail(JanetFiber *fiber, JanetFunction *func) {
     int32_t i;
     int32_t nextframetop = fiber->frame + func->def->slotcount;
     int32_t nextstacktop = nextframetop + JANET_FRAME_SIZE;
-    int32_t next_arity = fiber->stacktop - fiber->stackstart;
+    int32_t next_arity = (int32_t) fiber->stacktop - fiber->stackstart;
     int32_t stacksize;
 
     /* Check strict arity before messing with state */
@@ -516,11 +516,10 @@ JANET_CORE_FN(cfun_fiber_new,
         fiber->env = janet_gettable(argv, 2);
     }
     if (argc >= 2) {
-        int32_t i;
         JanetByteView view = janet_getbytes(argv, 1);
         fiber->flags = JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
         janet_fiber_set_status(fiber, JANET_STATUS_NEW);
-        for (i = 0; i < view.len; i++) {
+        for (size_t i = 0; i < view.len; i++) {
             if (view.bytes[i] >= '0' && view.bytes[i] <= '9') {
                 fiber->flags |= JANET_FIBER_MASK_USERN(view.bytes[i] - '0');
             } else {

src/core/fiber.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/filewatch.c

@@ -1,688 +0,0 @@
-/*
-* 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
-* 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.
-*/
-
-#ifndef JANET_AMALG
-#include "features.h"
-#include <janet.h>
-#include "util.h"
-#endif
-
-#ifdef JANET_EV
-#ifdef JANET_FILEWATCH
-
-#ifdef JANET_LINUX
-#include <sys/inotify.h>
-#include <unistd.h>
-#endif
-
-#ifdef JANET_WINDOWS
-#include <windows.h>
-#endif
-
-typedef struct {
-    const char *name;
-    uint32_t flag;
-} JanetWatchFlagName;
-
-typedef struct {
-#ifndef JANET_WINDOWS
-    JanetStream *stream;
-#endif
-    JanetTable *watch_descriptors;
-    JanetChannel *channel;
-    uint32_t default_flags;
-    int is_watching;
-} JanetWatcher;
-
-#ifdef JANET_LINUX
-
-#include <sys/inotify.h>
-#include <unistd.h>
-
-static const JanetWatchFlagName watcher_flags_linux[] = {
-    {"access", IN_ACCESS},
-    {"all", IN_ALL_EVENTS},
-    {"attrib", IN_ATTRIB},
-    {"close-nowrite", IN_CLOSE_NOWRITE},
-    {"close-write", IN_CLOSE_WRITE},
-    {"create", IN_CREATE},
-    {"delete", IN_DELETE},
-    {"delete-self", IN_DELETE_SELF},
-    {"ignored", IN_IGNORED},
-    {"modify", IN_MODIFY},
-    {"move-self", IN_MOVE_SELF},
-    {"moved-from", IN_MOVED_FROM},
-    {"moved-to", IN_MOVED_TO},
-    {"open", IN_OPEN},
-    {"q-overflow", IN_Q_OVERFLOW},
-    {"unmount", IN_UNMOUNT},
-};
-
-static uint32_t decode_watch_flags(const Janet *options, int32_t n) {
-    uint32_t flags = 0;
-    for (int32_t i = 0; i < n; i++) {
-        if (!(janet_checktype(options[i], JANET_KEYWORD))) {
-            janet_panicf("expected keyword, got %v", options[i]);
-        }
-        JanetKeyword keyw = janet_unwrap_keyword(options[i]);
-        const JanetWatchFlagName *result = janet_strbinsearch(watcher_flags_linux,
-                                           sizeof(watcher_flags_linux) / sizeof(JanetWatchFlagName),
-                                           sizeof(JanetWatchFlagName),
-                                           keyw);
-        if (!result) {
-            janet_panicf("unknown inotify flag %v", options[i]);
-        }
-        flags |= result->flag;
-    }
-    return flags;
-}
-
-static void janet_watcher_init(JanetWatcher *watcher, JanetChannel *channel, uint32_t default_flags) {
-    int fd;
-    do {
-        fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
-    } while (fd == -1 && errno == EINTR);
-    if (fd == -1) {
-        janet_panicv(janet_ev_lasterr());
-    }
-    watcher->watch_descriptors = janet_table(0);
-    watcher->channel = channel;
-    watcher->default_flags = default_flags;
-    watcher->is_watching = 0;
-    watcher->stream = janet_stream(fd, JANET_STREAM_READABLE, NULL);
-}
-
-static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t flags) {
-    if (watcher->stream == NULL) janet_panic("watcher closed");
-    int result;
-    do {
-        result = inotify_add_watch(watcher->stream->handle, path, flags);
-    } while (result == -1 && errno == EINTR);
-    if (result == -1) {
-        janet_panicv(janet_ev_lasterr());
-    }
-    Janet name = janet_cstringv(path);
-    Janet wd = janet_wrap_integer(result);
-    janet_table_put(watcher->watch_descriptors, name, wd);
-    janet_table_put(watcher->watch_descriptors, wd, name);
-}
-
-static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
-    if (watcher->stream == NULL) janet_panic("watcher closed");
-    Janet check = janet_table_get(watcher->watch_descriptors, janet_cstringv(path));
-    janet_assert(janet_checktype(check, JANET_NUMBER), "bad watch descriptor");
-    int watch_handle = janet_unwrap_integer(check);
-    int result;
-    do {
-        result = inotify_rm_watch(watcher->stream->handle, watch_handle);
-    } while (result != -1 && errno == EINTR);
-    if (result == -1) {
-        janet_panicv(janet_ev_lasterr());
-    }
-}
-
-static void watcher_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
-    JanetStream *stream = fiber->ev_stream;
-    JanetWatcher *watcher = *((JanetWatcher **) fiber->ev_state);
-    char buf[1024];
-    switch (event) {
-        default:
-            break;
-        case JANET_ASYNC_EVENT_MARK:
-            janet_mark(janet_wrap_abstract(watcher));
-            break;
-        case JANET_ASYNC_EVENT_CLOSE:
-            janet_schedule(fiber, janet_wrap_nil());
-            janet_async_end(fiber);
-            break;
-        case JANET_ASYNC_EVENT_ERR: {
-            janet_schedule(fiber, janet_wrap_nil());
-            janet_async_end(fiber);
-            break;
-        }
-    read_more:
-        case JANET_ASYNC_EVENT_HUP:
-        case JANET_ASYNC_EVENT_INIT:
-        case JANET_ASYNC_EVENT_READ: {
-            Janet name = janet_wrap_nil();
-
-            /* Assumption - read will never return partial events *
-             * From documentation:
-             *
-             * The behavior when the buffer given to read(2) is too small to
-             * return information about the next event depends on the kernel
-             * version: before Linux 2.6.21, read(2) returns 0; since Linux
-             * 2.6.21, read(2) fails with the error EINVAL.  Specifying a buffer
-             * of size
-             *
-             *     sizeof(struct inotify_event) + NAME_MAX + 1
-             *
-             * will be sufficient to read at least one event. */
-            ssize_t nread;
-            do {
-                nread = read(stream->handle, buf, sizeof(buf));
-            } while (nread == -1 && errno == EINTR);
-
-            /* Check for errors - special case errors that can just be waited on to fix */
-            if (nread == -1) {
-                if (errno == EAGAIN || errno == EWOULDBLOCK) {
-                    break;
-                }
-                janet_cancel(fiber, janet_ev_lasterr());
-                fiber->ev_state = NULL;
-                janet_async_end(fiber);
-                break;
-            }
-            if (nread < (ssize_t) sizeof(struct inotify_event)) break;
-
-            /* Iterate through all events read from the buffer */
-            char *cursor = buf;
-            while (cursor < buf + nread) {
-                struct inotify_event inevent;
-                memcpy(&inevent, cursor, sizeof(inevent));
-                cursor += sizeof(inevent);
-                /* Read path of inevent */
-                if (inevent.len) {
-                    name = janet_cstringv(cursor);
-                    cursor += inevent.len;
-                }
-
-                /* Got an event */
-                Janet path = janet_table_get(watcher->watch_descriptors, janet_wrap_integer(inevent.wd));
-                JanetKV *event = janet_struct_begin(6);
-                janet_struct_put(event, janet_ckeywordv("wd"), janet_wrap_integer(inevent.wd));
-                janet_struct_put(event, janet_ckeywordv("wd-path"), path);
-                if (janet_checktype(name, JANET_NIL)) {
-                    /* We were watching a file directly, so path is the full path. Split into dirname / basename */
-                    JanetString spath = janet_unwrap_string(path);
-                    const uint8_t *cursor = spath + janet_string_length(spath);
-                    const uint8_t *cursor_end = cursor;
-                    while (cursor > spath && cursor[0] != '/') {
-                        cursor--;
-                    }
-                    if (cursor == spath) {
-                        janet_struct_put(event, janet_ckeywordv("dir-name"), path);
-                        janet_struct_put(event, janet_ckeywordv("file-name"), name);
-                    } else {
-                        janet_struct_put(event, janet_ckeywordv("dir-name"), janet_wrap_string(janet_string(spath, (cursor - spath))));
-                        janet_struct_put(event, janet_ckeywordv("file-name"), janet_wrap_string(janet_string(cursor + 1, (cursor_end - cursor - 1))));
-                    }
-                } else {
-                    janet_struct_put(event, janet_ckeywordv("dir-name"), path);
-                    janet_struct_put(event, janet_ckeywordv("file-name"), name);
-                }
-                janet_struct_put(event, janet_ckeywordv("cookie"), janet_wrap_integer(inevent.cookie));
-                Janet etype = janet_ckeywordv("type");
-                const JanetWatchFlagName *wfn_end = watcher_flags_linux + sizeof(watcher_flags_linux) / sizeof(watcher_flags_linux[0]);
-                for (const JanetWatchFlagName *wfn = watcher_flags_linux; wfn < wfn_end; wfn++) {
-                    if ((inevent.mask & wfn->flag) == wfn->flag) janet_struct_put(event, etype, janet_ckeywordv(wfn->name));
-                }
-                Janet eventv = janet_wrap_struct(janet_struct_end(event));
-
-                janet_channel_give(watcher->channel, eventv);
-            }
-
-            /* Read some more if possible */
-            goto read_more;
-        }
-        break;
-    }
-}
-
-static void janet_watcher_listen(JanetWatcher *watcher) {
-    if (watcher->is_watching) janet_panic("already watching");
-    watcher->is_watching = 1;
-    JanetFunction *thunk = janet_thunk_delay(janet_wrap_nil());
-    JanetFiber *fiber = janet_fiber(thunk, 64, 0, NULL);
-    JanetWatcher **state = janet_malloc(sizeof(JanetWatcher *)); /* Gross */
-    *state = watcher;
-    janet_async_start_fiber(fiber, watcher->stream, JANET_ASYNC_LISTEN_READ, watcher_callback_read, state);
-    janet_gcroot(janet_wrap_abstract(watcher));
-}
-
-static void janet_watcher_unlisten(JanetWatcher *watcher) {
-    if (!watcher->is_watching) return;
-    watcher->is_watching = 0;
-    janet_stream_close(watcher->stream);
-    janet_gcunroot(janet_wrap_abstract(watcher));
-}
-
-#elif JANET_WINDOWS
-
-#define WATCHFLAG_RECURSIVE 0x100000u
-
-static const JanetWatchFlagName watcher_flags_windows[] = {
-    {
-        "all",
-        FILE_NOTIFY_CHANGE_ATTRIBUTES |
-        FILE_NOTIFY_CHANGE_CREATION |
-        FILE_NOTIFY_CHANGE_DIR_NAME |
-        FILE_NOTIFY_CHANGE_FILE_NAME |
-        FILE_NOTIFY_CHANGE_LAST_ACCESS |
-        FILE_NOTIFY_CHANGE_LAST_WRITE |
-        FILE_NOTIFY_CHANGE_SECURITY |
-        FILE_NOTIFY_CHANGE_SIZE |
-        WATCHFLAG_RECURSIVE
-    },
-    {"attributes", FILE_NOTIFY_CHANGE_ATTRIBUTES},
-    {"creation", FILE_NOTIFY_CHANGE_CREATION},
-    {"dir-name", FILE_NOTIFY_CHANGE_DIR_NAME},
-    {"file-name", FILE_NOTIFY_CHANGE_FILE_NAME},
-    {"last-access", FILE_NOTIFY_CHANGE_LAST_ACCESS},
-    {"last-write", FILE_NOTIFY_CHANGE_LAST_WRITE},
-    {"recursive", WATCHFLAG_RECURSIVE},
-    {"security", FILE_NOTIFY_CHANGE_SECURITY},
-    {"size", FILE_NOTIFY_CHANGE_SIZE},
-};
-
-static uint32_t decode_watch_flags(const Janet *options, int32_t n) {
-    uint32_t flags = 0;
-    for (int32_t i = 0; i < n; i++) {
-        if (!(janet_checktype(options[i], JANET_KEYWORD))) {
-            janet_panicf("expected keyword, got %v", options[i]);
-        }
-        JanetKeyword keyw = janet_unwrap_keyword(options[i]);
-        const JanetWatchFlagName *result = janet_strbinsearch(watcher_flags_windows,
-                                           sizeof(watcher_flags_windows) / sizeof(JanetWatchFlagName),
-                                           sizeof(JanetWatchFlagName),
-                                           keyw);
-        if (!result) {
-            janet_panicf("unknown windows filewatch flag %v", options[i]);
-        }
-        flags |= result->flag;
-    }
-    return flags;
-}
-
-static void janet_watcher_init(JanetWatcher *watcher, JanetChannel *channel, uint32_t default_flags) {
-    watcher->watch_descriptors = janet_table(0);
-    watcher->channel = channel;
-    watcher->default_flags = default_flags;
-    watcher->is_watching = 0;
-}
-
-/* Since the file info padding includes embedded file names, we want to include more space for data.
- * We also need to handle manually calculating changes if path names are too long, but ideally just avoid
- * that scenario as much as possible */
-#define FILE_INFO_PADDING (4096 * 4)
-
-typedef struct {
-    OVERLAPPED overlapped;
-    JanetStream *stream;
-    JanetWatcher *watcher;
-    JanetFiber *fiber;
-    JanetString dir_path;
-    uint32_t flags;
-    uint64_t buf[FILE_INFO_PADDING / sizeof(uint64_t)]; /* Ensure alignment */
-} OverlappedWatch;
-
-#define NotifyChange FILE_NOTIFY_INFORMATION
-
-static void read_dir_changes(OverlappedWatch *ow) {
-    BOOL result = ReadDirectoryChangesW(ow->stream->handle,
-                                        (NotifyChange *) ow->buf,
-                                        FILE_INFO_PADDING,
-                                        (ow->flags & WATCHFLAG_RECURSIVE) ? TRUE : FALSE,
-                                        ow->flags & ~WATCHFLAG_RECURSIVE,
-                                        NULL,
-                                        (OVERLAPPED *) ow,
-                                        NULL);
-    if (!result) {
-        janet_panicv(janet_ev_lasterr());
-    }
-}
-
-static const char *watcher_actions_windows[] = {
-    "unknown",
-    "added",
-    "removed",
-    "modified",
-    "renamed-old",
-    "renamed-new",
-};
-
-static void watcher_callback_read(JanetFiber *fiber, JanetAsyncEvent event) {
-    OverlappedWatch *ow = (OverlappedWatch *) fiber->ev_state;
-    JanetWatcher *watcher = ow->watcher;
-    switch (event) {
-        default:
-            break;
-        case JANET_ASYNC_EVENT_INIT:
-            janet_async_in_flight(fiber);
-            break;
-        case JANET_ASYNC_EVENT_MARK:
-            janet_mark(janet_wrap_abstract(ow->stream));
-            janet_mark(janet_wrap_fiber(ow->fiber));
-            janet_mark(janet_wrap_abstract(watcher));
-            janet_mark(janet_wrap_string(ow->dir_path));
-            break;
-        case JANET_ASYNC_EVENT_CLOSE:
-            janet_table_remove(ow->watcher->watch_descriptors, janet_wrap_string(ow->dir_path));
-            break;
-        case JANET_ASYNC_EVENT_ERR:
-        case JANET_ASYNC_EVENT_FAILED:
-            janet_stream_close(ow->stream);
-            break;
-        case JANET_ASYNC_EVENT_COMPLETE: {
-            if (!watcher->is_watching) {
-                janet_stream_close(ow->stream);
-                break;
-            }
-
-            NotifyChange *fni = (NotifyChange *) ow->buf;
-
-            while (1) {
-                /* Got an event */
-
-                /* Extract name */
-                Janet filename;
-                if (fni->FileNameLength) {
-                    int32_t nbytes = (int32_t) WideCharToMultiByte(CP_UTF8, 0, fni->FileName, fni->FileNameLength / sizeof(wchar_t), NULL, 0, NULL, NULL);
-                    janet_assert(nbytes, "bad utf8 path");
-                    uint8_t *into = janet_string_begin(nbytes);
-                    WideCharToMultiByte(CP_UTF8, 0, fni->FileName, fni->FileNameLength / sizeof(wchar_t), (char *) into, nbytes, NULL, NULL);
-                    filename = janet_wrap_string(janet_string_end(into));
-                } else {
-                    filename = janet_cstringv("");
-                }
-
-                JanetKV *event = janet_struct_begin(3);
-                janet_struct_put(event, janet_ckeywordv("type"), janet_ckeywordv(watcher_actions_windows[fni->Action]));
-                janet_struct_put(event, janet_ckeywordv("file-name"), filename);
-                janet_struct_put(event, janet_ckeywordv("dir-name"), janet_wrap_string(ow->dir_path));
-                Janet eventv = janet_wrap_struct(janet_struct_end(event));
-
-                janet_channel_give(watcher->channel, eventv);
-
-                /* Next event */
-                if (!fni->NextEntryOffset) break;
-                fni = (NotifyChange *)((char *)fni + fni->NextEntryOffset);
-            }
-
-            /* Make another call to read directory changes */
-            read_dir_changes(ow);
-            janet_async_in_flight(fiber);
-        }
-        break;
-    }
-}
-
-static void start_listening_ow(OverlappedWatch *ow) {
-    read_dir_changes(ow);
-    JanetStream *stream = ow->stream;
-    JanetFunction *thunk = janet_thunk_delay(janet_wrap_nil());
-    JanetFiber *fiber = janet_fiber(thunk, 64, 0, NULL);
-    fiber->supervisor_channel = janet_root_fiber()->supervisor_channel;
-    ow->fiber = fiber;
-    janet_async_start_fiber(fiber, stream, JANET_ASYNC_LISTEN_READ, watcher_callback_read, ow);
-}
-
-static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t flags) {
-    HANDLE handle = CreateFileA(path,
-                                FILE_LIST_DIRECTORY | GENERIC_READ,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                                NULL,
-                                OPEN_EXISTING,
-                                FILE_FLAG_OVERLAPPED | FILE_FLAG_BACKUP_SEMANTICS,
-                                NULL);
-    if (handle == INVALID_HANDLE_VALUE) {
-        janet_panicv(janet_ev_lasterr());
-    }
-    JanetStream *stream = janet_stream(handle, JANET_STREAM_READABLE, NULL);
-    OverlappedWatch *ow = janet_malloc(sizeof(OverlappedWatch));
-    memset(ow, 0, sizeof(OverlappedWatch));
-    ow->stream = stream;
-    ow->dir_path = janet_cstring(path);
-    ow->fiber = NULL;
-    Janet pathv = janet_wrap_string(ow->dir_path);
-    ow->flags = flags | watcher->default_flags;
-    ow->watcher = watcher;
-    ow->overlapped.hEvent = CreateEvent(NULL, FALSE, 0, NULL); /* Do we need this */
-    Janet streamv = janet_wrap_pointer(ow);
-    janet_table_put(watcher->watch_descriptors, pathv, streamv);
-    if (watcher->is_watching) {
-        start_listening_ow(ow);
-    }
-}
-
-static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
-    Janet pathv = janet_cstringv(path);
-    Janet streamv = janet_table_get(watcher->watch_descriptors, pathv);
-    if (janet_checktype(streamv, JANET_NIL)) {
-        janet_panicf("path %v is not being watched", pathv);
-    }
-    janet_table_remove(watcher->watch_descriptors, pathv);
-    OverlappedWatch *ow = janet_unwrap_pointer(streamv);
-    janet_stream_close(ow->stream);
-}
-
-static void janet_watcher_listen(JanetWatcher *watcher) {
-    if (watcher->is_watching) janet_panic("already watching");
-    watcher->is_watching = 1;
-    for (int32_t i = 0; i < watcher->watch_descriptors->capacity; i++) {
-        const JanetKV *kv = watcher->watch_descriptors->data + i;
-        if (!janet_checktype(kv->value, JANET_POINTER)) continue;
-        OverlappedWatch *ow = janet_unwrap_pointer(kv->value);
-        start_listening_ow(ow);
-    }
-    janet_gcroot(janet_wrap_abstract(watcher));
-}
-
-static void janet_watcher_unlisten(JanetWatcher *watcher) {
-    if (!watcher->is_watching) return;
-    watcher->is_watching = 0;
-    for (int32_t i = 0; i < watcher->watch_descriptors->capacity; i++) {
-        const JanetKV *kv = watcher->watch_descriptors->data + i;
-        if (!janet_checktype(kv->value, JANET_POINTER)) continue;
-        OverlappedWatch *ow = janet_unwrap_pointer(kv->value);
-        janet_stream_close(ow->stream);
-    }
-    janet_table_clear(watcher->watch_descriptors);
-    janet_gcunroot(janet_wrap_abstract(watcher));
-}
-
-#else
-
-/* Default implementation */
-
-static uint32_t decode_watch_flags(const Janet *options, int32_t n) {
-    (void) options;
-    (void) n;
-    return 0;
-}
-
-static void janet_watcher_init(JanetWatcher *watcher, JanetChannel *channel, uint32_t default_flags) {
-    (void) watcher;
-    (void) channel;
-    (void) default_flags;
-    janet_panic("filewatch not supported on this platform");
-}
-
-static void janet_watcher_add(JanetWatcher *watcher, const char *path, uint32_t flags) {
-    (void) watcher;
-    (void) flags;
-    (void) path;
-    janet_panic("nyi");
-}
-
-static void janet_watcher_remove(JanetWatcher *watcher, const char *path) {
-    (void) watcher;
-    (void) path;
-    janet_panic("nyi");
-}
-
-static void janet_watcher_listen(JanetWatcher *watcher) {
-    (void) watcher;
-    janet_panic("nyi");
-}
-
-static void janet_watcher_unlisten(JanetWatcher *watcher) {
-    (void) watcher;
-    janet_panic("nyi");
-}
-
-#endif
-
-/* C Functions */
-
-static int janet_filewatch_mark(void *p, size_t s) {
-    JanetWatcher *watcher = (JanetWatcher *) p;
-    (void) s;
-    if (watcher->channel == NULL) return 0; /* Incomplete initialization */
-#ifdef JANET_WINDOWS
-    for (int32_t i = 0; i < watcher->watch_descriptors->capacity; i++) {
-        const JanetKV *kv = watcher->watch_descriptors->data + i;
-        if (!janet_checktype(kv->value, JANET_POINTER)) continue;
-        OverlappedWatch *ow = janet_unwrap_pointer(kv->value);
-        janet_mark(janet_wrap_fiber(ow->fiber));
-        janet_mark(janet_wrap_abstract(ow->stream));
-        janet_mark(janet_wrap_string(ow->dir_path));
-    }
-#else
-    janet_mark(janet_wrap_abstract(watcher->stream));
-#endif
-    janet_mark(janet_wrap_abstract(watcher->channel));
-    janet_mark(janet_wrap_table(watcher->watch_descriptors));
-    return 0;
-}
-
-static const JanetAbstractType janet_filewatch_at = {
-    "filewatch/watcher",
-    NULL,
-    janet_filewatch_mark,
-    JANET_ATEND_GCMARK
-};
-
-JANET_CORE_FN(cfun_filewatch_make,
-              "(filewatch/new channel &opt default-flags)",
-              "Create a new filewatcher that will give events to a channel channel. See `filewatch/add` for available flags.\n\n"
-              "When an event is triggered by the filewatcher, a struct containing information will be given to channel as with `ev/give`. "
-              "The contents of the channel depend on the OS, but will contain some common keys:\n\n"
-              "* `:type` -- the type of the event that was raised.\n\n"
-              "* `:file-name` -- the base file name of the file that triggered the event.\n\n"
-              "* `:dir-name` -- the directory name of the file that triggered the event.\n\n"
-              "Events also will contain keys specific to the host OS.\n\n"
-              "Windows has no extra properties on events.\n\n"
-              "Linux has the following extra properties on events:\n\n"
-              "* `:wd` -- the integer key returned by `filewatch/add` for the path that triggered this.\n\n"
-              "* `:wd-path` -- the string path for watched directory of file. For files, will be the same as `:file-name`, and for directories, will be the same as `:dir-name`.\n\n"
-              "* `:cookie` -- a randomized integer used to associate related events, such as :moved-from and :moved-to events.\n\n"
-              "") {
-    janet_sandbox_assert(JANET_SANDBOX_FS_READ);
-    janet_arity(argc, 1, -1);
-    JanetChannel *channel = janet_getchannel(argv, 0);
-    JanetWatcher *watcher = janet_abstract(&janet_filewatch_at, sizeof(JanetWatcher));
-    uint32_t default_flags = decode_watch_flags(argv + 1, argc - 1);
-    janet_watcher_init(watcher, channel, default_flags);
-    return janet_wrap_abstract(watcher);
-}
-
-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"
-              "* `: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"
-              "* `: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"
-              "On Windows, events will have the following possible types:\n\n"
-              "* `:unknown`\n\n"
-              "* `:added`\n\n"
-              "* `:removed`\n\n"
-              "* `:modified`\n\n"
-              "* `:renamed-old`\n\n"
-              "* `:renamed-new`\n\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);
-    const char *path = janet_getcstring(argv, 1);
-    uint32_t flags = watcher->default_flags | decode_watch_flags(argv + 2, argc - 2);
-    janet_watcher_add(watcher, path, flags);
-    return argv[0];
-}
-
-JANET_CORE_FN(cfun_filewatch_remove,
-              "(filewatch/remove watcher path)",
-              "Remove a path from the watcher.") {
-    janet_fixarity(argc, 2);
-    JanetWatcher *watcher = janet_getabstract(argv, 0, &janet_filewatch_at);
-    const char *path = janet_getcstring(argv, 1);
-    janet_watcher_remove(watcher, path);
-    return argv[0];
-}
-
-JANET_CORE_FN(cfun_filewatch_listen,
-              "(filewatch/listen watcher)",
-              "Listen for changes in the watcher.") {
-    janet_fixarity(argc, 1);
-    JanetWatcher *watcher = janet_getabstract(argv, 0, &janet_filewatch_at);
-    janet_watcher_listen(watcher);
-    return janet_wrap_nil();
-}
-
-JANET_CORE_FN(cfun_filewatch_unlisten,
-              "(filewatch/unlisten watcher)",
-              "Stop listening for changes on a given watcher.") {
-    janet_fixarity(argc, 1);
-    JanetWatcher *watcher = janet_getabstract(argv, 0, &janet_filewatch_at);
-    janet_watcher_unlisten(watcher);
-    return janet_wrap_nil();
-}
-
-/* Module entry point */
-void janet_lib_filewatch(JanetTable *env) {
-    JanetRegExt cfuns[] = {
-        JANET_CORE_REG("filewatch/new", cfun_filewatch_make),
-        JANET_CORE_REG("filewatch/add", cfun_filewatch_add),
-        JANET_CORE_REG("filewatch/remove", cfun_filewatch_remove),
-        JANET_CORE_REG("filewatch/listen", cfun_filewatch_listen),
-        JANET_CORE_REG("filewatch/unlisten", cfun_filewatch_unlisten),
-        JANET_REG_END
-    };
-    janet_core_cfuns_ext(env, NULL, cfuns);
-}
-
-#endif
-#endif

src/core/gc.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -122,7 +122,7 @@ static void janet_mark_abstract(void *adata) {
 }
 
 /* Mark a bunch of items in memory */
-static void janet_mark_many(const Janet *values, int32_t n) {
+static void janet_mark_many(const Janet *values, size_t n) {
     if (values == NULL)
         return;
     const Janet *end = values + n;
@@ -262,7 +262,7 @@ static void janet_mark_function(JanetFunction *func) {
 }
 
 static void janet_mark_fiber(JanetFiber *fiber) {
-    int32_t i, j;
+    size_t i, j;
     JanetStackFrame *frame;
 recur:
     if (janet_gc_reachable(fiber))
@@ -321,13 +321,9 @@ static void janet_deinit_block(JanetGCObject *mem) {
             janet_symbol_deinit(((JanetStringHead *) mem)->data);
             break;
         case JANET_MEMORY_ARRAY:
-        case JANET_MEMORY_ARRAY_WEAK:
             janet_free(((JanetArray *) mem)->data);
             break;
         case JANET_MEMORY_TABLE:
-        case JANET_MEMORY_TABLE_WEAKK:
-        case JANET_MEMORY_TABLE_WEAKV:
-        case JANET_MEMORY_TABLE_WEAKKV:
             janet_free(((JanetTable *) mem)->data);
             break;
         case JANET_MEMORY_FIBER: {
@@ -346,9 +342,6 @@ 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");
             }
@@ -488,7 +481,7 @@ void janet_sweep() {
 #ifdef JANET_EV
     /* Sweep threaded abstract types for references to decrement */
     JanetKV *items = janet_vm.threaded_abstracts.data;
-    for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
+    for (size_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
         if (janet_checktype(items[i].key, JANET_ABSTRACT)) {
 
             /* If item was not visited during the mark phase, then this
@@ -500,12 +493,9 @@ 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");
                     }
@@ -675,14 +665,11 @@ int janet_gcunrootall(Janet root) {
 void janet_clear_memory(void) {
 #ifdef JANET_EV
     JanetKV *items = janet_vm.threaded_abstracts.data;
-    for (int32_t i = 0; i < janet_vm.threaded_abstracts.capacity; i++) {
+    for (size_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/gc.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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,7 +64,7 @@ enum JanetMemoryType {
 };
 
 /* To allocate collectable memory, one must call janet_alloc, initialize the memory,
- * and then call when janet_enablegc when it is initialized and reachable by the gc (on the JANET stack) */
+ * and then call when janet_enablegc when it is initailize and reachable by the gc (on the JANET stack) */
 void *janet_gcalloc(enum JanetMemoryType type, size_t size);
 
 #endif

src/core/inttypes.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose & contributors
+* Copyright (c) 2023 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
@@ -73,13 +73,13 @@ static void *int64_unmarshal(JanetMarshalContext *ctx) {
 
 static void it_s64_tostring(void *p, JanetBuffer *buffer) {
     char str[32];
-    snprintf(str, sizeof(str), "%" PRId64, *((int64_t *)p));
+    sprintf(str, "%" PRId64, *((int64_t *)p));
     janet_buffer_push_cstring(buffer, str);
 }
 
 static void it_u64_tostring(void *p, JanetBuffer *buffer) {
     char str[32];
-    snprintf(str, sizeof(str), "%" PRIu64, *((uint64_t *)p));
+    sprintf(str, "%" PRIu64, *((uint64_t *)p));
     janet_buffer_push_cstring(buffer, str);
 }
 
@@ -191,21 +191,21 @@ Janet janet_wrap_u64(uint64_t x) {
 
 JANET_CORE_FN(cfun_it_s64_new,
               "(int/s64 value)",
-              "Create a boxed signed 64 bit integer from a string value or a number.") {
+              "Create a boxed signed 64 bit integer from a string value.") {
     janet_fixarity(argc, 1);
     return janet_wrap_s64(janet_unwrap_s64(argv[0]));
 }
 
 JANET_CORE_FN(cfun_it_u64_new,
               "(int/u64 value)",
-              "Create a boxed unsigned 64 bit integer from a string value or a number.") {
+              "Create a boxed unsigned 64 bit integer from a string value.") {
     janet_fixarity(argc, 1);
     return janet_wrap_u64(janet_unwrap_u64(argv[0]));
 }
 
 JANET_CORE_FN(cfun_to_number,
               "(int/to-number value)",
-              "Convert an int/u64 or int/s64 to a number. Fails if the number is out of range for an int64.") {
+              "Convert an int/u64 or int/s64 to a number. Fails if the number is out of range for an int32.") {
     janet_fixarity(argc, 1);
     if (janet_type(argv[0]) == JANET_ABSTRACT) {
         void *abst = janet_unwrap_abstract(argv[0]);

src/core/io.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -31,7 +31,6 @@
 
 #ifndef JANET_WINDOWS
 #include <fcntl.h>
-#include <sys/stat.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #endif
@@ -42,11 +41,6 @@ static void io_file_marshal(void *p, JanetMarshalContext *ctx);
 static void *io_file_unmarshal(JanetMarshalContext *ctx);
 static Janet io_file_next(void *p, Janet key);
 
-#ifdef JANET_WINDOWS
-#define ftell _ftelli64
-#define fseek _fseeki64
-#endif
-
 const JanetAbstractType janet_file_type = {
     "core/file",
     cfun_io_gc,
@@ -65,8 +59,7 @@ const JanetAbstractType janet_file_type = {
 /* Check arguments to fopen */
 static int32_t checkflags(const uint8_t *str) {
     int32_t flags = 0;
-    int32_t i;
-    int32_t len = janet_string_length(str);
+    size_t len = janet_string_length(str);
     if (!len || len > 10)
         janet_panic("file mode must have a length between 1 and 10");
     switch (*str) {
@@ -86,7 +79,7 @@ static int32_t checkflags(const uint8_t *str) {
             janet_sandbox_assert(JANET_SANDBOX_FS_READ);
             break;
     }
-    for (i = 1; i < len; i++) {
+    for (size_t i = 1; i < len; i++) {
         switch (str[i]) {
             default:
                 janet_panicf("invalid flag %c, expected +, b, or n", str[i]);
@@ -132,7 +125,7 @@ JANET_CORE_FN(cfun_io_temp,
     // XXX use mkostemp when we can to avoid CLOEXEC race.
     FILE *tmp = tmpfile();
     if (!tmp)
-        janet_panicf("unable to create temporary file - %s", janet_strerror(errno));
+        janet_panicf("unable to create temporary file - %s", strerror(errno));
     return janet_makefile(tmp, JANET_FILE_WRITE | JANET_FILE_READ | JANET_FILE_BINARY);
 }
 
@@ -165,14 +158,6 @@ JANET_CORE_FN(cfun_io_fopen,
     }
     FILE *f = fopen((const char *)fname, (const char *)fmode);
     if (f != NULL) {
-#ifndef JANET_WINDOWS
-        struct stat st;
-        fstat(fileno(f), &st);
-        if (S_ISDIR(st.st_mode)) {
-            fclose(f);
-            janet_panicf("cannot open directory: %s", fname);
-        }
-#endif
         size_t bufsize = janet_optsize(argv, argc, 2, BUFSIZ);
         if (bufsize != BUFSIZ) {
             int result = setvbuf(f, NULL, bufsize ? _IOFBF : _IONBF, bufsize);
@@ -182,7 +167,7 @@ JANET_CORE_FN(cfun_io_fopen,
         }
     }
     return f ? janet_makefile(f, flags)
-           : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, janet_strerror(errno)), janet_wrap_nil())
+           : (flags & JANET_FILE_NONIL) ? (janet_panicf("failed to open file %s: %s", fname, strerror(errno)), janet_wrap_nil())
            : janet_wrap_nil();
 }
 
@@ -218,11 +203,11 @@ JANET_CORE_FN(cfun_io_fread,
     } else {
         buffer = janet_getbuffer(argv, 2);
     }
-    int32_t bufstart = buffer->count;
+    size_t bufstart = buffer->count;
     if (janet_checktype(argv[1], JANET_KEYWORD)) {
         const uint8_t *sym = janet_unwrap_keyword(argv[1]);
         if (!janet_cstrcmp(sym, "all")) {
-            int32_t sizeBefore;
+            size_t sizeBefore;
             do {
                 sizeBefore = buffer->count;
                 read_chunk(iof, buffer, 4096);
@@ -303,7 +288,7 @@ int janet_file_close(JanetFile *file) {
     if (!(file->flags & (JANET_FILE_NOT_CLOSEABLE | JANET_FILE_CLOSED))) {
         ret = fclose(file->file);
         file->flags |= JANET_FILE_CLOSED;
-        file->file = NULL; /* NULL dereference is easier to debug then other problems */
+        file->file = NULL; /* NULL derefence is easier to debug then other problems */
         return ret;
     }
     return 0;
@@ -351,7 +336,7 @@ JANET_CORE_FN(cfun_io_fseek,
     JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
     if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
-    int64_t offset = 0;
+    long int offset = 0;
     int whence = SEEK_CUR;
     if (argc >= 2) {
         const uint8_t *whence_sym = janet_getkeyword(argv, 1);
@@ -365,7 +350,7 @@ JANET_CORE_FN(cfun_io_fseek,
             janet_panicf("expected one of :cur, :set, :end, got %v", argv[1]);
         }
         if (argc == 3) {
-            offset = (int64_t) janet_getinteger64(argv, 2);
+            offset = (long) janet_getinteger64(argv, 2);
         }
     }
     if (fseek(iof->file, offset, whence)) janet_panic("error seeking file");
@@ -379,7 +364,7 @@ JANET_CORE_FN(cfun_io_ftell,
     JanetFile *iof = janet_getabstract(argv, 0, &janet_file_type);
     if (iof->flags & JANET_FILE_CLOSED)
         janet_panic("file is closed");
-    int64_t pos = ftell(iof->file);
+    long pos = ftell(iof->file);
     if (pos == -1) janet_panic("error getting position in file");
     return janet_wrap_number((double)pos);
 }
@@ -503,7 +488,7 @@ static Janet cfun_io_print_impl_x(int32_t argc, Janet *argv, int newline,
         }
     }
     for (int32_t i = offset; i < argc; ++i) {
-        int32_t len;
+        size_t len;
         const uint8_t *vstr;
         if (janet_checktype(argv[i], JANET_BUFFER)) {
             JanetBuffer *b = janet_unwrap_buffer(argv[i]);

src/core/marsh.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -68,15 +68,8 @@ enum {
     LB_STRUCT_PROTO, /* 223 */
 #ifdef JANET_EV
     LB_THREADED_ABSTRACT, /* 224 */
-    LB_POINTER_BUFFER, /* 225 */
+    LB_POINTER_BUFFER, /* 224 */
 #endif
-    LB_TABLE_WEAKK, /* 226 */
-    LB_TABLE_WEAKV, /* 227 */
-    LB_TABLE_WEAKKV, /* 228 */
-    LB_TABLE_WEAKK_PROTO, /* 229 */
-    LB_TABLE_WEAKV_PROTO, /* 230 */
-    LB_TABLE_WEAKKV_PROTO, /* 231 */
-    LB_ARRAY_WEAK, /* 232 */
 } LeadBytes;
 
 /* Helper to look inside an entry in an environment */
@@ -103,12 +96,12 @@ static Janet entry_getval(Janet env_entry) {
 /* Merge values from an environment into an existing lookup table. */
 void janet_env_lookup_into(JanetTable *renv, JanetTable *env, const char *prefix, int recurse) {
     while (env) {
-        for (int32_t i = 0; i < env->capacity; i++) {
+        for (size_t i = 0; i < env->capacity; i++) {
             if (janet_checktype(env->data[i].key, JANET_SYMBOL)) {
                 if (prefix) {
-                    int32_t prelen = (int32_t) strlen(prefix);
+                    size_t prelen = strlen(prefix);
                     const uint8_t *oldsym = janet_unwrap_symbol(env->data[i].key);
-                    int32_t oldlen = janet_string_length(oldsym);
+                    size_t oldlen = janet_string_length(oldsym);
                     uint8_t *symbuf = janet_smalloc(prelen + oldlen);
                     safe_memcpy(symbuf, prefix, prelen);
                     safe_memcpy(symbuf + prelen, oldsym, oldlen);
@@ -165,7 +158,7 @@ static void pushpointer(MarshalState *st, const void *ptr) {
     janet_buffer_push_bytes(st->buf, (const uint8_t *) &ptr, sizeof(ptr));
 }
 
-/* Marshal a size_t onto the buffer */
+/* Marshal a uint64_t onto the buffer */
 static void push64(MarshalState *st, uint64_t x) {
     if (x <= 0xF0) {
         /* Single byte */
@@ -183,6 +176,11 @@ static void push64(MarshalState *st, uint64_t x) {
     }
 }
 
+/* Marshal a size_t onto the buffer */
+static void pushsize(MarshalState *st, size_t x) {
+    push64(st, (uint64_t)x);
+}
+
 /* Forward declaration to enable mutual recursion. */
 static void marshal_one(MarshalState *st, Janet x, int flags);
 static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags);
@@ -196,7 +194,7 @@ static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags);
  * have no false positives, but may have false negatives. */
 static int fiber_cannot_be_marshalled(JanetFiber *fiber) {
     if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) return 1;
-    int32_t i = fiber->frame;
+    size_t i = fiber->frame;
     while (i > 0) {
         JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i - JANET_FRAME_SIZE);
         if (!frame->func) return 1; /* has cfunction on stack */
@@ -352,7 +350,7 @@ static void marshal_one_fiber(MarshalState *st, JanetFiber *fiber, int flags) {
         if (frame->env) frame->flags |= JANET_STACKFRAME_HASENV;
         if (!frame->func) janet_panicf("cannot marshal fiber with c stackframe (%v)", janet_wrap_cfunction((JanetCFunction) frame->pc));
         pushint(st, frame->flags);
-        pushint(st, frame->prevframe);
+        pushsize(st, frame->prevframe);
         int32_t pcdiff = (int32_t)(frame->pc - frame->func->def->bytecode);
         pushint(st, pcdiff);
         marshal_one(st, janet_wrap_function(frame->func), flags + 1);
@@ -502,7 +500,7 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
                 MARK_SEEN();
                 const uint8_t *regname = janet_unwrap_symbol(check);
                 pushbyte(st, LB_REGISTRY);
-                pushint(st, janet_string_length(regname));
+                pushsize(st, janet_string_length(regname));
                 pushbytes(st, regname, janet_string_length(regname));
                 return;
             }
@@ -542,14 +540,14 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
         case JANET_SYMBOL:
         case JANET_KEYWORD: {
             const uint8_t *str = janet_unwrap_string(x);
-            int32_t length = janet_string_length(str);
+            size_t length = janet_string_length(str);
             /* Record reference */
             MARK_SEEN();
             uint8_t lb = (type == JANET_STRING) ? LB_STRING :
                          (type == JANET_SYMBOL) ? LB_SYMBOL :
                          LB_KEYWORD;
             pushbyte(st, lb);
-            pushint(st, length);
+            pushsize(st, length);
             pushbytes(st, str, length);
             return;
         }
@@ -561,35 +559,34 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
             if ((flags & JANET_MARSHAL_UNSAFE) &&
                     (buffer->gc.flags & JANET_BUFFER_FLAG_NO_REALLOC)) {
                 pushbyte(st, LB_POINTER_BUFFER);
-                pushint(st, buffer->count);
-                pushint(st, buffer->capacity);
+                pushsize(st, buffer->count);
+                pushsize(st, buffer->capacity);
                 pushpointer(st, buffer->data);
                 return;
             }
 #endif
             pushbyte(st, LB_BUFFER);
-            pushint(st, buffer->count);
+            pushsize(st, buffer->count);
             pushbytes(st, buffer->data, buffer->count);
             return;
         }
         case JANET_ARRAY: {
-            int32_t i;
             JanetArray *a = janet_unwrap_array(x);
             MARK_SEEN();
-            enum JanetMemoryType memtype = janet_gc_type(a);
-            pushbyte(st, memtype == JANET_MEMORY_ARRAY_WEAK ? LB_ARRAY_WEAK : LB_ARRAY);
-            pushint(st, a->count);
-            for (i = 0; i < a->count; i++)
+            pushbyte(st, LB_ARRAY);
+            pushsize(st, a->count);
+            for (size_t i = 0; i < a->count; i++)
                 marshal_one(st, a->data[i], flags + 1);
             return;
         }
         case JANET_TUPLE: {
-            int32_t i, count, flag;
+            size_t i, count;
+            int32_t flag;
             const Janet *tup = janet_unwrap_tuple(x);
             count = janet_tuple_length(tup);
             flag = janet_tuple_flag(tup) >> 16;
             pushbyte(st, LB_TUPLE);
-            pushint(st, count);
+            pushsize(st, count);
             pushint(st, flag);
             for (i = 0; i < count; i++)
                 marshal_one(st, tup[i], flags + 1);
@@ -600,20 +597,11 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
         case JANET_TABLE: {
             JanetTable *t = janet_unwrap_table(x);
             MARK_SEEN();
-            enum JanetMemoryType memtype = janet_gc_type(t);
-            if (memtype == JANET_MEMORY_TABLE_WEAKK) {
-                pushbyte(st, t->proto ? LB_TABLE_WEAKK_PROTO : LB_TABLE_WEAKK);
-            } else if (memtype == JANET_MEMORY_TABLE_WEAKV) {
-                pushbyte(st, t->proto ? LB_TABLE_WEAKV_PROTO : LB_TABLE_WEAKV);
-            } else if (memtype == JANET_MEMORY_TABLE_WEAKKV) {
-                pushbyte(st, t->proto ? LB_TABLE_WEAKKV_PROTO : LB_TABLE_WEAKKV);
-            } else {
-                pushbyte(st, t->proto ? LB_TABLE_PROTO : LB_TABLE);
-            }
-            pushint(st, t->count);
+            pushbyte(st, t->proto ? LB_TABLE_PROTO : LB_TABLE);
+            pushsize(st, t->count);
             if (t->proto)
                 marshal_one(st, janet_wrap_table(t->proto), flags + 1);
-            for (int32_t i = 0; i < t->capacity; i++) {
+            for (size_t i = 0; i < t->capacity; i++) {
                 if (janet_checktype(t->data[i].key, JANET_NIL))
                     continue;
                 marshal_one(st, t->data[i].key, flags + 1);
@@ -622,14 +610,14 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
             return;
         }
         case JANET_STRUCT: {
-            int32_t count;
+            size_t count;
             const JanetKV *struct_ = janet_unwrap_struct(x);
             count = janet_struct_length(struct_);
             pushbyte(st, janet_struct_proto(struct_) ? LB_STRUCT_PROTO : LB_STRUCT);
-            pushint(st, count);
+            pushsize(st, count);
             if (janet_struct_proto(struct_))
                 marshal_one(st, janet_wrap_struct(janet_struct_proto(struct_)), flags + 1);
-            for (int32_t i = 0; i < janet_struct_capacity(struct_); i++) {
+            for (size_t i = 0; i < janet_struct_capacity(struct_); i++) {
                 if (janet_checktype(struct_[i].key, JANET_NIL))
                     continue;
                 marshal_one(st, struct_[i].key, flags + 1);
@@ -779,6 +767,10 @@ static uint64_t read64(UnmarshalState *st, const uint8_t **atdata) {
     return ret;
 }
 
+static size_t readsize(UnmarshalState *st, const uint8_t **atdata) {
+    return (size_t)read64(st, atdata);
+}
+
 #ifdef JANET_MARSHAL_DEBUG
 static void dump_reference_table(UnmarshalState *st) {
     for (int32_t i = 0; i < janet_v_count(st->lookup); i++) {
@@ -1099,7 +1091,7 @@ static const uint8_t *unmarshal_one_fiber(
     JanetTable *fiber_env = NULL;
 
     /* Check for bad flags and ints */
-    if ((int32_t)(frame + JANET_FRAME_SIZE) > fiber_stackstart ||
+    if ((frame + JANET_FRAME_SIZE) > fiber_stackstart ||
             fiber_stackstart > fiber_stacktop ||
             fiber_stacktop > fiber_maxstack) {
         janet_panic("fiber has incorrect stack setup");
@@ -1145,7 +1137,7 @@ static const uint8_t *unmarshal_one_fiber(
 
         /* Error checking */
         int32_t expected_framesize = def->slotcount;
-        if (expected_framesize != stacktop - stack) {
+        if (expected_framesize != (int32_t) stacktop - stack) {
             janet_panic("fiber stackframe size mismatch");
         }
         if (pcdiff >= def->bytecode_length) {
@@ -1372,7 +1364,7 @@ static const uint8_t *unmarshal_one(
         case LB_KEYWORD:
         case LB_REGISTRY: {
             data++;
-            int32_t len = readnat(st, &data);
+            size_t len = readsize(st, &data);
             MARSH_EOS(st, data - 1 + len);
             if (lead == LB_STRING) {
                 const uint8_t *str = janet_string(data, len);
@@ -1433,34 +1425,35 @@ static const uint8_t *unmarshal_one(
             return unmarshal_one_abstract(st, data, out, flags);
         }
         case LB_REFERENCE:
+        {
+            data++;
+            int32_t len = readnat(st, &data);
+            if (len >= janet_v_count(st->lookup))
+                    janet_panicf("invalid reference %d", len);
+            *out = st->lookup[len];
+            return data;
+        }
         case LB_ARRAY:
-        case LB_ARRAY_WEAK:
         case LB_TUPLE:
         case LB_STRUCT:
         case LB_STRUCT_PROTO:
         case LB_TABLE:
         case LB_TABLE_PROTO:
-        case LB_TABLE_WEAKK:
-        case LB_TABLE_WEAKV:
-        case LB_TABLE_WEAKKV:
-        case LB_TABLE_WEAKK_PROTO:
-        case LB_TABLE_WEAKV_PROTO:
-        case LB_TABLE_WEAKKV_PROTO:
             /* Things that open with integers */
         {
             data++;
-            int32_t len = readnat(st, &data);
+            size_t len = readsize(st, &data);
             /* DOS check */
             if (lead != LB_REFERENCE) {
                 MARSH_EOS(st, data - 1 + len);
             }
-            if (lead == LB_ARRAY || lead == LB_ARRAY_WEAK) {
+            if (lead == LB_ARRAY) {
                 /* Array */
-                JanetArray *array = (lead == LB_ARRAY_WEAK) ? janet_array_weak(len) : janet_array(len);
+                JanetArray *array = janet_array(len);
                 array->count = len;
                 *out = janet_wrap_array(array);
                 janet_v_push(st->lookup, *out);
-                for (int32_t i = 0; i < len; i++) {
+                for (size_t i = 0; i < len; i++) {
                     data = unmarshal_one(st, data, array->data + i, flags + 1);
                 }
             } else if (lead == LB_TUPLE) {
@@ -1468,7 +1461,7 @@ static const uint8_t *unmarshal_one(
                 Janet *tup = janet_tuple_begin(len);
                 int32_t flag = readint(st, &data);
                 janet_tuple_flag(tup) |= flag << 16;
-                for (int32_t i = 0; i < len; i++) {
+                for (size_t i = 0; i < len; i++) {
                     data = unmarshal_one(st, data, tup + i, flags + 1);
                 }
                 *out = janet_wrap_tuple(janet_tuple_end(tup));
@@ -1482,7 +1475,7 @@ static const uint8_t *unmarshal_one(
                     janet_asserttype(proto, JANET_STRUCT, st);
                     janet_struct_proto(struct_) = janet_unwrap_struct(proto);
                 }
-                for (int32_t i = 0; i < len; i++) {
+                for (size_t i = 0; i < len; i++) {
                     Janet key, value;
                     data = unmarshal_one(st, data, &key, flags + 1);
                     data = unmarshal_one(st, data, &value, flags + 1);
@@ -1490,31 +1483,18 @@ static const uint8_t *unmarshal_one(
                 }
                 *out = janet_wrap_struct(janet_struct_end(struct_));
                 janet_v_push(st->lookup, *out);
-            } else if (lead == LB_REFERENCE) {
-                if (len >= janet_v_count(st->lookup))
-                    janet_panicf("invalid reference %d", len);
-                *out = st->lookup[len];
             } else {
                 /* Table */
-                JanetTable *t;
-                if (lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKK) {
-                    t = janet_table_weakk(len);
-                } else if (lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKV) {
-                    t = janet_table_weakv(len);
-                } else if (lead == LB_TABLE_WEAKKV_PROTO || lead == LB_TABLE_WEAKKV) {
-                    t = janet_table_weakkv(len);
-                } else {
-                    t = janet_table(len);
-                }
+                JanetTable *t = janet_table(len);
                 *out = janet_wrap_table(t);
                 janet_v_push(st->lookup, *out);
-                if (lead == LB_TABLE_PROTO || lead == LB_TABLE_WEAKK_PROTO || lead == LB_TABLE_WEAKV_PROTO || lead == LB_TABLE_WEAKKV_PROTO) {
+                if (lead == LB_TABLE_PROTO) {
                     Janet proto;
                     data = unmarshal_one(st, data, &proto, flags + 1);
                     janet_asserttype(proto, JANET_TABLE, st);
                     t->proto = janet_unwrap_table(proto);
                 }
-                for (int32_t i = 0; i < len; i++) {
+                for (size_t i = 0; i < len; i++) {
                     Janet key, value;
                     data = unmarshal_one(st, data, &key, flags + 1);
                     data = unmarshal_one(st, data, &value, flags + 1);
@@ -1544,8 +1524,8 @@ static const uint8_t *unmarshal_one(
 #ifdef JANET_EV
         case LB_POINTER_BUFFER: {
             data++;
-            int32_t count = readnat(st, &data);
-            int32_t capacity = readnat(st, &data);
+            size_t count = readsize(st, &data);
+            size_t capacity = readsize(st, &data);
             MARSH_EOS(st, data + sizeof(void *));
             union {
                 void *ptr;

src/core/math.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -81,14 +81,14 @@ void janet_rng_seed(JanetRNG *rng, uint32_t seed) {
     for (int i = 0; i < 16; i++) janet_rng_u32(rng);
 }
 
-void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len) {
+void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, size_t len) {
     uint8_t state[16] = {0};
-    for (int32_t i = 0; i < len; i++)
+    for (size_t i = 0; i < len; i++)
         state[i & 0xF] ^= bytes[i];
-    rng->a = state[0] + ((uint32_t) state[1] << 8) + ((uint32_t) state[2] << 16) + ((uint32_t) state[3] << 24);
-    rng->b = state[4] + ((uint32_t) state[5] << 8) + ((uint32_t) state[6] << 16) + ((uint32_t) state[7] << 24);
-    rng->c = state[8] + ((uint32_t) state[9] << 8) + ((uint32_t) state[10] << 16) + ((uint32_t) state[11] << 24);
-    rng->d = state[12] + ((uint32_t) state[13] << 8) + ((uint32_t) state[14] << 16) + ((uint32_t) state[15] << 24);
+    rng->a = state[0] + (state[1] << 8) + (state[2] << 16) + (state[3] << 24);
+    rng->b = state[4] + (state[5] << 8) + (state[6] << 16) + (state[7] << 24);
+    rng->c = state[8] + (state[9] << 8) + (state[10] << 16) + (state[11] << 24);
+    rng->d = state[12] + (state[13] << 8) + (state[14] << 16) + (state[15] << 24);
     rng->counter = 0u;
     /* a, b, c, d can't all be 0 */
     if (rng->a == 0) rng->a = 1u;
@@ -349,26 +349,6 @@ JANET_CORE_FN(janet_cfun_lcm, "(math/lcm x y)",
     return janet_wrap_number(janet_lcm(x, y));
 }
 
-JANET_CORE_FN(janet_cfun_frexp, "(math/frexp x)",
-              "Returns a tuple of (mantissa, exponent) from number.") {
-    janet_fixarity(argc, 1);
-    double x = janet_getnumber(argv, 0);
-    int exp;
-    x = frexp(x, &exp);
-    Janet *result = janet_tuple_begin(2);
-    result[0] = janet_wrap_number(x);
-    result[1] = janet_wrap_number((double) exp);
-    return janet_wrap_tuple(janet_tuple_end(result));
-}
-
-JANET_CORE_FN(janet_cfun_ldexp, "(math/ldexp m e)",
-              "Creates a new number from a mantissa and an exponent.") {
-    janet_fixarity(argc, 2);
-    double x = janet_getnumber(argv, 0);
-    int32_t y = janet_getinteger(argv, 1);
-    return janet_wrap_number(ldexp(x, y));
-}
-
 /* Module entry point */
 void janet_lib_math(JanetTable *env) {
     JanetRegExt math_cfuns[] = {
@@ -415,8 +395,6 @@ void janet_lib_math(JanetTable *env) {
         JANET_CORE_REG("math/next", janet_nextafter),
         JANET_CORE_REG("math/gcd", janet_cfun_gcd),
         JANET_CORE_REG("math/lcm", janet_cfun_lcm),
-        JANET_CORE_REG("math/frexp", janet_cfun_frexp),
-        JANET_CORE_REG("math/ldexp", janet_cfun_ldexp),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, math_cfuns);

src/core/net.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose and contributors.
+* Copyright (c) 2023 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
@@ -152,7 +152,7 @@ void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
         if (res == 0) {
             janet_schedule(fiber, janet_wrap_abstract(stream));
         } else {
-            janet_cancel(fiber, janet_cstringv(janet_strerror(res)));
+            janet_cancel(fiber, janet_cstringv(strerror(res)));
             stream->flags |= JANET_STREAM_TOCLOSE;
         }
     } else {
@@ -319,13 +319,12 @@ JANET_NO_RETURN static void janet_sched_accept(JanetStream *stream, JanetFunctio
     NetStateAccept *state = janet_malloc(sizeof(NetStateAccept));
     memset(state, 0, sizeof(NetStateAccept));
     state->function = fun;
-    if (fun) janet_stream_level_triggered(stream);
     janet_async_start(stream, JANET_ASYNC_LISTEN_READ, net_callback_accept, state);
 }
 
 #endif
 
-/* Address info */
+/* Adress info */
 
 static int janet_get_sockettype(Janet *argv, int32_t argc, int32_t n) {
     JanetKeyword stype = janet_optkeyword(argv, argc, n, NULL);
@@ -341,7 +340,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, socklen_t *sizeout) {
+static struct addrinfo *janet_get_addrinfo(Janet *argv, int32_t offset, int socktype, int passive, int *is_unix) {
     /* Unix socket support - not yet supported on windows. */
 #ifndef JANET_WINDOWS
     if (janet_keyeq(argv[offset], "unix")) {
@@ -352,14 +351,15 @@ 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';
-            *sizeout = offsetof(struct sockaddr_un, sun_path) + janet_string_length(path);
-        }
+            snprintf(saddr->sun_path + 1, path_size - 1, "%s", path + 1);
+        } else
 #endif
+        {
+            snprintf(saddr->sun_path, path_size, "%s", path);
+        }
         *is_unix = 1;
         return (struct addrinfo *) saddr;
     }
@@ -384,11 +384,6 @@ 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;
 }
 
@@ -409,13 +404,12 @@ 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]));
-    socklen_t addrsize = 0;
-    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix, &addrsize);
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix);
 #ifndef JANET_WINDOWS
     /* no unix domain socket support on windows yet */
     if (is_unix) {
-        void *abst = janet_abstract(&janet_address_type, addrsize);
-        memcpy(abst, ai, addrsize);
+        void *abst = janet_abstract(&janet_address_type, sizeof(struct sockaddr_un));
+        memcpy(abst, ai, sizeof(struct sockaddr_un));
         Janet ret = janet_wrap_abstract(abst);
         return make_arr ? janet_wrap_array(janet_array_n(&ret, 1)) : ret;
     }
@@ -466,8 +460,7 @@ JANET_CORE_FN(cfun_net_connect,
     }
 
     /* Where we're connecting to */
-    socklen_t addrlen = 0;
-    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix, &addrlen);
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 0, &is_unix);
 
     /* Check if we're binding address */
     struct addrinfo *binding = NULL;
@@ -492,6 +485,7 @@ 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);
@@ -501,6 +495,7 @@ JANET_CORE_FN(cfun_net_connect,
             janet_panicf("could not create socket: %V", v);
         }
         addr = (void *) ai;
+        addrlen = sizeof(struct sockaddr_un);
     } else
 #endif
     {
@@ -547,9 +542,7 @@ JANET_CORE_FN(cfun_net_connect,
     }
 
     /* Wrap socket in abstract type JanetStream */
-    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);
+    JanetStream *stream = make_stream(sock, JANET_STREAM_READABLE | JANET_STREAM_WRITABLE);
 
     /* Set up the socket for non-blocking IO before connecting */
     janet_net_socknoblock(sock);
@@ -560,10 +553,7 @@ JANET_CORE_FN(cfun_net_connect,
     int err = WSAGetLastError();
     freeaddrinfo(ai);
 #else
-    int status;
-    do {
-        status = connect(sock, addr, addrlen);
-    } while (status == -1 && errno == EINTR);
+    int status = connect(sock, addr, addrlen);
     int err = errno;
     if (is_unix) {
         janet_free(ai);
@@ -587,73 +577,17 @@ 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) {
+static const char *serverify_socket(JSock sfd) {
     /* Set various socket options */
     int enable = 1;
-    if (reuse_addr) {
-        if (setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, (char *) &enable, sizeof(int)) < 0) {
-            return "setsockopt(SO_REUSEADDR) failed";
-        }
+    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
+    if (setsockopt(sfd, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int)) < 0) {
+        return "setsockopt(SO_REUSEPORT) failed";
     }
+#endif
     janet_net_socknoblock(sfd);
     return NULL;
 }
@@ -707,22 +641,19 @@ JANET_CORE_FN(cfun_net_shutdown,
 }
 
 JANET_CORE_FN(cfun_net_listen,
-              "(net/listen host port &opt type no-reuse)",
+              "(net/listen host port &opt type)",
               "Creates a server. Returns a new stream that is neither readable nor "
               "writeable. Use net/accept or net/accept-loop be to handle connections and start the server. "
               "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.") {
+              ":stream. The host and port arguments are the same as in net/address.") {
     janet_sandbox_assert(JANET_SANDBOX_NET_LISTEN);
-    janet_arity(argc, 2, 4);
+    janet_arity(argc, 2, 3);
 
     /* Get host, port, and handler*/
     int socktype = janet_get_sockettype(argv, argc, 2);
     int is_unix = 0;
-    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]));
+    struct addrinfo *ai = janet_get_addrinfo(argv, 0, socktype, 1, &is_unix);
 
     JSock sfd = JSOCKDEFAULT;
 #ifndef JANET_WINDOWS
@@ -732,8 +663,8 @@ 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, 0);
-        if (NULL != err || bind(sfd, (struct sockaddr *)ai, addrlen)) {
+        const char *err = serverify_socket(sfd);
+        if (NULL != err || bind(sfd, (struct sockaddr *)ai, sizeof(struct sockaddr_un))) {
             JSOCKCLOSE(sfd);
             janet_free(ai);
             if (err) {
@@ -755,7 +686,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, reuse);
+            const char *err = serverify_socket(sfd);
             if (NULL != err) {
                 JSOCKCLOSE(sfd);
                 continue;
@@ -897,7 +828,7 @@ JANET_CORE_FN(cfun_stream_accept_loop,
 JANET_CORE_FN(cfun_stream_accept,
               "(net/accept stream &opt timeout)",
               "Get the next connection on a server stream. This would usually be called in a loop in a dedicated fiber. "
-              "Takes an optional timeout in seconds, after which will raise an error. "
+              "Takes an optional timeout in seconds, after which will return nil. "
               "Returns a new duplex stream which represents a connection to the client.") {
     janet_arity(argc, 1, 2);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
@@ -912,7 +843,7 @@ JANET_CORE_FN(cfun_stream_read,
               "Read up to n bytes from a stream, suspending the current fiber until the bytes are available. "
               "`n` can also be the keyword `:all` to read into the buffer until end of stream. "
               "If less than n bytes are available (and more than 0), will push those bytes and return early. "
-              "Takes an optional timeout in seconds, after which will raise an error. "
+              "Takes an optional timeout in seconds, after which will return nil. "
               "Returns a buffer with up to n more bytes in it, or raises an error if the read failed.") {
     janet_arity(argc, 2, 4);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
@@ -932,7 +863,7 @@ JANET_CORE_FN(cfun_stream_read,
 JANET_CORE_FN(cfun_stream_chunk,
               "(net/chunk stream nbytes &opt buf timeout)",
               "Same a net/read, but will wait for all n bytes to arrive rather than return early. "
-              "Takes an optional timeout in seconds, after which will raise an error.") {
+              "Takes an optional timeout in seconds, after which will return nil.") {
     janet_arity(argc, 2, 4);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
     janet_stream_flags(stream, JANET_STREAM_READABLE | JANET_STREAM_SOCKET);
@@ -946,7 +877,7 @@ JANET_CORE_FN(cfun_stream_chunk,
 JANET_CORE_FN(cfun_stream_recv_from,
               "(net/recv-from stream nbytes buf &opt timeout)",
               "Receives data from a server stream and puts it into a buffer. Returns the socket-address the "
-              "packet came from. Takes an optional timeout in seconds, after which will raise an error.") {
+              "packet came from. Takes an optional timeout in seconds, after which will return nil.") {
     janet_arity(argc, 3, 4);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
     janet_stream_flags(stream, JANET_STREAM_UDPSERVER | JANET_STREAM_SOCKET);
@@ -960,7 +891,7 @@ JANET_CORE_FN(cfun_stream_recv_from,
 JANET_CORE_FN(cfun_stream_write,
               "(net/write stream data &opt timeout)",
               "Write data to a stream, suspending the current fiber until the write "
-              "completes. Takes an optional timeout in seconds, after which will raise an error. "
+              "completes. Takes an optional timeout in seconds, after which will return nil. "
               "Returns nil, or raises an error if the write failed.") {
     janet_arity(argc, 2, 3);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
@@ -979,7 +910,7 @@ JANET_CORE_FN(cfun_stream_write,
 JANET_CORE_FN(cfun_stream_send_to,
               "(net/send-to stream dest data &opt timeout)",
               "Writes a datagram to a server stream. dest is a the destination address of the packet. "
-              "Takes an optional timeout in seconds, after which will raise an error. "
+              "Takes an optional timeout in seconds, after which will return nil. "
               "Returns stream.") {
     janet_arity(argc, 3, 4);
     JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
@@ -1103,7 +1034,7 @@ JANET_CORE_FN(cfun_net_setsockopt,
 
     int r = setsockopt((JSock) stream->handle, st->level, st->optname, optval, optlen);
     if (r == -1) {
-        janet_panicf("setsockopt(%q): %s", argv[1], janet_strerror(errno));
+        janet_panicf("setsockopt(%q): %s", argv[1], strerror(errno));
     }
 
     return janet_wrap_nil();
@@ -1135,7 +1066,6 @@ 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

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose and contributors.
+* Copyright (c) 2023 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
@@ -27,10 +27,9 @@
 #include "gc.h"
 #endif
 
-#include <stdlib.h>
-
 #ifndef JANET_REDUCED_OS
 
+#include <stdlib.h>
 #include <time.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -39,7 +38,6 @@
 #include <string.h>
 #include <sys/stat.h>
 #include <signal.h>
-#include <locale.h>
 
 #ifdef JANET_BSD
 #include <sys/sysctl.h>
@@ -55,7 +53,6 @@
 #include <sys/utime.h>
 #include <io.h>
 #include <process.h>
-#define JANET_SPAWN_CHDIR
 #else
 #include <spawn.h>
 #include <utime.h>
@@ -66,8 +63,6 @@
 #ifdef JANET_APPLE
 #include <crt_externs.h>
 #define environ (*_NSGetEnviron())
-#include <AvailabilityMacros.h>
-int chroot(const char *dirname);
 #else
 extern char **environ;
 #endif
@@ -76,26 +71,6 @@ 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);
@@ -181,8 +156,6 @@ 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
@@ -200,8 +173,6 @@ JANET_CORE_FN(os_arch,
               "* :riscv64\n\n"
               "* :sparc\n\n"
               "* :wasm\n\n"
-              "* :s390\n\n"
-              "* :s390x\n\n"
               "* :unknown\n") {
     janet_fixarity(argc, 0);
     (void) argv;
@@ -228,10 +199,6 @@ JANET_CORE_FN(os_arch,
     return janet_ckeywordv("ppc");
 #elif (defined(__ppc64__) || defined(_ARCH_PPC64) || defined(_M_PPC))
     return janet_ckeywordv("ppc64");
-#elif (defined(__s390x__))
-    return janet_ckeywordv("s390x");
-#elif (defined(__s390__))
-    return janet_ckeywordv("s390");
 #else
     return janet_ckeywordv("unknown");
 #endif
@@ -277,7 +244,7 @@ JANET_CORE_FN(os_exit,
     }
     janet_deinit();
     if (argc >= 2 && janet_truthy(argv[1])) {
-        _Exit(status);
+        _exit(status);
     } else {
         exit(status);
     }
@@ -322,13 +289,6 @@ 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
@@ -349,7 +309,7 @@ static EnvBlock os_execute_env(int32_t argc, const Janet *argv) {
     JanetDictView dict = janet_getdictionary(argv, 2);
 #ifdef JANET_WINDOWS
     JanetBuffer *temp = janet_buffer(10);
-    for (int32_t i = 0; i < dict.cap; i++) {
+    for (size_t i = 0; i < dict.cap; i++) {
         const JanetKV *kv = dict.kvs + i;
         if (!janet_checktype(kv->key, JANET_STRING)) continue;
         if (!janet_checktype(kv->value, JANET_STRING)) continue;
@@ -365,26 +325,26 @@ static EnvBlock os_execute_env(int32_t argc, const Janet *argv) {
     memcpy(ret, temp->data, temp->count);
     return ret;
 #else
-    char **envp = janet_smalloc(sizeof(char *) * ((size_t)dict.len + 1));
+    char **envp = janet_smalloc(sizeof(char *) * (dict.len + 1));
     int32_t j = 0;
-    for (int32_t i = 0; i < dict.cap; i++) {
+    for (size_t i = 0; i < dict.cap; i++) {
         const JanetKV *kv = dict.kvs + i;
         if (!janet_checktype(kv->key, JANET_STRING)) continue;
         if (!janet_checktype(kv->value, JANET_STRING)) continue;
         const uint8_t *keys = janet_unwrap_string(kv->key);
         const uint8_t *vals = janet_unwrap_string(kv->value);
-        int32_t klen = janet_string_length(keys);
-        int32_t vlen = janet_string_length(vals);
+        size_t klen = janet_string_length(keys);
+        size_t vlen = janet_string_length(vals);
         /* Check keys has no embedded 0s or =s. */
         int skip = 0;
-        for (int32_t k = 0; k < klen; k++) {
+        for (size_t k = 0; k < klen; k++) {
             if (keys[k] == '\0' || keys[k] == '=') {
                 skip = 1;
                 break;
             }
         }
         if (skip) continue;
-        char *envitem = janet_smalloc((size_t) klen + (size_t) vlen + 2);
+        char *envitem = janet_smalloc(klen + vlen + 2);
         memcpy(envitem, keys, klen);
         envitem[klen] = '=';
         memcpy(envitem + klen + 1, vals, vlen);
@@ -420,7 +380,7 @@ static void os_execute_cleanup(EnvBlock envp, const char **child_argv) {
  * a single string of this format. Returns a buffer that can be cast into a c string. */
 static JanetBuffer *os_exec_escape(JanetView args) {
     JanetBuffer *b = janet_buffer(0);
-    for (int32_t i = 0; i < args.len; i++) {
+    for (size_t i = 0; i < args.len; i++) {
         const char *arg = janet_getcstring(args.items, i);
 
         /* Push leading space if not first */
@@ -573,12 +533,11 @@ 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));
-        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 {
+        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)) {
                 janet_schedule(args.fiber, janet_wrap_integer(status));
             }
         }
@@ -636,7 +595,6 @@ 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);
@@ -663,15 +621,16 @@ os_proc_wait_impl(JanetProc *proc) {
 
 JANET_CORE_FN(os_proc_wait,
               "(os/proc-wait proc)",
-              "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.") {
+              "Suspend the current fiber until the subprocess completes. Returns the subprocess return code. "
+              "os/proc-wait cannot be called twice on the same process. If `ev/with-deadline` cancels `os/proc-wait` "
+              "with an error or os/proc-wait is cancelled with any error caused by anything else, os/proc-wait still "
+              "finishes in the background. Only after os/proc-wait finishes, a process is cleaned up by the operating "
+              "system. Thus, a process becomes a zombie process if os/proc-wait is not called.") {
     janet_fixarity(argc, 1);
     JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
 #ifdef JANET_EV
     os_proc_wait_impl(proc);
+    return janet_wrap_nil();
 #else
     return os_proc_wait_impl(proc);
 #endif
@@ -776,13 +735,12 @@ 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 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.") {
+              "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.") {
     janet_arity(argc, 1, 3);
     JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
     if (proc->flags & JANET_PROC_WAITED) {
@@ -803,13 +761,14 @@ JANET_CORE_FN(os_proc_kill,
     }
     int status = kill(proc->pid, signal == -1 ? SIGKILL : signal);
     if (status) {
-        janet_panic(janet_strerror(errno));
+        janet_panic(strerror(errno));
     }
 #endif
     /* After killing process we wait on it. */
     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
@@ -820,9 +779,9 @@ JANET_CORE_FN(os_proc_kill,
 
 JANET_CORE_FN(os_proc_close,
               "(os/proc-close proc)",
-              "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.") {
+              "Close pipes created by `os/spawn` if they have not been closed. Then, if os/proc-wait was not already "
+              "called on proc, os/proc-wait is called on it, and it returns the exit code returned by os/proc-wait. "
+              "Otherwise, returns nil.") {
     janet_fixarity(argc, 1);
     JanetProc *proc = janet_getabstract(argv, 0, &ProcAT);
 #ifdef JANET_EV
@@ -840,24 +799,12 @@ 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];
@@ -1182,7 +1129,6 @@ 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;
 
@@ -1207,28 +1153,11 @@ 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);
@@ -1243,7 +1172,6 @@ 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));
@@ -1260,10 +1188,6 @@ 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) {
@@ -1271,7 +1195,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(_fileno(stdin));
+        startupInfo.hStdInput = (HANDLE) _get_osfhandle(0);
     }
 
     if (pipe_out != JANET_HANDLE_NONE) {
@@ -1279,17 +1203,15 @@ 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(_fileno(stdout));
+        startupInfo.hStdOutput = (HANDLE) _get_osfhandle(1);
     }
 
     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(_fileno(stderr));
+        startupInfo.hStdError = (HANDLE) _get_osfhandle(2);
     }
 
     int cp_failed = 0;
@@ -1300,7 +1222,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 */
-                       lpCurrentDirectory,
+                       NULL, /* use parents starting directory */
                        &startupInfo,
                        &processInfo)) {
         cp_failed = 1;
@@ -1324,8 +1246,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     /* Result */
     int status = 0;
 
-    const char **child_argv = janet_smalloc(sizeof(char *) * ((size_t) exargs.len + 1));
-    for (int32_t i = 0; i < exargs.len; i++)
+    const char **child_argv = janet_smalloc(sizeof(char *) * (exargs.len + 1));
+    for (size_t i = 0; i < exargs.len; i++)
         child_argv[i] = janet_getcstring(exargs.items, i);
     child_argv[exargs.len] = NULL;
     /* Coerce to form that works for spawn. I'm fairly confident no implementation
@@ -1338,6 +1260,9 @@ 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;
@@ -1349,7 +1274,8 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
                 status = execv(cargv[0], cargv);
             }
         } while (status == -1 && errno == EINTR);
-        janet_panicf("%p: %s", cargv[0], janet_strerror(errno ? errno : ENOENT));
+        janet_panicf("%p: %s", cargv[0], strerror(errno ? errno : ENOENT));
+#endif
     }
 
     /* Use posix_spawn to spawn new process */
@@ -1357,15 +1283,6 @@ 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);
@@ -1388,8 +1305,6 @@ 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;
@@ -1416,7 +1331,7 @@ static Janet os_execute_impl(int32_t argc, Janet *argv, JanetExecuteMode mode) {
     os_execute_cleanup(envp, child_argv);
     if (status) {
         /* correct for macos bug where errno is not set */
-        janet_panicf("%p: %s", argv[0], janet_strerror(errno ? errno : ENOENT));
+        janet_panicf("%p: %s", argv[0], strerror(errno ? errno : ENOENT));
     }
 
 #endif
@@ -1461,57 +1376,45 @@ 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 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 "
+              "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 "
               "current environment is inherited.\n"
-              "* :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.") {
+              "* :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.") {
     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 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.") {
+              "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.") {
     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 "
+              "Hoever, 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,
@@ -1522,14 +1425,14 @@ JANET_CORE_FN(os_posix_fork,
     janet_fixarity(argc, 0);
     (void) argv;
 #ifdef JANET_WINDOWS
-    janet_panic("not supported on Windows");
+    janet_panic("not supported");
 #else
     pid_t result;
     do {
         result = fork();
     } while (result == -1 && errno == EINTR);
     if (result == -1) {
-        janet_panic(janet_strerror(errno));
+        janet_panic(strerror(errno));
     }
     if (result) {
         JanetProc *proc = janet_abstract(&ProcAT, sizeof(JanetProc));
@@ -1542,28 +1445,6 @@ JANET_CORE_FN(os_posix_fork,
 #endif
 }
 
-JANET_CORE_FN(os_posix_chroot,
-              "(os/posix-chroot dirname)",
-              "Call `chroot` to change the root directory to `dirname`. "
-              "Not supported on all systems (POSIX only).") {
-    janet_sandbox_assert(JANET_SANDBOX_CHROOT);
-    janet_fixarity(argc, 1);
-#ifdef JANET_WINDOWS
-    (void) argv;
-    janet_panic("not supported on Windows");
-#else
-    const char *root = janet_getcstring(argv, 0);
-    int result;
-    do {
-        result = chroot(root);
-    } while (result == -1 && errno == EINTR);
-    if (result == -1) {
-        janet_panic(janet_strerror(errno));
-    }
-    return janet_wrap_nil();
-#endif
-}
-
 #ifdef JANET_EV
 /* Runs in a separate thread */
 static JanetEVGenericMessage os_shell_subr(JanetEVGenericMessage args) {
@@ -1700,8 +1581,8 @@ JANET_CORE_FN(os_clock,
     janet_sandbox_assert(JANET_SANDBOX_HRTIME);
     janet_arity(argc, 0, 2);
 
-    JanetKeyword sourcestr = janet_optkeyword(argv, argc, 0, NULL);
-    if (sourcestr == NULL || janet_cstrcmp(sourcestr, "realtime") == 0) {
+    JanetKeyword sourcestr = janet_optkeyword(argv, argc, 0, (const uint8_t *) "realtime");
+    if (janet_cstrcmp(sourcestr, "realtime") == 0) {
         source = JANET_TIME_REALTIME;
     } else if (janet_cstrcmp(sourcestr, "monotonic") == 0) {
         source = JANET_TIME_MONOTONIC;
@@ -1714,8 +1595,8 @@ JANET_CORE_FN(os_clock,
     struct timespec tv;
     if (janet_gettime(&tv, source)) janet_panic("could not get time");
 
-    JanetKeyword formatstr = janet_optkeyword(argv, argc, 1, NULL);
-    if (formatstr == NULL || janet_cstrcmp(formatstr, "double") == 0) {
+    JanetKeyword formatstr = janet_optkeyword(argv, argc, 1, (const uint8_t *) "double");
+    if (janet_cstrcmp(formatstr, "double") == 0) {
         double dtime = (double)(tv.tv_sec + (tv.tv_nsec / 1E9));
         return janet_wrap_number(dtime);
     } else if (janet_cstrcmp(formatstr, "int") == 0) {
@@ -1763,7 +1644,7 @@ JANET_CORE_FN(os_isatty,
     return janet_wrap_boolean(_isatty(fd));
 #else
     int fd = fileno(f);
-    if (fd == -1) janet_panic(janet_strerror(errno));
+    if (fd == -1) janet_panic(strerror(errno));
     return janet_wrap_boolean(isatty(fd));
 #endif
 }
@@ -1789,9 +1670,8 @@ JANET_CORE_FN(os_cryptorand,
               "Get or append `n` bytes of good quality random data provided by the OS. Returns a new buffer or `buf`.") {
     JanetBuffer *buffer;
     janet_arity(argc, 1, 2);
-    int32_t offset;
-    int32_t n = janet_getinteger(argv, 0);
-    if (n < 0) janet_panic("expected positive integer");
+    size_t offset;
+    size_t n = janet_getsize(argv, 0);
     if (argc == 2) {
         buffer = janet_getbuffer(argv, 1);
         offset = buffer->count;
@@ -1991,13 +1871,14 @@ 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
     }
 
     if (t == (time_t) -1) {
-        janet_panicf("%s", janet_strerror(errno));
+        janet_panicf("%s", strerror(errno));
     }
 
     return janet_wrap_number((double)t);
@@ -2009,43 +1890,6 @@ JANET_CORE_FN(os_mktime,
 #define j_symlink symlink
 #endif
 
-JANET_CORE_FN(os_setlocale,
-              "(os/setlocale &opt locale category)",
-              "Set the system locale, which affects how dates and numbers are formatted. "
-              "Passing nil to locale will return the current locale. Category can be one of:\n\n"
-              " * :all (default)\n"
-              " * :collate\n"
-              " * :ctype\n"
-              " * :monetary\n"
-              " * :numeric\n"
-              " * :time\n\n"
-              "Returns the new locale if set successfully, otherwise nil. Note that this will affect "
-              "other functions such as `os/strftime` and even `printf`.") {
-    janet_arity(argc, 0, 2);
-    const char *locale_name = janet_optcstring(argv, argc, 0, NULL);
-    int category_int = LC_ALL;
-    if (argc > 1 && !janet_checktype(argv[1], JANET_NIL)) {
-        if (janet_keyeq(argv[1], "all")) {
-            category_int = LC_ALL;
-        } else if (janet_keyeq(argv[1], "collate")) {
-            category_int = LC_COLLATE;
-        } else if (janet_keyeq(argv[1], "ctype")) {
-            category_int = LC_CTYPE;
-        } else if (janet_keyeq(argv[1], "monetary")) {
-            category_int = LC_MONETARY;
-        } else if (janet_keyeq(argv[1], "numeric")) {
-            category_int = LC_NUMERIC;
-        } else if (janet_keyeq(argv[1], "time")) {
-            category_int = LC_TIME;
-        } else {
-            janet_panicf("expected one of :all, :collate, :ctype, :monetary, :numeric, or :time, got %v", argv[1]);
-        }
-    }
-    const char *old = setlocale(category_int, locale_name);
-    if (old == NULL) return janet_wrap_nil();
-    return janet_cstringv(old);
-}
-
 JANET_CORE_FN(os_link,
               "(os/link oldpath newpath &opt symlink)",
               "Create a link at newpath that points to oldpath and returns nil. "
@@ -2057,12 +1901,13 @@ JANET_CORE_FN(os_link,
 #ifdef JANET_WINDOWS
     (void) argc;
     (void) argv;
-    janet_panic("not supported on Windows");
+    janet_panic("os/link not supported on Windows");
+    return janet_wrap_nil();
 #else
     const char *oldpath = janet_getcstring(argv, 0);
     const char *newpath = janet_getcstring(argv, 1);
     int res = ((argc == 3 && janet_truthy(argv[2])) ? j_symlink : link)(oldpath, newpath);
-    if (-1 == res) janet_panicf("%s: %s -> %s", janet_strerror(errno), oldpath, newpath);
+    if (-1 == res) janet_panicf("%s: %s -> %s", strerror(errno), oldpath, newpath);
     return janet_wrap_nil();
 #endif
 }
@@ -2075,12 +1920,13 @@ JANET_CORE_FN(os_symlink,
 #ifdef JANET_WINDOWS
     (void) argc;
     (void) argv;
-    janet_panic("not supported on Windows");
+    janet_panic("os/symlink not supported on Windows");
+    return janet_wrap_nil();
 #else
     const char *oldpath = janet_getcstring(argv, 0);
     const char *newpath = janet_getcstring(argv, 1);
     int res = j_symlink(oldpath, newpath);
-    if (-1 == res) janet_panicf("%s: %s -> %s", janet_strerror(errno), oldpath, newpath);
+    if (-1 == res) janet_panicf("%s: %s -> %s", strerror(errno), oldpath, newpath);
     return janet_wrap_nil();
 #endif
 }
@@ -2102,7 +1948,7 @@ JANET_CORE_FN(os_mkdir,
 #endif
     if (res == 0) return janet_wrap_true();
     if (errno == EEXIST) return janet_wrap_false();
-    janet_panicf("%s: %s", janet_strerror(errno), path);
+    janet_panicf("%s: %s", strerror(errno), path);
 }
 
 JANET_CORE_FN(os_rmdir,
@@ -2116,7 +1962,7 @@ JANET_CORE_FN(os_rmdir,
 #else
     int res = rmdir(path);
 #endif
-    if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
+    if (-1 == res) janet_panicf("%s: %s", strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2131,7 +1977,7 @@ JANET_CORE_FN(os_cd,
 #else
     int res = chdir(path);
 #endif
-    if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
+    if (-1 == res) janet_panicf("%s: %s", strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2155,7 +2001,7 @@ JANET_CORE_FN(os_touch,
         bufp = NULL;
     }
     int res = utime(path, bufp);
-    if (-1 == res) janet_panic(janet_strerror(errno));
+    if (-1 == res) janet_panic(strerror(errno));
     return janet_wrap_nil();
 }
 
@@ -2165,7 +2011,7 @@ JANET_CORE_FN(os_remove,
     janet_fixarity(argc, 1);
     const char *path = janet_getcstring(argv, 0);
     int status = remove(path);
-    if (-1 == status) janet_panicf("%s: %s", janet_strerror(errno), path);
+    if (-1 == status) janet_panicf("%s: %s", strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2177,13 +2023,14 @@ JANET_CORE_FN(os_readlink,
 #ifdef JANET_WINDOWS
     (void) argc;
     (void) argv;
-    janet_panic("not supported on Windows");
+    janet_panic("os/readlink not supported on Windows");
+    return janet_wrap_nil();
 #else
     static char buffer[PATH_MAX];
     const char *path = janet_getcstring(argv, 0);
     ssize_t len = readlink(path, buffer, sizeof buffer);
     if (len < 0 || (size_t)len >= sizeof buffer)
-        janet_panicf("%s: %s", janet_strerror(errno), path);
+        janet_panicf("%s: %s", strerror(errno), path);
     return janet_stringv((const uint8_t *)buffer, len);
 #endif
 }
@@ -2433,6 +2280,7 @@ 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();
     }
 }
 
@@ -2477,7 +2325,7 @@ JANET_CORE_FN(os_chmod,
 #else
     int res = chmod(path, os_getmode(argv, 1));
 #endif
-    if (-1 == res) janet_panicf("%s: %s", janet_strerror(errno), path);
+    if (-1 == res) janet_panicf("%s: %s", strerror(errno), path);
     return janet_wrap_nil();
 }
 
@@ -2513,7 +2361,7 @@ JANET_CORE_FN(os_dir,
         janet_panicf("path too long: %s", dir);
     sprintf(pattern, "%s/*", dir);
     intptr_t res = _findfirst(pattern, &afile);
-    if (-1 == res) janet_panicv(janet_cstringv(janet_strerror(errno)));
+    if (-1 == res) janet_panicv(janet_cstringv(strerror(errno)));
     do {
         if (strcmp(".", afile.name) && strcmp("..", afile.name)) {
             janet_array_push(paths, janet_cstringv(afile.name));
@@ -2524,18 +2372,8 @@ JANET_CORE_FN(os_dir,
     /* Read directory items with opendir / readdir / closedir */
     struct dirent *dp;
     DIR *dfd = opendir(dir);
-    if (dfd == NULL) janet_panicf("cannot open directory %s: %s", dir, janet_strerror(errno));
-    for (;;) {
-        errno = 0;
-        dp = readdir(dfd);
-        if (dp == NULL) {
-            if (errno) {
-                int olderr = errno;
-                closedir(dfd);
-                janet_panicf("failed to read directory %s: %s", dir, janet_strerror(olderr));
-            }
-            break;
-        }
+    if (dfd == NULL) janet_panicf("cannot open directory %s", dir);
+    while ((dp = readdir(dfd)) != NULL) {
         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, "..")) {
             continue;
         }
@@ -2555,7 +2393,7 @@ JANET_CORE_FN(os_rename,
     const char *dest = janet_getcstring(argv, 1);
     int status = rename(src, dest);
     if (status) {
-        janet_panic(janet_strerror(errno));
+        janet_panic(strerror(errno));
     }
     return janet_wrap_nil();
 }
@@ -2575,7 +2413,7 @@ JANET_CORE_FN(os_realpath,
 #else
     char *dest = realpath(src, NULL);
 #endif
-    if (NULL == dest) janet_panicf("%s: %s", janet_strerror(errno), src);
+    if (NULL == dest) janet_panicf("%s: %s", strerror(errno), src);
     Janet ret = janet_cstringv(dest);
     janet_free(dest);
     return ret;
@@ -2781,7 +2619,7 @@ JANET_CORE_FN(os_open,
     } else if (write_flag && !read_flag) {
         open_flags |= O_WRONLY;
     } else {
-        open_flags |= O_RDWR;
+        open_flags = O_RDWR;
     }
 
     do {
@@ -2793,24 +2631,16 @@ JANET_CORE_FN(os_open,
 }
 
 JANET_CORE_FN(os_pipe,
-              "(os/pipe &opt flags)",
+              "(os/pipe)",
               "Create a readable stream and a writable stream that are connected. Returns a two-element "
               "tuple where the first element is a readable stream and the second element is the writable "
-              "stream. `flags` is a keyword set of flags to disable non-blocking settings on the ends of the pipe. "
-              "This may be desired if passing the pipe to a subprocess with `os/spawn`.\n\n"
-              "* :W - sets the writable end of the pipe to a blocking stream.\n"
-              "* :R - sets the readable end of the pipe to a blocking stream.\n\n"
-              "By default, both ends of the pipe are non-blocking for use with the `ev` module.") {
+              "stream.") {
     (void) argv;
-    janet_arity(argc, 0, 1);
+    janet_fixarity(argc, 0);
     JanetHandle fds[2];
-    int flags = 0;
-    if (argc > 0 && !janet_checktype(argv[0], JANET_NIL)) {
-        flags = (int) janet_getflags(argv, 0, "WR");
-    }
-    if (janet_make_pipe(fds, flags)) janet_panicv(janet_ev_lasterr());
-    JanetStream *reader = janet_stream(fds[0], (flags & 2) ? 0 : JANET_STREAM_READABLE, NULL);
-    JanetStream *writer = janet_stream(fds[1], (flags & 1) ? 0 : JANET_STREAM_WRITABLE, NULL);
+    if (janet_make_pipe(fds, 0)) janet_panicv(janet_ev_lasterr());
+    JanetStream *reader = janet_stream(fds[0], JANET_STREAM_READABLE, NULL);
+    JanetStream *writer = janet_stream(fds[1], JANET_STREAM_WRITABLE, NULL);
     Janet tup[2] = {janet_wrap_abstract(reader), janet_wrap_abstract(writer)};
     return janet_wrap_tuple(janet_tuple_n(tup, 2));
 }
@@ -2857,7 +2687,6 @@ void janet_lib_os(JanetTable *env) {
         JANET_CORE_REG("os/strftime", os_strftime),
         JANET_CORE_REG("os/sleep", os_sleep),
         JANET_CORE_REG("os/isatty", os_isatty),
-        JANET_CORE_REG("os/setlocale", os_setlocale),
 
         /* env functions */
         JANET_CORE_REG("os/environ", os_environ),
@@ -2872,7 +2701,6 @@ void janet_lib_os(JanetTable *env) {
         JANET_CORE_REG("os/touch", os_touch),
         JANET_CORE_REG("os/realpath", os_realpath),
         JANET_CORE_REG("os/cd", os_cd),
-        JANET_CORE_REG("os/posix-chroot", os_posix_chroot),
 #ifndef JANET_NO_UMASK
         JANET_CORE_REG("os/umask", os_umask),
 #endif
@@ -2902,10 +2730,6 @@ 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),
-#ifdef JANET_EV
-        JANET_CORE_REG("os/sigaction", os_sigaction),
-#endif
 #endif
 
         /* high resolution timers */
@@ -2914,6 +2738,7 @@ 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/parse.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -59,11 +59,11 @@ int janet_is_symbol_char(uint8_t c) {
 /* Validate some utf8. Useful for identifiers. Only validates
  * the encoding, does not check for valid code points (they
  * are less well defined than the encoding). */
-int janet_valid_utf8(const uint8_t *str, int32_t len) {
-    int32_t i = 0;
-    int32_t j;
+int janet_valid_utf8(const uint8_t *str, size_t len) {
+    size_t i = 0;
+    size_t j;
     while (i < len) {
-        int32_t nexti;
+        size_t nexti;
         uint8_t c = str[i];
 
         /* Check the number of bytes in code point */
@@ -231,7 +231,7 @@ static void delim_error(JanetParser *parser, size_t stack_index, char c, const c
                 janet_buffer_push_u8(buffer, '`');
             }
         }
-        janet_formatb(buffer, " opened at line %d, column %d", (int32_t) s->line, (int32_t) s->column);
+        janet_formatb(buffer, " opened at line %d, column %d", s->line, s->column);
     }
     parser->error = (const char *) janet_string(buffer->data, buffer->count);
     parser->flag |= JANET_PARSER_GENERATED_ERROR;
@@ -363,7 +363,8 @@ static int stringend(JanetParser *p, JanetParseState *state) {
         JanetParseState top = p->states[p->statecount - 1];
         int32_t indent_col = (int32_t) top.column - 1;
         uint8_t *r = bufstart, *end = r + buflen;
-        /* Unless there are only spaces before EOLs, disable reindenting */
+        /* Check if there are any characters before the start column -
+         * if so, do not reindent. */
         int reindent = 1;
         while (reindent && (r < end)) {
             if (*r++ == '\n') {
@@ -373,36 +374,34 @@ static int stringend(JanetParser *p, JanetParseState *state) {
                         break;
                     }
                 }
-                if ((r + 1) < end && *r == '\r' && *(r + 1) == '\n') reindent = 1;
             }
         }
-        /* Now reindent if able */
-        if (reindent) {
+        /* Now reindent if able to, otherwise just drop leading newline. */
+        if (!reindent) {
+            if (buflen > 0 && bufstart[0] == '\n') {
+                buflen--;
+                bufstart++;
+            }
+        } else {
             uint8_t *w = bufstart;
             r = bufstart;
             while (r < end) {
                 if (*r == '\n') {
-                    *w++ = *r++;
+                    if (r == bufstart) {
+                        /* Skip leading newline */
+                        r++;
+                    } else {
+                        *w++ = *r++;
+                    }
                     for (int32_t j = 0; (r < end) && (*r != '\n') && (j < indent_col); j++, r++);
-                    if ((r + 1) < end && *r == '\r' && *(r + 1) == '\n') *w++ = *r++;
                 } else {
                     *w++ = *r++;
                 }
             }
             buflen = (int32_t)(w - bufstart);
         }
-        /* Check for leading EOL so we can remove it */
-        if (buflen > 1 && bufstart[0] == '\r' && bufstart[1] == '\n') { /* Windows EOL */
-            buflen = buflen - 2;
-            bufstart = bufstart + 2;
-        } else if (buflen > 0 && bufstart[0] == '\n') { /* Unix EOL */
-            buflen--;
-            bufstart++;
-        }
-        /* Check for trailing EOL so we can remove it */
-        if (buflen > 1 && bufstart[buflen - 2] == '\r' && bufstart[buflen - 1] == '\n') { /* Windows EOL */
-            buflen = buflen - 2;
-        } else if (buflen > 0 && bufstart[buflen - 1] == '\n') { /* Unix EOL */
+        /* Check for trailing newline character so we can remove it */
+        if (buflen > 0 && bufstart[buflen - 1] == '\n') {
             buflen--;
         }
     }
@@ -435,8 +434,8 @@ static int stringchar(JanetParser *p, JanetParseState *state, uint8_t c) {
 }
 
 /* Check for string equality in the buffer */
-static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) {
-    int32_t index;
+static int check_str_const(const char *cstr, const uint8_t *str, size_t len) {
+    size_t index;
     for (index = 0; index < len; index++) {
         uint8_t c = str[index];
         uint8_t k = ((const uint8_t *)cstr)[index];
@@ -450,14 +449,14 @@ static int check_str_const(const char *cstr, const uint8_t *str, int32_t len) {
 static int tokenchar(JanetParser *p, JanetParseState *state, uint8_t c) {
     Janet ret;
     double numval;
-    int32_t blen;
+    size_t blen;
     if (janet_is_symbol_char(c)) {
         push_buf(p, (uint8_t) c);
         if (c > 127) state->argn = 1; /* Use to indicate non ascii */
         return 1;
     }
     /* Token finished */
-    blen = (int32_t) p->bufcount;
+    blen = p->bufcount;
     int start_dig = p->buf[0] >= '0' && p->buf[0] <= '9';
     int start_num = start_dig || p->buf[0] == '-' || p->buf[0] == '+' || p->buf[0] == '.';
     if (p->buf[0] == ':') {
@@ -468,13 +467,8 @@ static int tokenchar(JanetParser *p, JanetParseState *state, uint8_t c) {
             return 0;
         }
         ret = janet_keywordv(p->buf + 1, blen - 1);
-#ifdef JANET_INT_TYPES
-    } else if (start_num && !janet_scan_numeric(p->buf, blen, &ret)) {
-        (void) numval;
-#else
     } else if (start_num && !janet_scan_number(p->buf, blen, &numval)) {
         ret = janet_wrap_number(numval);
-#endif
     } else if (!check_str_const("nil", p->buf, blen)) {
         ret = janet_wrap_nil();
     } else if (!check_str_const("false", p->buf, blen)) {
@@ -926,13 +920,13 @@ JANET_CORE_FN(cfun_parse_consume,
     JanetParser *p = janet_getabstract(argv, 0, &janet_parser_type);
     JanetByteView view = janet_getbytes(argv, 1);
     if (argc == 3) {
-        int32_t offset = janet_getinteger(argv, 2);
-        if (offset < 0 || offset > view.len)
+        size_t offset = janet_getsize(argv, 2);
+        if (offset > view.len)
             janet_panicf("invalid offset %d out of range [0,%d]", offset, view.len);
         view.len -= offset;
         view.bytes += offset;
     }
-    int32_t i;
+    size_t i;
     for (i = 0; i < view.len; i++) {
         janet_parser_consume(p, view.bytes[i]);
         switch (janet_parser_status(p)) {
@@ -940,10 +934,10 @@ JANET_CORE_FN(cfun_parse_consume,
             case JANET_PARSE_PENDING:
                 break;
             default:
-                return janet_wrap_integer(i + 1);
+                return janet_wrap_size(i + 1);
         }
     }
-    return janet_wrap_integer(i);
+    return janet_wrap_size(i);
 }
 
 JANET_CORE_FN(cfun_parse_eof,
@@ -980,7 +974,7 @@ JANET_CORE_FN(cfun_parse_insert,
         }
     } else if (s->flags & (PFLAG_STRING | PFLAG_LONGSTRING)) {
         const uint8_t *str = janet_to_string(argv[1]);
-        int32_t slen = janet_string_length(str);
+        size_t slen = janet_string_length(str);
         size_t newcount = p->bufcount + slen;
         if (p->bufcap < newcount) {
             size_t newcap = 2 * newcount;

src/core/peg.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -65,9 +65,9 @@ typedef struct {
  * to save state at branches, and then reload
  * if one branch fails and try a new branch. */
 typedef struct {
-    int32_t cap;
-    int32_t tcap;
-    int32_t scratch;
+    size_t cap;
+    size_t tcap;
+    size_t scratch;
 } CapState;
 
 /* Save the current capture state */
@@ -134,7 +134,7 @@ static LineCol get_linecol_from_position(PegState *s, int32_t position) {
      *   a newline character is consider to be on the same line as the character before
      *   (\n is line terminator, not line separator).
      * - in the not-found case, we still want to find the greatest-indexed newline that
-     *   is before position. we use that to calculate the line and column.
+     *   is before position. we use that to calcuate the line and column.
      * - in the case that lo = 0 and s->linemap[0] is still greater than position, we
      *   are on the first line and our column is position + 1. */
     int32_t hi = s->linemaplen; /* hi is greater than the actual line */
@@ -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) && (hi == UINT32_MAX))) {
+                if (!next_text || next_text == text) {
                     cap_load(s, cs2);
                     break;
                 }
@@ -423,10 +423,10 @@ tail:
             /* check number parsing */
             double x = 0.0;
             int32_t base = (int32_t) rule[2];
-            if (janet_scan_number_base(text, (int32_t)(result - text), base, &x)) return NULL;
+            if (janet_scan_number_base(text, (size_t)(result - text), base, &x)) return NULL;
             /* Specialized pushcap - avoid intermediate string creation */
             if (!s->has_backref && s->mode == PEG_MODE_ACCUMULATE) {
-                janet_buffer_push_bytes(s->scratch, text, (int32_t)(result - text));
+                janet_buffer_push_bytes(s->scratch, text, (size_t)(result - text));
             } else {
                 uint32_t tag = rule[3];
                 pushcap(s, janet_wrap_number(x), tag);
@@ -465,16 +465,6 @@ tail:
             return result;
         }
 
-        case RULE_ONLY_TAGS: {
-            CapState cs = cap_save(s);
-            down1(s);
-            const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
-            up1(s);
-            if (!result) return NULL;
-            cap_load_keept(s, cs);
-            return result;
-        }
-
         case RULE_GROUP: {
             uint32_t tag = rule[2];
             int oldmode = s->mode;
@@ -496,30 +486,6 @@ tail:
             return result;
         }
 
-        case RULE_NTH: {
-            uint32_t nth = rule[1];
-            if (nth > INT32_MAX) nth = INT32_MAX;
-            uint32_t tag = rule[3];
-            int oldmode = s->mode;
-            CapState cs = cap_save(s);
-            s->mode = PEG_MODE_NORMAL;
-            down1(s);
-            const uint8_t *result = peg_rule(s, s->bytecode + rule[2], text);
-            up1(s);
-            s->mode = oldmode;
-            if (!result) return NULL;
-            int32_t num_sub_captures = s->captures->count - cs.cap;
-            Janet cap;
-            if (num_sub_captures > (int32_t) nth) {
-                cap = s->captures->data[cs.cap + nth];
-            } else {
-                return NULL;
-            }
-            cap_load_keept(s, cs);
-            pushcap(s, cap, tag);
-            return result;
-        }
-
         case RULE_SUB: {
             const uint8_t *text_start = text;
             const uint32_t *rule_window = s->bytecode + rule[1];
@@ -544,80 +510,41 @@ 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];
             const uint32_t *rule_subpattern = s->bytecode + rule[2];
 
-            const uint8_t *chunk_start = text;
-            const uint8_t *chunk_end = NULL;
-
-            while (text <= saved_end) {
-                /* Find next split (or end of text) */
+            const uint8_t *separator_end = NULL;
+            do {
+                const uint8_t *text_start = text;
                 CapState cs = cap_save(s);
                 down1(s);
-                while (text <= saved_end) {
-                    chunk_end = text;
-                    const uint8_t *check = peg_rule(s, rule_separator, text);
+                while (text <= s->text_end) {
+                    separator_end = peg_rule(s, rule_separator, text);
                     cap_load(s, cs);
-                    if (check) {
-                        text = check;
+                    if (separator_end) {
                         break;
                     }
                     text++;
                 }
                 up1(s);
 
-                /* Match between splits */
-                s->text_end = chunk_end;
+                if (separator_end) {
+                    s->text_end = text;
+                    text = separator_end;
+                }
+
                 down1(s);
-                const uint8_t *subpattern_end = peg_rule(s, rule_subpattern, chunk_start);
+                const uint8_t *subpattern_end = peg_rule(s, rule_subpattern, text_start);
                 up1(s);
                 s->text_end = saved_end;
-                if (!subpattern_end) return NULL; /* Don't match anything */
 
-                /* Ensure forward progress */
-                if (text == chunk_start) return NULL;
-                chunk_start = text;
-            }
+                if (!subpattern_end) {
+                    return NULL;
+                }
+            } while (separator_end);
 
-            s->text_end = saved_end;
             return s->text_end;
         }
 
@@ -670,7 +597,7 @@ tail:
         case RULE_ERROR: {
             int oldmode = s->mode;
             s->mode = PEG_MODE_NORMAL;
-            int32_t old_cap = s->captures->count;
+            size_t old_cap = s->captures->count;
             down1(s);
             const uint8_t *result = peg_rule(s, s->bytecode + rule[1], text);
             up1(s);
@@ -740,11 +667,11 @@ tail:
         case RULE_READINT: {
             uint32_t tag = rule[2];
             uint32_t signedness = rule[1] & 0x10;
-            uint32_t endianness = rule[1] & 0x20;
+            uint32_t endianess = rule[1] & 0x20;
             int width = (int)(rule[1] & 0xF);
             if (text + width > s->text_end) return NULL;
             uint64_t accum = 0;
-            if (endianness) {
+            if (endianess) {
                 /* BE */
                 for (int i = 0; i < width; i++) accum = (accum << 8) | text[i];
             } else {
@@ -998,7 +925,7 @@ static void spec_set(Builder *b, int32_t argc, const Janet *argv) {
     Reserve r = reserve(b, 9);
     const uint8_t *str = peg_getset(b, argv[0]);
     uint32_t bitmap[8] = {0};
-    for (int32_t i = 0; i < janet_string_length(str); i++)
+    for (size_t i = 0; i < janet_string_length(str); i++)
         bitmap_set(bitmap, str[i]);
     emit_rule(r, RULE_SET, 8, bitmap);
 }
@@ -1134,9 +1061,6 @@ static void spec_thru(Builder *b, int32_t argc, const Janet *argv) {
 static void spec_drop(Builder *b, int32_t argc, const Janet *argv) {
     spec_onerule(b, argc, argv, RULE_DROP);
 }
-static void spec_only_tags(Builder *b, int32_t argc, const Janet *argv) {
-    spec_onerule(b, argc, argv, RULE_ONLY_TAGS);
-}
 
 /* Rule of the form [rule, tag] */
 static void spec_cap1(Builder *b, int32_t argc, const Janet *argv, uint32_t op) {
@@ -1160,15 +1084,6 @@ static void spec_unref(Builder *b, int32_t argc, const Janet *argv) {
     spec_cap1(b, argc, argv, RULE_UNREF);
 }
 
-static void spec_nth(Builder *b, int32_t argc, const Janet *argv) {
-    peg_arity(b, argc, 2, 3);
-    Reserve r = reserve(b, 4);
-    uint32_t nth = peg_getnat(b, argv[0]);
-    uint32_t rule = peg_compile1(b, argv[1]);
-    uint32_t tag = (argc == 3) ? emit_tag(b, argv[2]) : 0;
-    emit_3(r, RULE_NTH, nth, rule, tag);
-}
-
 static void spec_capture_number(Builder *b, int32_t argc, const Janet *argv) {
     peg_arity(b, argc, 1, 3);
     Reserve r = reserve(b, 4);
@@ -1266,14 +1181,6 @@ 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);
@@ -1355,9 +1262,7 @@ static const SpecialPair peg_specials[] = {
     {"line", spec_line},
     {"look", spec_look},
     {"not", spec_not},
-    {"nth", spec_nth},
     {"number", spec_capture_number},
-    {"only-tags", spec_only_tags},
     {"opt", spec_opt},
     {"position", spec_position},
     {"quote", spec_capture},
@@ -1370,7 +1275,6 @@ 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},
@@ -1464,11 +1368,6 @@ static uint32_t peg_compile1(Builder *b, Janet peg) {
             emit_bytes(b, RULE_LITERAL, len, str);
             break;
         }
-        case JANET_BUFFER: {
-            const JanetBuffer *buf = janet_unwrap_buffer(peg);
-            emit_bytes(b, RULE_LITERAL, buf->count, buf->data);
-            break;
-        }
         case JANET_TABLE: {
             /* Build grammar table */
             JanetTable *new_grammar = janet_table_clone(janet_unwrap_table(peg));
@@ -1485,7 +1384,7 @@ static uint32_t peg_compile1(Builder *b, Janet peg) {
             /* Build grammar table */
             const JanetKV *st = janet_unwrap_struct(peg);
             JanetTable *new_grammar = janet_table(2 * janet_struct_capacity(st));
-            for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
+            for (size_t i = 0; i < janet_struct_capacity(st); i++) {
                 if (janet_checktype(st[i].key, JANET_KEYWORD)) {
                     janet_table_put(new_grammar, st[i].key, st[i].value);
                 }
@@ -1710,7 +1609,6 @@ 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;
@@ -1721,7 +1619,6 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                 break;
             case RULE_ERROR:
             case RULE_DROP:
-            case RULE_ONLY_TAGS:
             case RULE_NOT:
             case RULE_TO:
             case RULE_THRU:
@@ -1731,16 +1628,10 @@ static void *peg_unmarshal(JanetMarshalContext *ctx) {
                 i += 2;
                 break;
             case RULE_READINT:
-                /* [ width | (endianness << 5) | (signedness << 6), tag ] */
+                /* [ width | (endianess << 5) | (signedness << 6), tag ] */
                 if (rule[1] > JANET_MAX_READINT_WIDTH) goto bad;
                 i += 3;
                 break;
-            case RULE_NTH:
-                /* [nth, rule, tag] */
-                if (rule[2] >= blen) goto bad;
-                op_flags[rule[2]] |= 0x01;
-                i += 4;
-                break;
             default:
                 goto bad;
         }
@@ -1834,7 +1725,7 @@ static JanetPeg *compile_peg(Janet x) {
 JANET_CORE_FN(cfun_peg_compile,
               "(peg/compile peg)",
               "Compiles a peg source data structure into a <core/peg>. This will speed up matching "
-              "if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to supplement "
+              "if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to suppliment "
               "the grammar of the peg for otherwise undefined peg keywords.") {
     janet_fixarity(argc, 1);
     JanetPeg *peg = compile_peg(argv[0]);
@@ -1914,7 +1805,7 @@ JANET_CORE_FN(cfun_peg_find,
               "(peg/find peg text &opt start & args)",
               "Find first index where the peg matches in text. Returns an integer, or nil if not found.") {
     PegCall c = peg_cfun_init(argc, argv, 0);
-    for (int32_t i = c.start; i < c.bytes.len; i++) {
+    for (size_t i = c.start; i < c.bytes.len; i++) {
         peg_call_reset(&c);
         if (peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i))
             return janet_wrap_integer(i);
@@ -1927,7 +1818,7 @@ JANET_CORE_FN(cfun_peg_find_all,
               "Find all indexes where the peg matches in text. Returns an array of integers.") {
     PegCall c = peg_cfun_init(argc, argv, 0);
     JanetArray *ret = janet_array(0);
-    for (int32_t i = c.start; i < c.bytes.len; i++) {
+    for (size_t i = c.start; i < c.bytes.len; i++) {
         peg_call_reset(&c);
         if (peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i))
             janet_array_push(ret, janet_wrap_integer(i));
@@ -1938,8 +1829,8 @@ JANET_CORE_FN(cfun_peg_find_all,
 static Janet cfun_peg_replace_generic(int32_t argc, Janet *argv, int only_one) {
     PegCall c = peg_cfun_init(argc, argv, 1);
     JanetBuffer *ret = janet_buffer(0);
-    int32_t trail = 0;
-    for (int32_t i = c.start; i < c.bytes.len;) {
+    size_t trail = 0;
+    for (size_t i = c.start; i < c.bytes.len;) {
         peg_call_reset(&c);
         const uint8_t *result = peg_rule(&c.s, c.s.bytecode, c.bytes.bytes + i);
         if (NULL != result) {
@@ -1947,7 +1838,7 @@ static Janet cfun_peg_replace_generic(int32_t argc, Janet *argv, int only_one) {
                 janet_buffer_push_bytes(ret, c.bytes.bytes + trail, (i - trail));
                 trail = i;
             }
-            int32_t nexti = (int32_t)(result - c.bytes.bytes);
+            size_t nexti = (size_t)(result - c.bytes.bytes);
             JanetByteView subst = janet_text_substitution(&c.subst, c.bytes.bytes + i, nexti - i, c.s.captures);
             janet_buffer_push_bytes(ret, subst.bytes, subst.len);
             trail = nexti;

src/core/pp.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -134,9 +134,9 @@ static void string_description_b(JanetBuffer *buffer, const char *title, void *p
 #undef POINTSIZE
 }
 
-static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, int32_t len) {
+static void janet_escape_string_impl(JanetBuffer *buffer, const uint8_t *str, size_t len) {
     janet_buffer_push_u8(buffer, '"');
-    for (int32_t i = 0; i < len; ++i) {
+    for (size_t i = 0; i < len; ++i) {
         uint8_t c = str[i];
         switch (c) {
             case '"':
@@ -279,10 +279,10 @@ void janet_to_string_b(JanetBuffer *buffer, Janet x) {
 
 /* Check if a symbol or keyword contains no symbol characters */
 static int contains_bad_chars(const uint8_t *sym, int issym) {
-    int32_t len = janet_string_length(sym);
+    size_t len = janet_string_length(sym);
     if (len && issym && sym[0] >= '0' && sym[0] <= '9') return 1;
     if (!janet_valid_utf8(sym, len)) return 1;
-    for (int32_t i = 0; i < len; i++) {
+    for (size_t i = 0; i < len; i++) {
         if (!janet_is_symbol_char(sym[i])) return 1;
     }
     return 0;
@@ -379,10 +379,8 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             break;
         case JANET_NUMBER:
             janet_buffer_ensure(S->buffer, S->buffer->count + BUFSIZE, 2);
-            double num = janet_unwrap_number(x);
-            if (isnan(num)) return 1;
-            if (isinf(num)) return 1;
-            janet_buffer_dtostr(S->buffer, num);
+            int count = snprintf((char *) S->buffer->data + S->buffer->count, BUFSIZE, "%.17g", janet_unwrap_number(x));
+            S->buffer->count += count;
             break;
         case JANET_SYMBOL:
         case JANET_KEYWORD:
@@ -393,7 +391,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             JanetTuple t = janet_unwrap_tuple(x);
             int isb = janet_tuple_flag(t) & JANET_TUPLE_FLAG_BRACKETCTOR;
             janet_buffer_push_u8(S->buffer, isb ? '[' : '(');
-            for (int32_t i = 0; i < janet_tuple_length(t); i++) {
+            for (size_t i = 0; i < janet_tuple_length(t); i++) {
                 if (i) janet_buffer_push_u8(S->buffer, ' ');
                 if (print_jdn_one(S, t[i], depth - 1)) return 1;
             }
@@ -404,7 +402,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             janet_table_put(&S->seen, x, janet_wrap_true());
             JanetArray *a = janet_unwrap_array(x);
             janet_buffer_push_cstring(S->buffer, "@[");
-            for (int32_t i = 0; i < a->count; i++) {
+            for (size_t i = 0; i < a->count; i++) {
                 if (i) janet_buffer_push_u8(S->buffer, ' ');
                 if (print_jdn_one(S, a->data[i], depth - 1)) return 1;
             }
@@ -416,7 +414,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             JanetTable *tab = janet_unwrap_table(x);
             janet_buffer_push_cstring(S->buffer, "@{");
             int isFirst = 1;
-            for (int32_t i = 0; i < tab->capacity; i++) {
+            for (size_t i = 0; i < tab->capacity; i++) {
                 const JanetKV *kv = tab->data + i;
                 if (janet_checktype(kv->key, JANET_NIL)) continue;
                 if (!isFirst) janet_buffer_push_u8(S->buffer, ' ');
@@ -432,7 +430,7 @@ static int print_jdn_one(struct pretty *S, Janet x, int depth) {
             JanetStruct st = janet_unwrap_struct(x);
             janet_buffer_push_u8(S->buffer, '{');
             int isFirst = 1;
-            for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
+            for (size_t i = 0; i < janet_struct_capacity(st); i++) {
                 const JanetKV *kv = st + i;
                 if (janet_checktype(kv->key, JANET_NIL)) continue;
                 if (!isFirst) janet_buffer_push_u8(S->buffer, ' ');
@@ -538,7 +536,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
         }
         case JANET_ARRAY:
         case JANET_TUPLE: {
-            int32_t i = 0, len = 0;
+            size_t i = 0, len = 0;
             const Janet *arr = NULL;
             int isarray = janet_checktype(x, JANET_ARRAY);
             janet_indexed_view(x, &arr, &len);
@@ -589,7 +587,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                 if (NULL != proto) {
                     Janet name = janet_table_get(proto, janet_ckeywordv("_name"));
                     const uint8_t *n;
-                    int32_t len;
+                    size_t len;
                     if (janet_bytes_view(name, &n, &len)) {
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
@@ -606,7 +604,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
                 if (NULL != proto) {
                     Janet name = janet_struct_get(proto, janet_ckeywordv("_name"));
                     const uint8_t *n;
-                    int32_t len;
+                    size_t len;
                     if (janet_bytes_view(name, &n, &len)) {
                         if (S->flags & JANET_PRETTY_COLOR) {
                             janet_buffer_push_cstring(S->buffer, janet_class_color);
@@ -625,7 +623,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
             if (S->depth == 0) {
                 janet_buffer_push_cstring(S->buffer, "...");
             } else {
-                int32_t i = 0, len = 0, cap = 0;
+                size_t i = 0, len = 0, cap = 0;
                 const JanetKV *kvs = NULL;
                 janet_dictionary_view(x, &kvs, &len, &cap);
                 if (!istable && !(S->flags & JANET_PRETTY_ONELINE) && len >= JANET_PRETTY_DICT_ONELINE)
@@ -832,7 +830,7 @@ static const char *scanformat(
         if (loc != NULL && *loc != '\0') {
             const char *mapping = get_fmt_mapping(*p2++);
             size_t len = strlen(mapping);
-            memcpy(form, mapping, len);
+            strcpy(form, mapping);
             form += len;
         } else {
             *(form++) = *(p2++);
@@ -897,13 +895,13 @@ void janet_formatbv(JanetBuffer *b, const char *format, va_list args) {
                 case 's':
                 case 'S': {
                     const char *str = va_arg(args, const char *);
-                    int32_t len = c[-1] == 's'
-                                  ? (int32_t) strlen(str)
+                    size_t len = c[-1] == 's'
+                                  ? strlen(str)
                                   : janet_string_length((JanetString) str);
                     if (form[2] == '\0')
                         janet_buffer_push_bytes(b, (const uint8_t *) str, len);
                     else {
-                        if (len != (int32_t) strlen((const char *) str))
+                        if (len != strlen((const char *) str))
                             janet_panic("string contains zeros");
                         if (!strchr(form, '.') && len >= 100) {
                             janet_panic("no precision and string is too long to be formatted");
@@ -1060,11 +1058,19 @@ void janet_buffer_format(
                     break;
                 }
                 case 's': {
-                    const char *s = janet_getcbytes(argv, arg);
+                    JanetByteView bytes = janet_getbytes(argv, arg);
+                    const uint8_t *s = bytes.bytes;
+                    int32_t l = bytes.len;
                     if (form[2] == '\0')
-                        janet_buffer_push_cstring(b, s);
+                        janet_buffer_push_bytes(b, s, l);
                     else {
-                        nb = snprintf(item, MAX_ITEM, form, s);
+                        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);
+                        }
                     }
                     break;
                 }

src/core/regalloc.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/regalloc.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/run.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -26,28 +26,25 @@
 #include "state.h"
 #endif
 
-/* 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;
+/* Run a string */
+int janet_dobytes(JanetTable *env, const uint8_t *bytes, size_t len, const char *sourcePath, Janet *out) {
+    JanetParser parser;
     int errflags = 0, done = 0;
-    int32_t index = 0;
+    size_t index = 0;
     Janet ret = janet_wrap_nil();
     JanetFiber *fiber = NULL;
     const uint8_t *where = sourcePath ? janet_cstring(sourcePath) : NULL;
 
     if (where) janet_gcroot(janet_wrap_string(where));
     if (NULL == sourcePath) sourcePath = "<unknown>";
-    parser = janet_abstract(&janet_parser_type, sizeof(JanetParser));
-    janet_parser_init(parser);
-    janet_gcroot(janet_wrap_abstract(parser));
+    janet_parser_init(&parser);
 
     /* While we haven't seen an error */
     while (!done) {
 
         /* Evaluate parsed values */
-        while (janet_parser_has_more(parser)) {
-            Janet form = janet_parser_produce(parser);
+        while (janet_parser_has_more(&parser)) {
+            Janet form = janet_parser_produce(&parser);
             JanetCompileResult cres = janet_compile(form, env, where);
             if (cres.status == JANET_COMPILE_OK) {
                 JanetFunction *f = janet_thunk(cres.funcdef);
@@ -56,30 +53,27 @@ 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 |= JANET_DO_ERROR_RUNTIME;
+                    errflags |= 0x01;
                     done = 1;
                 }
             } else {
-                int32_t line = (int32_t) parser->line;
-                int32_t col = (int32_t) parser->column;
+                ret = janet_wrap_string(cres.error);
+                int32_t line = (int32_t) parser.line;
+                int32_t col = (int32_t) parser.column;
                 if ((cres.error_mapping.line > 0) &&
                         (cres.error_mapping.column > 0)) {
                     line = cres.error_mapping.line;
                     col = cres.error_mapping.column;
                 }
-                JanetString ctx = janet_formatc("%s:%d:%d: compile error",
-                                                sourcePath, line, col);
-                JanetString errstr = janet_formatc("%s: %s",
-                                                   (const char *)ctx,
-                                                   (const char *)cres.error);
-                ret = janet_wrap_string(errstr);
                 if (cres.macrofiber) {
-                    janet_eprintf("%s", (const char *)ctx);
+                    janet_eprintf("%s:%d:%d: compile error", sourcePath,
+                                  line, col);
                     janet_stacktrace_ext(cres.macrofiber, ret, "");
                 } else {
-                    janet_eprintf("%s\n", (const char *)errstr);
+                    janet_eprintf("%s:%d:%d: compile error: %s\n", sourcePath,
+                                  line, col, (const char *)cres.error);
                 }
-                errflags |= JANET_DO_ERROR_COMPILE;
+                errflags |= 0x02;
                 done = 1;
             }
         }
@@ -87,28 +81,26 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
         if (done) break;
 
         /* Dispatch based on parse state */
-        switch (janet_parser_status(parser)) {
+        switch (janet_parser_status(&parser)) {
             case JANET_PARSE_DEAD:
                 done = 1;
                 break;
             case JANET_PARSE_ERROR: {
-                errflags |= JANET_DO_ERROR_PARSE;
-                int32_t line = (int32_t) parser->line;
-                int32_t col = (int32_t) parser->column;
-                JanetString errstr = janet_formatc("%s:%d:%d: parse error: %s",
-                                                   sourcePath, line, col,
-                                                   janet_parser_error(parser));
-                ret = janet_wrap_string(errstr);
-                janet_eprintf("%s\n", (const char *)errstr);
+                const char *e = janet_parser_error(&parser);
+                errflags |= 0x04;
+                ret = janet_cstringv(e);
+                int32_t line = (int32_t) parser.line;
+                int32_t col = (int32_t) parser.column;
+                janet_eprintf("%s:%d:%d: parse error: %s\n", sourcePath, line, col, e);
                 done = 1;
                 break;
             }
             case JANET_PARSE_ROOT:
             case JANET_PARSE_PENDING:
                 if (index >= len) {
-                    janet_parser_eof(parser);
+                    janet_parser_eof(&parser);
                 } else {
-                    janet_parser_consume(parser, bytes[index++]);
+                    janet_parser_consume(&parser, bytes[index++]);
                 }
                 break;
         }
@@ -116,7 +108,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
     }
 
     /* Clean up and return errors */
-    janet_gcunroot(janet_wrap_abstract(parser));
+    janet_parser_deinit(&parser);
     if (where) janet_gcunroot(janet_wrap_string(where));
 #ifdef JANET_EV
     /* Enter the event loop if we are not already in it */
@@ -127,8 +119,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
         janet_loop();
         if (fiber) {
             janet_gcunroot(janet_wrap_fiber(fiber));
-            if (!errflags)
-                ret = fiber->last_value;
+            ret = fiber->last_value;
         }
     }
 #endif
@@ -137,7 +128,7 @@ int janet_dobytes(JanetTable *env, const uint8_t *bytes, int32_t len, const char
 }
 
 int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out) {
-    int32_t len = 0;
+    size_t len = 0;
     while (str[len]) ++len;
     return janet_dobytes(env, (const uint8_t *)str, len, sourcePath, out);
 }

src/core/specials.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -72,7 +72,7 @@ static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) {
         default:
             return janetc_cslot(x);
         case JANET_TUPLE: {
-            int32_t i, len;
+            size_t i, len;
             const Janet *tup = janet_unwrap_tuple(x);
             len = janet_tuple_length(tup);
             if (len > 1 && janet_checktype(tup[0], JANET_SYMBOL)) {
@@ -96,16 +96,15 @@ static JanetSlot quasiquote(JanetFopts opts, Janet x, int depth, int level) {
                             : JOP_MAKE_TUPLE);
         }
         case JANET_ARRAY: {
-            int32_t i;
             JanetArray *array = janet_unwrap_array(x);
-            for (i = 0; i < array->count; i++)
+            for (size_t i = 0; i < array->count; i++)
                 janet_v_push(slots, quasiquote(subopts, array->data[i], depth - 1, level));
             return qq_slots(opts, slots, JOP_MAKE_ARRAY);
         }
         case JANET_TABLE:
         case JANET_STRUCT: {
             const JanetKV *kv = NULL, *kvs = NULL;
-            int32_t len, cap = 0;
+            size_t len, cap = 0;
             janet_dictionary_view(x, &kvs, &len, &cap);
             while ((kv = janet_dictionary_next(kvs, cap, kv))) {
                 JanetSlot key = quasiquote(subopts, kv->key, depth - 1, level);
@@ -156,10 +155,10 @@ static int destructure(JanetCompiler *c,
             return leaf(c, janet_unwrap_symbol(left), right, attr);
         case JANET_TUPLE:
         case JANET_ARRAY: {
-            int32_t len = 0;
+            size_t len = 0;
             const Janet *values = NULL;
             janet_indexed_view(left, &values, &len);
-            for (int32_t i = 0; i < len; i++) {
+            for (size_t i = 0; i < len; i++) {
                 JanetSlot nextright = janetc_farslot(c);
                 Janet subval = values[i];
 
@@ -170,11 +169,11 @@ static int destructure(JanetCompiler *c,
                     }
 
                     if (i + 2 < len) {
-                        int32_t num_extra = len - i - 1;
+                        size_t num_extra = len - i - 1;
                         Janet *extra = janet_tuple_begin(num_extra);
                         janet_tuple_flag(extra) |= JANET_TUPLE_FLAG_BRACKETCTOR;
 
-                        for (int32_t j = 0; j < num_extra; ++j) {
+                        for (size_t j = 0; j < num_extra; ++j) {
                             extra[j] = values[j + i + 1];
                         }
 
@@ -237,9 +236,9 @@ static int destructure(JanetCompiler *c,
         case JANET_TABLE:
         case JANET_STRUCT: {
             const JanetKV *kvs = NULL;
-            int32_t cap = 0, len = 0;
+            size_t cap = 0, len = 0;
             janet_dictionary_view(left, &kvs, &len, &cap);
-            for (int32_t i = 0; i < cap; i++) {
+            for (size_t i = 0; i < cap; i++) {
                 if (janet_checktype(kvs[i].key, JANET_NIL)) continue;
                 JanetSlot nextright = janetc_farslot(c);
                 JanetSlot k = janetc_value(janetc_fopts_default(c), kvs[i].key);
@@ -362,7 +361,7 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
         janet_indexed_view(lhs, &view_lhs.items, &view_lhs.len);
         janet_indexed_view(rhs, &view_rhs.items, &view_rhs.len);
         int found_amp = 0;
-        for (int32_t i = 0; i < view_lhs.len; i++) {
+        for (size_t i = 0; i < view_lhs.len; i++) {
             if (janet_symeq(view_lhs.items[i], "&")) {
                 found_amp = 1;
                 /* Good error will be generated later. */
@@ -370,7 +369,7 @@ SlotHeadPair *dohead_destructure(JanetCompiler *c, SlotHeadPair *into, JanetFopt
             }
         }
         if (!found_amp) {
-            for (int32_t i = 0; i < view_lhs.len; i++) {
+            for (size_t i = 0; i < view_lhs.len; i++) {
                 Janet sub_rhs = view_rhs.len <= i ? janet_wrap_nil() : view_rhs.items[i];
                 into = dohead_destructure(c, into, subopts, view_lhs.items[i], sub_rhs);
             }
@@ -925,7 +924,6 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     int structarg = 0;
     int allow_extra = 0;
     int selfref = 0;
-    int hasname = 0;
     int seenamp = 0;
     int seenopt = 0;
     int namedargs = 0;
@@ -944,10 +942,6 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     head = argv[0];
     if (janet_checktype(head, JANET_SYMBOL)) {
         selfref = 1;
-        hasname = 1;
-        parami = 1;
-    } else if (janet_checktype(head, JANET_KEYWORD)) {
-        hasname = 1;
         parami = 1;
     }
     if (parami >= argn || !janet_checktype(argv[parami], JANET_TUPLE)) {
@@ -1108,7 +1102,7 @@ static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
     if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
     if (structarg) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;
 
-    if (hasname) def->name = janet_unwrap_symbol(head); /* Also correctly unwraps keyword */
+    if (selfref) def->name = janet_unwrap_symbol(head);
     janet_def_addflags(def);
     defindex = janetc_addfuncdef(c, def);
 

src/core/state.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -58,7 +58,7 @@ void janet_vm_load(JanetVM *from) {
 }
 
 /* Trigger suspension of the Janet vm by trying to
- * exit the interpreter loop when convenient. You can optionally
+ * exit the interpeter loop when convenient. You can optionally
  * use NULL to interrupt the current VM when convenient */
 void janet_interpreter_interrupt(JanetVM *vm) {
     vm = vm ? vm : &janet_vm;

src/core/state.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -23,16 +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
-#include <windows.h>
-#else
+#ifndef JANET_WINDOWS
 #include <pthread.h>
 #endif
 #endif
@@ -47,33 +42,24 @@ typedef struct JanetScratch {
 typedef struct {
     JanetGCObject *self;
     JanetGCObject *other;
-    int32_t index;
-    int32_t index2;
+    size_t index;
+    size_t index2;
 } JanetTraversalNode;
 
 typedef struct {
-    int32_t capacity;
-    int32_t head;
-    int32_t tail;
+    size_t capacity;
+    size_t head;
+    size_t tail;
     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;
-    HANDLE worker_event;
-#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
@@ -114,7 +100,6 @@ struct JanetVM {
      * return point for panics. */
     jmp_buf *signal_buf;
     Janet *return_reg;
-    int coerce_error;
 
     /* The global registry for c functions. Used to store meta-data
      * along with otherwise bare c function pointers. */
@@ -164,11 +149,6 @@ struct JanetVM {
     JanetTraversalNode *traversal_top;
     JanetTraversalNode *traversal_base;
 
-    /* Thread safe strerror error buffer - for janet_strerror */
-#ifndef JANET_WINDOWS
-    char strerror_buf[256];
-#endif
-
     /* Event loop and scheduler globals */
 #ifdef JANET_EV
     size_t tq_count;

src/core/string.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -31,8 +31,8 @@
 #include <string.h>
 
 /* Begin building a string */
-uint8_t *janet_string_begin(int32_t length) {
-    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) length + 1);
+uint8_t *janet_string_begin(size_t length) {
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + length + 1);
     head->length = length;
     uint8_t *data = (uint8_t *)head->data;
     data[length] = 0;
@@ -46,8 +46,8 @@ const uint8_t *janet_string_end(uint8_t *str) {
 }
 
 /* Load a buffer as a string */
-const uint8_t *janet_string(const uint8_t *buf, int32_t len) {
-    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + (size_t) len + 1);
+const uint8_t *janet_string(const uint8_t *buf, size_t len) {
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_STRING, sizeof(JanetStringHead) + len + 1);
     head->length = len;
     head->hash = janet_string_calchash(buf, len);
     uint8_t *data = (uint8_t *)head->data;
@@ -58,9 +58,9 @@ const uint8_t *janet_string(const uint8_t *buf, int32_t len) {
 
 /* Compare two strings */
 int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) {
-    int32_t xlen = janet_string_length(lhs);
-    int32_t ylen = janet_string_length(rhs);
-    int32_t len = xlen > ylen ? ylen : xlen;
+    size_t xlen = janet_string_length(lhs);
+    size_t ylen = janet_string_length(rhs);
+    size_t len = xlen > ylen ? ylen : xlen;
     int res = memcmp(lhs, rhs, len);
     if (res) return res > 0 ? 1 : -1;
     if (xlen == ylen) return 0;
@@ -68,13 +68,13 @@ int janet_string_compare(const uint8_t *lhs, const uint8_t *rhs) {
 }
 
 /* Compare a janet string with a piece of memory */
-int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash) {
+int janet_string_equalconst(const uint8_t *lhs, const uint8_t *rhs, size_t rlen, int32_t rhash) {
     int32_t lhash = janet_string_hash(lhs);
-    int32_t llen = janet_string_length(lhs);
-    if (lhash != rhash || llen != rlen)
-        return 0;
+    size_t llen = janet_string_length(lhs);
     if (lhs == rhs)
         return 1;
+    if (lhash != rhash || llen != rlen)
+        return 0;
     return !memcmp(lhs, rhs, rlen);
 }
 
@@ -92,10 +92,10 @@ const uint8_t *janet_cstring(const char *str) {
 /* Knuth Morris Pratt Algorithm */
 
 struct kmp_state {
-    int32_t i;
-    int32_t j;
-    int32_t textlen;
-    int32_t patlen;
+    size_t i;
+    size_t j;
+    size_t textlen;
+    size_t patlen;
     int32_t *lookup;
     const uint8_t *text;
     const uint8_t *pat;
@@ -103,8 +103,8 @@ struct kmp_state {
 
 static void kmp_init(
     struct kmp_state *s,
-    const uint8_t *text, int32_t textlen,
-    const uint8_t *pat, int32_t patlen) {
+    const uint8_t *text, size_t textlen,
+    const uint8_t *pat, size_t patlen) {
     if (patlen == 0) {
         janet_panic("expected non-empty pattern");
     }
@@ -121,7 +121,8 @@ static void kmp_init(
     s->patlen = patlen;
     /* Init state machine */
     {
-        int32_t i, j;
+        size_t i;
+        int32_t j;
         for (i = 1, j = 0; i < patlen; i++) {
             while (j && pat[j] != pat[i]) j = lookup[j - 1];
             if (pat[j] == pat[i]) j++;
@@ -140,10 +141,10 @@ static void kmp_seti(struct kmp_state *state, int32_t i) {
 }
 
 static int32_t kmp_next(struct kmp_state *state) {
-    int32_t i = state->i;
-    int32_t j = state->j;
-    int32_t textlen = state->textlen;
-    int32_t patlen = state->patlen;
+    size_t i = state->i;
+    size_t j = state->j;
+    size_t textlen = state->textlen;
+    size_t patlen = state->patlen;
     const uint8_t *text = state->text;
     const uint8_t *pat = state->pat;
     int32_t *lookup = state->lookup;
@@ -204,12 +205,11 @@ JANET_CORE_FN(cfun_string_repeat,
               "Returns a string that is `n` copies of `bytes` concatenated.") {
     janet_fixarity(argc, 2);
     JanetByteView view = janet_getbytes(argv, 0);
-    int32_t rep = janet_getinteger(argv, 1);
-    if (rep < 0) janet_panic("expected non-negative number of repetitions");
+    size_t rep = janet_getsize(argv, 1);
     if (rep == 0) return janet_cstringv("");
-    int64_t mulres = (int64_t) rep * view.len;
-    if (mulres > INT32_MAX) janet_panic("result string is too long");
-    uint8_t *newbuf = janet_string_begin((int32_t) mulres);
+    uint64_t mulres = (uint64_t) rep * view.len;
+    if (mulres > JANET_INTMAX_SIZE) janet_panic("result string is too long");
+    uint8_t *newbuf = janet_string_begin(mulres);
     uint8_t *end = newbuf + mulres;
     for (uint8_t *p = newbuf; p < end; p += view.len) {
         safe_memcpy(p, view.bytes, view.len);
@@ -223,7 +223,7 @@ JANET_CORE_FN(cfun_string_bytes,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     Janet *tup = janet_tuple_begin(view.len);
-    int32_t i;
+    size_t i;
     for (i = 0; i < view.len; i++) {
         tup[i] = janet_wrap_integer((int32_t) view.bytes[i]);
     }
@@ -251,7 +251,7 @@ JANET_CORE_FN(cfun_string_asciilower,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
-    for (int32_t i = 0; i < view.len; i++) {
+    for (size_t i = 0; i < view.len; i++) {
         uint8_t c = view.bytes[i];
         if (c >= 65 && c <= 90) {
             buf[i] = c + 32;
@@ -270,7 +270,7 @@ JANET_CORE_FN(cfun_string_asciiupper,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
-    for (int32_t i = 0; i < view.len; i++) {
+    for (size_t i = 0; i < view.len; i++) {
         uint8_t c = view.bytes[i];
         if (c >= 97 && c <= 122) {
             buf[i] = c - 32;
@@ -287,7 +287,7 @@ JANET_CORE_FN(cfun_string_reverse,
     janet_fixarity(argc, 1);
     JanetByteView view = janet_getbytes(argv, 0);
     uint8_t *buf = janet_string_begin(view.len);
-    int32_t i, j;
+    size_t i, j;
     for (i = 0, j = view.len - 1; i < view.len; i++, j--) {
         buf[i] = view.bytes[j];
     }
@@ -474,13 +474,13 @@ JANET_CORE_FN(cfun_string_checkset,
     JanetByteView set = janet_getbytes(argv, 0);
     JanetByteView str = janet_getbytes(argv, 1);
     /* Populate set */
-    for (int32_t i = 0; i < set.len; i++) {
+    for (size_t i = 0; i < set.len; i++) {
         int index = set.bytes[i] >> 5;
         uint32_t mask = 1 << (set.bytes[i] & 0x1F);
         bitset[index] |= mask;
     }
     /* Check set */
-    for (int32_t i = 0; i < str.len; i++) {
+    for (size_t i = 0; i < str.len; i++) {
         int index = str.bytes[i] >> 5;
         uint32_t mask = 1 << (str.bytes[i] & 0x1F);
         if (!(bitset[index] & mask)) {
@@ -504,24 +504,24 @@ JANET_CORE_FN(cfun_string_join,
         joiner.len = 0;
     }
     /* Check args */
-    int32_t i;
-    int64_t finallen = 0;
+    size_t i;
+    size_t finallen = 0;
     for (i = 0; i < parts.len; i++) {
         const uint8_t *chunk;
-        int32_t chunklen = 0;
+        size_t chunklen = 0;
         if (!janet_bytes_view(parts.items[i], &chunk, &chunklen)) {
             janet_panicf("item %d of parts is not a byte sequence, got %v", i, parts.items[i]);
         }
         if (i) finallen += joiner.len;
         finallen += chunklen;
-        if (finallen > INT32_MAX)
+        if (finallen > JANET_INTMAX_SIZE)
             janet_panic("result string too long");
     }
     uint8_t *buf, *out;
-    out = buf = janet_string_begin((int32_t) finallen);
+    out = buf = janet_string_begin(finallen);
     for (i = 0; i < parts.len; i++) {
         const uint8_t *chunk = NULL;
-        int32_t chunklen = 0;
+        size_t chunklen = 0;
         if (i) {
             safe_memcpy(out, joiner.bytes, joiner.len);
             out += joiner.len;
@@ -568,23 +568,23 @@ JANET_CORE_FN(cfun_string_format,
 }
 
 static int trim_help_checkset(JanetByteView set, uint8_t x) {
-    for (int32_t j = 0; j < set.len; j++)
+    for (size_t j = 0; j < set.len; j++)
         if (set.bytes[j] == x)
             return 1;
     return 0;
 }
 
-static int32_t trim_help_leftedge(JanetByteView str, JanetByteView set) {
-    for (int32_t i = 0; i < str.len; i++)
+static size_t trim_help_leftedge(JanetByteView str, JanetByteView set) {
+    for (size_t i = 0; i < str.len; i++)
         if (!trim_help_checkset(set, str.bytes[i]))
             return i;
     return str.len;
 }
 
-static int32_t trim_help_rightedge(JanetByteView str, JanetByteView set) {
-    for (int32_t i = str.len - 1; i >= 0; i--)
-        if (!trim_help_checkset(set, str.bytes[i]))
-            return i + 1;
+static size_t trim_help_rightedge(JanetByteView str, JanetByteView set) {
+    for (size_t i = 0; i < str.len; i++)
+        if (!trim_help_checkset(set, str.bytes[str.len - i - 1]))
+            return str.len - i;
     return 0;
 }
 
@@ -605,8 +605,8 @@ JANET_CORE_FN(cfun_string_trim,
               "`set` is provided, consider only characters in `set` to be whitespace.") {
     JanetByteView str, set;
     trim_help_args(argc, argv, &str, &set);
-    int32_t left_edge = trim_help_leftedge(str, set);
-    int32_t right_edge = trim_help_rightedge(str, set);
+    size_t left_edge = trim_help_leftedge(str, set);
+    size_t right_edge = trim_help_rightedge(str, set);
     if (right_edge < left_edge)
         return janet_stringv(NULL, 0);
     return janet_stringv(str.bytes + left_edge, right_edge - left_edge);

src/core/strtod.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -34,9 +34,9 @@
  * because E is a valid digit in bases 15 or greater. For bases greater than
  * 10, the letters are used as digits. A through Z correspond to the digits 10
  * through 35, and the lowercase letters have the same values. The radix number
- * is always in base 10. For example, a hexadecimal number could be written
+ * is always in base 10. For example, a hexidecimal number could be written
  * '16rdeadbeef'. janet_scan_number also supports some c style syntax for
- * hexadecimal literals. The previous number could also be written
+ * hexidecimal literals. The previous number could also be written
  * '0xdeadbeef'.
  */
 
@@ -249,7 +249,7 @@ static double convert(
  * and integer, return 0. */
 int janet_scan_number_base(
     const uint8_t *str,
-    int32_t len,
+    size_t len,
     int32_t base,
     double *out) {
     const uint8_t *end = str + len;
@@ -301,7 +301,6 @@ int janet_scan_number_base(
     if (base == 0) {
         base = 10;
     }
-    int exp_base = base;
 
     /* Skip leading zeros */
     while (str < end && (*str == '0' || *str == '.')) {
@@ -323,12 +322,6 @@ int janet_scan_number_base(
         } else if (*str == '&') {
             foundexp = 1;
             break;
-        } else if (base == 16 && (*str == 'P' || *str == 'p')) { /* IEEE hex float */
-            foundexp = 1;
-            exp_base = 10;
-            base = 2;
-            ex *= 4; /* We need to correct the current exponent after we change the base */
-            break;
         } else if (base == 10 && (*str == 'E' || *str == 'e')) {
             foundexp = 1;
             break;
@@ -367,9 +360,9 @@ int janet_scan_number_base(
         }
         while (str < end) {
             int digit = digit_lookup[*str & 0x7F];
-            if (*str > 127 || digit >= exp_base) goto error;
+            if (*str > 127 || digit >= base) goto error;
             if (ee < (INT32_MAX / 40)) {
-                ee = exp_base * ee + digit;
+                ee = base * ee + digit;
             }
             str++;
             seenadigit = 1;
@@ -392,7 +385,7 @@ error:
 
 int janet_scan_number(
     const uint8_t *str,
-    int32_t len,
+    size_t len,
     double *out) {
     return janet_scan_number_base(str, len, 0, out);
 }
@@ -401,7 +394,7 @@ int janet_scan_number(
 
 static int scan_uint64(
     const uint8_t *str,
-    int32_t len,
+    size_t len,
     uint64_t *out,
     int *neg) {
     const uint8_t *end = str + len;
@@ -464,7 +457,7 @@ static int scan_uint64(
     return 1;
 }
 
-int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) {
+int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out) {
     int neg;
     uint64_t bi;
     if (scan_uint64(str, len, &bi, &neg)) {
@@ -484,7 +477,7 @@ int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out) {
     return 0;
 }
 
-int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out) {
+int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out) {
     int neg;
     uint64_t bi;
     if (scan_uint64(str, len, &bi, &neg)) {
@@ -496,53 +489,4 @@ int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out) {
     return 0;
 }
 
-/* Similar to janet_scan_number but allows for
- * more numeric types with a given suffix. */
-int janet_scan_numeric(
-    const uint8_t *str,
-    int32_t len,
-    Janet *out) {
-    int result;
-    double num;
-    int64_t i64 = 0;
-    uint64_t u64 = 0;
-    if (len < 2 || str[len - 2] != ':') {
-        result = janet_scan_number_base(str, len, 0, &num);
-        *out = janet_wrap_number(num);
-        return result;
-    }
-    switch (str[len - 1]) {
-        default:
-            return 1;
-        case 'n':
-            result = janet_scan_number_base(str, len - 2, 0, &num);
-            *out = janet_wrap_number(num);
-            return result;
-        /* Condition is inverted janet_scan_int64 and janet_scan_uint64 */
-        case 's':
-            result = !janet_scan_int64(str, len - 2, &i64);
-            *out = janet_wrap_s64(i64);
-            return result;
-        case 'u':
-            result = !janet_scan_uint64(str, len - 2, &u64);
-            *out = janet_wrap_u64(u64);
-            return result;
-    }
-}
-
 #endif
-
-void janet_buffer_dtostr(JanetBuffer *buffer, double x) {
-#define BUFSIZE 32
-    janet_buffer_extra(buffer, BUFSIZE);
-    int count = snprintf((char *) buffer->data + buffer->count, BUFSIZE, "%.17g", x);
-#undef BUFSIZE
-    /* fix locale issues with commas */
-    for (int i = 0; i < count; i++) {
-        char c = buffer->data[buffer->count + i];
-        if (c == ',') {
-            buffer->data[buffer->count + i] = '.';
-        }
-    }
-    buffer->count += count;
-}

src/core/struct.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -29,12 +29,18 @@
 #endif
 
 /* Begin creation of a struct */
-JanetKV *janet_struct_begin(int32_t count) {
+JanetKV *janet_struct_begin(size_t count) {
     /* Calculate capacity as power of 2 after 2 * count. */
-    int32_t capacity = janet_tablen(2 * count);
-    if (capacity < 0) capacity = janet_tablen(count + 1);
 
-    size_t size = sizeof(JanetStructHead) + (size_t) capacity * sizeof(JanetKV);
+    uint64_t double_count =
+        (count > JANET_INTMAX_SIZE / 2) ? JANET_INTMAX_SIZE : 2 * count;
+    uint64_t capacity = janet_tablen(double_count);
+
+    uint64_t part_size = capacity * sizeof(JanetKV);
+    if (part_size > JANET_INTMAX_SIZE){
+        part_size = JANET_INTMIN_SIZE;
+    }
+    size_t size = sizeof(JanetStructHead) + (uint64_t) part_size;
     JanetStructHead *head = janet_gcalloc(JANET_MEMORY_STRUCT, size);
     head->length = count;
     head->capacity = capacity;
@@ -49,9 +55,9 @@ JanetKV *janet_struct_begin(int32_t count) {
 /* Find an item in a struct without looking for prototypes. Should be similar to janet_dict_find, but
  * specialized to structs (slightly more compact). */
 const JanetKV *janet_struct_find(const JanetKV *st, Janet key) {
-    int32_t cap = janet_struct_capacity(st);
-    int32_t index = janet_maphash(cap, janet_hash(key));
-    int32_t i;
+    size_t cap = janet_struct_capacity(st);
+    size_t index = (size_t) janet_maphash(cap, janet_hash(key));
+    size_t i;
     for (i = index; i < cap; i++)
         if (janet_checktype(st[i].key, JANET_NIL) || janet_equals(st[i].key, key))
             return st + i;
@@ -70,20 +76,20 @@ const JanetKV *janet_struct_find(const JanetKV *st, Janet key) {
  * hash map is independent of insertion order.
  */
 void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) {
-    int32_t cap = janet_struct_capacity(st);
+    size_t cap = janet_struct_capacity(st);
     int32_t hash = janet_hash(key);
-    int32_t index = janet_maphash(cap, hash);
-    int32_t i, j, dist;
-    int32_t bounds[4] = {index, cap, 0, index};
+    size_t index = (size_t) janet_maphash(cap, hash);
+    size_t i, j, dist;
+    size_t bounds[4] = {index, cap, 0, index};
     if (janet_checktype(key, JANET_NIL) || janet_checktype(value, JANET_NIL)) return;
     if (janet_checktype(key, JANET_NUMBER) && isnan(janet_unwrap_number(key))) return;
     /* Avoid extra items */
-    if (janet_struct_hash(st) == janet_struct_length(st)) return;
+    if ((size_t) janet_struct_hash(st) == janet_struct_length(st)) return;
     for (dist = 0, j = 0; j < 4; j += 2)
         for (i = bounds[j]; i < bounds[j + 1]; i++, dist++) {
             int status;
             int32_t otherhash;
-            int32_t otherindex, otherdist;
+            size_t otherindex, otherdist;
             JanetKV *kv = st + i;
             /* We found an empty slot, so just add key and value */
             if (janet_checktype(kv->key, JANET_NIL)) {
@@ -100,7 +106,7 @@ void janet_struct_put_ext(JanetKV *st, Janet key, Janet value, int replace) {
              * will compare properly - i.e., {1 2 3 4} should equal {3 4 1 2}.
              * Collisions are resolved via an insertion sort insertion. */
             otherhash = janet_hash(kv->key);
-            otherindex = janet_maphash(cap, otherhash);
+            otherindex = (size_t) janet_maphash(cap, otherhash);
             otherdist = (i + cap - otherindex) & (cap - 1);
             if (dist < otherdist)
                 status = -1;
@@ -139,12 +145,12 @@ void janet_struct_put(JanetKV *st, Janet key, Janet value) {
 
 /* Finish building a struct */
 const JanetKV *janet_struct_end(JanetKV *st) {
-    if (janet_struct_hash(st) != janet_struct_length(st)) {
+    if ((size_t) janet_struct_hash(st) != janet_struct_length(st)) {
         /* Error building struct, probably duplicate values. We need to rebuild
          * the struct using only the values that went in. The second creation should always
          * succeed. */
         JanetKV *newst = janet_struct_begin(janet_struct_hash(st));
-        for (int32_t i = 0; i < janet_struct_capacity(st); i++) {
+        for (size_t i = 0; i < janet_struct_capacity(st); i++) {
             JanetKV *kv = st + i;
             if (!janet_checktype(kv->key, JANET_NIL)) {
                 janet_struct_put(newst, kv->key, kv->value);
@@ -192,7 +198,7 @@ Janet janet_struct_get_ex(const JanetKV *st, Janet key, JanetStruct *which) {
 /* Convert struct to table */
 JanetTable *janet_struct_to_table(const JanetKV *st) {
     JanetTable *table = janet_table(janet_struct_capacity(st));
-    int32_t i;
+    size_t i;
     for (i = 0; i < janet_struct_capacity(st); i++) {
         const JanetKV *kv = st + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
@@ -238,21 +244,21 @@ JANET_CORE_FN(cfun_struct_flatten,
     JanetStruct st = janet_getstruct(argv, 0);
 
     /* get an upper bounds on the number of items in the final struct */
-    int64_t pair_count = 0;
+    size_t pair_count = 0;
     JanetStruct cursor = st;
     while (cursor) {
         pair_count += janet_struct_length(cursor);
         cursor = janet_struct_proto(cursor);
     }
 
-    if (pair_count > INT32_MAX) {
+    if (pair_count > JANET_INTMAX_SIZE) {
         janet_panic("struct too large");
     }
 
-    JanetKV *accum = janet_struct_begin((int32_t) pair_count);
+    JanetKV *accum = janet_struct_begin(pair_count);
     cursor = st;
     while (cursor) {
-        for (int32_t i = 0; i < janet_struct_capacity(cursor); i++) {
+        for (size_t i = 0; i < janet_struct_capacity(cursor); i++) {
             const JanetKV *kv = cursor + i;
             if (!janet_checktype(kv->key, JANET_NIL)) {
                 janet_struct_put_ext(accum, kv->key, kv->value, 0);
@@ -283,7 +289,7 @@ JANET_CORE_FN(cfun_struct_to_table,
         }
         /* TODO - implement as memcpy since struct memory should be compatible
          * with table memory */
-        for (int32_t i = 0; i < janet_struct_capacity(cursor); i++) {
+        for (size_t i = 0; i < janet_struct_capacity(cursor); i++) {
             const JanetKV *kv = cursor + i;
             if (!janet_checktype(kv->key, JANET_NIL)) {
                 janet_table_put(tab_cursor, kv->key, kv->value);
@@ -294,16 +300,6 @@ JANET_CORE_FN(cfun_struct_to_table,
     return janet_wrap_table(tab);
 }
 
-JANET_CORE_FN(cfun_struct_rawget,
-              "(struct/rawget st key)",
-              "Gets a value from a struct `st` without looking at the prototype struct. "
-              "If `st` does not contain the key directly, the function will return "
-              "nil without checking the prototype. Returns the value in the struct.") {
-    janet_fixarity(argc, 2);
-    JanetStruct st = janet_getstruct(argv, 0);
-    return janet_struct_rawget(st, argv[1]);
-}
-
 /* Load the struct module */
 void janet_lib_struct(JanetTable *env) {
     JanetRegExt struct_cfuns[] = {
@@ -311,7 +307,6 @@ void janet_lib_struct(JanetTable *env) {
         JANET_CORE_REG("struct/getproto", cfun_struct_getproto),
         JANET_CORE_REG("struct/proto-flatten", cfun_struct_flatten),
         JANET_CORE_REG("struct/to-table", cfun_struct_to_table),
-        JANET_CORE_REG("struct/rawget", cfun_struct_rawget),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, struct_cfuns);

src/core/symcache.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -66,7 +66,7 @@ static const uint8_t JANET_SYMCACHE_DELETED[1] = {0};
  * where one would put it. */
 static const uint8_t **janet_symcache_findmem(
     const uint8_t *str,
-    int32_t len,
+    size_t len,
     int32_t hash,
     int *success) {
     uint32_t bounds[4];
@@ -116,10 +116,10 @@ notfound:
     janet_symcache_findmem((str), janet_string_length(str), janet_string_hash(str), (success))
 
 /* Resize the cache. */
-static void janet_cache_resize(uint32_t newCapacity) {
-    uint32_t i, oldCapacity;
+static void janet_cache_resize(size_t newCapacity) {
+    size_t i, oldCapacity;
     const uint8_t **oldCache = janet_vm.cache;
-    const uint8_t **newCache = janet_calloc(1, (size_t) newCapacity * sizeof(const uint8_t *));
+    const uint8_t **newCache = janet_calloc(1, newCapacity * sizeof(const uint8_t *));
     if (newCache == NULL) {
         JANET_OUT_OF_MEMORY;
     }
@@ -169,14 +169,14 @@ void janet_symbol_deinit(const uint8_t *sym) {
 }
 
 /* Create a symbol from a byte string */
-const uint8_t *janet_symbol(const uint8_t *str, int32_t len) {
+const uint8_t *janet_symbol(const uint8_t *str, size_t len) {
     int32_t hash = janet_string_calchash(str, len);
     uint8_t *newstr;
     int success = 0;
     const uint8_t **bucket = janet_symcache_findmem(str, len, hash, &success);
     if (success)
         return *bucket;
-    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + (size_t) len + 1);
+    JanetStringHead *head = janet_gcalloc(JANET_MEMORY_SYMBOL, sizeof(JanetStringHead) + len + 1);
     head->hash = hash;
     head->length = len;
     newstr = (uint8_t *)(head->data);
@@ -188,7 +188,7 @@ const uint8_t *janet_symbol(const uint8_t *str, int32_t len) {
 
 /* Get a symbol from a cstring */
 const uint8_t *janet_csymbol(const char *cstr) {
-    return janet_symbol((const uint8_t *)cstr, (int32_t) strlen(cstr));
+    return janet_symbol((const uint8_t *)cstr, strlen(cstr));
 }
 
 /* Increment the gensym buffer */

src/core/symcache.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/table.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -30,9 +30,9 @@
 
 #define JANET_TABLE_FLAG_STACK 0x10000
 
-static void *janet_memalloc_empty_local(int32_t count) {
-    int32_t i;
-    void *mem = janet_smalloc((size_t) count * sizeof(JanetKV));
+static void *janet_memalloc_empty_local(size_t count) {
+    size_t i;
+    void *mem = janet_smalloc(count * sizeof(JanetKV));
     JanetKV *mmem = (JanetKV *)mem;
     for (i = 0; i < count; i++) {
         JanetKV *kv = mmem + i;
@@ -42,7 +42,7 @@ static void *janet_memalloc_empty_local(int32_t count) {
     return mem;
 }
 
-static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, int stackalloc) {
+static JanetTable *janet_table_init_impl(JanetTable *table, size_t capacity, int stackalloc) {
     JanetKV *data;
     capacity = janet_tablen(capacity);
     if (stackalloc) table->gc.flags = JANET_TABLE_FLAG_STACK;
@@ -67,13 +67,13 @@ static JanetTable *janet_table_init_impl(JanetTable *table, int32_t capacity, in
     return table;
 }
 
-/* Initialize a table (for use with scratch memory) */
-JanetTable *janet_table_init(JanetTable *table, int32_t capacity) {
+/* Initialize a table (for use withs scratch memory) */
+JanetTable *janet_table_init(JanetTable *table, size_t capacity) {
     return janet_table_init_impl(table, capacity, 1);
 }
 
 /* Initialize a table without using scratch memory */
-JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity) {
+JanetTable *janet_table_init_raw(JanetTable *table, size_t capacity) {
     return janet_table_init_impl(table, capacity, 0);
 }
 
@@ -88,22 +88,22 @@ void janet_table_deinit(JanetTable *table) {
 
 /* Create a new table */
 
-JanetTable *janet_table(int32_t capacity) {
+JanetTable *janet_table(size_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
 
-JanetTable *janet_table_weakk(int32_t capacity) {
+JanetTable *janet_table_weakk(size_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKK, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
 
-JanetTable *janet_table_weakv(int32_t capacity) {
+JanetTable *janet_table_weakv(size_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKV, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
 
-JanetTable *janet_table_weakkv(int32_t capacity) {
+JanetTable *janet_table_weakkv(size_t capacity) {
     JanetTable *table = janet_gcalloc(JANET_MEMORY_TABLE_WEAKKV, sizeof(JanetTable));
     return janet_table_init_impl(table, capacity, 0);
 }
@@ -115,7 +115,7 @@ JanetKV *janet_table_find(JanetTable *t, Janet key) {
 }
 
 /* Resize the dictionary table. */
-static void janet_table_rehash(JanetTable *t, int32_t size) {
+static void janet_table_rehash(JanetTable *t, size_t size) {
     JanetKV *olddata = t->data;
     JanetKV *newdata;
     int islocal = t->gc.flags & JANET_TABLE_FLAG_STACK;
@@ -127,11 +127,11 @@ static void janet_table_rehash(JanetTable *t, int32_t size) {
             JANET_OUT_OF_MEMORY;
         }
     }
-    int32_t oldcapacity = t->capacity;
+    size_t oldcapacity = t->capacity;
     t->data = newdata;
     t->capacity = size;
     t->deleted = 0;
-    for (int32_t i = 0; i < oldcapacity; i++) {
+    for (size_t i = 0; i < oldcapacity; i++) {
         JanetKV *kv = olddata + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
             JanetKV *newkv = janet_table_find(t, kv->key);
@@ -235,7 +235,7 @@ static void janet_table_put_no_overwrite(JanetTable *t, Janet key, Janet value)
 
 /* Clear a table */
 void janet_table_clear(JanetTable *t) {
-    int32_t capacity = t->capacity;
+    size_t capacity = t->capacity;
     JanetKV *data = t->data;
     janet_memempty(data, capacity);
     t->count = 0;
@@ -253,13 +253,13 @@ JanetTable *janet_table_clone(JanetTable *table) {
     if (NULL == newTable->data) {
         JANET_OUT_OF_MEMORY;
     }
-    memcpy(newTable->data, table->data, (size_t) table->capacity * sizeof(JanetKV));
+    memcpy(newTable->data, table->data, table->capacity * sizeof(JanetKV));
     return newTable;
 }
 
 /* Merge a table or struct into a table */
-static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, int32_t cap) {
-    int32_t i;
+static void janet_table_mergekv(JanetTable *table, const JanetKV *kvs, size_t cap) {
+    size_t i;
     for (i = 0; i < cap; i++) {
         const JanetKV *kv = kvs + i;
         if (!janet_checktype(kv->key, JANET_NIL)) {
@@ -316,16 +316,23 @@ JANET_CORE_FN(cfun_table_new,
               "can be avoided. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getnat(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     return janet_wrap_table(janet_table(cap));
 }
+/*
+    uint32_t flags = janet_getflags(argv, 1, "kv");
+    if (flags == 0) return janet_wrap_table(janet_table(cap));
+    if (flags == 1) return janet_wrap_table(janet_table_weakk(cap));
+    if (flags == 2) return janet_wrap_table(janet_table_weakv(cap));
+    return janet_wrap_table(janet_table_weakkv(cap));
+    */
 
 JANET_CORE_FN(cfun_table_weak,
               "(table/weak capacity)",
               "Creates a new empty table with weak references to keys and values. Similar to `table/new`. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getnat(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     return janet_wrap_table(janet_table_weakkv(cap));
 }
 
@@ -334,7 +341,7 @@ JANET_CORE_FN(cfun_table_weak_keys,
               "Creates a new empty table with weak references to keys and normal references to values. Similar to `table/new`. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getnat(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     return janet_wrap_table(janet_table_weakk(cap));
 }
 
@@ -343,7 +350,7 @@ JANET_CORE_FN(cfun_table_weak_values,
               "Creates a new empty table with normal references to keys and weak references to values. Similar to `table/new`. "
               "Returns the new table.") {
     janet_fixarity(argc, 1);
-    int32_t cap = janet_getnat(argv, 0);
+    size_t cap = janet_getsize(argv, 0);
     return janet_wrap_table(janet_table_weakv(cap));
 }
 
@@ -372,14 +379,12 @@ JANET_CORE_FN(cfun_table_setproto,
 }
 
 JANET_CORE_FN(cfun_table_tostruct,
-              "(table/to-struct tab &opt proto)",
-              "Convert a table to a struct. Returns a new struct.") {
-    janet_arity(argc, 1, 2);
+              "(table/to-struct tab)",
+              "Convert a table to a struct. Returns a new struct. This function "
+              "does not take into account prototype tables.") {
+    janet_fixarity(argc, 1);
     JanetTable *t = janet_gettable(argv, 0);
-    JanetStruct proto = janet_optstruct(argv, argc, 1, NULL);
-    JanetStruct st = janet_table_to_struct(t);
-    janet_struct_proto(st) = proto;
-    return janet_wrap_struct(st);
+    return janet_wrap_struct(janet_table_to_struct(t));
 }
 
 JANET_CORE_FN(cfun_table_rawget,

src/core/tuple.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -31,8 +31,8 @@
 /* Create a new empty tuple of the given size. This will return memory
  * which should be filled with Janets. The memory will not be collected until
  * janet_tuple_end is called. */
-Janet *janet_tuple_begin(int32_t length) {
-    size_t size = sizeof(JanetTupleHead) + ((size_t) length * sizeof(Janet));
+Janet *janet_tuple_begin(size_t length) {
+    size_t size = sizeof(JanetTupleHead) + (length * sizeof(Janet));
     JanetTupleHead *head = janet_gcalloc(JANET_MEMORY_TUPLE, size);
     head->sm_line = -1;
     head->sm_column = -1;
@@ -47,7 +47,7 @@ const Janet *janet_tuple_end(Janet *tuple) {
 }
 
 /* Build a tuple with n values */
-const Janet *janet_tuple_n(const Janet *values, int32_t n) {
+const Janet *janet_tuple_n(const Janet *values, size_t n) {
     Janet *t = janet_tuple_begin(n);
     safe_memcpy(t, values, sizeof(Janet) * n);
     return janet_tuple_end(t);
@@ -116,34 +116,6 @@ JANET_CORE_FN(cfun_tuple_setmap,
     return argv[0];
 }
 
-JANET_CORE_FN(cfun_tuple_join,
-              "(tuple/join & parts)",
-              "Create a tuple by joining together other tuples and arrays.") {
-    janet_arity(argc, 0, -1);
-    int32_t total_len = 0;
-    for (int32_t i = 0; i < argc; i++) {
-        int32_t len = 0;
-        const Janet *vals = NULL;
-        if (!janet_indexed_view(argv[i], &vals, &len)) {
-            janet_panicf("expected indexed type for argument %d, got %v", i, argv[i]);
-        }
-        if (INT32_MAX - total_len < len) {
-            janet_panic("tuple too large");
-        }
-        total_len += len;
-    }
-    Janet *tup = janet_tuple_begin(total_len);
-    Janet *tup_cursor = tup;
-    for (int32_t i = 0; i < argc; i++) {
-        int32_t len = 0;
-        const Janet *vals = NULL;
-        janet_indexed_view(argv[i], &vals, &len);
-        memcpy(tup_cursor, vals, len * sizeof(Janet));
-        tup_cursor += len;
-    }
-    return janet_wrap_tuple(janet_tuple_end(tup));
-}
-
 /* Load the tuple module */
 void janet_lib_tuple(JanetTable *env) {
     JanetRegExt tuple_cfuns[] = {
@@ -152,7 +124,6 @@ void janet_lib_tuple(JanetTable *env) {
         JANET_CORE_REG("tuple/type", cfun_tuple_type),
         JANET_CORE_REG("tuple/sourcemap", cfun_tuple_sourcemap),
         JANET_CORE_REG("tuple/setmap", cfun_tuple_setmap),
-        JANET_CORE_REG("tuple/join", cfun_tuple_join),
         JANET_REG_END
     };
     janet_core_cfuns_ext(env, NULL, tuple_cfuns);

src/core/util.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -79,7 +79,6 @@ const char *const janet_type_names[16] = {
     "pointer"
 };
 
-/* Docstring for signal lists these */
 const char *const janet_signal_names[14] = {
     "ok",
     "error",
@@ -97,7 +96,6 @@ const char *const janet_signal_names[14] = {
     "await"
 };
 
-/* Docstring for fiber/status lists these */
 const char *const janet_status_names[16] = {
     "dead",
     "error",
@@ -117,20 +115,14 @@ const char *const janet_status_names[16] = {
     "alive"
 };
 
-uint32_t janet_hash_mix(uint32_t input, uint32_t more) {
-    uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2));
-    return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2));
-}
-
 #ifndef JANET_PRF
 
-int32_t janet_string_calchash(const uint8_t *str, int32_t len) {
-    if (NULL == str || len == 0) return 5381;
+int32_t janet_string_calchash(const uint8_t *str, size_t len) {
+    if (NULL == str) return 5381;
     const uint8_t *end = str + len;
     uint32_t hash = 5381;
     while (str < end)
         hash = (hash << 5) + hash + *str++;
-    hash = janet_hash_mix(hash, (uint32_t) len);
     return (int32_t) hash;
 }
 
@@ -238,7 +230,7 @@ void janet_init_hash_key(uint8_t new_key[JANET_HASH_KEY_SIZE]) {
 
 /* Calculate hash for string */
 
-int32_t janet_string_calchash(const uint8_t *str, int32_t len) {
+int32_t janet_string_calchash(const uint8_t *str, size_t len) {
     uint32_t hash;
     hash = halfsiphash(str, len, hash_key);
     return (int32_t)hash;
@@ -246,8 +238,13 @@ int32_t janet_string_calchash(const uint8_t *str, int32_t len) {
 
 #endif
 
+uint32_t janet_hash_mix(uint32_t input, uint32_t more) {
+    uint32_t mix1 = (more + 0x9e3779b9 + (input << 6) + (input >> 2));
+    return input ^ (0x9e3779b9 + (mix1 << 6) + (mix1 >> 2));
+}
+
 /* Computes hash of an array of values */
-int32_t janet_array_calchash(const Janet *array, int32_t len) {
+int32_t janet_array_calchash(const Janet *array, size_t len) {
     const Janet *end = array + len;
     uint32_t hash = 33;
     while (array < end) {
@@ -257,7 +254,7 @@ int32_t janet_array_calchash(const Janet *array, int32_t len) {
 }
 
 /* Computes hash of an array of values */
-int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) {
+int32_t janet_kv_calchash(const JanetKV *kvs, size_t len) {
     const JanetKV *end = kvs + len;
     uint32_t hash = 33;
     while (kvs < end) {
@@ -270,8 +267,7 @@ int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len) {
 
 /* Calculate next power of 2. May overflow. If n is 0,
  * will return 0. */
-int32_t janet_tablen(int32_t n) {
-    if (n < 0) return 0;
+uint64_t janet_tablen(uint64_t n) {
     n |= n >> 1;
     n |= n >> 2;
     n |= n >> 4;
@@ -288,9 +284,9 @@ void safe_memcpy(void *dest, const void *src, size_t len) {
 
 /* Helper to find a value in a Janet struct or table. Returns the bucket
  * containing the key, or the first empty bucket if there is no such key. */
-const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) {
+const JanetKV *janet_dict_find(const JanetKV *buckets, size_t cap, Janet key) {
     int32_t index = janet_maphash(cap, janet_hash(key));
-    int32_t i;
+    size_t i;
     const JanetKV *first_bucket = NULL;
     /* Higher half */
     for (i = index; i < cap; i++) {
@@ -306,7 +302,7 @@ const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) {
         }
     }
     /* Lower half */
-    for (i = 0; i < index; i++) {
+    for (i = 0; i < (size_t) index; i++) {
         const JanetKV *kv = buckets + i;
         if (janet_checktype(kv->key, JANET_NIL)) {
             if (janet_checktype(kv->value, JANET_NIL)) {
@@ -322,7 +318,7 @@ const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key) {
 }
 
 /* Get a value from a janet struct or table. */
-Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key) {
+Janet janet_dictionary_get(const JanetKV *data, size_t cap, Janet key) {
     const JanetKV *kv = janet_dict_find(data, cap, key);
     if (kv && !janet_checktype(kv->key, JANET_NIL)) {
         return kv->value;
@@ -331,7 +327,7 @@ Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key) {
 }
 
 /* Iterate through a struct or dictionary generically */
-const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv) {
+const JanetKV *janet_dictionary_next(const JanetKV *kvs, size_t cap, const JanetKV *kv) {
     const JanetKV *end = kvs + cap;
     kv = (kv == NULL) ? kvs : kv + 1;
     while (kv < end) {
@@ -345,8 +341,8 @@ const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const Jane
 /* Compare a janet string with a cstring. More efficient than loading
  * c string as a janet string. */
 int janet_cstrcmp(const uint8_t *str, const char *other) {
-    int32_t len = janet_string_length(str);
-    int32_t index;
+    size_t len = janet_string_length(str);
+    size_t index;
     for (index = 0; index < len; index++) {
         uint8_t c = str[index];
         uint8_t k = ((const uint8_t *)other)[index];
@@ -694,7 +690,7 @@ static JanetByteView to_byte_view(Janet value) {
 JanetByteView janet_text_substitution(
     Janet *subst,
     const uint8_t *bytes,
-    uint32_t len,
+    size_t len,
     JanetArray *extra_argv) {
     int32_t extra_argc = extra_argv == NULL ? 0 : extra_argv->count;
     JanetType type = janet_type(*subst);
@@ -744,7 +740,7 @@ Janet janet_resolve_core(const char *name) {
 
 /* Read both tuples and arrays as c pointers + int32_t length. Return 1 if the
  * view can be constructed, 0 if an invalid type. */
-int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) {
+int janet_indexed_view(Janet seq, const Janet **data, size_t *len) {
     if (janet_checktype(seq, JANET_ARRAY)) {
         *data = janet_unwrap_array(seq)->data;
         *len = janet_unwrap_array(seq)->count;
@@ -759,7 +755,7 @@ int janet_indexed_view(Janet seq, const Janet **data, int32_t *len) {
 
 /* Read both strings and buffer as unsigned character array + int32_t len.
  * Returns 1 if the view can be constructed and 0 if the type is invalid. */
-int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) {
+int janet_bytes_view(Janet str, const uint8_t **data, size_t *len) {
     JanetType t = janet_type(str);
     if (t == JANET_STRING || t == JANET_SYMBOL || t == JANET_KEYWORD) {
         *data = janet_unwrap_string(str);
@@ -786,7 +782,7 @@ int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len) {
 /* Read both structs and tables as the entries of a hashtable with
  * identical structure. Returns 1 if the view can be constructed and
  * 0 if the type is invalid. */
-int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap) {
+int janet_dictionary_view(Janet tab, const JanetKV **data, size_t *len, size_t *cap) {
     if (janet_checktype(tab, JANET_TABLE)) {
         *data = janet_unwrap_table(tab)->data;
         *cap = janet_unwrap_table(tab)->capacity;
@@ -829,30 +825,18 @@ int janet_checkuint64(Janet x) {
     return janet_checkuint64range(dval);
 }
 
-int janet_checkint16(Janet x) {
-    if (!janet_checktype(x, JANET_NUMBER))
-        return 0;
-    double dval = janet_unwrap_number(x);
-    return janet_checkint16range(dval);
-}
-
-int janet_checkuint16(Janet x) {
-    if (!janet_checktype(x, JANET_NUMBER))
-        return 0;
-    double dval = janet_unwrap_number(x);
-    return janet_checkuint16range(dval);
-}
-
 int janet_checksize(Janet x) {
     if (!janet_checktype(x, JANET_NUMBER))
         return 0;
     double dval = janet_unwrap_number(x);
-    if (dval != (double)((size_t) dval)) return 0;
-    if (SIZE_MAX > JANET_INTMAX_INT64) {
-        return dval <= JANET_INTMAX_INT64;
-    } else {
-        return dval <= SIZE_MAX;
-    }
+    return janet_checksizerange(dval);
+}
+
+int janet_checkssize(Janet x) {
+    if (!janet_checktype(x, JANET_NUMBER))
+        return 0;
+    double dval = janet_unwrap_number(x);
+    return janet_checkssizerange(dval);
 }
 
 JanetTable *janet_get_core_table(const char *name) {
@@ -865,21 +849,21 @@ JanetTable *janet_get_core_table(const char *name) {
 }
 
 /* Sort keys of a dictionary type */
-int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer) {
+int32_t janet_sorted_keys(const JanetKV *dict, size_t cap, int32_t *index_buffer) {
 
     /* First, put populated indices into index_buffer */
-    int32_t next_index = 0;
-    for (int32_t i = 0; i < cap; i++) {
+    size_t next_index = 0;
+    for (size_t i = 0; i < cap; i++) {
         if (!janet_checktype(dict[i].key, JANET_NIL)) {
             index_buffer[next_index++] = i;
         }
     }
 
     /* Next, sort those (simple insertion sort here for now) */
-    for (int32_t i = 1; i < next_index; i++) {
+    for (size_t i = 1; i < next_index; i++) {
         int32_t index_to_insert = index_buffer[i];
         Janet lhs = dict[index_to_insert].key;
-        for (int32_t j = i - 1; j >= 0; j--) {
+        for (size_t j = i - 1; j > 0; j--) {
             index_buffer[j + 1] = index_buffer[j];
             Janet rhs = dict[index_buffer[j]].key;
             if (janet_compare(lhs, rhs) >= 0) {
@@ -931,24 +915,27 @@ 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_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 {
+    if (source == JANET_TIME_REALTIME) {
         clock_serv_t cclock;
         mach_timespec_t mts;
-        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);
+        host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &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;
 }
@@ -967,20 +954,6 @@ int janet_gettime(struct timespec *spec, enum JanetTimeSource source) {
 #endif
 #endif
 
-/* Better strerror (thread-safe if available) */
-const char *janet_strerror(int e) {
-#ifdef JANET_WINDOWS
-    /* Microsoft strerror seems sane here and is thread safe by default */
-    return strerror(e);
-#elif defined(__GLIBC__)
-    /* See https://linux.die.net/man/3/strerror_r */
-    return strerror_r(e, janet_vm.strerror_buf, sizeof(janet_vm.strerror_buf));
-#else
-    strerror_r(e, janet_vm.strerror_buf, sizeof(janet_vm.strerror_buf));
-    return janet_vm.strerror_buf;
-#endif
-}
-
 /* Setting C99 standard makes this not available, but it should
  * work/link properly if we detect a BSD */
 #if defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)

src/core/util.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -33,7 +33,6 @@
 #include <errno.h>
 #include <stddef.h>
 #include <stdbool.h>
-#include <math.h>
 
 #ifdef JANET_EV
 #ifndef JANET_WINDOWS
@@ -67,22 +66,20 @@
 /* Utils */
 uint32_t janet_hash_mix(uint32_t input, uint32_t more);
 #define janet_maphash(cap, hash) ((uint32_t)(hash) & (cap - 1))
-int janet_valid_utf8(const uint8_t *str, int32_t len);
+int janet_valid_utf8(const uint8_t *str, size_t len);
 int janet_is_symbol_char(uint8_t c);
 extern const char janet_base64[65];
-int32_t janet_array_calchash(const Janet *array, int32_t len);
-int32_t janet_kv_calchash(const JanetKV *kvs, int32_t len);
-int32_t janet_string_calchash(const uint8_t *str, int32_t len);
-int32_t janet_tablen(int32_t n);
+int32_t janet_array_calchash(const Janet *array, size_t len);
+int32_t janet_kv_calchash(const JanetKV *kvs, size_t len);
+int32_t janet_string_calchash(const uint8_t *str, size_t len);
+uint64_t janet_tablen(uint64_t n);
 void safe_memcpy(void *dest, const void *src, size_t len);
 void janet_buffer_push_types(JanetBuffer *buffer, int types);
-const JanetKV *janet_dict_find(const JanetKV *buckets, int32_t cap, Janet key);
-void janet_memempty(JanetKV *mem, int32_t count);
-void *janet_memalloc_empty(int32_t count);
+const JanetKV *janet_dict_find(const JanetKV *buckets, size_t cap, Janet key);
+void janet_memempty(JanetKV *mem, size_t count);
+void *janet_memalloc_empty(size_t count);
 JanetTable *janet_get_core_table(const char *name);
 void janet_def_addflags(JanetFuncDef *def);
-void janet_buffer_dtostr(JanetBuffer *buffer, double x);
-const char *janet_strerror(int e);
 const void *janet_strbinsearch(
     const void *tab,
     size_t tabcount,
@@ -99,7 +96,7 @@ JanetBinding janet_binding_from_entry(Janet entry);
 JanetByteView janet_text_substitution(
     Janet *subst,
     const uint8_t *bytes,
-    uint32_t len,
+    size_t len,
     JanetArray *extra_args);
 
 /* Registry functions */
@@ -142,7 +139,7 @@ int janet_gettime(struct timespec *spec, enum JanetTimeSource source);
 #define strdup(x) _strdup(x)
 #endif
 
-/* Use LoadLibrary on windows or dlopen on posix to load dynamic libraries
+/* Use LoadLibrary on windows or dlopen on posix to load dynamic libaries
  * with native code. */
 #if defined(JANET_NO_DYNAMIC_MODULES)
 typedef int Clib;
@@ -190,6 +187,9 @@ void janet_lib_debug(JanetTable *env);
 #ifdef JANET_PEG
 void janet_lib_peg(JanetTable *env);
 #endif
+#ifdef JANET_TYPED_ARRAY
+void janet_lib_typed_array(JanetTable *env);
+#endif
 #ifdef JANET_INT_TYPES
 void janet_lib_inttypes(JanetTable *env);
 #endif
@@ -200,11 +200,7 @@ extern const JanetAbstractType janet_address_type;
 #ifdef JANET_EV
 void janet_lib_ev(JanetTable *env);
 void janet_ev_mark(void);
-void janet_async_start_fiber(JanetFiber *fiber, JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state);
 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);

src/core/value.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -31,7 +31,7 @@
 
 #include <math.h>
 
-static void push_traversal_node(void *lhs, void *rhs, int32_t index2) {
+static void push_traversal_node(void *lhs, void *rhs, size_t index2) {
     JanetTraversalNode node;
     node.self = (JanetGCObject *) lhs;
     node.other = (JanetGCObject *) rhs;
@@ -75,7 +75,7 @@ static int traversal_next(Janet *x, Janet *y) {
         if ((self->flags & JANET_MEM_TYPEBITS) == JANET_MEMORY_TUPLE) {
             /* Node is a tuple at index t->index */
             if (t->index < tself->length && t->index < tother->length) {
-                int32_t index = t->index++;
+                size_t index = t->index++;
                 *x = tself->data[index];
                 *y = tother->data[index];
                 janet_vm.traversal = t;
@@ -88,13 +88,13 @@ static int traversal_next(Janet *x, Janet *y) {
             /* Node is a struct at index t->index: if t->index2 is true, we should return the values. */
             if (t->index2) {
                 t->index2 = 0;
-                int32_t index = t->index++;
+                size_t index = t->index++;
                 *x = sself->data[index].value;
                 *y = sother->data[index].value;
                 janet_vm.traversal = t;
                 return 0;
             }
-            for (int32_t i = t->index; i < sself->capacity; i++) {
+            for (size_t i = t->index; i < sself->capacity; i++) {
                 t->index2 = 1;
                 *x = sself->data[t->index].key;
                 *y = sother->data[t->index].key;
@@ -135,7 +135,7 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
         case JANET_TABLE:
         case JANET_STRUCT: {
             const JanetKV *start;
-            int32_t cap;
+            size_t cap;
             if (t == JANET_TABLE) {
                 JanetTable *tab = janet_unwrap_table(ds);
                 cap = tab->capacity;
@@ -161,7 +161,7 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
         case JANET_BUFFER:
         case JANET_ARRAY:
         case JANET_TUPLE: {
-            int32_t i;
+            size_t i;
             if (janet_checktype(key, JANET_NIL)) {
                 i = 0;
             } else if (janet_checkint(key)) {
@@ -169,7 +169,7 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
             } else {
                 break;
             }
-            int32_t len;
+            size_t len;
             if (t == JANET_BUFFER) {
                 len = janet_unwrap_buffer(ds)->count;
             } else if (t == JANET_ARRAY) {
@@ -179,8 +179,8 @@ Janet janet_next_impl(Janet ds, Janet key, int is_interpreter) {
             } else {
                 len = janet_string_length(janet_unwrap_string(ds));
             }
-            if (i < len && i >= 0) {
-                return janet_wrap_integer(i);
+            if (i < len) {
+                return janet_wrap_size(i);
             }
             break;
         }
@@ -423,8 +423,8 @@ int janet_compare(Janet x, Janet y) {
             case JANET_STRUCT: {
                 const JanetKV *lhs = janet_unwrap_struct(x);
                 const JanetKV *rhs = janet_unwrap_struct(y);
-                int32_t llen = janet_struct_capacity(lhs);
-                int32_t rlen = janet_struct_capacity(rhs);
+                size_t llen = janet_struct_capacity(lhs);
+                size_t rlen = janet_struct_capacity(rhs);
                 int32_t lhash = janet_struct_hash(lhs);
                 int32_t rhash = janet_struct_hash(rhs);
                 if (llen < rlen) return -1;
@@ -439,10 +439,9 @@ int janet_compare(Janet x, Janet y) {
     return status - 2;
 }
 
-static int32_t getter_checkint(JanetType type, Janet key, int32_t max) {
-    if (!janet_checkint(key)) goto bad;
-    int32_t ret = janet_unwrap_integer(key);
-    if (ret < 0) goto bad;
+static size_t getter_checksize(JanetType type, Janet key, size_t max) {
+    if (!janet_checksize(key)) goto bad;
+    size_t ret = janet_unwrap_size(key);
     if (ret >= max) goto bad;
     return ret;
 bad:
@@ -465,19 +464,19 @@ Janet janet_in(Janet ds, Janet key) {
             break;
         case JANET_ARRAY: {
             JanetArray *array = janet_unwrap_array(ds);
-            int32_t index = getter_checkint(type, key, array->count);
+            size_t index = getter_checksize(type, key, array->count);
             value = array->data[index];
             break;
         }
         case JANET_TUPLE: {
             const Janet *tuple = janet_unwrap_tuple(ds);
-            int32_t len = janet_tuple_length(tuple);
-            value = tuple[getter_checkint(type, key, len)];
+            size_t len = janet_tuple_length(tuple);
+            value = tuple[getter_checksize(type, key, len)];
             break;
         }
         case JANET_BUFFER: {
             JanetBuffer *buffer = janet_unwrap_buffer(ds);
-            int32_t index = getter_checkint(type, key, buffer->count);
+            size_t index = getter_checksize(type, key, buffer->count);
             value = janet_wrap_integer(buffer->data[index]);
             break;
         }
@@ -485,7 +484,7 @@ Janet janet_in(Janet ds, Janet key) {
         case JANET_SYMBOL:
         case JANET_KEYWORD: {
             const uint8_t *str = janet_unwrap_string(ds);
-            int32_t index = getter_checkint(type, key, janet_string_length(str));
+            size_t index = getter_checksize(type, key, janet_string_length(str));
             value = janet_wrap_integer(str[index]);
             break;
         }
@@ -519,9 +518,8 @@ Janet janet_get(Janet ds, Janet key) {
         case JANET_STRING:
         case JANET_SYMBOL:
         case JANET_KEYWORD: {
-            if (!janet_checkint(key)) return janet_wrap_nil();
-            int32_t index = janet_unwrap_integer(key);
-            if (index < 0) return janet_wrap_nil();
+            if (!janet_checksize(key)) return janet_wrap_nil();
+            size_t index = janet_unwrap_size(key);
             const uint8_t *str = janet_unwrap_string(ds);
             if (index >= janet_string_length(str)) return janet_wrap_nil();
             return janet_wrap_integer(str[index]);
@@ -539,8 +537,7 @@ Janet janet_get(Janet ds, Janet key) {
         case JANET_TUPLE:
         case JANET_BUFFER: {
             if (!janet_checkint(key)) return janet_wrap_nil();
-            int32_t index = janet_unwrap_integer(key);
-            if (index < 0) return janet_wrap_nil();
+            size_t index = janet_unwrap_size(key);
             if (t == JANET_ARRAY) {
                 JanetArray *a = janet_unwrap_array(ds);
                 if (index >= a->count) return janet_wrap_nil();
@@ -573,9 +570,8 @@ Janet janet_get(Janet ds, Janet key) {
     }
 }
 
-Janet janet_getindex(Janet ds, int32_t index) {
+Janet janet_getindex(Janet ds, size_t index) {
     Janet value;
-    if (index < 0) janet_panic("expected non-negative index");
     switch (janet_type(ds)) {
         default:
             janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, ds);
@@ -638,7 +634,7 @@ Janet janet_getindex(Janet ds, int32_t index) {
     return value;
 }
 
-int32_t janet_length(Janet x) {
+size_t janet_length(Janet x) {
     switch (janet_type(x)) {
         default:
             janet_panicf("expected %T, got %v", JANET_TFLAG_LENGTHABLE, x);
@@ -661,14 +657,14 @@ int32_t janet_length(Janet x) {
             const JanetAbstractType *type = janet_abstract_type(abst);
             if (type->length != NULL) {
                 size_t len = type->length(abst, janet_abstract_size(abst));
-                if (len > INT32_MAX) {
+                if (len > JANET_INTMAX_SIZE) {
                     janet_panicf("invalid integer length %u", len);
                 }
-                return (int32_t)(len);
+                return len;
             }
             Janet argv[1] = { x };
             Janet len = janet_mcall("length", 1, argv);
-            if (!janet_checkint(len))
+            if (!janet_checksize(len))
                 janet_panicf("invalid integer length %v", len);
             return janet_unwrap_integer(len);
         }
@@ -682,17 +678,17 @@ Janet janet_lengthv(Janet x) {
         case JANET_STRING:
         case JANET_SYMBOL:
         case JANET_KEYWORD:
-            return janet_wrap_integer(janet_string_length(janet_unwrap_string(x)));
+            return janet_wrap_size(janet_string_length(janet_unwrap_string(x)));
         case JANET_ARRAY:
-            return janet_wrap_integer(janet_unwrap_array(x)->count);
+            return janet_wrap_size(janet_unwrap_array(x)->count);
         case JANET_BUFFER:
-            return janet_wrap_integer(janet_unwrap_buffer(x)->count);
+            return janet_wrap_size(janet_unwrap_buffer(x)->count);
         case JANET_TUPLE:
-            return janet_wrap_integer(janet_tuple_length(janet_unwrap_tuple(x)));
+            return janet_wrap_size(janet_tuple_length(janet_unwrap_tuple(x)));
         case JANET_STRUCT:
-            return janet_wrap_integer(janet_struct_length(janet_unwrap_struct(x)));
+            return janet_wrap_size(janet_struct_length(janet_unwrap_struct(x)));
         case JANET_TABLE:
-            return janet_wrap_integer(janet_unwrap_table(x)->count);
+            return janet_wrap_size(janet_unwrap_table(x)->count);
         case JANET_ABSTRACT: {
             void *abst = janet_unwrap_abstract(x);
             const JanetAbstractType *type = janet_abstract_type(abst);
@@ -715,7 +711,7 @@ Janet janet_lengthv(Janet x) {
     }
 }
 
-void janet_putindex(Janet ds, int32_t index, Janet value) {
+void janet_putindex(Janet ds, size_t index, Janet value) {
     switch (janet_type(ds)) {
         default:
             janet_panicf("expected %T, got %v",
@@ -742,13 +738,13 @@ void janet_putindex(Janet ds, int32_t index, Janet value) {
         }
         case JANET_TABLE: {
             JanetTable *table = janet_unwrap_table(ds);
-            janet_table_put(table, janet_wrap_integer(index), value);
+            janet_table_put(table, janet_wrap_size(index), value);
             break;
         }
         case JANET_ABSTRACT: {
             JanetAbstractType *type = (JanetAbstractType *)janet_abstract_type(janet_unwrap_abstract(ds));
             if (type->put) {
-                (type->put)(janet_unwrap_abstract(ds), janet_wrap_integer(index), value);
+                (type->put)(janet_unwrap_abstract(ds), janet_wrap_size(index), value);
             } else {
                 janet_panicf("no setter for %v ", ds);
             }
@@ -765,7 +761,7 @@ void janet_put(Janet ds, Janet key, Janet value) {
                          JANET_TFLAG_ARRAY | JANET_TFLAG_BUFFER | JANET_TFLAG_TABLE, ds);
         case JANET_ARRAY: {
             JanetArray *array = janet_unwrap_array(ds);
-            int32_t index = getter_checkint(type, key, INT32_MAX - 1);
+            size_t index = getter_checksize(type, key, JANET_INTMAX_SIZE - 1);
             if (index >= array->count) {
                 janet_array_setcount(array, index + 1);
             }
@@ -774,7 +770,7 @@ void janet_put(Janet ds, Janet key, Janet value) {
         }
         case JANET_BUFFER: {
             JanetBuffer *buffer = janet_unwrap_buffer(ds);
-            int32_t index = getter_checkint(type, key, INT32_MAX - 1);
+            size_t index = getter_checksize(type, key, JANET_INTMAX_SIZE - 1);
             if (!janet_checkint(value))
                 janet_panicf("can only put integers in buffers, got %v", value);
             if (index >= buffer->count) {

src/core/vector.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/vector.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

src/core/vm.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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_atomic_load_relaxed(&janet_vm.auto_suspend)) { \
+    if ((COND) && janet_vm.auto_suspend) { \
         fiber->flags |= (JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP); \
         vm_return(JANET_SIGNAL_INTERRUPT, janet_wrap_nil()); \
     } \
@@ -318,7 +318,7 @@ static Janet janet_binop_call(const char *lmethod, const char *rmethod, Janet lh
         Janet lr = janet_method_lookup(rhs, rmethod);
         Janet argv[2] = { rhs, lhs };
         if (janet_checktype(lr, JANET_NIL)) {
-            janet_panicf("could not find method :%s for %v or :%s for %v",
+            janet_panicf("could not find method :%s for %v, or :%s for %v",
                          lmethod, lhs,
                          rmethod, rhs);
         }
@@ -798,14 +798,14 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     vm_pcnext();
 
     VM_OP(JOP_JUMP)
-    vm_maybe_auto_suspend(DS <= 0);
     pc += DS;
+    vm_maybe_auto_suspend(DS <= 0);
     vm_next();
 
     VM_OP(JOP_JUMP_IF)
     if (janet_truthy(stack[A])) {
-        vm_maybe_auto_suspend(ES <= 0);
         pc += ES;
+        vm_maybe_auto_suspend(ES <= 0);
     } else {
         pc++;
     }
@@ -815,15 +815,15 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     if (janet_truthy(stack[A])) {
         pc++;
     } else {
-        vm_maybe_auto_suspend(ES <= 0);
         pc += ES;
+        vm_maybe_auto_suspend(ES <= 0);
     }
     vm_next();
 
     VM_OP(JOP_JUMP_IF_NIL)
     if (janet_checktype(stack[A], JANET_NIL)) {
-        vm_maybe_auto_suspend(ES <= 0);
         pc += ES;
+        vm_maybe_auto_suspend(ES <= 0);
     } else {
         pc++;
     }
@@ -833,8 +833,8 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
     if (janet_checktype(stack[A], JANET_NIL)) {
         pc++;
     } else {
-        vm_maybe_auto_suspend(ES <= 0);
         pc += ES;
+        vm_maybe_auto_suspend(ES <= 0);
     }
     vm_next();
 
@@ -997,7 +997,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
 
     VM_OP(JOP_PUSH_ARRAY) {
         const Janet *vals;
-        int32_t len;
+        size_t len;
         if (janet_indexed_view(stack[D], &vals, &len)) {
             janet_fiber_pushn(fiber, vals, len);
         } else {
@@ -1268,7 +1268,7 @@ static JanetSignal run_vm(JanetFiber *fiber, Janet in) {
 /*
  * Execute a single instruction in the fiber. Does this by inspecting
  * the fiber, setting a breakpoint at the next instruction, executing, and
- * resetting breakpoints to how they were prior. Yes, it's a bit hacky.
+ * reseting breakpoints to how they were prior. Yes, it's a bit hacky.
  */
 JanetSignal janet_step(JanetFiber *fiber, Janet in, Janet *out) {
     /* No finished or currently alive fibers. */
@@ -1373,10 +1373,7 @@ Janet janet_call(JanetFunction *fun, int32_t argc, const Janet *argv) {
 
     /* Run vm */
     janet_vm.fiber->flags |= JANET_FIBER_RESUME_NO_USEVAL | JANET_FIBER_RESUME_NO_SKIP;
-    int old_coerce_error = janet_vm.coerce_error;
-    janet_vm.coerce_error = 1;
     JanetSignal signal = run_vm(janet_vm.fiber, janet_wrap_nil());
-    janet_vm.coerce_error = old_coerce_error;
 
     /* Teardown */
     janet_vm.stackn = oldn;
@@ -1387,15 +1384,6 @@ 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]));
-        }
         janet_panicv(*janet_vm.return_reg);
     }
 
@@ -1442,10 +1430,8 @@ void janet_try_init(JanetTryState *state) {
     state->vm_fiber = janet_vm.fiber;
     state->vm_jmp_buf = janet_vm.signal_buf;
     state->vm_return_reg = janet_vm.return_reg;
-    state->coerce_error = janet_vm.coerce_error;
     janet_vm.return_reg = &(state->payload);
     janet_vm.signal_buf = &(state->buf);
-    janet_vm.coerce_error = 0;
 }
 
 void janet_restore(JanetTryState *state) {
@@ -1454,7 +1440,6 @@ void janet_restore(JanetTryState *state) {
     janet_vm.fiber = state->vm_fiber;
     janet_vm.signal_buf = state->vm_jmp_buf;
     janet_vm.return_reg = state->vm_return_reg;
-    janet_vm.coerce_error = state->coerce_error;
 }
 
 static JanetSignal janet_continue_no_check(JanetFiber *fiber, Janet in, Janet *out) {
@@ -1628,7 +1613,7 @@ int janet_init(void) {
     janet_vm.registry_count = 0;
     janet_vm.registry_dirty = 0;
 
-    /* Initialize abstract registry */
+    /* Intialize abstract registry */
     janet_vm.abstract_registry = janet_table(0);
     janet_gcroot(janet_wrap_table(janet_vm.abstract_registry));
 

src/core/wrap.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -88,6 +88,12 @@ int (janet_unwrap_boolean)(Janet x) {
 int32_t (janet_unwrap_integer)(Janet x) {
     return janet_unwrap_integer(x);
 }
+size_t (janet_unwrap_size)(Janet x) {
+    return janet_unwrap_size(x);
+}
+ssize_t (janet_unwrap_ssize)(Janet x) {
+    return janet_unwrap_ssize(x);
+}
 
 #if defined(JANET_NANBOX_32) || defined(JANET_NANBOX_64)
 Janet(janet_wrap_nil)(void) {
@@ -144,6 +150,12 @@ Janet(janet_wrap_pointer)(void *x) {
 Janet(janet_wrap_integer)(int32_t x) {
     return janet_wrap_integer(x);
 }
+Janet(janet_wrap_size)(size_t x) {
+    return janet_wrap_size(x);
+}
+Janet(janet_wrap_ssize)(ssize_t x) {
+    return janet_wrap_ssize(x);
+}
 #endif
 
 #ifndef JANET_NANBOX_32
@@ -160,10 +172,10 @@ Janet(janet_wrap_number)(double x) {
 
 /*****/
 
-void *janet_memalloc_empty(int32_t count) {
-    int32_t i;
-    void *mem = janet_malloc((size_t) count * sizeof(JanetKV));
-    janet_vm.next_collection += (size_t) count * sizeof(JanetKV);
+void *janet_memalloc_empty(size_t count) {
+    size_t i;
+    void *mem = janet_malloc(count * sizeof(JanetKV));
+    janet_vm.next_collection += count * sizeof(JanetKV);
     if (NULL == mem) {
         JANET_OUT_OF_MEMORY;
     }
@@ -176,8 +188,8 @@ void *janet_memalloc_empty(int32_t count) {
     return mem;
 }
 
-void janet_memempty(JanetKV *mem, int32_t count) {
-    int32_t i;
+void janet_memempty(JanetKV *mem, size_t count) {
+    size_t i;
     for (i = 0; i < count; i++) {
         mem[i].key = janet_wrap_nil();
         mem[i].value = janet_wrap_nil();

src/include/janet.h

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -46,7 +46,7 @@ extern "C" {
 #endif
 
 /*
- * Detect OS and endianness.
+ * Detect OS and endianess.
  * From webkit source. There is likely some extreneous
  * detection for unsupported platforms
  */
@@ -67,21 +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
 #endif
 
-/* Check for Illumos */
-#if defined(__illumos__)
-#define JANET_ILLUMOS 1
-#endif
-
 /* Check Unix */
 #if defined(_AIX) \
     || defined(__APPLE__) /* Darwin */ \
@@ -122,8 +112,7 @@ extern "C" {
     || defined(__s390x__) /* S390 64-bit (BE) */ \
     || (defined(__ppc64__) || defined(__PPC64__)) \
     || defined(__aarch64__) /* ARM 64-bit */ \
-    || (defined(__riscv) && (__riscv_xlen == 64)) /* RISC-V 64-bit */ \
-    || defined(__loongarch64) /* LoongArch64 64-bit */
+    || (defined(__riscv) && (__riscv_xlen == 64)) /* RISC-V 64-bit */
 #define JANET_64 1
 #else
 #define JANET_32 1
@@ -147,7 +136,6 @@ extern "C" {
     || defined(__s390x__) /* S390 64-bit */ \
     || defined(__s390__)  /* S390 32-bit */ \
     || defined(__ARMEB__) /* ARM big endian */ \
-    || defined(__AARCH64EB__) /* ARM64 big endian */ \
     || ((defined(__CC_ARM) || defined(__ARMCC__)) /* ARM RealView compiler */ \
         && defined(__BIG_ENDIAN))
 #define JANET_BIG_ENDIAN 1
@@ -155,12 +143,6 @@ extern "C" {
 #define JANET_LITTLE_ENDIAN 1
 #endif
 
-/* Limits for converting doubles to 64 bit integers */
-#define JANET_INTMAX_DOUBLE 9007199254740992.0
-#define JANET_INTMIN_DOUBLE (-9007199254740992.0)
-#define JANET_INTMAX_INT64 9007199254740992
-#define JANET_INTMIN_INT64 (-9007199254740992)
-
 /* Check emscripten */
 #ifdef __EMSCRIPTEN__
 #define JANET_NO_DYNAMIC_MODULES
@@ -168,7 +150,7 @@ extern "C" {
 #endif
 
 /* Check sun */
-#if defined(__sun) && !defined(JANET_ILLUMOS)
+#ifdef __sun
 #define JANET_NO_UTC_MKTIME
 #endif
 
@@ -176,12 +158,14 @@ extern "C" {
 /* Also enable the thread library only if not single-threaded */
 #ifdef JANET_SINGLE_THREADED
 #define JANET_THREAD_LOCAL
-#elif !(defined(JANET_THREAD_LOCAL)) && defined(__GNUC__)
+#undef JANET_THREADS
+#elif defined(__GNUC__)
 #define JANET_THREAD_LOCAL __thread
-#elif !(defined(JANET_THREAD_LOCAL)) && defined(_MSC_BUILD)
+#elif defined(_MSC_BUILD)
 #define JANET_THREAD_LOCAL __declspec(thread)
-#elif !(defined(JANET_THREAD_LOCAL))
+#else
 #define JANET_THREAD_LOCAL
+#undef JANET_THREADS
 #endif
 
 /* Enable or disable dynamic module loading. Enabled by default. */
@@ -219,11 +203,6 @@ extern "C" {
 #define JANET_EV
 #endif
 
-/* Enable or disable the filewatch/ module */
-#if !defined(JANET_NO_FILEWATCH)
-#define JANET_FILEWATCH
-#endif
-
 /* Enable or disable networking */
 #if defined(JANET_EV) && !defined(JANET_NO_NET) && !defined(__EMSCRIPTEN__)
 #define JANET_NET
@@ -276,7 +255,7 @@ extern "C" {
 #endif
 #endif
 
-/* Tell compiler some functions don't return */
+/* Tell complier some functions don't return */
 #ifndef JANET_NO_RETURN
 #ifdef JANET_WINDOWS
 #define JANET_NO_RETURN __declspec(noreturn)
@@ -286,7 +265,7 @@ extern "C" {
 #endif
 
 /* Prevent some recursive functions from recursing too deeply
- * and crashing (the parser). Instead, error out. */
+ * ands crashing (the parser). Instead, error out. */
 #define JANET_RECURSION_GUARD 1024
 
 /* Maximum depth to follow table prototypes before giving up and returning nil. */
@@ -368,7 +347,6 @@ typedef struct {
 #ifdef JANET_EV
 typedef struct JanetOSMutex JanetOSMutex;
 typedef struct JanetOSRWLock JanetOSRWLock;
-typedef struct JanetChannel JanetChannel;
 #endif
 
 /***** END SECTION CONFIG *****/
@@ -388,6 +366,26 @@ typedef struct JanetChannel JanetChannel;
 #include <stddef.h>
 #include <stdio.h>
 
+/* Limits for converting doubles to 64 bit integers */
+#define JANET_INTMAX_DOUBLE 9007199254740992.0
+#define JANET_INTMIN_DOUBLE (-9007199254740992.0)
+#define JANET_INTMAX_INT64 9007199254740992
+#define JANET_INTMIN_INT64 (-9007199254740992)
+#if defined(JANET_64)
+    #define JANET_INTMAX_SIZE JANET_INTMAX_INT64
+    #define JANET_INTMIN_SIZE JANET_INTMIN_INT64
+#else
+    #define JANET_INTMAX_SIZE INT32_MAX
+    #define JANET_INTMIN_SIZE INT32_MIN
+#endif
+
+/* signed size */
+#ifdef _SSIZE_T
+typedef ssize_t ssize_t;
+#else
+typedef ptrdiff_t ssize_t;
+#endif
+
 /* What to do when out of memory */
 #ifndef JANET_OUT_OF_MEMORY
 #define JANET_OUT_OF_MEMORY do { fprintf(stderr, "%s:%d - janet out of memory\n", __FILE__, __LINE__); exit(1); } while (0)
@@ -600,7 +598,6 @@ 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 {
@@ -643,9 +640,7 @@ typedef void (*JanetEVCallback)(JanetFiber *fiber, JanetAsyncEvent event);
  * call when ever an event is sent from the event loop. state is an optional (can be NULL)
  * pointer to data allocated with janet_malloc. This pointer will be passed to callback as
  * fiber->ev_state. It will also be freed for you by the runtime when the event loop determines
- * it can no longer be referenced. On windows, the contents of state MUST contained an OVERLAPPED struct at the 0 offset. */
-
-JANET_API void janet_async_start_fiber(JanetFiber *fiber, JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state);
+ * it can no longer be referenced. On windows, the contents of state MUST contained an OVERLAPPED struct. */
 JANET_API JANET_NO_RETURN void janet_async_start(JanetStream *stream, JanetAsyncMode mode, JanetEVCallback callback, void *state);
 
 /* Do not send any more events to the given callback. Call this after scheduling fiber to be resume
@@ -655,12 +650,6 @@ JANET_API void janet_async_end(JanetFiber *fiber);
 /* Needed for windows to mark a fiber as waiting for an IOCP completion event. Noop on other platforms. */
 JANET_API void janet_async_in_flight(JanetFiber *fiber);
 
-/* On some platforms, it is important to be able to control if a stream is edge-trigger or level triggered.
- * For example, a server that is accepting connections might want to be level triggered or edge-triggered
- * depending on expected service. */
-JANET_API void janet_stream_edge_triggered(JanetStream *stream);
-JANET_API void janet_stream_level_triggered(JanetStream *stream);
-
 #endif
 
 /* Janet uses atomic integers in several places for synchronization between threads and
@@ -673,7 +662,6 @@ 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
@@ -729,6 +717,8 @@ JANET_API JanetCFunction janet_unwrap_cfunction(Janet x);
 JANET_API int janet_unwrap_boolean(Janet x);
 JANET_API double janet_unwrap_number(Janet x);
 JANET_API int32_t janet_unwrap_integer(Janet x);
+JANET_API size_t janet_unwrap_size(Janet x);
+JANET_API ssize_t janet_unwrap_ssize(Janet x);
 
 JANET_API Janet janet_wrap_nil(void);
 JANET_API Janet janet_wrap_number(double x);
@@ -749,6 +739,8 @@ JANET_API Janet janet_wrap_table(JanetTable *x);
 JANET_API Janet janet_wrap_abstract(JanetAbstract x);
 JANET_API Janet janet_wrap_pointer(void *x);
 JANET_API Janet janet_wrap_integer(int32_t x);
+JANET_API Janet janet_wrap_size(size_t x);
+JANET_API Janet janet_wrap_ssize(ssize_t x);
 
 /***** END SECTION NON-C API *****/
 
@@ -916,22 +908,25 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 /* End of tagged union implementation */
 #endif
 
-JANET_API int janet_checkint16(Janet x);
-JANET_API int janet_checkuint16(Janet x);
 JANET_API int janet_checkint(Janet x);
 JANET_API int janet_checkuint(Janet x);
 JANET_API int janet_checkint64(Janet x);
 JANET_API int janet_checkuint64(Janet x);
 JANET_API int janet_checksize(Janet x);
+JANET_API int janet_checkssize(Janet x);
 JANET_API JanetAbstract janet_checkabstract(Janet x, const JanetAbstractType *at);
-#define janet_checkint16range(x) ((x) >= INT16_MIN && (x) <= INT16_MAX && (x) == (int16_t)(x))
-#define janet_checkuint16range(x) ((x) >= 0 && (x) <= UINT16_MAX && (x) == (uint16_t)(x))
 #define janet_checkintrange(x) ((x) >= INT32_MIN && (x) <= INT32_MAX && (x) == (int32_t)(x))
 #define janet_checkuintrange(x) ((x) >= 0 && (x) <= UINT32_MAX && (x) == (uint32_t)(x))
 #define janet_checkint64range(x) ((x) >= JANET_INTMIN_DOUBLE && (x) <= JANET_INTMAX_DOUBLE && (x) == (int64_t)(x))
 #define janet_checkuint64range(x) ((x) >= 0 && (x) <= JANET_INTMAX_DOUBLE && (x) == (uint64_t)(x))
+#define janet_checksizerange(x) ((x) >= 0 && (x) <= JANET_INTMAX_SIZE && (x) == (size_t)(x))
+#define janet_checkssizerange(x) ((x) >= JANET_INTMIN_SIZE && (x) <= JANET_INTMAX_SIZE && (x) == (ssize_t)(x))
 #define janet_unwrap_integer(x) ((int32_t) janet_unwrap_number(x))
 #define janet_wrap_integer(x) janet_wrap_number((int32_t)(x))
+#define janet_unwrap_size(x) ((size_t) janet_unwrap_number(x))
+#define janet_wrap_size(x) janet_wrap_number((size_t)(x))
+#define janet_unwrap_ssize(x) ((ssize_t) janet_unwrap_number(x))
+#define janet_wrap_ssize(x) janet_wrap_number((ssize_t)(x))
 
 #define janet_checktypes(x, tps) ((1 << janet_type(x)) & (tps))
 
@@ -995,25 +990,25 @@ struct JanetStackFrame {
 /* A dynamic array type. */
 struct JanetArray {
     JanetGCObject gc;
-    int32_t count;
-    int32_t capacity;
+    size_t count;
+    size_t capacity;
     Janet *data;
 };
 
 /* A byte buffer type. Used as a mutable string or string builder. */
 struct JanetBuffer {
     JanetGCObject gc;
-    int32_t count;
-    int32_t capacity;
+    size_t count;
+    size_t capacity;
     uint8_t *data;
 };
 
 /* A mutable associative data type. Backed by a hashtable. */
 struct JanetTable {
     JanetGCObject gc;
-    int32_t count;
-    int32_t capacity;
-    int32_t deleted;
+    size_t count;
+    size_t capacity;
+    size_t deleted;
     JanetKV *data;
     JanetTable *proto;
 };
@@ -1027,7 +1022,7 @@ struct JanetKV {
 /* Prefix for a tuple */
 struct JanetTupleHead {
     JanetGCObject gc;
-    int32_t length;
+    size_t length;
     int32_t hash;
     int32_t sm_line;
     int32_t sm_column;
@@ -1037,9 +1032,9 @@ struct JanetTupleHead {
 /* Prefix for a struct */
 struct JanetStructHead {
     JanetGCObject gc;
-    int32_t length;
+    size_t length;
     int32_t hash;
-    int32_t capacity;
+    size_t capacity;
     const JanetKV *proto;
     const JanetKV data[];
 };
@@ -1047,7 +1042,7 @@ struct JanetStructHead {
 /* Prefix for a string */
 struct JanetStringHead {
     JanetGCObject gc;
-    int32_t length;
+    size_t length;
     int32_t hash;
     const uint8_t data[];
 };
@@ -1189,7 +1184,6 @@ 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
@@ -1209,8 +1203,7 @@ 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       NULL,JANET_ATEND_GCPERTHREAD
-#define JANET_ATEND_GCPERTHREAD
+#define JANET_ATEND_BYTES
 
 struct JanetReg {
     const char *name;
@@ -1233,23 +1226,23 @@ struct JanetMethod {
 
 struct JanetView {
     const Janet *items;
-    int32_t len;
+    size_t len;
 };
 
 struct JanetByteView {
     const uint8_t *bytes;
-    int32_t len;
+    size_t len;
 };
 
 struct JanetDictView {
     const JanetKV *kvs;
-    int32_t len;
-    int32_t cap;
+    size_t len;
+    size_t cap;
 };
 
 struct JanetRange {
-    int32_t start;
-    int32_t end;
+    size_t start;
+    size_t end;
 };
 
 struct JanetRNG {
@@ -1274,7 +1267,6 @@ typedef struct {
     /* new state */
     jmp_buf buf;
     Janet payload;
-    int coerce_error;
 } JanetTryState;
 
 /***** END SECTION TYPES *****/
@@ -1435,7 +1427,6 @@ JANET_API void janet_loop1_interrupt(JanetVM *vm);
 
 /* Wrapper around streams */
 JANET_API JanetStream *janet_stream(JanetHandle handle, uint32_t flags, const JanetMethod *methods);
-JANET_API JanetStream *janet_stream_ext(JanetHandle handle, uint32_t flags, const JanetMethod *methods, size_t size); /* Allow for type punning streams */
 JANET_API void janet_stream_close(JanetStream *stream);
 JANET_API Janet janet_cfun_stream_close(int32_t argc, Janet *argv);
 JANET_API Janet janet_cfun_stream_read(int32_t argc, Janet *argv);
@@ -1456,7 +1447,6 @@ JANET_NO_RETURN JANET_API void janet_sleep_await(double sec);
 /* For use inside listeners - adds a timeout to the current fiber, such that
  * it will be resumed after sec seconds if no other event schedules the current fiber. */
 JANET_API void janet_addtimeout(double sec);
-JANET_API void janet_addtimeout_nil(double sec);
 JANET_API void janet_ev_inc_refcount(void);
 JANET_API void janet_ev_dec_refcount(void);
 
@@ -1467,14 +1457,6 @@ JANET_API void *janet_abstract_threaded(const JanetAbstractType *atype, size_t s
 JANET_API int32_t janet_abstract_incref(void *abst);
 JANET_API int32_t janet_abstract_decref(void *abst);
 
-/* Expose channel utilities */
-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);
-
 /* Expose some OS sync primitives */
 JANET_API size_t janet_os_mutex_size(void);
 JANET_API size_t janet_os_rwlock_size(void);
@@ -1619,23 +1601,17 @@ 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_dobytes(JanetTable *env, const uint8_t *bytes, size_t len, const char *sourcePath, Janet *out);
 JANET_API int janet_dostring(JanetTable *env, const char *str, const char *sourcePath, Janet *out);
 
 /* Run the entrypoint of a wrapped program */
 JANET_API int janet_loop_fiber(JanetFiber *fiber);
 
 /* Number scanning */
-JANET_API int janet_scan_number(const uint8_t *str, int32_t len, double *out);
-JANET_API int janet_scan_number_base(const uint8_t *str, int32_t len, int32_t base, double *out);
-JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out);
-JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);
-#ifdef JANET_INT_TYPES
-JANET_API int janet_scan_numeric(const uint8_t *str, int32_t len, Janet *out);
-#endif
+JANET_API int janet_scan_number(const uint8_t *str, size_t len, double *out);
+JANET_API int janet_scan_number_base(const uint8_t *str, size_t len, int32_t base, double *out);
+JANET_API int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out);
+JANET_API int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out);
 
 /* Debugging */
 JANET_API void janet_debug_break(JanetFuncDef *def, int32_t pc);
@@ -1648,30 +1624,30 @@ JANET_API void janet_debug_find(
 extern JANET_API const JanetAbstractType janet_rng_type;
 JANET_API JanetRNG *janet_default_rng(void);
 JANET_API void janet_rng_seed(JanetRNG *rng, uint32_t seed);
-JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, int32_t len);
+JANET_API void janet_rng_longseed(JanetRNG *rng, const uint8_t *bytes, size_t len);
 JANET_API uint32_t janet_rng_u32(JanetRNG *rng);
 JANET_API double janet_rng_double(JanetRNG *rng);
 
 /* Array functions */
-JANET_API JanetArray *janet_array(int32_t capacity);
-JANET_API JanetArray *janet_array_weak(int32_t capacity);
-JANET_API JanetArray *janet_array_n(const Janet *elements, int32_t n);
-JANET_API void janet_array_ensure(JanetArray *array, int32_t capacity, int32_t growth);
-JANET_API void janet_array_setcount(JanetArray *array, int32_t count);
+JANET_API JanetArray *janet_array(size_t capacity);
+JANET_API JanetArray *janet_array_weak(size_t capacity);
+JANET_API JanetArray *janet_array_n(const Janet *elements, size_t n);
+JANET_API void janet_array_ensure(JanetArray *array, size_t capacity, size_t growth);
+JANET_API void janet_array_setcount(JanetArray *array, size_t count);
 JANET_API void janet_array_push(JanetArray *array, Janet x);
 JANET_API Janet janet_array_pop(JanetArray *array);
 JANET_API Janet janet_array_peek(JanetArray *array);
 
 /* Buffer functions */
 #define JANET_BUFFER_FLAG_NO_REALLOC 0x10000
-JANET_API JanetBuffer *janet_buffer(int32_t capacity);
-JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, int32_t capacity);
-JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, int32_t capacity, int32_t count);
+JANET_API JanetBuffer *janet_buffer(size_t capacity);
+JANET_API JanetBuffer *janet_buffer_init(JanetBuffer *buffer, size_t capacity);
+JANET_API JanetBuffer *janet_pointer_buffer_unsafe(void *memory, size_t capacity, size_t count);
 JANET_API void janet_buffer_deinit(JanetBuffer *buffer);
-JANET_API void janet_buffer_ensure(JanetBuffer *buffer, int32_t capacity, int32_t growth);
-JANET_API void janet_buffer_setcount(JanetBuffer *buffer, int32_t count);
-JANET_API void janet_buffer_extra(JanetBuffer *buffer, int32_t n);
-JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, int32_t len);
+JANET_API void janet_buffer_ensure(JanetBuffer *buffer, size_t capacity, size_t growth);
+JANET_API void janet_buffer_setcount(JanetBuffer *buffer, size_t count);
+JANET_API void janet_buffer_extra(JanetBuffer *buffer, size_t n);
+JANET_API void janet_buffer_push_bytes(JanetBuffer *buffer, const uint8_t *string, size_t len);
 JANET_API void janet_buffer_push_string(JanetBuffer *buffer, JanetString string);
 JANET_API void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring);
 JANET_API void janet_buffer_push_u8(JanetBuffer *buffer, uint8_t x);
@@ -1690,21 +1666,21 @@ JANET_API void janet_buffer_push_u64(JanetBuffer *buffer, uint64_t x);
 #define janet_tuple_sm_line(t) (janet_tuple_head(t)->sm_line)
 #define janet_tuple_sm_column(t) (janet_tuple_head(t)->sm_column)
 #define janet_tuple_flag(t) (janet_tuple_head(t)->gc.flags)
-JANET_API Janet *janet_tuple_begin(int32_t length);
+JANET_API Janet *janet_tuple_begin(size_t length);
 JANET_API JanetTuple janet_tuple_end(Janet *tuple);
-JANET_API JanetTuple janet_tuple_n(const Janet *values, int32_t n);
+JANET_API JanetTuple janet_tuple_n(const Janet *values, size_t n);
 
 /* String/Symbol functions */
 #define janet_string_head(s) ((JanetStringHead *)((char *)s - offsetof(JanetStringHead, data)))
 #define janet_string_length(s) (janet_string_head(s)->length)
 #define janet_string_hash(s) (janet_string_head(s)->hash)
-JANET_API uint8_t *janet_string_begin(int32_t length);
+JANET_API uint8_t *janet_string_begin(size_t length);
 JANET_API JanetString janet_string_end(uint8_t *str);
-JANET_API JanetString janet_string(const uint8_t *buf, int32_t len);
+JANET_API JanetString janet_string(const uint8_t *buf, size_t len);
 JANET_API JanetString janet_cstring(const char *cstring);
 JANET_API int janet_string_compare(JanetString lhs, JanetString rhs);
 JANET_API int janet_string_equal(JanetString lhs, JanetString rhs);
-JANET_API int janet_string_equalconst(JanetString lhs, const uint8_t *rhs, int32_t rlen, int32_t rhash);
+JANET_API int janet_string_equalconst(JanetString lhs, const uint8_t *rhs, size_t rlen, int32_t rhash);
 JANET_API JanetString janet_description(Janet x);
 JANET_API JanetString janet_to_string(Janet x);
 JANET_API void janet_to_string_b(JanetBuffer *buffer, Janet x);
@@ -1716,7 +1692,7 @@ JANET_API JanetBuffer *janet_formatb(JanetBuffer *bufp, const char *format, ...)
 JANET_API void janet_formatbv(JanetBuffer *bufp, const char *format, va_list args);
 
 /* Symbol functions */
-JANET_API JanetSymbol janet_symbol(const uint8_t *str, int32_t len);
+JANET_API JanetSymbol janet_symbol(const uint8_t *str, size_t len);
 JANET_API JanetSymbol janet_csymbol(const char *str);
 JANET_API JanetSymbol janet_symbol_gen(void);
 #define janet_symbolv(str, len) janet_wrap_symbol(janet_symbol((str), (len)))
@@ -1735,7 +1711,7 @@ JANET_API JanetSymbol janet_symbol_gen(void);
 #define janet_struct_capacity(t) (janet_struct_head(t)->capacity)
 #define janet_struct_hash(t) (janet_struct_head(t)->hash)
 #define janet_struct_proto(t) (janet_struct_head(t)->proto)
-JANET_API JanetKV *janet_struct_begin(int32_t count);
+JANET_API JanetKV *janet_struct_begin(size_t count);
 JANET_API void janet_struct_put(JanetKV *st, Janet key, Janet value);
 JANET_API JanetStruct janet_struct_end(JanetKV *st);
 JANET_API Janet janet_struct_get(JanetStruct st, Janet key);
@@ -1745,9 +1721,9 @@ JANET_API JanetTable *janet_struct_to_table(JanetStruct st);
 JANET_API const JanetKV *janet_struct_find(JanetStruct st, Janet key);
 
 /* Table functions */
-JANET_API JanetTable *janet_table(int32_t capacity);
-JANET_API JanetTable *janet_table_init(JanetTable *table, int32_t capacity);
-JANET_API JanetTable *janet_table_init_raw(JanetTable *table, int32_t capacity);
+JANET_API JanetTable *janet_table(size_t capacity);
+JANET_API JanetTable *janet_table_init(JanetTable *table, size_t capacity);
+JANET_API JanetTable *janet_table_init_raw(JanetTable *table, size_t capacity);
 JANET_API void janet_table_deinit(JanetTable *table);
 JANET_API Janet janet_table_get(JanetTable *t, Janet key);
 JANET_API Janet janet_table_get_ex(JanetTable *t, Janet key, JanetTable **which);
@@ -1760,9 +1736,6 @@ JANET_API void janet_table_merge_struct(JanetTable *table, JanetStruct other);
 JANET_API JanetKV *janet_table_find(JanetTable *t, Janet key);
 JANET_API JanetTable *janet_table_clone(JanetTable *table);
 JANET_API void janet_table_clear(JanetTable *table);
-JANET_API JanetTable *janet_table_weakk(int32_t capacity);
-JANET_API JanetTable *janet_table_weakv(int32_t capacity);
-JANET_API JanetTable *janet_table_weakkv(int32_t capacity);
 
 /* Fiber */
 JANET_API JanetFiber *janet_fiber(JanetFunction *callee, int32_t capacity, int32_t argc, const Janet *argv);
@@ -1773,11 +1746,11 @@ JANET_API JanetFiber *janet_current_fiber(void);
 JANET_API JanetFiber *janet_root_fiber(void);
 
 /* Treat similar types through uniform interfaces for iteration */
-JANET_API int janet_indexed_view(Janet seq, const Janet **data, int32_t *len);
-JANET_API int janet_bytes_view(Janet str, const uint8_t **data, int32_t *len);
-JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, int32_t *len, int32_t *cap);
-JANET_API Janet janet_dictionary_get(const JanetKV *data, int32_t cap, Janet key);
-JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, int32_t cap, const JanetKV *kv);
+JANET_API int janet_indexed_view(Janet seq, const Janet **data, size_t *len);
+JANET_API int janet_bytes_view(Janet str, const uint8_t **data, size_t *len);
+JANET_API int janet_dictionary_view(Janet tab, const JanetKV **data, size_t *len, size_t *cap);
+JANET_API Janet janet_dictionary_get(const JanetKV *data, size_t cap, Janet key);
+JANET_API const JanetKV *janet_dictionary_next(const JanetKV *kvs, size_t cap, const JanetKV *kv);
 
 /* Abstract */
 #define janet_abstract_head(u) ((JanetAbstractHead *)((char *)u - offsetof(JanetAbstractHead, data)))
@@ -1826,7 +1799,6 @@ JANET_API void janet_gcpressure(size_t s);
 /* Functions */
 JANET_API JanetFuncDef *janet_funcdef_alloc(void);
 JANET_API JanetFunction *janet_thunk(JanetFuncDef *def);
-JANET_API JanetFunction *janet_thunk_delay(Janet x);
 JANET_API int janet_verify(JanetFuncDef *def);
 
 /* Pretty printing */
@@ -1854,17 +1826,17 @@ JANET_API int janet_cstrcmp(JanetString str, const char *other);
 JANET_API Janet janet_in(Janet ds, Janet key);
 JANET_API Janet janet_get(Janet ds, Janet key);
 JANET_API Janet janet_next(Janet ds, Janet key);
-JANET_API Janet janet_getindex(Janet ds, int32_t index);
-JANET_API int32_t janet_length(Janet x);
+JANET_API Janet janet_getindex(Janet ds, size_t index);
+JANET_API size_t janet_length(Janet x);
 JANET_API Janet janet_lengthv(Janet x);
 JANET_API void janet_put(Janet ds, Janet key, Janet value);
-JANET_API void janet_putindex(Janet ds, int32_t index, Janet value);
+JANET_API void janet_putindex(Janet ds, size_t index, Janet value);
 #define janet_flag_at(F, I) ((F) & ((1ULL) << (I)))
 JANET_API Janet janet_wrap_number_safe(double x);
 JANET_API int janet_keyeq(Janet x, const char *cstring);
 JANET_API int janet_streq(Janet x, const char *cstring);
 JANET_API int janet_symeq(Janet x, const char *cstring);
-JANET_API int32_t janet_sorted_keys(const JanetKV *dict, int32_t cap, int32_t *index_buffer);
+JANET_API int32_t janet_sorted_keys(const JanetKV *dict, size_t cap, int32_t *index_buffer);
 
 /* VM functions */
 JANET_API int janet_init(void);
@@ -1900,7 +1872,6 @@ JANET_API void janet_stacktrace_ext(JanetFiber *fiber, Janet err, const char *pr
 #define JANET_SANDBOX_FFI_USE 2048
 #define JANET_SANDBOX_FFI_JIT 4096
 #define JANET_SANDBOX_SIGNAL 8192
-#define JANET_SANDBOX_CHROOT 16384
 #define JANET_SANDBOX_FFI (JANET_SANDBOX_FFI_DEFINE | JANET_SANDBOX_FFI_USE | JANET_SANDBOX_FFI_JIT)
 #define JANET_SANDBOX_FS (JANET_SANDBOX_FS_WRITE | JANET_SANDBOX_FS_READ | JANET_SANDBOX_FS_TEMP)
 #define JANET_SANDBOX_NET (JANET_SANDBOX_NET_CONNECT | JANET_SANDBOX_NET_LISTEN)
@@ -2067,21 +2038,19 @@ JANET_API void *janet_getpointer(const Janet *argv, int32_t n);
 
 JANET_API int32_t janet_getnat(const Janet *argv, int32_t n);
 JANET_API int32_t janet_getinteger(const Janet *argv, int32_t n);
-JANET_API int16_t janet_getinteger16(const Janet *argv, int32_t n);
 JANET_API int64_t janet_getinteger64(const Janet *argv, int32_t n);
-JANET_API uint32_t janet_getuinteger(const Janet *argv, int32_t n);
-JANET_API uint16_t janet_getuinteger16(const Janet *argv, int32_t n);
 JANET_API uint64_t janet_getuinteger64(const Janet *argv, int32_t n);
 JANET_API size_t janet_getsize(const Janet *argv, int32_t n);
+JANET_API ssize_t janet_getssize(const Janet *argv, int32_t n);
 JANET_API JanetView janet_getindexed(const Janet *argv, int32_t n);
 JANET_API JanetByteView janet_getbytes(const Janet *argv, int32_t n);
 JANET_API JanetDictView janet_getdictionary(const Janet *argv, int32_t n);
 JANET_API void *janet_getabstract(const Janet *argv, int32_t n, const JanetAbstractType *at);
 JANET_API JanetRange janet_getslice(int32_t argc, const Janet *argv);
-JANET_API int32_t janet_gethalfrange(const Janet *argv, int32_t n, int32_t length, const char *which);
-JANET_API int32_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, int32_t length);
-JANET_API int32_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, int32_t length);
-JANET_API int32_t janet_getargindex(const Janet *argv, int32_t n, int32_t length, const char *which);
+JANET_API size_t janet_gethalfrange(const Janet *argv, int32_t n, size_t length, const char *which);
+JANET_API size_t janet_getstartrange(const Janet *argv, int32_t argc, int32_t n, size_t length);
+JANET_API size_t janet_getendrange(const Janet *argv, int32_t argc, int32_t n, size_t length);
+JANET_API size_t janet_getargindex(const Janet *argv, int32_t n, size_t length, const char *which);
 JANET_API uint64_t janet_getflags(const Janet *argv, int32_t n, const char *flags);
 
 /* Optionals */
@@ -2102,12 +2071,13 @@ JANET_API int32_t janet_optnat(const Janet *argv, int32_t argc, int32_t n, int32
 JANET_API int32_t janet_optinteger(const Janet *argv, int32_t argc, int32_t n, int32_t dflt);
 JANET_API int64_t janet_optinteger64(const Janet *argv, int32_t argc, int32_t n, int64_t dflt);
 JANET_API size_t janet_optsize(const Janet *argv, int32_t argc, int32_t n, size_t dflt);
+JANET_API ssize_t janet_optssize(const Janet *argv, int32_t argc, int32_t n, ssize_t dflt);
 JANET_API JanetAbstract janet_optabstract(const Janet *argv, int32_t argc, int32_t n, const JanetAbstractType *at, JanetAbstract dflt);
 
 /* Mutable optional types specify a size default, and construct a new value if none is provided */
-JANET_API JanetBuffer *janet_optbuffer(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
-JANET_API JanetTable *janet_opttable(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
-JANET_API JanetArray *janet_optarray(const Janet *argv, int32_t argc, int32_t n, int32_t dflt_len);
+JANET_API JanetBuffer *janet_optbuffer(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len);
+JANET_API JanetTable *janet_opttable(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len);
+JANET_API JanetArray *janet_optarray(const Janet *argv, int32_t argc, int32_t n, size_t dflt_len);
 
 JANET_API Janet janet_dyn(const char *name);
 JANET_API void janet_setdyn(const char *name, Janet value);
@@ -2193,16 +2163,13 @@ typedef enum {
     RULE_TO,           /* [rule] */
     RULE_THRU,         /* [rule] */
     RULE_LENPREFIX,    /* [rule_a, rule_b (repeat rule_b rule_a times)] */
-    RULE_READINT,      /* [(signedness << 4) | (endianness << 5) | bytewidth, tag] */
+    RULE_READINT,      /* [(signedness << 4) | (endianess << 5) | bytewidth, tag] */
     RULE_LINE,         /* [tag] */
     RULE_COLUMN,       /* [tag] */
     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] */
+    RULE_SPLIT         /* [rule, rule] */
 } JanetPegOpcod;
 
 typedef struct {
@@ -2231,8 +2198,8 @@ JANET_API Janet janet_wrap_s64(int64_t x);
 JANET_API Janet janet_wrap_u64(uint64_t x);
 JANET_API int64_t janet_unwrap_s64(Janet x);
 JANET_API uint64_t janet_unwrap_u64(Janet x);
-JANET_API int janet_scan_int64(const uint8_t *str, int32_t len, int64_t *out);
-JANET_API int janet_scan_uint64(const uint8_t *str, int32_t len, uint64_t *out);
+JANET_API int janet_scan_int64(const uint8_t *str, size_t len, int64_t *out);
+JANET_API int janet_scan_uint64(const uint8_t *str, size_t len, uint64_t *out);
 
 #endif
 

src/mainclient/shell.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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
@@ -626,7 +626,7 @@ static JanetByteView longest_common_prefix(void) {
         bv = gbl_matches[0];
         for (int i = 0; i < gbl_match_count; i++) {
             JanetByteView other = gbl_matches[i];
-            int32_t minlen = other.len < bv.len ? other.len : bv.len;
+            size_t minlen = other.len < bv.len ? other.len : bv.len;
             for (bv.len = 0; bv.len < minlen; bv.len++) {
                 if (bv.bytes[bv.len] != other.bytes[bv.len]) {
                     break;
@@ -691,7 +691,7 @@ static void doc_format(JanetString doc, int32_t width) {
     int32_t current = 0;
     if (maxcol > 200) maxcol = 200;
     fprintf(stderr, "    ");
-    for (int32_t i = 0; i < janet_string_length(doc); i++) {
+    for (size_t i = 0; i < janet_string_length(doc); i++) {
         uint8_t b = doc[i];
         switch (b) {
             default: {
@@ -814,13 +814,13 @@ static void kshowcomp(void) {
     check_specials(prefix);
 
     JanetByteView lcp = longest_common_prefix();
-    for (int i = prefix.len; i < lcp.len; i++) {
+    for (size_t i = prefix.len; i < lcp.len; i++) {
         insert(lcp.bytes[i], 0);
     }
 
     if (!gbl_lines_below && prefix.len != lcp.len) return;
 
-    int32_t maxlen = 0;
+    size_t maxlen = 0;
     for (int i = 0; i < gbl_match_count; i++)
         if (gbl_matches[i].len > maxlen)
             maxlen = gbl_matches[i].len;
@@ -867,7 +867,7 @@ static int line() {
     if (write_console((char *) gbl_prompt, gbl_plen) == -1) return -1;
     for (;;) {
         char c;
-        char seq[5];
+        char seq[3];
 
         int rc;
         do {
@@ -991,20 +991,6 @@ static int line() {
                                 default:
                                     break;
                             }
-                        } else if (seq[2] == ';') {
-                            if (read_console(seq + 3, 2) == -1) break;
-                            if (seq[3] == '5') {
-                                switch (seq[4]) {
-                                    case 'C': /* ctrl-right */
-                                        krightw();
-                                        break;
-                                    case 'D': /* ctrl-left */
-                                        kleftw();
-                                        break;
-                                    default:
-                                        break;
-                                }
-                            }
                         }
                     } else if (seq[0] == 'O') {
                         if (read_console(seq + 1, 1) == -1) break;
@@ -1177,7 +1163,6 @@ int main(int argc, char **argv) {
     janet_resolve(env, janet_csymbol("cli-main"), &mainfun);
     Janet mainargs[1] = { janet_wrap_array(args) };
     JanetFiber *fiber = janet_fiber(janet_unwrap_function(mainfun), 64, 1, mainargs);
-    janet_gcroot(janet_wrap_fiber(fiber));
     fiber->env = env;
 
     /* Run the fiber in an event loop */

test/amalg/main.c

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2025 Calvin Rose
+* Copyright (c) 2023 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

test/helper.janet

@@ -4,57 +4,29 @@
 (var num-tests-run 0)
 (var suite-name 0)
 (var start-time 0)
-(var skip-count 0)
-(var skip-n 0)
 
 (def is-verbose (os/getenv "VERBOSE"))
 
-(defn- assert-no-tail
+(defn assert
   "Override's the default assert with some nice error handling."
   [x &opt e]
-  (++ num-tests-run)
-  (when (pos? skip-n)
-    (-- skip-n)
-    (++ skip-count)
-    (break x))
   (default e "assert error")
+  (++ num-tests-run)
   (when x (++ num-tests-passed))
   (def str (string e))
-  (def stack (debug/stack (fiber/current)))
-  (def frame (last stack))
+  (def frame (last (debug/stack (fiber/current))))
   (def line-info (string/format "%s:%d"
                               (frame :source) (frame :source-line)))
   (if x
     (when is-verbose (eprintf "\e[32m✔\e[0m %s: %s: %v" line-info (describe e) x))
-    (do
-      (eprintf "\e[31m✘\e[0m %s: %s: %v" line-info (describe e) x) (eflush)))
+    (do (eprintf "\e[31m✘\e[0m %s: %s: %v" line-info (describe e) x) (eflush)))
   x)
 
-(defn skip-asserts
-  "Skip some asserts"
-  [n]
-  (+= skip-n n)
-  nil)
-
-(defmacro assert
-  [x &opt e]
-  (def xx (gensym))
-  (default e (string/format "%j" x))
-  ~(do
-     (def ,xx ,x)
-     (,assert-no-tail ,xx ,e)
-     ,xx))
-
 (defmacro assert-error
   [msg & forms]
   (def errsym (keyword (gensym)))
   ~(assert (= ,errsym (try (do ,;forms) ([_] ,errsym))) ,msg))
 
-(defmacro assert-error-value
-  [msg errval & forms]
-  (def e (gensym))
-  ~(assert (= ,errval (try (do ,;forms) ([,e] ,e))) ,msg))
-
 (defn check-compile-error
   [form]
   (def result (compile form))
@@ -80,22 +52,5 @@
 (defn end-suite []
   (def delta (- (os/clock) start-time))
   (eprinf "Finished suite %s in %.3f seconds - " suite-name delta)
-  (eprint num-tests-passed " of " num-tests-run " tests passed (" skip-count " skipped).")
-  (if (not= (+ skip-count num-tests-passed) num-tests-run) (os/exit 1)))
-
-(defn rmrf
-  "rm -rf in janet"
-  [x]
-  (case (os/lstat x :mode)
-    nil nil
-    :directory (do
-                 (each y (os/dir x)
-                   (rmrf (string x "/" y)))
-                 (os/rmdir x))
-    (os/rm x))
-  nil)
-
-(defn randdir
-  "Get a random directory name"
-  []
-  (string "tmp_dir_" (slice (string (math/random) ".tmp") 2)))
+  (eprint num-tests-passed " of " num-tests-run " tests passed.")
+  (if (not= num-tests-passed num-tests-run) (os/exit 1)))