tests: report C binding failure phases on Windows

2026-11-09 12:57:03 +00:00 · 2026-10-26 15:02:43 -04:00
56 changed files with 417 additions and 8119 deletions
@@ -4,9 +4,9 @@ env:
  LLHTTP_VERSION: "v9.2.1"
  RESTINIO_VERSION: "0.7.10"
  EXPECTED_LITE_URL: "https://raw.githubusercontent.com/martinmoene/expected-lite/master/include/nonstd/expected.hpp"
-  UBUNTU_FULL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-cxx-dev libargon2-dev"
-  UBUNTU_MESON_DEPS: "ninja-build libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-dev python3-setuptools python3-pip libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-cxx-dev libargon2-dev"
-  UBUNTU_MINIMAL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libfmt-dev libgnutls28-dev libcppunit-dev libmsgpack-cxx-dev libargon2-dev"
+  UBUNTU_FULL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"
+  UBUNTU_MESON_DEPS: "ninja-build libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-dev python3-setuptools python3-pip libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-dev libargon2-dev"
+  UBUNTU_MINIMAL_DEPS: "libncurses5-dev libreadline-dev nettle-dev libfmt-dev libgnutls28-dev libcppunit-dev libmsgpack-dev libargon2-dev"
  DEBIAN13_DEPS: "git libtool pkg-config wget cmake libncurses5-dev libreadline-dev nettle-dev libasio-dev libgnutls28-dev libuv1-dev python3-pip python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev libfmt-dev libmsgpack-cxx-dev libargon2-dev"

 on: [push, pull_request]
@@ -33,18 +33,6 @@ jobs:
      - name: Build with Ninja
        run: cd build && ninja

-      - uses: dtolnay/rust-toolchain@stable
-
-      - name: Test Rust bindings
-        env:
-          LIBRARY_PATH: ${{ github.workspace }}/build
-          LD_LIBRARY_PATH: ${{ github.workspace }}/build
-          RUSTFLAGS: -L native=${{ github.workspace }}/build
-        run: |
-          cargo test --manifest-path rust/Cargo.toml --all-targets
-          cargo test --manifest-path rust/Cargo.toml --all-features --all-targets
-          cargo test --manifest-path rust/Cargo.toml --all-features --doc
-
  build-ubuntu-minimal:
    name: Ubuntu/GCC minimal build
    runs-on: ubuntu-latest
@@ -12,7 +12,7 @@ jobs:
          sudo apt update && \
          sudo apt install libncurses5-dev libreadline-dev nettle-dev \
          libgnutls28-dev libuv1-dev python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
-          libfmt-dev libmsgpack-cxx-dev libargon2-dev libasio-dev \
+          libfmt-dev libmsgpack-dev libargon2-dev libasio-dev \
          llvm llvm-dev clang clang-tools && \
          sudo apt remove gcc g++

@@ -1,206 +0,0 @@
-name: Node.js Package
-
-on:
-  push:
-    branches: ['**']
-    paths:
-      - 'nodejs/**'
-      - '.github/workflows/nodejs-package.yml'
-      - 'src/**'
-      - 'include/**'
-      - 'cmake/**'
-      - 'CMakeLists.txt'
-      - 'vcpkg*.json'
-      - 'ports/**'
-      - 'LICENSE'
-  pull_request:
-    paths:
-      - 'nodejs/**'
-      - '.github/workflows/nodejs-package.yml'
-      - 'src/**'
-      - 'include/**'
-      - 'cmake/**'
-      - 'CMakeLists.txt'
-      - 'vcpkg*.json'
-      - 'ports/**'
-      - 'LICENSE'
-  workflow_call:
-  workflow_dispatch:
-
-permissions:
-  contents: read
-  packages: read
-
-jobs:
-  build:
-    name: Build ${{ matrix.target }}
-    runs-on: ${{ matrix.os }}
-    container:
-      image: ${{ matrix.container }}
-      credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
-    timeout-minutes: 45
-    defaults:
-      run:
-        working-directory: nodejs
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - os: ubuntu-26.04
-            target: linux-x64
-            container: ghcr.io/${{ github.repository }}/opendht-deps-noble:latest
-          - os: macos-15
-            target: darwin-arm64
-          - os: macos-15-intel
-            target: darwin-x64
-          - os: windows-2022
-            target: win32-x64
-    env:
-      VCPKG_DISABLE_METRICS: '1'
-      VCPKG_DEFAULT_TRIPLET: x64-windows-release
-      VCPKG_INSTALLED_DIR: ${{ github.workspace }}/vcpkg_installed
-      VCPKG_BINARY_SOURCES: clear;files,${{ github.workspace }}/vcpkg-binary-cache,readwrite
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version: '22'
-          cache: npm
-          cache-dependency-path: nodejs/package-lock.json
-      - name: Install macOS dependencies
-        if: runner.os == 'macOS'
-        run: brew install cmake ninja pkg-config dylibbundler gnutls nettle argon2 msgpack-cxx fmt jsoncpp simdutf asio llhttp openssl
-      - name: Install restinio
-        if: runner.os == 'macOS'
-        env:
-          RESTINIO_VERSION: '0.7.10'
-        run: |
-          include="$RUNNER_TEMP/opendht-proxy/include"
-          mkdir -p "$include/nonstd"
-          curl -fsSL --retry 3 https://raw.githubusercontent.com/martinmoene/expected-lite/v0.10.0/include/nonstd/expected.hpp -o "$include/nonstd/expected.hpp"
-          curl -fsSL --retry 3 "https://github.com/Stiffstream/restinio/releases/download/v${RESTINIO_VERSION}/restinio-${RESTINIO_VERSION}.tar.bz2" -o "$RUNNER_TEMP/restinio.tar.bz2"
-          tar -xjf "$RUNNER_TEMP/restinio.tar.bz2" -C "$RUNNER_TEMP"
-          cp -R "$RUNNER_TEMP/restinio-${RESTINIO_VERSION}/dev/restinio" "$include/"
-          echo "CMAKE_PREFIX_PATH=$RUNNER_TEMP/opendht-proxy" >> "$GITHUB_ENV"
-      - name: Set up MSVC
-        if: runner.os == 'Windows'
-        uses: ilammy/msvc-dev-cmd@v1
-        with:
-          arch: x64
-      - name: Set up vcpkg
-        if: runner.os == 'Windows'
-        uses: lukka/run-vcpkg@v11
-        with:
-          vcpkgJsonGlob: vcpkg.json
-          vcpkgConfigurationJsonGlob: vcpkg-configuration.json
-      - name: Cache Windows native dependencies
-        if: runner.os == 'Windows'
-        uses: actions/cache@v6
-        with:
-          path: ${{ github.workspace }}/vcpkg-binary-cache
-          key: node-vcpkg-${{ env.VCPKG_DEFAULT_TRIPLET }}-${{ hashFiles('vcpkg.json', 'vcpkg-configuration.json', 'ports/**') }}-${{ github.run_id }}-${{ github.run_attempt }}
-          restore-keys: |
-            node-vcpkg-${{ env.VCPKG_DEFAULT_TRIPLET }}-${{ hashFiles('vcpkg.json', 'vcpkg-configuration.json', 'ports/**') }}-
-      - run: npm ci --no-audit --no-fund
-      - name: Build Unix addon
-        if: runner.os != 'Windows'
-        shell: bash
-        run: |
-          if [[ "$RUNNER_OS" == 'macOS' ]]; then
-            export MACOSX_DEPLOYMENT_TARGET=15.0
-            openssl_prefix=$(brew --prefix openssl)
-            export PKG_CONFIG_PATH="$openssl_prefix/lib/pkgconfig${PKG_CONFIG_PATH:+:$PKG_CONFIG_PATH}"
-          fi
-          npm run build -- --CDOPENDHT_DOWNLOAD_DEPS=OFF
-      - name: Build Windows addon
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          npm run build -- `
-            "--CDCMAKE_TOOLCHAIN_FILE=$env:VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake" `
-            "--CDVCPKG_MANIFEST_DIR=$env:GITHUB_WORKSPACE" `
-            "--CDVCPKG_INSTALLED_DIR=$env:VCPKG_INSTALLED_DIR" `
-            "--CDVCPKG_TARGET_TRIPLET=$env:VCPKG_DEFAULT_TRIPLET" `
-            --CDVCPKG_MANIFEST_NO_DEFAULT_FEATURES=ON `
-            --CDVCPKG_MANIFEST_FEATURES=proxy `
-            --CDCMAKE_MSVC_RUNTIME_LIBRARY=MultiThreadedDLL `
-            --CDOPENDHT_DOWNLOAD_DEPS=OFF
-          if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-          "$env:VCPKG_INSTALLED_DIR/$env:VCPKG_DEFAULT_TRIPLET/bin" >> $env:GITHUB_PATH
-          "OPENDHT_LIBRARY_PATH=$env:VCPKG_INSTALLED_DIR/$env:VCPKG_DEFAULT_TRIPLET/bin" >> $env:GITHUB_ENV
-      - run: npm test
-      - run: npm run typecheck
-      - run: npm run bundle
-      - name: Include static simdutf licenses
-        if: runner.os == 'Linux'
-        run: |
-          mkdir -p prebuilds/linux-x64/licenses/simdutf
-          cp /usr/share/doc/simdutf/LICENSE-* prebuilds/linux-x64/licenses/simdutf/
-      - run: npm run test:package
-      - uses: actions/upload-artifact@v7
-        with:
-          name: opendht-node-prebuild-${{ matrix.target }}
-          path: nodejs/prebuilds/
-          if-no-files-found: error
-
-  package:
-    name: Assemble npm archive
-    needs: build
-    runs-on: ubuntu-26.04
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version: '22'
-      - uses: actions/download-artifact@v8
-        with:
-          pattern: opendht-node-prebuild-*
-          path: nodejs/prebuilds
-          merge-multiple: true
-      - name: Set release version
-        if: github.event_name == 'push' && github.ref_type == 'tag'
-        working-directory: nodejs
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          release_version=$(npm version "${RELEASE_TAG#v}" --no-git-tag-version --ignore-scripts --allow-same-version)
-          if [[ "$release_version" != "$RELEASE_TAG" ]]; then
-            printf '::error::Release tag %s is not an exact npm semantic version (normalized to %s).\n' "$RELEASE_TAG" "$release_version" >&2
-            exit 1
-          fi
-      - name: Pack all platforms
-        working-directory: nodejs
-        run: |
-          npm ci --ignore-scripts
-          mkdir -p dist
-          npm pack --pack-destination dist
-      - uses: actions/upload-artifact@v7
-        with:
-          name: opendht-node-npm
-          path: nodejs/dist/*.tgz
-          if-no-files-found: error
-
-  smoke:
-    name: Install on ${{ matrix.os }} / Node ${{ matrix.node }}
-    needs: package
-    runs-on: ${{ matrix.os }}
-    timeout-minutes: 10
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-24.04, ubuntu-26.04, macos-15, macos-15-intel, windows-2022]
-        node: ['22', '24', '26']
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version: ${{ matrix.node }}
-      - uses: actions/download-artifact@v8
-        with:
-          name: opendht-node-npm
-          path: nodejs/dist
-      - name: Test installed archive without a native build toolchain
-        working-directory: nodejs
-        run: npm run test:package -- dist
@@ -4,10 +4,10 @@ permissions:
  contents: read

 on:
+  release:
+    types: [published]
  push:
-    branches: ['**']
  pull_request:
-  workflow_call:
  workflow_dispatch:

 jobs:
@@ -23,7 +23,7 @@ jobs:

      # Run locally with: pipx run cibuildwheel --platform linux python
      - name: Build wheels
-        uses: pypa/cibuildwheel@v4.3.5
+        uses: pypa/cibuildwheel@v4.3.4
        with:
          package-dir: python

@@ -82,3 +82,19 @@ jobs:
        with:
          name: opendht-wheels-win_amd64
          path: ./build/wheelhouse/*.whl
+
+  publish:
+    runs-on: ubuntu-latest
+    needs: [build_wheels, build_wheels_windows]
+    steps:
+    - uses: actions/download-artifact@v8
+      with:
+        pattern: opendht-wheels-*
+        path: dist
+        merge-multiple: true
+
+    - name: Publish package
+      if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags')
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}
@@ -8,9 +8,7 @@ on:
 env:
  REGISTRY: ghcr.io
  IMAGE_NAME_DEPS: ${{ github.repository }}/opendht-deps
-  IMAGE_NAME_DEPS_NOBLE: ${{ github.repository }}/opendht-deps-noble
  IMAGE_NAME: ${{ github.repository }}/opendht
-  IMAGE_NAME_NOBLE: ${{ github.repository }}/opendht-noble
  IMAGE_NAME_DEPS_LLVM: ${{ github.repository }}/opendht-deps-llvm
  IMAGE_NAME_LLVM: ${{ github.repository }}/opendht-llvm
  IMAGE_NAME_DHTNODE: ${{ github.repository }}/dhtnode
@@ -18,19 +16,6 @@ env:
  IMAGE_NAME_ALPINE_DEPS: ${{ github.repository }}/opendht-deps-alpine

 jobs:
-  nodejs-package:
-    name: Build and verify Node.js package
-    uses: ./.github/workflows/nodejs-package.yml
-    permissions:
-      contents: read
-      packages: read
-
-  python-wheels:
-    name: Build Python wheels
-    uses: ./.github/workflows/python-wheels.yml
-    permissions:
-      contents: read
-
  build-and-push-deps-image:
    name: Dependency Docker image
    runs-on: ubuntu-latest
@@ -71,46 +56,6 @@ jobs:
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

-  build-and-push-deps-image-noble:
-    name: Dependency Docker image (Ubuntu 24.04)
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v7
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v4
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v6
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME_DEPS_NOBLE }}
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v7
-        with:
-          context: .
-          file: docker/DockerfileDepsNoble
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-
  build-and-push-image:
    name: OpenDHT Docker image
    runs-on: ubuntu-latest
@@ -153,47 +98,6 @@ jobs:
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}

-  build-and-push-image-noble:
-    name: OpenDHT Docker image (Ubuntu 24.04)
-    runs-on: ubuntu-latest
-    needs: build-and-push-deps-image-noble
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v7
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-
-      - name: Log in to the Container registry
-        uses: docker/login-action@v4
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v6
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME_NOBLE }}
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v7
-        with:
-          context: .
-          file: docker/DockerfileNoble
-          platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-
  build-and-push-deps-image-llvm:
    name: Dependency Docker image (LLVM)
    runs-on: ubuntu-latest
@@ -568,7 +472,7 @@ jobs:
  create-github-release:
    name: Create GitHub Release
    runs-on: ubuntu-latest
-    needs: [build-windows-msi, build-windows-dhtnode, nodejs-package]
+    needs: [build-windows-msi, build-windows-dhtnode]
    permissions:
      contents: write

@@ -588,99 +492,11 @@ jobs:
          name: opendht-windows-dhtnode
          path: downloaded_artifacts/static_dhtnode

-      - name: Download npm archive
-        uses: actions/download-artifact@v8
-        with:
-          name: opendht-node-npm
-          path: downloaded_artifacts/nodejs
-
      - name: Create Release
        id: create_release
        uses: softprops/action-gh-release@v3
        with:
          draft: true
-          prerelease: ${{ contains(github.ref_name, '-') }}
          files: |
            downloaded_artifacts/windows_msi/*.msi
            downloaded_artifacts/static_dhtnode/**/*dhtnode.exe
-            downloaded_artifacts/nodejs/*.tgz
-
-  publish-npm:
-    name: Publish opendht to npm
-    needs: create-github-release
-    runs-on: ubuntu-26.04
-    environment:
-      name: npm
-      url: https://www.npmjs.com/package/opendht
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v7
-      - uses: actions/setup-node@v7
-        with:
-          node-version: '24'
-          registry-url: https://registry.npmjs.org/
-          package-manager-cache: false
-      - uses: actions/download-artifact@v8
-        with:
-          name: opendht-node-npm
-          path: nodejs/dist
-      - name: Publish verified archive
-        working-directory: nodejs
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          dist_tag=latest
-          if [[ "${RELEASE_TAG#v}" == *-* ]]; then
-            dist_tag=next
-          fi
-          npm publish ./dist/*.tgz --access public --provenance --tag "$dist_tag"
-
-  publish-pypi:
-    name: Publish opendht to PyPI
-    needs: [create-github-release, python-wheels]
-    runs-on: ubuntu-latest
-    environment:
-      name: pypi
-      url: https://pypi.org/p/opendht
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/download-artifact@v8
-        with:
-          pattern: opendht-wheels-*
-          path: dist
-          merge-multiple: true
-      - name: Publish wheels
-        uses: pypa/gh-action-pypi-publish@release/v1
-
-  publish-crate:
-    name: Publish opendht to crates.io
-    needs: create-github-release
-    runs-on: ubuntu-latest
-    environment:
-      name: crates-io
-      url: https://crates.io/crates/opendht
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/checkout@v7
-      - uses: taiki-e/install-action@v2
-        with:
-          tool: cargo-edit
-      - name: Set crate version from release tag
-        working-directory: rust
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: cargo set-version "${RELEASE_TAG#v}"
-      - name: Authenticate with crates.io
-        id: auth
-        uses: rust-lang/crates-io-auth-action@v1
-      - name: Publish crate
-        working-directory: rust
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ steps.auth.outputs.token }}
-        run: cargo publish --allow-dirty
@@ -115,29 +115,12 @@ cmake -DOPENDHT_PYTHON=ON \
 | `OPENDHT_PUSH_NOTIFICATIONS` | OFF | Push notification support |
 | `OPENDHT_SANITIZE` | OFF | AddressSanitizer + stack protector |

-## Node.js Bindings
-
-Node-API bindings wrap the C++ API directly with `node-addon-api`, including
-RSA/EC keys, certificates, identities, and signed/encrypted DHT operations.
-With the native dependencies above, Node.js 22.9+, and CMake installed, run
-`npm ci`, `npm run build`, `npm test`, and `npm run typecheck` from `nodejs/`.
-This creates a separate native build without changing the existing build tree.
-See [the Node.js binding guide](nodejs/README.md) for the API and current limits.
-`npm run package` creates a platform prebuild with bundled native dependencies;
-`npm run test:package` verifies installation outside the source tree. The Node.js
-package CI builds Linux x64, macOS ARM64/x64, and Windows x64 prebuilds and checks
-the assembled npm archive on Node 22, 24, and 26 before release attachment.
-
 ## C and Rust Bindings

 Enable `OPENDHT_C=ON` to build the C ABI. With `BUILD_TESTING=ON`, CTest runs
 `test_c`; Meson registers the same test as `CBindings` when `c` and `tests` are
 enabled. Rust regression and callback-lifetime tests run with Cargo; see
-[the Rust build guide](rust/BUILD.md) for build and library-path settings.
-
-`dht_infohash` and `dht_pkid` have `uint32_t` alignment, matching the native hash
-types, while retaining their 20-byte and 32-byte sizes. Rebuild consumers against
-the updated header; foreign-language declarations must match this alignment.
+[the Rust binding guide](rust/README.md) for build and library-path settings.

 C handles returned by constructors, imports, and reference functions are owned
 and require their matching delete/unref function. Data views, string getters,
@@ -10,10 +10,10 @@ if(POLICY CMP0167)
 endif()

 set (opendht_VERSION_MAJOR 4)
-set (opendht_VERSION_MINOR 5.0)
+set (opendht_VERSION_MINOR 4.2)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
-set (PACKAGE_VERSION "${opendht_VERSION}-rc.1")
-set (VERSION "${PACKAGE_VERSION}")
+set (PACKAGE_VERSION ${opendht_VERSION})
+set (VERSION "${opendht_VERSION}")
 project (opendht
    VERSION ${opendht_VERSION}
    DESCRIPTION "OpenDHT: A lightweight C++17 Distributed Hash Table library."
@@ -421,7 +421,7 @@ else ()
 endif ()
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DMSGPACK_NO_BOOST -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT")

-add_definitions(-DPACKAGE_VERSION="${PACKAGE_VERSION}")
+add_definitions(-DPACKAGE_VERSION="${opendht_VERSION}")

 if (ASIO_INCLUDE_DIR)
    include_directories (SYSTEM "${ASIO_INCLUDE_DIR}")
@@ -849,9 +849,6 @@ if (BUILD_TESTING)
        add_executable(test_c tests/test_c.c)
        target_include_directories(test_c PRIVATE c include)
        target_link_libraries(test_c PRIVATE opendht-c)
-        if (MSVC)
-            target_link_libraries(test_c PRIVATE ${GNUTLS_LIBRARIES})
-        endif()
        add_test(NAME test_c COMMAND test_c)
    endif()
    if (NOT MSVC)
@@ -4,10 +4,7 @@
    <a id="user-content-opendht-" class="anchor" href="/savoirfairelinux/opendht/blob/master/README.md#opendht-" aria-hidden="true"></a>OpenDHT
 </h1>

-[![PyPI - Version](https://img.shields.io/pypi/v/opendht?style=flat)](https://pypi.org/project/opendht/)
-[![crates.io - Version](https://img.shields.io/crates/v/opendht?style=flat)](https://crates.io/crates/opendht)
-[![npm - Version](https://img.shields.io/npm/v/opendht?style=flat)](https://www.npmjs.com/package/opendht)
-[![Docker Image](https://img.shields.io/badge/Docker-ghcr.io-2496ED?style=flat&logo=docker&logoColor=white)](https://github.com/savoirfairelinux/opendht/pkgs/container/opendht%2Fopendht)
+![PyPI - Version](https://img.shields.io/pypi/v/opendht?style=flat)

 A lightweight C++17 Distributed Hash Table implementation.

@@ -20,7 +17,7 @@ Values are distributed over the network, with redundancy.
 * Public key cryptography layer providing optional data signature and encryption (using GnuTLS)
 * IPv4 and IPv6 support
 * Clean and powerful **C++17** map API
- * Bindings for **C, Rust, Node.js & Python 3**
+ * Bindings for **C, Rust & Python 3**
 * REST API with optional HTTP client+server with push notification support

 ## Documentation
@@ -12,11 +12,6 @@ using PrivkeySp = std::shared_ptr<dht::crypto::PrivateKey>;
 using PubkeySp = std::shared_ptr<const dht::crypto::PublicKey>;
 using CertSp = std::shared_ptr<dht::crypto::Certificate>;

-static_assert(sizeof(dht_infohash) == sizeof(dht::InfoHash));
-static_assert(alignof(dht_infohash) == alignof(dht::InfoHash));
-static_assert(sizeof(dht_pkid) == sizeof(dht::PkId));
-static_assert(alignof(dht_pkid) == alignof(dht::PkId));
-
 struct CompletionGuard
 {
    CompletionGuard(dht_done_cb callback, void* data)
@@ -39,17 +39,9 @@ OPENDHT_C_PUBLIC dht_data_view dht_blob_get_data(const dht_blob* data);
 OPENDHT_C_PUBLIC void dht_blob_delete(dht_blob* data);

 // dht::InfoHash
-#ifdef __cplusplus
-#define OPENDHT_C_ALIGN_UINT32 alignas(uint32_t)
-#elif defined(_MSC_VER)
-#define OPENDHT_C_ALIGN_UINT32 __declspec(align(4))
-#else
-#define OPENDHT_C_ALIGN_UINT32 _Alignas(uint32_t)
-#endif
-
 struct OPENDHT_C_PUBLIC dht_infohash
 {
-    OPENDHT_C_ALIGN_UINT32 uint8_t d[HASH_LEN];
+    uint8_t d[HASH_LEN];
 };
 typedef struct dht_infohash dht_infohash;
 OPENDHT_C_PUBLIC void dht_infohash_zero(dht_infohash* h);
@@ -64,10 +56,9 @@ OPENDHT_C_PUBLIC bool dht_infohash_is_zero(const dht_infohash* h);
 // dht::PkId
 struct OPENDHT_C_PUBLIC dht_pkid
 {
-    OPENDHT_C_ALIGN_UINT32 uint8_t d[32];
+    uint8_t d[32];
 };
 typedef struct dht_pkid dht_pkid;
-#undef OPENDHT_C_ALIGN_UINT32
 OPENDHT_C_PUBLIC const char* dht_pkid_print(const dht_pkid* h);

 // dht::crypto::PublicKey
@@ -5,16 +5,15 @@ LABEL org.opencontainers.image.source=https://github.com/savoirfairelinux/opendh
 COPY . opendht

 RUN cd opendht && mkdir build && cd build \
-	&& cmake -GNinja .. -DCMAKE_INSTALL_PREFIX=/usr \
-	-DBUILD_TESTING=Off \
-	-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
-	-DCMAKE_BUILD_TYPE=RelWithDebInfo \
-	-DOPENDHT_C=On \
-	-DOPENDHT_PEER_DISCOVERY=On \
-	-DOPENDHT_PYTHON=On \
-	-DOPENDHT_TOOLS=On \
-	-DOPENDHT_PROXY_SERVER=On \
-	-DOPENDHT_PROXY_CLIENT=On \
-	-DOPENDHT_SYSTEMD=On \
-	&& ninja && ninja install \
+	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
+				-DBUILD_TESTING=Off \
+				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
+				-DOPENDHT_C=On \
+				-DOPENDHT_PEER_DISCOVERY=On \
+				-DOPENDHT_PYTHON=On \
+				-DOPENDHT_TOOLS=On \
+				-DOPENDHT_PROXY_SERVER=On \
+				-DOPENDHT_PROXY_CLIENT=On \
+				-DOPENDHT_SYSTEMD=On \
+	&& make -j8 && make install \
 	&& cd ../.. && rm -rf opendht
@@ -10,7 +10,6 @@ ENV DESTDIR=/install
 RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
                -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
-                -DCMAKE_BUILD_TYPE=RelWithDebInfo \
                -DBUILD_TESTING=Off \
                -DOPENDHT_C=On \
                -DOPENDHT_PEER_DISCOVERY=On \
@@ -8,7 +8,7 @@ RUN apt-get update && apt-get install -y \
    && echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections

 RUN apt-get update && apt-get install -y \
-    build-essential pkg-config cmake git wget meson ninja-build \
+    build-essential pkg-config cmake git wget meson \
    libtool \
    python3-dev python3-setuptools python3-build python3-virtualenv cython3 \
    libncurses5-dev libreadline-dev nettle-dev libcppunit-dev \
@@ -7,7 +7,7 @@ RUN apk add --no-cache \
        cython python3-dev py3-setuptools \
        ncurses-dev readline-dev nettle-dev \
        cppunit-dev gnutls-dev jsoncpp-dev \
-        argon2-dev openssl-dev fmt-dev simdutf-dev \
+        argon2-dev openssl-dev fmt-dev \
        llhttp-dev asio-dev msgpack-cxx-dev \
    && rm -rf /var/cache/apk/*

@@ -18,19 +18,6 @@ RUN apt-get update && apt-get install -y \

 RUN pip3 install meson Cython

-ARG SIMDUTF_VERSION=8.0.0
-RUN mkdir simdutf \
-    && wget -q "https://github.com/simdutf/simdutf/archive/refs/tags/v${SIMDUTF_VERSION}.tar.gz" -O simdutf.tar.gz \
-    && tar -xzf simdutf.tar.gz -C simdutf --strip-components=1 \
-    && cmake -S simdutf -B simdutf/build -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
-        -DBUILD_SHARED_LIBS=OFF -DSIMDUTF_TESTS=OFF -DSIMDUTF_TOOLS=OFF \
-    && cmake --build simdutf/build --parallel 2 \
-    && cmake --install simdutf/build \
-    && install -D simdutf/LICENSE-MIT /usr/share/doc/simdutf/LICENSE-MIT \
-    && install -D simdutf/LICENSE-APACHE /usr/share/doc/simdutf/LICENSE-APACHE \
-    && rm -rf simdutf simdutf.tar.gz
-
 RUN mkdir /usr/include/nonstd \
    && wget https://raw.githubusercontent.com/martinmoene/expected-lite/master/include/nonstd/expected.hpp \
    -O /usr/include/nonstd/expected.hpp
@@ -1,56 +0,0 @@
-FROM ubuntu:24.04
-LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
-LABEL org.opencontainers.image.source=https://github.com/savoirfairelinux/opendht
-
-RUN apt-get update && apt-get install -y \
-    dialog apt-utils \
-    && apt-get clean \
-    && echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections
-
-RUN apt-get update && apt-get install -y \
-    build-essential pkg-config cmake git wget meson ninja-build patchelf \
-    libtool \
-    python3-dev python3-setuptools python3-build python3-virtualenv cython3 \
-    libncurses5-dev libreadline-dev nettle-dev libcppunit-dev \
-    libgnutls28-dev libuv1-dev libjsoncpp-dev libargon2-dev \
-    libssl-dev libfmt-dev libasio-dev libmsgpack-cxx-dev \
-    && apt-get clean && rm -rf /var/lib/apt/lists/* /var/cache/apt/*
-
-ARG LLHTTP_VERSION=9.2.1
-RUN mkdir llhttp \
-    && wget -q "https://github.com/nodejs/llhttp/archive/refs/tags/release/v${LLHTTP_VERSION}.tar.gz" -O llhttp.tar.gz \
-    && tar -xzf llhttp.tar.gz -C llhttp --strip-components=1 \
-    && cmake -S llhttp -B llhttp/build -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr \
-    && cmake --build llhttp/build --parallel 2 \
-    && cmake --install llhttp/build \
-    && rm -rf llhttp llhttp.tar.gz
-
-ARG SIMDUTF_VERSION=8.0.0
-RUN mkdir simdutf \
-    && wget -q "https://github.com/simdutf/simdutf/archive/refs/tags/v${SIMDUTF_VERSION}.tar.gz" -O simdutf.tar.gz \
-    && tar -xzf simdutf.tar.gz -C simdutf --strip-components=1 \
-    && cmake -S simdutf -B simdutf/build -DCMAKE_BUILD_TYPE=Release \
-        -DCMAKE_INSTALL_PREFIX=/usr/local -DCMAKE_POSITION_INDEPENDENT_CODE=ON \
-        -DBUILD_SHARED_LIBS=OFF -DSIMDUTF_TESTS=OFF -DSIMDUTF_TOOLS=OFF \
-    && cmake --build simdutf/build --parallel 2 \
-    && cmake --install simdutf/build \
-    && install -D simdutf/LICENSE-MIT /usr/share/doc/simdutf/LICENSE-MIT \
-    && install -D simdutf/LICENSE-APACHE /usr/share/doc/simdutf/LICENSE-APACHE \
-    && rm -rf simdutf simdutf.tar.gz
-
-RUN mkdir /usr/include/nonstd \
-    && wget https://raw.githubusercontent.com/martinmoene/expected-lite/master/include/nonstd/expected.hpp \
-    -O /usr/include/nonstd/expected.hpp
-
-ARG RESTINIO_VERSION=0.7.10
-RUN echo "*** Downloading RESTinio ***" \
-    && mkdir restinio && cd restinio \
-    && wget "https://github.com/Stiffstream/restinio/releases/download/v${RESTINIO_VERSION}/restinio-${RESTINIO_VERSION}.tar.bz2" \
-    && ls -l && tar -xjf "restinio-${RESTINIO_VERSION}.tar.bz2" \
-    && cd "restinio-${RESTINIO_VERSION}/dev" \
-    && cmake -DCMAKE_INSTALL_PREFIX=/usr -DRESTINIO_TEST=Off -DRESTINIO_SAMPLE=Off -DRESTINIO_BENCHMARK=Off \
-    -DRESTINIO_WITH_SOBJECTIZER=Off -DRESTINIO_DEP_STANDALONE_ASIO=system -DRESTINIO_DEP_LLHTTP=system \
-    -DRESTINIO_DEP_FMT=system -DRESTINIO_DEP_EXPECTED_LITE=system . \
-    && make -j2 && make install \
-    && cd ../../ && rm -rf restinio* \
-    && ldconfig
@@ -8,7 +8,6 @@ RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DBUILD_TESTING=Off \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
-				-DCMAKE_BUILD_TYPE=RelWithDebInfo \
 				-DOPENDHT_C=On \
 				-DOPENDHT_PEER_DISCOVERY=On \
 				-DOPENDHT_PYTHON=On \
@@ -7,7 +7,6 @@ COPY . opendht
 RUN cd opendht && mkdir build && cd build \
 	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
 				-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
-				-DCMAKE_BUILD_TYPE=RelWithDebInfo \
 				-DOPENDHT_C=On \
 				-DOPENDHT_PEER_DISCOVERY=On \
 				-DOPENDHT_PYTHON=On \
@@ -1,20 +0,0 @@
-FROM ghcr.io/savoirfairelinux/opendht/opendht-deps-noble:latest
-LABEL maintainer="Adrien Béraud <adrien.beraud@savoirfairelinux.com>"
-LABEL org.opencontainers.image.source=https://github.com/savoirfairelinux/opendht
-
-COPY . opendht
-
-RUN cd opendht && mkdir build && cd build \
-	&& cmake .. -DCMAKE_INSTALL_PREFIX=/usr \
-	-DBUILD_TESTING=Off \
-	-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=On \
-	-DCMAKE_BUILD_TYPE=RelWithDebInfo \
-	-DOPENDHT_C=On \
-	-DOPENDHT_PEER_DISCOVERY=On \
-	-DOPENDHT_PYTHON=On \
-	-DOPENDHT_TOOLS=On \
-	-DOPENDHT_PROXY_SERVER=On \
-	-DOPENDHT_PROXY_CLIENT=On \
-	-DOPENDHT_SYSTEMD=On \
-	&& make -j8 && make install \
-	&& cd ../.. && rm -rf opendht
@@ -19,9 +19,7 @@
 #include <mutex>

 namespace dht {
-// Appended only: the values are serialized as integers by MSGPACK_ADD_ENUM,
-// so reordering would break compatibility with deployed proxies.
-enum class PushType { None = 0, Android, iOS, UnifiedPush, Huawei };
+enum class PushType { None = 0, Android, iOS, UnifiedPush };
 }
 MSGPACK_ADD_ENUM(dht::PushType)

@@ -134,7 +132,6 @@ public:
        PushStats androidPush;
        PushStats iosPush;
        PushStats unifiedPush;
-        PushStats huaweiPush;

        /** Average requests per second */
        double requestRate {0};
@@ -400,7 +397,6 @@ private:
    PushStats androidPush_;
    PushStats iosPush_;
    PushStats unifiedPush_;
-    PushStats huaweiPush_;

    // Thread-safe access to listeners map.
    std::mutex lockListener_;
@@ -5,7 +5,7 @@ project(
    'cython',
    license: 'MIT',
    license_files: 'LICENSE',
-    version: '4.5.0-rc.1',
+    version: '4.4.2',
    meson_version: '>=1.1.0',
    default_options: ['cpp_std=c++20', 'warning_level=3'],
 )
@@ -55,12 +55,7 @@ if host_machine.system() == 'linux' and io_uring.found()
 endif
 conf_data = configuration_data()

-add_project_arguments(
-    '-DMSGPACK_NO_BOOST',
-    '-DASIO_STANDALONE',
-    '-DPACKAGE_VERSION="' + meson.project_version() + '"',
-    language: 'cpp',
-)
+add_project_arguments('-DMSGPACK_NO_BOOST', '-DASIO_STANDALONE', language: 'cpp')
 if io_uring.found()
    add_project_arguments('-DASIO_HAS_IO_URING', '-DASIO_DISABLE_EPOLL', language: 'cpp')
    conf_data.set('iouring_lib', ', liburing')
@@ -273,7 +268,6 @@ if get_option('tests').enabled()
            'test_c',
            'tests/test_c.c',
            include_directories: ['c', opendht_interface_inc],
-            dependencies: [gnutls],
            link_with: opendht_c,
        )
        test('CBindings', test_c)
@@ -1,5 +0,0 @@
-node_modules/
-build*/
-prebuilds/
-dist/
-examples/dhtnode.js
@@ -1,64 +0,0 @@
-cmake_minimum_required(VERSION 3.21)
-project(opendht_node LANGUAGES C CXX)
-
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(OPENDHT_TOOLS OFF CACHE BOOL "Build DHT tools")
-set(OPENDHT_PYTHON OFF CACHE BOOL "Build Python bindings")
-set(OPENDHT_PROXY_CLIENT ON CACHE BOOL "Enable DHT proxy client")
-set(OPENDHT_PEER_DISCOVERY OFF CACHE BOOL "Enable multicast peer discovery")
-set(OPENDHT_DOCUMENTATION OFF CACHE BOOL "Build documentation")
-set(BUILD_TESTING OFF CACHE BOOL "Build native tests")
-add_subdirectory(.. native EXCLUDE_FROM_ALL)
-
-find_program(NODE_EXECUTABLE node REQUIRED)
-execute_process(
-    COMMAND "${NODE_EXECUTABLE}" --input-type=module -e "import addon from 'node-addon-api'; process.stdout.write(addon.include_dir)"
-    WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
-    OUTPUT_VARIABLE NODE_ADDON_API_DIR
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-    COMMAND_ERROR_IS_FATAL ANY
-)
-
-add_library(opendht_node MODULE addon.cpp crypto.cpp ${CMAKE_JS_SRC})
-target_compile_definitions(opendht_node PRIVATE NAPI_VERSION=8 NAPI_CPP_EXCEPTIONS)
-target_include_directories(opendht_node PRIVATE
-    ${CMAKE_JS_INC}
-    "${CMAKE_CURRENT_SOURCE_DIR}/${NODE_ADDON_API_DIR}"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../include"
-    "${CMAKE_CURRENT_BINARY_DIR}/native/include"
-)
-target_link_libraries(opendht_node PRIVATE opendht ${CMAKE_JS_LIB})
-if(OPENDHT_SANITIZE AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-    target_compile_options(opendht_node PRIVATE -fsanitize=address -fstack-protector-strong)
-    target_link_options(opendht_node PRIVATE -fsanitize=address)
-endif()
-set_target_properties(opendht_node PROPERTIES
-    PREFIX ""
-    SUFFIX ".node"
-    OUTPUT_NAME "opendht"
-    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIG>"
-    RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/$<CONFIG>"
-)
-if(APPLE)
-    target_link_options(opendht_node PRIVATE "-undefined" "dynamic_lookup")
-endif()
-if(WIN32)
-    add_custom_command(TARGET opendht_node POST_BUILD
-        COMMAND ${CMAKE_COMMAND} -E copy_if_different
-            $<TARGET_RUNTIME_DLLS:opendht_node> $<TARGET_FILE_DIR:opendht_node>
-        COMMAND_EXPAND_LISTS
-    )
-endif()
-if(MSVC)
-    target_compile_options(opendht_node PRIVATE /EHsc)
-    target_include_directories(opendht_node PRIVATE
-        "${CMAKE_CURRENT_SOURCE_DIR}/../src/compat/msvc"
-        "${CMAKE_CURRENT_SOURCE_DIR}/../src/compat/win32"
-    )
-    if(CMAKE_JS_NODELIB_DEF AND CMAKE_JS_NODELIB_TARGET)
-        execute_process(COMMAND ${CMAKE_AR} /def:${CMAKE_JS_NODELIB_DEF}
-            /out:${CMAKE_JS_NODELIB_TARGET} ${CMAKE_STATIC_LINKER_FLAGS})
-    endif()
-endif()
@@ -1,243 +0,0 @@
-# OpenDHT Node.js Bindings
-
-Initial Node-API bindings using `node-addon-api` directly over the C++ library.
-Node.js 22.9 or later is required; the addon targets Node-API version 8.
-
-## Install
-
-```sh
-npm install opendht
-```
-
-## Build
-
-Install the native dependencies described in [BUILD.md](../BUILD.md), plus Node.js,
-a C++17 compiler, and CMake 3.21 or later. Ninja is optional. Proxy-client support
-defaults to enabled and requires ASIO, llhttp, RESTinio, and expected-lite headers.
-
-```sh
-cd nodejs
-npm ci
-npm run build
-npm test
-npm run typecheck
-```
-
-CMake.js builds OpenDHT from the parent source directory in `nodejs/build/native`.
-It does not change the repository's existing build directory. Tools, Python,
-peer discovery, documentation, and native tests default to disabled in this build.
-Native CMake options can be passed through, for example:
-
-```sh
-npm run build -- --CDOPENDHT_PEER_DISCOVERY=ON
-```
-
-For an existing build, change cached options directly with CMake, for example
-`cmake -S . -B build -DOPENDHT_PROXY_CLIENT=ON`, then rebuild. A custom build can
-disable proxy support with `-DOPENDHT_PROXY_CLIENT=OFF`; requesting a proxy then
-throws an explicit unsupported-build error.
-
-The loader checks local builds, then compatible Node-API binaries under `prebuilds/`.
-Set `OPENDHT_NODE_BINDING` to an absolute addon path to select an explicit build.
-Packaged binaries include OpenDHT and non-system native dependencies, so archive
-installation does not require a compiler or a system OpenDHT installation.
-
-## Usage
-
-```js
-import { DhtRunner, hash } from 'opendht';
-
-async function main() {
-    const writer = new DhtRunner();
-    const reader = new DhtRunner();
-    try {
-        writer.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-        reader.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-        writer.bootstrap('127.0.0.1', reader.getBoundPort());
-        reader.bootstrap('127.0.0.1', writer.getBoundPort());
-        const key = hash('example');
-        const stored = await writer.put(key, Buffer.from('hello'), { id: 42n });
-        if (!stored) throw new Error('DHT put failed');
-        for await (const value of reader.get(key)) {
-            console.log(value.id, value.data.toString());
-        }
-    } finally {
-        await Promise.all([writer.close(), reader.close()]);
-    }
-}
-
-main().catch(console.error);
-```
-
-## API
-
- `hash(string | Uint8Array)` returns a SHA-1 hash as a 40-character hex string.
-  All get/put/listen keys must be hex hashes, not unhashed application keys.
- `version` is the underlying OpenDHT version.
- `run({port, ipv4, ipv6, network, persistPath, identity})` starts a threaded node. Port 0
-  selects a free port. The defaults bind both IP families on all interfaces.
-  `persistPath` is optional; use an empty string to disable persistence.
-  `proxyServer` and `proxyUserAgent` configure proxy mode (see below).
- `getBoundPort(4 | 6)` defaults to IPv4; `getNodeId()` returns the node's hex ID.
- `getStatus()` returns the latest JS-dispatched `{ipv4, ipv6}` connectivity
-  snapshot. Each family is `'disconnected'`, `'connecting'`, or `'connected'`.
-  `runner.on('statusChanged', status => {})` receives changes on the JS thread.
-  New and closing/closed runners report both families as disconnected. No status
-  events are delivered after close begins; close does not emit a final event.
- `bootstrap(host, port)` queues bootstrap discovery. Returning does not mean the
-  peer is connected; subsequent DHT operations report their own completion.
- `put(key, Uint8Array, {id, type, userType, permanent})` copies the input and
-  resolves to the native success boolean. IDs are unsigned 64-bit `bigint` values.
- `get(key)` returns an async iterator of values as they arrive. The iterator
-  ends when the lookup completes, or rejects with `ERR_DHT_GET_FAILED` on failure.
-  `getAll(key)` returns a single promise resolving to the complete value array.
-  Values contain `id`, `type`, `seq`, `userType`, copied `Buffer` data, `isSigned`,
-  `isEncrypted`, and an `owner` long fingerprint (or null for unsigned values).
- `listen(key, (value, expired) => {})` returns a listener with idempotent
-  `cancel()`. Queued deliveries are suppressed after cancellation. Callback
-  return values are ignored; callbacks may cancel or close the runner.
- `listen(key)` without a callback returns an async iterator of `{value, expired}`
-  events. It continues until cancelled or the runner closes.
- `close()` is idempotent and returns the same promise on repeated calls. It
-  waits off the JS thread for graceful shutdown, then joins the native threads.
-  After two seconds it forces the join if graceful shutdown has not completed.
-  Pending operations reject with `ERR_DHT_CLOSED`. A closed runner cannot restart.
- `ref()` and `unref()` control whether the runner keeps Node's event loop alive.
-  Running nodes are referenced by default. `Symbol.asyncDispose` calls `close()`.
-
-Callbacks run only on their owning JS thread. There is no polling timer or worker
-thread waiting on each get/put. Explicitly close runners; GC cleanup and Node
-environment cleanup hooks are fallbacks, including forced worker termination.
-Pending operations, active listeners, and registered status handlers keep their
-runner alive until completion, cancellation, handler removal, or explicit close.
-Graceful persistence cannot be guaranteed if the process is killed.
-
-The binding does not cap the callback queue, accumulated `getAll()` results, or
-iterator buffers. Slow iterator consumers can accumulate values without
-backpressure. Queued callbacks retain their native values until delivery or cleanup.
-
-## Async Iteration
-
-`get()` and callback-free `listen()` start immediately and return iterators with
-`next()`, `return()`, `throw()`, `cancel()`, and `Symbol.asyncDispose`.
-Leaving a `for await` loop with `break` or an exception cancels the subscription.
-Explicit cancellation discards buffered values and settles pending reads as done.
-Closing the runner rejects active get iterators with `ERR_DHT_CLOSED`; listener
-iterators end normally. Successful get completion preserves unread buffered values.
-
-```js
-for await (const value of runner.get(hash('example'))) {
-  console.log(value.id, value.data);
-}
-const snapshots = await runner.getAll(hash('example'));
-
-for await (const { value, expired } of runner.listen(hash('updates'))) {
-  console.log(value.id, expired);
-  if (expired) break;
-}
-```
-
-## Proxy Configuration
-
-Pass the URL of an OpenDHT HTTP(S) proxy at startup:
-
-```js
-runner.run({
-  proxyServer: 'https://proxy.example.com',
-  proxyUserAgent: 'my-app/1.0',
-});
-```
-
-This selects the native OpenDHT proxy client, not an HTTP CONNECT or SOCKS proxy.
-The node does not bind UDP sockets in this mode; `port`, `ipv4`, `ipv6`, and
-`bootstrap()` are for direct DHT nodes. Omit `proxyServer` or use an empty string
-for direct networking. Proxy settings are startup-only; create a new runner to
-change transports or servers. Packaged binaries include proxy-client support.
-
-## Crypto
-
-`PrivateKey.generate(options)` and `Identity.generate(name, options)` return
-promises and generate keys off the JS thread. Options accept `algorithm: 'ec'`
-(the default, using OpenDHT's default EC curve) or `'rsa'`. RSA `bits` must be an
-integer between 2048 and 8192; the default is 2048.
-
- `new PrivateKey(bytes, password?)` imports PEM/DER; `serialize(password?)`
-  exports PKCS#8 PEM. A nonempty password encrypts the exported key.
- `privateKey.getPublicKey()` returns an owned public key. `sign(bytes)` and
-  `decrypt(bytes)` return copied Buffers.
- `new PublicKey(bytes)` imports a public key; `serialize()` exports DER.
-  `checkSignature(data, signature)` returns a boolean. `encrypt(bytes)` requires
-  an RSA key; EC keys support signatures, not this encryption scheme.
- `new Certificate(bytes)` imports PEM/DER or a PEM certificate chain;
-  `serialize()` exports a PEM chain. Import does not establish trust or validate
-  the chain against a trust store. `getPublicKey()` returns its public key.
- Public keys and certificates expose `getId()` (40 hex characters) and
-  `getLongId()` (64 hex characters).
- `new Identity(privateKey, certificate)` requires matching fingerprints.
-  Its read-only `privateKey` and `certificate` properties return owned wrappers.
- Pass `identity` to `run()` to enable `putSigned(key, data, options?)` and
-  `putEncrypted(key, data, recipientPublicKey, options?)`. Both return the same
-  success boolean as `put()`. Encrypted values are signed by the sender and
-  transparently decrypted for the recipient by OpenDHT's get/listen layer.
-
-```js
-import { Identity, DhtRunner } from 'opendht';
-
-async function createAuthenticatedNode() {
-    const identity = await Identity.generate('example', { algorithm: 'rsa', bits: 2048 });
-    const runner = new DhtRunner();
-    runner.run({ port: 0, identity });
-    return { runner, identity };
-}
-```
-
-Crypto methods take Uint8Array/Buffer inputs, not implicit text encodings. Imports
-must be nonempty. Malformed handles/data,
-mismatched identities, and unsupported encryption keys raise JS exceptions.
-Only generation is asynchronous; import/export/sign/encrypt/decrypt are
-synchronous and should be used from worker threads for large workloads.
-
-## Packaging And CI
-
-From a successful Release build:
-
-```sh
-npm run package
-npm run test:package
-```
-
-`bundle` copies the addon into `prebuilds/<platform>-<arch>/`, gathers its runtime
-dependencies, rewrites native loader paths, and copies dependency license
-notices. macOS needs `dylibbundler` and Apple developer tools; Linux needs
-`patchelf` and Debian/Ubuntu dependency copyright files. Windows uses the vcpkg
-installed tree (`VCPKG_INSTALLED_DIR`, `VCPKG_DEFAULT_TRIPLET`) and MSVC tools.
-`OPENDHT_LIBRARY_PATH` adds native library search directories when bundling.
-An explicit addon path may be passed to `npm run bundle -- /absolute/addon.node`.
-Bundling replaces only the current platform's generated prebuild directory.
-
-`test:package` creates an npm archive, installs it in a temporary consumer with
-install scripts disabled and no dev dependencies, forces prebuild-only loading,
-and runs the full runtime suite. Pass an archive file or a directory containing
-one archive to test it directly, for example `npm run test:package -- dist`.
-Only runtime JS, declarations, the example's TypeScript source, documentation,
-and prebuilds are included in the archive. `prepack` compiles the example, so
-archive creation needs the development dependencies; archive installation does not.
-
-The [Node.js package workflow](../.github/workflows/nodejs-package.yml) builds:
-
-| Target | Build Baseline |
-| --- | --- |
-| Linux x64 | Ubuntu 24.04 / glibc 2.39 (Noble dependency image) |
-| macOS ARM64 and x64 | macOS 15 |
-| Windows x64 | Windows Server 2022 / MSVC |
-
-CI combines platform prebuilds into one npm archive and verifies that archive on
-Node 22, 24, and 26 on each platform, including Ubuntu 24.04 and 26.04. Branch
-pushes, pull requests, and manual runs build and test without publishing.
-musl/Alpine and other architectures are not currently built. Node-API stability
-does not remove OS/libc or native dependency compatibility requirements. Review
-the included dependency licenses and source-distribution obligations before
-redistributing binaries.
-
-Query filters, AbortSignal support, certificate trust-store validation, CA
-issuance controls, and runtime proxy switching remain future work.
@@ -1,734 +0,0 @@
-#include <napi.h>
-#include <opendht.h>
-#include <gnutls/gnutls.h>
-#include "crypto.h"
-#include <algorithm>
-#include <atomic>
-#include <chrono>
-#include <cmath>
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <optional>
-#include <unordered_map>
-
-namespace {
-
-struct GnuTlsContext
-{
-    const int result = gnutls_global_init();
-
-    ~GnuTlsContext()
-    {
-        if (result == GNUTLS_E_SUCCESS)
-            gnutls_global_deinit();
-    }
-};
-
-using opendht_node::guarded;
-
-uint32_t
-unsignedNumber(Napi::Value value, uint32_t maximum, const char* name)
-{
-    if (!value.IsNumber())
-        throw Napi::TypeError::New(value.Env(), std::string(name) + " must be a number");
-    const auto number = value.As<Napi::Number>().DoubleValue();
-    if (!std::isfinite(number) || number < 0 || number > maximum || std::floor(number) != number)
-        throw Napi::RangeError::New(value.Env(), std::string(name) + " is out of range");
-    return static_cast<uint32_t>(number);
-}
-
-uint64_t
-unsignedBigInt(Napi::Value value)
-{
-    if (!value.IsBigInt())
-        throw Napi::TypeError::New(value.Env(), "id must be a bigint");
-    int sign = 0;
-    size_t count = 1;
-    uint64_t word = 0;
-    value.As<Napi::BigInt>().ToWords(&sign, &count, &word);
-    if (sign || count > 1)
-        throw Napi::RangeError::New(value.Env(), "id must fit in an unsigned 64-bit integer");
-    return word;
-}
-
-std::string
-text(Napi::Value value, const char* name)
-{
-    if (!value.IsString())
-        throw Napi::TypeError::New(value.Env(), std::string(name) + " must be a string");
-    auto result = value.As<Napi::String>().Utf8Value();
-    if (result.find('\0') != std::string::npos)
-        throw Napi::TypeError::New(value.Env(), std::string(name) + " must not contain NUL bytes");
-    return result;
-}
-
-dht::InfoHash
-infoHash(Napi::Value value)
-{
-    const auto result = text(value, "hash");
-    if (result.size() != 40 || result.find_first_not_of("0123456789abcdefABCDEF") != std::string::npos)
-        throw Napi::TypeError::New(value.Env(), "Expected a 40-character hexadecimal hash");
-    return dht::InfoHash(result);
-}
-
-Napi::Object
-optionsObject(Napi::Value value)
-{
-    if (!value.IsObject() || value.IsArray() || value.IsNull())
-        throw Napi::TypeError::New(value.Env(), "options must be an object");
-    return value.As<Napi::Object>();
-}
-
-Napi::Object
-valueToJS(Napi::Env env, const dht::Value& value)
-{
-    auto result = Napi::Object::New(env);
-    result.Set("id", Napi::BigInt::New(env, value.id));
-    result.Set("type", Napi::Number::New(env, value.type));
-    result.Set("seq", Napi::Number::New(env, value.seq));
-    result.Set("data", Napi::Buffer<uint8_t>::Copy(env, value.data.data(), value.data.size()));
-    result.Set("userType", Napi::String::New(env, value.user_type));
-    result.Set("owner",
-               value.owner ? Napi::Value(Napi::String::New(env, value.owner->getLongId().to_view()))
-                           : Napi::Value(env.Null()));
-    result.Set("isSigned", Napi::Boolean::New(env, value.isSigned()));
-    result.Set("isEncrypted", Napi::Boolean::New(env, value.isEncrypted()));
-    return result;
-}
-
-struct PendingOperation
-{
-    Napi::Promise::Deferred deferred;
-    bool get;
-    std::vector<std::shared_ptr<const dht::Value>> values;
-    Napi::FunctionReference onValue;
-    std::shared_ptr<std::atomic_bool> cancelled;
-};
-
-struct Subscription
-{
-    dht::InfoHash key;
-    std::shared_future<size_t> token;
-    Napi::FunctionReference callback;
-};
-
-struct RunnerState
-{
-    using Callback = std::function<void(RunnerState&)>;
-
-    explicit RunnerState(Napi::Env environment)
-        : env(environment)
-    {}
-
-    static std::shared_ptr<RunnerState> create(Napi::Env env)
-    {
-        auto state = std::make_shared<RunnerState>(env);
-        auto dispatchOwner = std::make_unique<std::shared_ptr<RunnerState>>(state);
-        napi_threadsafe_function function;
-        if (napi_create_threadsafe_function(env,
-                                            nullptr,
-                                            nullptr,
-                                            Napi::String::New(env, "OpenDHT callbacks"),
-                                            0,
-                                            1,
-                                            dispatchOwner.get(),
-                                            finalizeDispatcher,
-                                            state.get(),
-                                            dispatch,
-                                            &function)
-            != napi_ok)
-            throw Napi::Error::New(env, "Could not create OpenDHT callback dispatcher");
-        dispatchOwner.release();
-        state->dispatcher = Napi::ThreadSafeFunction(function);
-        state->dispatcher.Unref(env);
-        auto closeOwner = std::make_unique<std::shared_ptr<RunnerState>>(state);
-        if (napi_create_async_work(env,
-                                   nullptr,
-                                   Napi::String::New(env, "OpenDHT close"),
-                                   executeClose,
-                                   completeClose,
-                                   closeOwner.get(),
-                                   &state->closeWork)
-            != napi_ok) {
-            state->dispatcher.Release();
-            throw Napi::Error::New(env, "Could not create OpenDHT cleanup work");
-        }
-        if (napi_add_async_cleanup_hook(env, cleanup, state.get(), &state->cleanupHook) != napi_ok) {
-            napi_delete_async_work(env, state->closeWork);
-            state->dispatcher.Release();
-            throw Napi::Error::New(env, "Could not register OpenDHT cleanup hook");
-        }
-        state->closeOwner = closeOwner.release();
-        return state;
-    }
-
-    void requireRunning() const
-    {
-        if (closing)
-            throw Napi::Error::New(env, "DHT runner is closed");
-        if (!started)
-            throw Napi::Error::New(env, "DHT runner is not running");
-    }
-
-    void startClose()
-    {
-        if (closing.exchange(true))
-            return;
-        if (napi_queue_async_work(env, closeWork) != napi_ok) {
-            executeClose(env, closeOwner);
-            completeClose(env, napi_ok, closeOwner);
-        }
-    }
-
-    void send(Callback callback)
-    {
-        if (closing)
-            return;
-        auto task = std::make_unique<Callback>(std::move(callback));
-        if (dispatcher.NonBlockingCall(static_cast<void*>(task.get())) == napi_ok)
-            task.release();
-    }
-
-    void sendValue(uint64_t operation, std::shared_ptr<const dht::Value> value, bool expired = false)
-    {
-        send([operation, value = std::move(value), expired](RunnerState& state) mutable {
-            const auto listener = state.listeners.find(operation);
-            if (listener != state.listeners.end()) {
-                listener->second.callback.Call({valueToJS(state.env, *value), Napi::Boolean::New(state.env, expired)});
-            } else if (const auto pending = state.operations.find(operation); pending != state.operations.end()) {
-                if (!pending->second.onValue.IsEmpty())
-                    pending->second.onValue.Call({valueToJS(state.env, *value)});
-                else
-                    pending->second.values.emplace_back(std::move(value));
-            }
-        });
-    }
-
-    void completeOperation(uint64_t identifier, bool ok)
-    {
-        const auto pending = operations.find(identifier);
-        if (pending == operations.end())
-            return;
-        auto operation = std::move(pending->second);
-        operations.erase(pending);
-        if (!operation.get) {
-            operation.deferred.Resolve(Napi::Boolean::New(env, ok));
-        } else if (!ok) {
-            auto error = Napi::Error::New(env, "DHT get failed");
-            error.Set("code", "ERR_DHT_GET_FAILED");
-            operation.deferred.Reject(error.Value());
-        } else if (!operation.onValue.IsEmpty()) {
-            operation.deferred.Resolve(env.Undefined());
-        } else {
-            auto values = Napi::Array::New(env, operation.values.size());
-            for (size_t index = 0; index < operation.values.size(); ++index)
-                values.Set(static_cast<uint32_t>(index), valueToJS(env, *operation.values[index]));
-            operation.deferred.Resolve(values);
-        }
-    }
-
-    Napi::Object status() const
-    {
-        auto result = Napi::Object::New(env);
-        result.Set("ipv4", Napi::String::New(env, dht::statusToStr(closing ? dht::NodeStatus::Disconnected : status4)));
-        result.Set("ipv6", Napi::String::New(env, dht::statusToStr(closing ? dht::NodeStatus::Disconnected : status6)));
-        return result;
-    }
-
-    static void dispatch(napi_env environment, napi_value, void* context, void* data)
-    {
-        auto state = static_cast<RunnerState*>(context);
-        std::unique_ptr<Callback> callback(static_cast<Callback*>(data));
-        if (!environment || state->envClosing || state->closing)
-            return;
-        try {
-            (*callback)(*state);
-        } catch (const Napi::Error& error) {
-            napi_fatal_exception(environment, error.Value());
-        } catch (const std::exception& error) {
-            napi_fatal_exception(environment, Napi::Error::New(environment, error.what()).Value());
-        }
-    }
-
-    static void finalizeDispatcher(napi_env, void* data, void*)
-    {
-        delete static_cast<std::shared_ptr<RunnerState>*>(data);
-    }
-
-    static void cleanup(napi_async_cleanup_hook_handle, void* data)
-    {
-        auto state = static_cast<RunnerState*>(data);
-        state->envClosing = true;
-        state->startClose();
-    }
-
-    static void executeClose(napi_env, void* data)
-    {
-        auto state = *static_cast<std::shared_ptr<RunnerState>*>(data);
-        struct ShutdownSignal
-        {
-            std::mutex mutex;
-            std::condition_variable condition;
-            bool done = false;
-        };
-        try {
-            auto signal = std::make_shared<ShutdownSignal>();
-            state->runner.shutdown(
-                [signal] {
-                    std::lock_guard lock(signal->mutex);
-                    signal->done = true;
-                    signal->condition.notify_one();
-                },
-                true);
-            std::unique_lock lock(signal->mutex);
-            signal->condition.wait_for(lock, std::chrono::seconds(2), [&] { return signal->done; });
-        } catch (const std::exception& error) {
-            state->closeError = error.what();
-        }
-        state->runner.join();
-    }
-
-    Napi::Error makeCloseError() const
-    {
-        auto error = Napi::Error::New(env, closeError.empty() ? "DHT runner is closed" : closeError);
-        error.Set("code", "ERR_DHT_CLOSED");
-        return error;
-    }
-
-    static void completeClose(napi_env environment, napi_status, void* data)
-    {
-        std::unique_ptr<std::shared_ptr<RunnerState>> owner(static_cast<std::shared_ptr<RunnerState>*>(data));
-        auto state = *owner;
-        state->finished = true;
-        if (!state->envClosing) {
-            state->dispatcher.Release();
-            auto error = state->makeCloseError();
-            for (auto& pending : state->operations)
-                pending.second.deferred.Reject(error.Value());
-            if (state->closeDeferred) {
-                if (state->closeError.empty())
-                    state->closeDeferred->Resolve(Napi::Env(environment).Undefined());
-                else
-                    state->closeDeferred->Reject(error.Value());
-            }
-        }
-        state->operations.clear();
-        state->listeners.clear();
-        state->closeDeferred.reset();
-        state->closePromise.Reset();
-        state->onStatus.Reset();
-        state->owner.Reset();
-        napi_delete_async_work(environment, state->closeWork);
-        napi_remove_async_cleanup_hook(state->cleanupHook);
-        state->closeOwner = nullptr;
-    }
-
-    Napi::Env env;
-    dht::DhtRunner runner;
-    Napi::ThreadSafeFunction dispatcher;
-    napi_async_work closeWork {};
-    napi_async_cleanup_hook_handle cleanupHook {};
-    std::shared_ptr<RunnerState>* closeOwner {};
-    std::atomic_bool closing {false};
-    bool envClosing = false;
-    bool started = false;
-    bool hasIdentity = false;
-    bool finished = false;
-    uint64_t nextOperation = 1;
-    std::string closeError;
-    std::unordered_map<uint64_t, PendingOperation> operations;
-    std::unordered_map<uint64_t, Subscription> listeners;
-    std::optional<Napi::Promise::Deferred> closeDeferred;
-    Napi::Reference<Napi::Promise> closePromise;
-    Napi::FunctionReference onStatus;
-    Napi::ObjectReference owner;
-    dht::NodeStatus status4 = dht::NodeStatus::Disconnected;
-    dht::NodeStatus status6 = dht::NodeStatus::Disconnected;
-};
-
-class Runner : public Napi::ObjectWrap<Runner>
-{
-public:
-    explicit Runner(const Napi::CallbackInfo& info)
-        : Napi::ObjectWrap<Runner>(info)
-        , state_(RunnerState::create(info.Env()))
-    {
-        if (info.Length() && info[0].IsFunction())
-            state_->onStatus = Napi::Persistent(info[0].As<Napi::Function>());
-    }
-
-    ~Runner() override { state_->startClose(); }
-
-    static Napi::Function define(Napi::Env env)
-    {
-        return DefineClass(env,
-                           "NativeRunner",
-                           {
-                               InstanceMethod("run", &Runner::run),
-                               InstanceMethod("close", &Runner::close),
-                               InstanceMethod("isRunning", &Runner::isRunning),
-                               InstanceMethod("getBoundPort", &Runner::getBoundPort),
-                               InstanceMethod("getNodeId", &Runner::getNodeId),
-                               InstanceMethod("getStatus", &Runner::getStatus),
-                               InstanceMethod("bootstrap", &Runner::bootstrap),
-                               InstanceMethod("get", &Runner::get),
-                               InstanceMethod("getAll", &Runner::getAll),
-                               InstanceMethod("cancelGet", &Runner::cancelGet),
-                               InstanceMethod("put", &Runner::put),
-                               InstanceMethod("putSigned", &Runner::putSigned),
-                               InstanceMethod("putEncrypted", &Runner::putEncrypted),
-                               InstanceMethod("listen", &Runner::listen),
-                               InstanceMethod("cancelListen", &Runner::cancelListen),
-                               InstanceMethod("ref", &Runner::ref),
-                               InstanceMethod("unref", &Runner::unref),
-                               InstanceMethod("setOwner", &Runner::setOwner),
-                           });
-    }
-
-private:
-    Napi::Value run(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            if (state_->closing)
-                throw Napi::Error::New(info.Env(), "DHT runner is closed");
-            if (state_->started)
-                throw Napi::Error::New(info.Env(), "DHT runner is already running");
-            auto options = info.Length() && !info[0].IsUndefined() ? optionsObject(info[0])
-                                                                   : Napi::Object::New(info.Env());
-            const auto port = options.Has("port") ? unsignedNumber(options.Get("port"), 65535, "port") : 0;
-            const auto ipv4 = options.Has("ipv4") ? text(options.Get("ipv4"), "ipv4") : "0.0.0.0";
-            const auto ipv6 = options.Has("ipv6") ? text(options.Get("ipv6"), "ipv6") : "::";
-            dht::DhtRunner::Config config;
-            if (options.Has("network"))
-                config.dht_config.node_config.network = unsignedNumber(options.Get("network"), UINT32_MAX, "network");
-            if (options.Has("persistPath"))
-                config.dht_config.node_config.persist_path = text(options.Get("persistPath"), "persistPath");
-            if (options.Has("identity"))
-                config.dht_config.id = opendht_node::readIdentity(options.Get("identity"));
-            if (options.Has("proxyServer"))
-                config.proxy_server = text(options.Get("proxyServer"), "proxyServer");
-            if (options.Has("proxyUserAgent")) {
-                config.proxy_user_agent = text(options.Get("proxyUserAgent"), "proxyUserAgent");
-                if (config.proxy_user_agent.find_first_of("\r\n") != std::string::npos)
-                    throw Napi::TypeError::New(info.Env(), "proxyUserAgent must not contain line breaks");
-            }
-            dht::DhtRunner::Context context;
-            const std::weak_ptr<RunnerState> state = state_;
-            context.statusChangedCallback = [state](dht::NodeStatus ipv4, dht::NodeStatus ipv6) {
-                if (auto owner = state.lock())
-                    owner->send([ipv4, ipv6](RunnerState& state) {
-                        state.status4 = ipv4;
-                        state.status6 = ipv6;
-                        if (!state.onStatus.IsEmpty())
-                            state.onStatus.Call({state.status()});
-                    });
-            };
-            const auto service = std::to_string(port);
-            state_->runner.run(ipv4.c_str(), ipv6.c_str(), service.c_str(), config, std::move(context));
-            state_->started = true;
-            state_->hasIdentity = bool(config.dht_config.id.first);
-            state_->dispatcher.Ref(info.Env());
-            return info.Env().Undefined();
-        });
-    }
-
-    Napi::Value close(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            if (!state_->closePromise.IsEmpty())
-                return state_->closePromise.Value();
-            auto deferred = Napi::Promise::Deferred::New(info.Env());
-            if (state_->finished) {
-                if (!state_->closeError.empty())
-                    deferred.Reject(state_->makeCloseError().Value());
-                else
-                    deferred.Resolve(info.Env().Undefined());
-            } else {
-                state_->closeDeferred = deferred;
-                state_->closePromise = Napi::Persistent(deferred.Promise());
-                state_->startClose();
-            }
-            return deferred.Promise();
-        });
-    }
-
-    Napi::Value isRunning(const Napi::CallbackInfo& info)
-    {
-        return Napi::Boolean::New(info.Env(), !state_->closing && state_->runner.isRunning());
-    }
-
-    Napi::Value getStatus(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value { return state_->status(); });
-    }
-
-    Napi::Value getBoundPort(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            const auto family = info.Length() ? unsignedNumber(info[0], 6, "family") : 4;
-            if (family != 4 && family != 6)
-                throw Napi::RangeError::New(info.Env(), "family must be 4 or 6");
-            return Napi::Number::New(info.Env(), state_->runner.getBoundPort(family == 4 ? AF_INET : AF_INET6));
-        });
-    }
-
-    Napi::Value getNodeId(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            return Napi::String::New(info.Env(), state_->runner.getNodeId().to_view());
-        });
-    }
-
-    Napi::Value bootstrap(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            const auto host = text(info[0], "host");
-            const auto port = unsignedNumber(info[1], 65535, "port");
-            if (host.empty() || !port)
-                throw Napi::RangeError::New(info.Env(), "bootstrap requires a host and nonzero port");
-            state_->runner.bootstrap(host, std::to_string(port));
-            return info.Env().Undefined();
-        });
-    }
-
-    Napi::Value get(const Napi::CallbackInfo& info) { return getValues(info, true); }
-
-    Napi::Value getAll(const Napi::CallbackInfo& info) { return getValues(info, false); }
-
-    Napi::Value getValues(const Napi::CallbackInfo& info, bool stream)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            const auto key = infoHash(info[0]);
-            if (stream && !info[1].IsFunction())
-                throw Napi::TypeError::New(info.Env(), "callback must be a function");
-            const auto operation = state_->nextOperation++;
-            auto deferred = Napi::Promise::Deferred::New(info.Env());
-            auto cancelled = std::make_shared<std::atomic_bool>(false);
-            PendingOperation pending {deferred, true, {}, {}, cancelled};
-            if (stream)
-                pending.onValue = Napi::Persistent(info[1].As<Napi::Function>());
-            state_->operations.emplace(operation, std::move(pending));
-            const std::weak_ptr<RunnerState> state = state_;
-            try {
-                state_->runner.get(key,
-                                   dht::GetCallback([state, operation, cancelled](
-                                                        const std::vector<std::shared_ptr<dht::Value>>& values) {
-                                       const auto owner = state.lock();
-                                       if (!owner || owner->closing || *cancelled)
-                                           return false;
-                                       for (const auto& value : values)
-                                           owner->sendValue(operation, value);
-                                       return !owner->closing && !*cancelled;
-                                   }),
-                                   dht::DoneCallbackSimple([state, operation](bool ok) {
-                                       if (const auto owner = state.lock())
-                                           owner->send([operation, ok](RunnerState& state) {
-                                               state.completeOperation(operation, ok);
-                                           });
-                                   }));
-            } catch (...) {
-                state_->operations.erase(operation);
-                throw;
-            }
-            if (stream) {
-                auto result = Napi::Object::New(info.Env());
-                result.Set("token", Napi::BigInt::New(info.Env(), operation));
-                result.Set("done", deferred.Promise());
-                return result;
-            }
-            return deferred.Promise();
-        });
-    }
-
-    Napi::Value cancelGet(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            const auto operation = state_->operations.find(unsignedBigInt(info[0]));
-            if (operation != state_->operations.end() && !operation->second.onValue.IsEmpty()) {
-                *operation->second.cancelled = true;
-                operation->second.deferred.Resolve(info.Env().Undefined());
-                state_->operations.erase(operation);
-            }
-            return info.Env().Undefined();
-        });
-    }
-
-    Napi::Value put(const Napi::CallbackInfo& info) { return putValue(info, PutMode::Plain); }
-
-    Napi::Value putSigned(const Napi::CallbackInfo& info) { return putValue(info, PutMode::Signed); }
-
-    Napi::Value putEncrypted(const Napi::CallbackInfo& info) { return putValue(info, PutMode::Encrypted); }
-
-    enum class PutMode { Plain, Signed, Encrypted };
-
-    Napi::Value putValue(const Napi::CallbackInfo& info, PutMode mode)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            if (mode != PutMode::Plain && !state_->hasIdentity)
-                throw Napi::Error::New(info.Env(), "Signed and encrypted puts require an identity");
-            std::shared_ptr<dht::crypto::PublicKey> recipient;
-            if (mode == PutMode::Encrypted) {
-                recipient = opendht_node::readEncryptionKey(info[3]);
-            }
-            const auto key = infoHash(info[0]);
-            if (!info[1].IsTypedArray() || info[1].As<Napi::TypedArray>().TypedArrayType() != napi_uint8_array)
-                throw Napi::TypeError::New(info.Env(), "data must be a Uint8Array");
-            const auto data = info[1].As<Napi::Uint8Array>();
-            dht::Blob bytes(data.ElementLength());
-            if (!bytes.empty())
-                std::copy_n(data.Data(), bytes.size(), bytes.data());
-            auto value = std::make_shared<dht::Value>(std::move(bytes));
-            auto options = info.Length() > 2 && !info[2].IsUndefined() ? optionsObject(info[2])
-                                                                       : Napi::Object::New(info.Env());
-            if (options.Has("id"))
-                value->id = unsignedBigInt(options.Get("id"));
-            if (options.Has("type"))
-                value->type = unsignedNumber(options.Get("type"), 65535, "type");
-            if (options.Has("userType")) {
-                if (!options.Get("userType").IsString())
-                    throw Napi::TypeError::New(info.Env(), "userType must be a string");
-                value->user_type = options.Get("userType").As<Napi::String>().Utf8Value();
-            }
-            bool permanent = false;
-            if (options.Has("permanent")) {
-                if (!options.Get("permanent").IsBoolean())
-                    throw Napi::TypeError::New(info.Env(), "permanent must be a boolean");
-                permanent = options.Get("permanent").As<Napi::Boolean>().Value();
-            }
-            const auto operation = state_->nextOperation++;
-            auto deferred = Napi::Promise::Deferred::New(info.Env());
-            state_->operations.emplace(operation, PendingOperation {deferred, false, {}, {}, {}});
-            const std::weak_ptr<RunnerState> state = state_;
-            try {
-                dht::DoneCallbackSimple done = [state, operation](bool ok) {
-                    if (const auto owner = state.lock())
-                        owner->send([operation, ok](RunnerState& state) { state.completeOperation(operation, ok); });
-                };
-                if (mode == PutMode::Signed)
-                    state_->runner.putSigned(key, value, std::move(done), permanent);
-                else if (mode == PutMode::Encrypted)
-                    state_->runner.putEncrypted(key, recipient, value, std::move(done), permanent);
-                else
-                    state_->runner.put(key, value, std::move(done), dht::time_point::max(), permanent);
-            } catch (...) {
-                state_->operations.erase(operation);
-                throw;
-            }
-            return deferred.Promise();
-        });
-    }
-
-    Napi::Value listen(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            const auto key = infoHash(info[0]);
-            if (!info[1].IsFunction())
-                throw Napi::TypeError::New(info.Env(), "callback must be a function");
-            const auto operation = state_->nextOperation++;
-            const std::weak_ptr<RunnerState> state = state_;
-            auto token = state_->runner
-                             .listen(key,
-                                     dht::ValueCallback(
-                                         [state, operation](const std::vector<std::shared_ptr<dht::Value>>& values,
-                                                            bool expired) {
-                                             const auto owner = state.lock();
-                                             if (!owner || owner->closing)
-                                                 return false;
-                                             for (const auto& value : values)
-                                                 owner->sendValue(operation, value, expired);
-                                             return !owner->closing;
-                                         }))
-                             .share();
-            state_->listeners.emplace(operation,
-                                      Subscription {key,
-                                                    std::move(token),
-                                                    Napi::Persistent(info[1].As<Napi::Function>())});
-            return Napi::BigInt::New(info.Env(), operation);
-        });
-    }
-
-    Napi::Value cancelListen(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            if (state_->closing)
-                return info.Env().Undefined();
-            const auto listener = state_->listeners.find(unsignedBigInt(info[0]));
-            if (listener != state_->listeners.end()) {
-                state_->runner.cancelListen(listener->second.key, listener->second.token);
-                state_->listeners.erase(listener);
-            }
-            return info.Env().Undefined();
-        });
-    }
-
-    Napi::Value ref(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            state_->dispatcher.Ref(info.Env());
-            return info.This();
-        });
-    }
-
-    Napi::Value unref(const Napi::CallbackInfo& info)
-    {
-        return guarded(info, [&]() -> Napi::Value {
-            state_->requireRunning();
-            state_->dispatcher.Unref(info.Env());
-            return info.This();
-        });
-    }
-
-    Napi::Value setOwner(const Napi::CallbackInfo& info)
-    {
-        if (!state_->closing) {
-            state_->owner.Reset();
-            if (info[0].IsObject())
-                state_->owner = Napi::Persistent(info[0].As<Napi::Object>());
-        }
-        return info.Env().Undefined();
-    }
-
-    std::shared_ptr<RunnerState> state_;
-};
-
-Napi::Value
-hash(const Napi::CallbackInfo& info)
-{
-    const auto env = info.Env();
-    dht::InfoHash result;
-    if (info.Length() == 1 && info[0].IsString()) {
-        result = dht::InfoHash::get(info[0].As<Napi::String>().Utf8Value());
-    } else if (info.Length() == 1 && info[0].IsTypedArray()
-               && info[0].As<Napi::TypedArray>().TypedArrayType() == napi_uint8_array) {
-        const auto data = info[0].As<Napi::Uint8Array>();
-        result = dht::InfoHash::get(data.Data(), data.ElementLength());
-    } else {
-        throw Napi::TypeError::New(env, "Expected a string or Uint8Array");
-    }
-    return Napi::String::New(env, result.to_view());
-}
-
-Napi::Object
-initialize(Napi::Env env, Napi::Object exports)
-{
-    static const GnuTlsContext crypto;
-    if (crypto.result != GNUTLS_E_SUCCESS)
-        throw Napi::Error::New(env, std::string("Unable to initialize GnuTLS: ") + gnutls_strerror(crypto.result));
-    opendht_node::initializeCrypto(env, exports);
-    exports.Set("NativeRunner", Runner::define(env));
-    exports.Set("hash", Napi::Function::New(env, hash));
-    exports.Set("version", Napi::String::New(env, dht::version()));
-    return exports;
-}
-
-} // namespace
-
-NODE_API_MODULE(opendht, initialize)
@@ -1,304 +0,0 @@
-#include "crypto.h"
-
-#include <algorithm>
-#include <cmath>
-#include <variant>
-
-namespace opendht_node {
-namespace {
-
-using PublicKey = std::shared_ptr<dht::crypto::PublicKey>;
-using PrivateKey = std::shared_ptr<dht::crypto::PrivateKey>;
-using Certificate = std::shared_ptr<dht::crypto::Certificate>;
-using Identity = dht::crypto::Identity;
-using Handle = std::variant<PublicKey, PrivateKey, Certificate, Identity>;
-
-constexpr napi_type_tag cryptoTag {0x37cdf3e4648e4cb5ULL, 0x964fb031062c245aULL};
-
-Handle&
-handle(Napi::Value value)
-{
-    bool matches = false;
-    if (!value.IsExternal() || napi_check_object_type_tag(value.Env(), value, &cryptoTag, &matches) != napi_ok
-        || !matches)
-        throw Napi::TypeError::New(value.Env(), "Invalid OpenDHT crypto handle");
-    return *value.As<Napi::External<Handle>>().Data();
-}
-
-template<typename Type>
-Type
-read(Napi::Value value)
-{
-    if (auto result = std::get_if<Type>(&handle(value)))
-        return *result;
-    throw Napi::TypeError::New(value.Env(), "Wrong OpenDHT crypto handle type");
-}
-
-Napi::Value
-wrap(Napi::Env env, Handle value)
-{
-    auto owner = std::make_unique<Handle>(std::move(value));
-    auto result = Napi::External<Handle>::New(env, owner.get(), [](Napi::Env, Handle* data) { delete data; });
-    owner.release();
-    if (napi_type_tag_object(env, result, &cryptoTag) != napi_ok)
-        throw Napi::Error::New(env, "Could not tag OpenDHT crypto handle");
-    return result;
-}
-
-dht::Blob
-bytes(Napi::Value value)
-{
-    if (!value.IsTypedArray() || value.As<Napi::TypedArray>().TypedArrayType() != napi_uint8_array)
-        throw Napi::TypeError::New(value.Env(), "Expected a Uint8Array");
-    auto array = value.As<Napi::Uint8Array>();
-    dht::Blob result(array.ElementLength());
-    if (!result.empty())
-        std::copy_n(array.Data(), result.size(), result.data());
-    return result;
-}
-
-std::string
-string(Napi::Value value)
-{
-    if (!value.IsString())
-        throw Napi::TypeError::New(value.Env(), "Expected a string");
-    auto result = value.As<Napi::String>().Utf8Value();
-    if (result.find('\0') != std::string::npos)
-        throw Napi::TypeError::New(value.Env(), "Crypto strings must not contain NUL bytes");
-    return result;
-}
-
-Napi::Buffer<uint8_t>
-buffer(Napi::Env env, const dht::Blob& value)
-{
-    return Napi::Buffer<uint8_t>::Copy(env, value.data(), value.size());
-}
-
-PublicKey
-publicKey(const Handle& value)
-{
-    if (auto key = std::get_if<PublicKey>(&value))
-        return *key;
-    if (auto key = std::get_if<PrivateKey>(&value))
-        return (*key)->getSharedPublicKey();
-    if (auto certificate = std::get_if<Certificate>(&value))
-        return (*certificate)->getSharedPublicKey();
-    return std::get<Identity>(value).second->getSharedPublicKey();
-}
-
-class GenerateWorker : public Napi::AsyncWorker
-{
-public:
-    GenerateWorker(Napi::Env env, bool identity, std::string name, bool rsa, unsigned bits)
-        : Napi::AsyncWorker(env, "OpenDHT crypto generation")
-        , deferred_(Napi::Promise::Deferred::New(env))
-        , identity_(identity)
-        , name_(std::move(name))
-        , rsa_(rsa)
-        , bits_(bits)
-    {}
-
-    Napi::Promise promise() const { return deferred_.Promise(); }
-
-    void Execute() override
-    {
-        try {
-            if (identity_)
-                result_ = rsa_ ? dht::crypto::generateIdentity(name_, {}, bits_)
-                               : dht::crypto::generateEcIdentity(name_);
-            else
-                result_ = std::make_shared<dht::crypto::PrivateKey>(rsa_ ? dht::crypto::PrivateKey::generate(bits_)
-                                                                         : dht::crypto::PrivateKey::generateEC());
-        } catch (const std::exception& error) {
-            SetError(error.what());
-        }
-    }
-
-    void OnOK() override { deferred_.Resolve(wrap(Env(), std::move(result_))); }
-    void OnError(const Napi::Error& error) override { deferred_.Reject(error.Value()); }
-
-private:
-    Napi::Promise::Deferred deferred_;
-    bool identity_;
-    std::string name_;
-    bool rsa_;
-    unsigned bits_;
-    Handle result_;
-};
-
-Napi::Value
-generate(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        const auto kind = string(info[0]);
-        const auto name = string(info[1]);
-        const auto algorithm = string(info[2]);
-        if (algorithm != "rsa" && algorithm != "ec")
-            throw Napi::TypeError::New(info.Env(), "algorithm must be rsa or ec");
-        if (!info[3].IsNumber())
-            throw Napi::TypeError::New(info.Env(), "bits must be a number");
-        const auto bits = info[3].As<Napi::Number>().DoubleValue();
-        if (!std::isfinite(bits) || std::floor(bits) != bits || bits < 2048 || bits > 8192)
-            throw Napi::RangeError::New(info.Env(), "RSA bits must be an integer between 2048 and 8192");
-        if (kind != "private" && kind != "identity")
-            throw Napi::TypeError::New(info.Env(), "Invalid crypto generation type");
-        auto worker = std::make_unique<GenerateWorker>(info.Env(), kind == "identity", name, algorithm == "rsa", bits);
-        auto promise = worker->promise();
-        worker->Queue();
-        worker.release();
-        return promise;
-    });
-}
-
-Napi::Value
-import(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        const auto kind = string(info[0]);
-        auto data = bytes(info[1]);
-        if (data.empty())
-            throw Napi::TypeError::New(info.Env(), "Crypto imports must not be empty");
-        if (kind == "private")
-            return wrap(info.Env(), std::make_shared<dht::crypto::PrivateKey>(data, string(info[2])));
-        if (kind == "public")
-            return wrap(info.Env(), std::make_shared<dht::crypto::PublicKey>(data));
-        if (kind == "certificate")
-            return wrap(info.Env(), std::make_shared<dht::crypto::Certificate>(data));
-        throw Napi::TypeError::New(info.Env(), "Invalid crypto import type");
-    });
-}
-
-Napi::Value
-serialize(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        auto& value = handle(info[0]);
-        if (auto key = std::get_if<PrivateKey>(&value))
-            return buffer(info.Env(), (*key)->serialize(string(info[1])));
-        if (auto certificate = std::get_if<Certificate>(&value))
-            return buffer(info.Env(), (*certificate)->getPacked());
-        dht::Blob result;
-        readPublicKey(info[0])->pack(result);
-        return buffer(info.Env(), result);
-    });
-}
-
-Napi::Value
-getPublicKey(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&] { return wrap(info.Env(), publicKey(handle(info[0]))); });
-}
-
-Napi::Value
-getId(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        const auto key = publicKey(handle(info[0]));
-        if (!info[1].IsBoolean())
-            throw Napi::TypeError::New(info.Env(), "Expected a boolean");
-        return Napi::String::New(info.Env(),
-                                 info[1].As<Napi::Boolean>().Value() ? key->getLongId().toString()
-                                                                     : key->getId().toString());
-    });
-}
-
-Napi::Value
-sign(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        return buffer(info.Env(), read<PrivateKey>(info[0])->sign(bytes(info[1])));
-    });
-}
-
-Napi::Value
-verify(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        return Napi::Boolean::New(info.Env(), readPublicKey(info[0])->checkSignature(bytes(info[1]), bytes(info[2])));
-    });
-}
-
-Napi::Value
-encrypt(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        const auto key = readEncryptionKey(info[0]);
-        return buffer(info.Env(), key->encrypt(bytes(info[1])));
-    });
-}
-
-Napi::Value
-decrypt(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        return buffer(info.Env(), read<PrivateKey>(info[0])->decrypt(bytes(info[1])));
-    });
-}
-
-Napi::Value
-identity(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        auto key = read<PrivateKey>(info[0]);
-        auto certificate = read<Certificate>(info[1]);
-        if (key->getPublicKey().getLongId() != certificate->getLongId())
-            throw Napi::TypeError::New(info.Env(), "Identity key and certificate do not match");
-        return wrap(info.Env(), Identity {std::move(key), std::move(certificate)});
-    });
-}
-
-Napi::Value
-identityPart(const Napi::CallbackInfo& info)
-{
-    return guarded(info, [&]() -> Napi::Value {
-        const auto value = readIdentity(info[0]);
-        if (!info[1].IsBoolean())
-            throw Napi::TypeError::New(info.Env(), "Expected a boolean");
-        return info[1].As<Napi::Boolean>().Value() ? wrap(info.Env(), value.first) : wrap(info.Env(), value.second);
-    });
-}
-
-} // namespace
-
-dht::crypto::Identity
-readIdentity(Napi::Value value)
-{
-    return read<Identity>(value);
-}
-std::shared_ptr<dht::crypto::PublicKey>
-readPublicKey(Napi::Value value)
-{
-    return read<PublicKey>(value);
-}
-
-std::shared_ptr<dht::crypto::PublicKey>
-readEncryptionKey(Napi::Value value)
-{
-    const auto key = readPublicKey(value);
-    const auto algorithm = gnutls_pubkey_get_pk_algorithm(key->pk, nullptr);
-    if (algorithm != GNUTLS_PK_RSA
-#if GNUTLS_VERSION_NUMBER >= 0x030804
-        && algorithm != GNUTLS_PK_RSA_OAEP
-#endif
-    )
-        throw Napi::TypeError::New(value.Env(), "Encryption requires an RSA public key");
-    return key;
-}
-
-void
-initializeCrypto(Napi::Env env, Napi::Object exports)
-{
-    exports.Set("cryptoGenerate", Napi::Function::New(env, generate));
-    exports.Set("cryptoImport", Napi::Function::New(env, import));
-    exports.Set("cryptoSerialize", Napi::Function::New(env, serialize));
-    exports.Set("cryptoPublicKey", Napi::Function::New(env, getPublicKey));
-    exports.Set("cryptoId", Napi::Function::New(env, getId));
-    exports.Set("cryptoSign", Napi::Function::New(env, sign));
-    exports.Set("cryptoVerify", Napi::Function::New(env, verify));
-    exports.Set("cryptoEncrypt", Napi::Function::New(env, encrypt));
-    exports.Set("cryptoDecrypt", Napi::Function::New(env, decrypt));
-    exports.Set("cryptoIdentity", Napi::Function::New(env, identity));
-    exports.Set("cryptoIdentityPart", Napi::Function::New(env, identityPart));
-}
-
-} // namespace opendht_node
@@ -1,26 +0,0 @@
-#pragma once
-
-#include <napi.h>
-#include <opendht/crypto.h>
-
-namespace opendht_node {
-
-template<typename Callback>
-Napi::Value
-guarded(const Napi::CallbackInfo& info, Callback&& callback)
-{
-    try {
-        return callback();
-    } catch (const Napi::Error&) {
-        throw;
-    } catch (const std::exception& error) {
-        throw Napi::Error::New(info.Env(), error.what());
-    }
-}
-
-dht::crypto::Identity readIdentity(Napi::Value value);
-std::shared_ptr<dht::crypto::PublicKey> readPublicKey(Napi::Value value);
-std::shared_ptr<dht::crypto::PublicKey> readEncryptionKey(Napi::Value value);
-void initializeCrypto(Napi::Env env, Napi::Object exports);
-
-} // namespace opendht_node
@@ -1,56 +0,0 @@
-export default function createCrypto(native) {
-    const handles = new WeakMap();
-
-    function handle(value, Type) {
-        if (!(value instanceof Type) || !handles.has(value)) throw new TypeError(`Expected ${Type.name}`);
-        return handles.get(value);
-    }
-
-    function wrap(Type, nativeHandle) {
-        const result = Object.create(Type.prototype);
-        handles.set(result, nativeHandle);
-        return result;
-    }
-
-    function generate(kind, name, options = {}) {
-        if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Invalid crypto options');
-        return native.cryptoGenerate(kind, name, options.algorithm ?? 'ec', options.bits ?? 2048);
-    }
-
-    class PublicKey {
-        constructor(data) { handles.set(this, native.cryptoImport('public', data)); }
-        serialize() { return native.cryptoSerialize(handle(this, PublicKey)); }
-        getId() { return native.cryptoId(handle(this, PublicKey), false); }
-        getLongId() { return native.cryptoId(handle(this, PublicKey), true); }
-        checkSignature(data, signature) { return native.cryptoVerify(handle(this, PublicKey), data, signature); }
-        encrypt(data) { return native.cryptoEncrypt(handle(this, PublicKey), data); }
-    }
-
-    class PrivateKey {
-        constructor(data, password = '') { handles.set(this, native.cryptoImport('private', data, password)); }
-        static generate(options) { return generate('private', '', options).then(value => wrap(PrivateKey, value)); }
-        serialize(password = '') { return native.cryptoSerialize(handle(this, PrivateKey), password); }
-        getPublicKey() { return wrap(PublicKey, native.cryptoPublicKey(handle(this, PrivateKey))); }
-        sign(data) { return native.cryptoSign(handle(this, PrivateKey), data); }
-        decrypt(data) { return native.cryptoDecrypt(handle(this, PrivateKey), data); }
-    }
-
-    class Certificate {
-        constructor(data) { handles.set(this, native.cryptoImport('certificate', data)); }
-        serialize() { return native.cryptoSerialize(handle(this, Certificate)); }
-        getPublicKey() { return wrap(PublicKey, native.cryptoPublicKey(handle(this, Certificate))); }
-        getId() { return native.cryptoId(handle(this, Certificate), false); }
-        getLongId() { return native.cryptoId(handle(this, Certificate), true); }
-    }
-
-    class Identity {
-        constructor(privateKey, certificate) {
-            handles.set(this, native.cryptoIdentity(handle(privateKey, PrivateKey), handle(certificate, Certificate)));
-        }
-        static generate(name = 'dhtnode', options) { return generate('identity', name, options).then(value => wrap(Identity, value)); }
-        get privateKey() { return wrap(PrivateKey, native.cryptoIdentityPart(handle(this, Identity), true)); }
-        get certificate() { return wrap(Certificate, native.cryptoIdentityPart(handle(this, Identity), false)); }
-    }
-
-    return { PublicKey, PrivateKey, Certificate, Identity, handle };
-}
@@ -1,171 +0,0 @@
-#!/usr/bin/env node
-
-import { clearLine, createInterface, cursorTo, type Interface } from 'node:readline';
-import { parseArgs } from 'node:util';
-import type { ConnectivityStatus, Listener, Value } from '../index.js';
-
-const commands = 'get KEY | put KEY TEXT | sign KEY TEXT | listen KEY | cancel KEY | help | quit';
-
-function portNumber(value: string, name: string, minimum = 0): number {
-    const port = Number(value);
-    if (!Number.isInteger(port) || port < minimum || port > 65535) {
-        throw new Error(`${name} must be an integer between ${minimum} and 65535`);
-    }
-    return port;
-}
-
-function errorMessage(error: unknown): string {
-    return error instanceof Error ? error.message : String(error);
-}
-
-function report(error: unknown): void {
-    console.error(errorMessage(error));
-    process.exitCode = 1;
-}
-
-async function main(): Promise<void> {
-    const { values } = parseArgs({
-        options: {
-            help: { type: 'boolean', short: 'h' },
-            port: { type: 'string', short: 'p', default: '4222' },
-            ipv4: { type: 'string', default: '0.0.0.0' },
-            ipv6: { type: 'string', default: '::' },
-            bootstrap: { type: 'string', short: 'b' },
-            'bootstrap-port': { type: 'string', default: '4222' },
-        },
-    });
-    if (values.help) {
-        console.log(`Usage: npm run dhtnode -- [options]
-
-  -p, --port PORT           Local UDP port (default: 4222; 0 selects a free port)
-  -b, --bootstrap HOST      Optional bootstrap hostname or IP address
-      --bootstrap-port PORT  Bootstrap UDP port (default: 4222)
-      --ipv4 ADDRESS       IPv4 bind address (default: 0.0.0.0)
-      --ipv6 ADDRESS       IPv6 bind address (default: ::)
-  -h, --help               Show help
-
-Commands: ${commands}
-Keys are text labels hashed with SHA-1. Values are UTF-8 text.`);
-        return;
-    }
-    const port = portNumber(values.port, 'port');
-    const bootstrapPort = portNumber(values['bootstrap-port'], 'bootstrap-port', 1);
-    const { DhtRunner, Identity, hash } = await import('../index.js');
-    const identity = await Identity.generate('dhtnode.ts');
-    const runner = new DhtRunner();
-    const listeners = new Map<string, Listener>();
-    const pending = new Set<Promise<void>>();
-    let lines: Interface | undefined;
-    let closing: Promise<void> | undefined;
-
-    function close(): Promise<void> {
-        if (!closing) {
-            for (const listener of listeners.values()) listener.cancel();
-            listeners.clear();
-            lines?.close();
-            closing = runner.close();
-        }
-        return closing;
-    }
-
-    function print(message: string): void {
-        if (process.stdout.isTTY && lines) {
-            clearLine(process.stdout, 0);
-            cursorTo(process.stdout, 0);
-        }
-        console.log(message);
-        if (!closing && process.stdin.isTTY) lines?.prompt(true);
-    }
-
-    const stop = (): void => { close().catch(report); };
-    const printValue = (label: string, value: Value): void => {
-        print(`${label} ${value.id}: ${JSON.stringify(value.data.toString('utf8'))}${value.isSigned ? ' [signed]' : ''}`);
-    };
-    const printStatus = (status: ConnectivityStatus): void => {
-        print(`Connectivity: IPv4 ${status.ipv4}, IPv6 ${status.ipv6}`);
-    };
-
-    async function execute(line: string): Promise<void> {
-        const [, command, key, data] = line.trim().match(/^(\S+)(?:\s+(\S+))?(?:\s+(.+))?$/) || [];
-        if (!command) return;
-        if (command === 'help') {
-            print(commands);
-            return;
-        }
-        if (!key) throw new Error('Expected a key. Type help for commands.');
-        const location = hash(key);
-        switch (command) {
-            case 'get': {
-                const found = await runner.getAll(location);
-                if (closing) return;
-                for (const value of found) printValue(key, value);
-                if (!found.length) print(`No values for ${key}`);
-                break;
-            }
-            case 'put':
-            case 'sign': {
-                if (data === undefined) throw new Error(`Usage: ${command} KEY TEXT`);
-                const payload = Buffer.from(data, 'utf8');
-                const ok = command === 'sign' ? await runner.putSigned(location, payload)
-                    : await runner.put(location, payload);
-                if (closing) return;
-                if (!ok) throw new Error(`Put failed for ${key}`);
-                print(`Stored ${key}`);
-                break;
-            }
-            case 'listen':
-                if (!listeners.has(key)) {
-                    listeners.set(key, runner.listen(location, (value, expired) => {
-                        printValue(`${expired ? 'Expired' : 'Value'} ${key}`, value);
-                    }));
-                }
-                print(`Listening ${key}`);
-                break;
-            case 'cancel':
-                listeners.get(key)?.cancel();
-                listeners.delete(key);
-                print(`Cancelled ${key}`);
-                break;
-            default:
-                throw new Error('Unknown command. Type help for commands.');
-        }
-    }
-
-    runner.on('error', error => { report(error); stop(); });
-    runner.on('statusChanged', printStatus);
-    process.on('SIGINT', stop);
-    process.on('SIGTERM', stop);
-    try {
-        runner.run({ port, ipv4: values.ipv4, ipv6: values.ipv6, identity });
-        if (values.bootstrap) runner.bootstrap(values.bootstrap, bootstrapPort);
-        lines = createInterface({ input: process.stdin, output: process.stdout });
-        lines.on('SIGINT', stop);
-        lines.setPrompt('dht> ');
-        print(`Node ${runner.getNodeId()} listening on UDP ${runner.getBoundPort()}`);
-        printStatus(runner.getStatus());
-        if (process.stdin.isTTY) print(commands);
-        for await (const line of lines) {
-            if (closing) break;
-            if (/^(quit|exit)(?:\s|$)/.test(line.trim())) {
-                stop();
-                break;
-            }
-            const operation = execute(line).catch(error => {
-                if (!closing) console.error(errorMessage(error));
-            }).finally(() => { pending.delete(operation); });
-            pending.add(operation);
-            if (process.stdin.isTTY) lines.prompt();
-        }
-        if (!closing) await Promise.all(pending);
-    } finally {
-        try {
-            await close();
-            await Promise.all(pending);
-        } finally {
-            process.removeListener('SIGINT', stop);
-            process.removeListener('SIGTERM', stop);
-        }
-    }
-}
-
-main().catch(report);
@@ -1,120 +0,0 @@
-import { Buffer } from 'node:buffer';
-import { EventEmitter } from 'node:events';
-
-export const version: string;
-export function hash(data: string | Uint8Array): string;
-
-export interface KeyOptions {
-    algorithm?: 'ec' | 'rsa';
-    bits?: number;
-}
-
-export class PublicKey {
-    constructor(data: Uint8Array);
-    serialize(): Buffer;
-    getId(): string;
-    getLongId(): string;
-    checkSignature(data: Uint8Array, signature: Uint8Array): boolean;
-    encrypt(data: Uint8Array): Buffer;
-}
-
-export class PrivateKey {
-    constructor(data: Uint8Array, password?: string);
-    static generate(options?: KeyOptions): Promise<PrivateKey>;
-    serialize(password?: string): Buffer;
-    getPublicKey(): PublicKey;
-    sign(data: Uint8Array): Buffer;
-    decrypt(data: Uint8Array): Buffer;
-}
-
-export class Certificate {
-    constructor(data: Uint8Array);
-    serialize(): Buffer;
-    getPublicKey(): PublicKey;
-    getId(): string;
-    getLongId(): string;
-}
-
-export class Identity {
-    constructor(privateKey: PrivateKey, certificate: Certificate);
-    static generate(name?: string, options?: KeyOptions): Promise<Identity>;
-    readonly privateKey: PrivateKey;
-    readonly certificate: Certificate;
-}
-
-export interface RunOptions {
-    port?: number;
-    ipv4?: string;
-    ipv6?: string;
-    network?: number;
-    persistPath?: string;
-    identity?: Identity;
-    proxyServer?: string;
-    proxyUserAgent?: string;
-}
-
-export interface PutOptions {
-    id?: bigint;
-    type?: number;
-    userType?: string;
-    permanent?: boolean;
-}
-
-export interface Value {
-    id: bigint;
-    type: number;
-    seq: number;
-    data: Buffer;
-    userType: string;
-    owner: string | null;
-    isSigned: boolean;
-    isEncrypted: boolean;
-}
-
-export interface Listener {
-    cancel(): void;
-}
-
-export interface ListenEvent {
-    value: Value;
-    expired: boolean;
-}
-
-export interface ValueIterator<T> extends AsyncIterableIterator<T, undefined>, Listener, AsyncDisposable {
-    return(): Promise<IteratorResult<T, undefined>>;
-    throw(error?: unknown): Promise<IteratorResult<T, undefined>>;
-}
-
-export interface ListenerIterator extends ValueIterator<ListenEvent> { }
-
-export type NodeStatus = 'disconnected' | 'connecting' | 'connected';
-
-export interface ConnectivityStatus {
-    ipv4: NodeStatus;
-    ipv6: NodeStatus;
-}
-
-export interface RunnerEvents {
-    statusChanged: [status: ConnectivityStatus];
-    error: [error: Error];
-}
-
-export class DhtRunner extends EventEmitter<RunnerEvents> implements AsyncDisposable {
-    run(options?: RunOptions): void;
-    isRunning(): boolean;
-    getBoundPort(family?: 4 | 6): number;
-    getNodeId(): string;
-    getStatus(): ConnectivityStatus;
-    bootstrap(host: string, port: number): void;
-    get(key: string): ValueIterator<Value>;
-    getAll(key: string): Promise<Value[]>;
-    put(key: string, data: Uint8Array, options?: PutOptions): Promise<boolean>;
-    putSigned(key: string, data: Uint8Array, options?: PutOptions): Promise<boolean>;
-    putEncrypted(key: string, data: Uint8Array, recipient: PublicKey, options?: PutOptions): Promise<boolean>;
-    listen(key: string): ListenerIterator;
-    listen(key: string, callback: (value: Value, expired: boolean) => void): Listener;
-    close(): Promise<void>;
-    ref(): this;
-    unref(): this;
-    [Symbol.asyncDispose](): Promise<void>;
-}
@@ -1,187 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { constants } from 'node:os';
-import { dlopen } from 'node:process';
-import load from 'node-gyp-build';
-import createCrypto from './crypto.js';
-
-const binding = { exports: {} };
-const flags = process.platform === 'linux'
-    ? constants.dlopen.RTLD_LAZY | constants.dlopen.RTLD_DEEPBIND
-    : undefined;
-dlopen(binding, process.env.OPENDHT_NODE_BINDING || load.path(import.meta.dirname),
-    flags);
-const native = binding.exports;
-const { PublicKey, PrivateKey, Certificate, Identity, handle } = createCrypto(native);
-
-function eventReporter(owner, event) {
-    return value => { owner.deref()?.emit(event, value); };
-}
-
-class DhtRunner extends EventEmitter {
-    #native;
-    #closing;
-    #listeners = 0;
-    #pending = 0;
-    #iterators = new Set();
-
-    constructor() {
-        super();
-        const owner = new WeakRef(this);
-        this.#native = new native.NativeRunner(eventReporter(owner, 'statusChanged'));
-    }
-
-    #updateOwner() {
-        this.#native.setOwner(this.#listeners || this.#pending || this.listenerCount('statusChanged') ? this : null);
-    }
-
-    #track(operation) {
-        this.#pending++;
-        this.#updateOwner();
-        return operation.finally(() => {
-            this.#pending--;
-            this.#updateOwner();
-        });
-    }
-
-    on(event, listener) { super.on(event, listener); this.#updateOwner(); return this; }
-    addListener(event, listener) { return this.on(event, listener); }
-    prependListener(event, listener) { super.prependListener(event, listener); this.#updateOwner(); return this; }
-    removeListener(event, listener) { super.removeListener(event, listener); this.#updateOwner(); return this; }
-    off(event, listener) { return this.removeListener(event, listener); }
-    removeAllListeners(...args) { super.removeAllListeners(...args); this.#updateOwner(); return this; }
-
-    run(options) {
-        if (typeof options?.proxyServer === 'string' && options.proxyServer) {
-            const proxy = new URL(options.proxyServer);
-            if (proxy.protocol !== 'http:' && proxy.protocol !== 'https:')
-                throw new TypeError('proxyServer must be an HTTP(S) URL');
-        }
-        if (options?.identity !== undefined) options = { ...options, identity: handle(options.identity, Identity) };
-        this.#native.run(options);
-    }
-    isRunning() { return this.#native.isRunning(); }
-    getBoundPort(family = 4) { return this.#native.getBoundPort(family); }
-    getNodeId() { return this.#native.getNodeId(); }
-    getStatus() { return this.#native.getStatus(); }
-    bootstrap(host, port) { this.#native.bootstrap(host, port); }
-    get(key) {
-        return this.#iterate((push, finish) => {
-            const operation = this.#native.get(key, push);
-            this.#track(operation.done).then(() => finish(), finish);
-            return () => this.#native.cancelGet(operation.token);
-        }, true);
-    }
-    getAll(key) { return this.#track(this.#native.getAll(key)); }
-    put(key, data, options) { return this.#track(this.#native.put(key, data, options)); }
-    putSigned(key, data, options) { return this.#track(this.#native.putSigned(key, data, options)); }
-    putEncrypted(key, data, recipient, options) {
-        return this.#track(this.#native.putEncrypted(key, data, options, handle(recipient, PublicKey)));
-    }
-
-    listen(key, callback) {
-        if (callback === undefined) {
-            return this.#iterate(push => {
-                const subscription = this.listen(key, (value, expired) => push({ value, expired }));
-                return () => subscription.cancel();
-            });
-        }
-        const token = this.#native.listen(key, callback);
-        this.#listeners++;
-        this.#updateOwner();
-        let cancelled = false;
-        return {
-            cancel: () => {
-                if (cancelled) return;
-                this.#native.cancelListen(token);
-                cancelled = true;
-                this.#listeners--;
-                this.#updateOwner();
-            },
-        };
-    }
-
-    #iterate(subscribe, rejectOnClose = false) {
-        let values = [];
-        let offset = 0;
-        const pending = [];
-        let done = false;
-        let failure;
-        const finish = error => {
-            if (done) return;
-            done = true;
-            failure = error;
-            unsubscribe();
-            this.#iterators.delete(onClose);
-            if (failure) {
-                values = [];
-                offset = 0;
-            }
-            for (const { resolve, reject } of pending.splice(0)) {
-                if (failure) reject(failure);
-                else resolve({ value: undefined, done: true });
-            }
-        };
-        const cancel = () => {
-            values = [];
-            offset = 0;
-            failure = undefined;
-            finish();
-        };
-        const onClose = () => {
-            if (rejectOnClose) {
-                const error = new Error('DHT runner is closed');
-                error.code = 'ERR_DHT_CLOSED';
-                finish(error);
-            } else cancel();
-        };
-        const unsubscribe = subscribe(value => {
-            if (done) return;
-            const waiter = pending.shift();
-            if (waiter) waiter.resolve({ value, done: false });
-            else values.push(value);
-        }, finish);
-        this.#iterators.add(onClose);
-        return {
-            next() {
-                if (failure) return Promise.reject(failure);
-                if (offset < values.length) {
-                    const value = values[offset];
-                    values[offset++] = undefined;
-                    if (offset === values.length) {
-                        values = [];
-                        offset = 0;
-                    }
-                    return Promise.resolve({ value, done: false });
-                }
-                if (done) return Promise.resolve({ value: undefined, done: true });
-                return new Promise((resolve, reject) => pending.push({ resolve, reject }));
-            },
-            return() {
-                cancel();
-                return Promise.resolve({ value: undefined, done: true });
-            },
-            throw(error) {
-                cancel();
-                return Promise.reject(error);
-            },
-            cancel,
-            [Symbol.asyncIterator]() { return this; },
-            [Symbol.asyncDispose]() { cancel(); return Promise.resolve(); },
-        };
-    }
-
-    close() {
-        if (!this.#closing) {
-            this.#closing = this.#native.close();
-            for (const cancel of this.#iterators) cancel();
-        }
-        return this.#closing;
-    }
-    ref() { this.#native.ref(); return this; }
-    unref() { this.#native.unref(); return this; }
-    [Symbol.asyncDispose]() { return this.close(); }
-}
-
-export { DhtRunner, PublicKey, PrivateKey, Certificate, Identity };
-export const hash = native.hash;
-export const version = native.version;
@@ -1,904 +0,0 @@
-{
-    "name": "opendht",
-    "version": "0.1.0",
-    "lockfileVersion": 3,
-    "requires": true,
-    "packages": {
-        "": {
-            "name": "opendht",
-            "version": "0.1.0",
-            "license": "MIT",
-            "dependencies": {
-                "node-gyp-build": "^4.8.4"
-            },
-            "devDependencies": {
-                "@types/node": "^22.20.5",
-                "cmake-js": "^8.0.0",
-                "node-addon-api": "^8.5.0",
-                "typescript": "^7.0.2"
-            },
-            "engines": {
-                "node": ">=22.9.0"
-            }
-        },
-        "node_modules/@isaacs/fs-minipass": {
-            "version": "4.0.1",
-            "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
-            "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
-            "dev": true,
-            "license": "ISC",
-            "dependencies": {
-                "minipass": "^7.0.4"
-            },
-            "engines": {
-                "node": ">=18.0.0"
-            }
-        },
-        "node_modules/@types/node": {
-            "version": "22.20.5",
-            "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.5.tgz",
-            "integrity": "sha512-U2+DNr+wSjpsTS/wZGYHq7GcwfuSmKiKvoPvK22zwTlRhU91yOniN4qRR5KhIjvif7ysw/dz/hKmfDH0Ris4aA==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "undici-types": "~6.21.0"
-            }
-        },
-        "node_modules/@typescript/typescript-aix-ppc64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-aix-ppc64/-/typescript-aix-ppc64-7.0.2.tgz",
-            "integrity": "sha512-MTKKkWB7p/0E9xi1d1tHtZ5PiLkGEMIq88pK2CubZjOsLtYTLqhgIgi6zepFa+9GHZ6h05NMCkQxGKiPXMxXtQ==",
-            "cpu": [
-                "ppc64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "aix"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-darwin-arm64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-arm64/-/typescript-darwin-arm64-7.0.2.tgz",
-            "integrity": "sha512-gowzar9MwS/aRWp6f3a4KUqzRjAZjOsmGNCM6LcTgXum+dBfgsBVMN+AgvOCCbguXyick6LJhpBszxMebJ8syA==",
-            "cpu": [
-                "arm64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "darwin"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-darwin-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-darwin-x64/-/typescript-darwin-x64-7.0.2.tgz",
-            "integrity": "sha512-SZ9xZInqApNlNGc9s0W1VSsktYSOe9cFqNOIqmN1Gs8SmkjKZYFt017G4VwPxASInODuAdbTW7sXiFUf893RgA==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "darwin"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-freebsd-arm64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-arm64/-/typescript-freebsd-arm64-7.0.2.tgz",
-            "integrity": "sha512-W5NH4y/J0plIIS5b2xvTEkU7JFxyqdMAOgf+Ilhl0vHQXKO5dZoxd+C/jEtq56c4F3wk71RB4BMRQ2XdI+bwYQ==",
-            "cpu": [
-                "arm64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "freebsd"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-freebsd-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-freebsd-x64/-/typescript-freebsd-x64-7.0.2.tgz",
-            "integrity": "sha512-UMGDx5sTpzNw3WiPebH7l90IWfJggEd+egHt/q6p7/Cm3zqoV7VxkGXt+3DxPIw8CcmvAB0j3sVVfbhX+M4Tpw==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "freebsd"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-arm": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm/-/typescript-linux-arm-7.0.2.tgz",
-            "integrity": "sha512-gffT3xPz9sR7j/YJExkyPntrI0P2EP9XbOyWzth2/Gs0RstK+90RBcO0ncXoXy/beYll1SXw846Nf2zdnEz0QQ==",
-            "cpu": [
-                "arm"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-arm64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-arm64/-/typescript-linux-arm64-7.0.2.tgz",
-            "integrity": "sha512-Qh4eU4/y3yDjnfjjyPYihMj5/ODIlmt+Bzu17OI+fiSRDW57QmU5SiN63exPRNJPKUzcc1INa1NXdrJ+MqHjUQ==",
-            "cpu": [
-                "arm64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-loong64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-loong64/-/typescript-linux-loong64-7.0.2.tgz",
-            "integrity": "sha512-uEHck9i8hoAzXPiYRib1O7miOnz23SxIeVl6F4LXox+qov1K35jHcEW6VHKvZI+pyvl7fZEP4MCU5LYvIq1GuQ==",
-            "cpu": [
-                "loong64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-mips64el": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-mips64el/-/typescript-linux-mips64el-7.0.2.tgz",
-            "integrity": "sha512-R4KvAMnE43W5Qeqb0Ly56O3mWMWIAgsMyz36DCaycd5nbg/9kzm0liw3JocfRqyJY0KPmzFjbswozXyW0DnIYA==",
-            "cpu": [
-                "mips64el"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-ppc64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-ppc64/-/typescript-linux-ppc64-7.0.2.tgz",
-            "integrity": "sha512-DORx5b3sd/4S7eayxm4FQv+A7CrkUIGRaHiwI8oiHTAI1fAPWhF4J0vAlkC8biAlHSVVwxMQ3tjZ2/DVbnQiiA==",
-            "cpu": [
-                "ppc64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-riscv64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-riscv64/-/typescript-linux-riscv64-7.0.2.tgz",
-            "integrity": "sha512-wf0jqEDOjrPRnKwYRyyJDRo11KMbvMFrU+q4zqKyChODBzvlkbhNQfKvLxQCcwTpdDaXSHZTVuh0JoCrKCUMHQ==",
-            "cpu": [
-                "riscv64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-s390x": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-s390x/-/typescript-linux-s390x-7.0.2.tgz",
-            "integrity": "sha512-IkwJc3L7yhytWd/ewjyxNDfOmswCm9GWMJT/ue/dU4aZNbwZeYAetq42VyLmsmSjvoX7z74X6ZaYCtzAr0EuGw==",
-            "cpu": [
-                "s390x"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-linux-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-linux-x64/-/typescript-linux-x64-7.0.2.tgz",
-            "integrity": "sha512-EYdf2cNg7rgCWJnxCdJ+F3V39O8ihb37eHAu1LK8oAFizgTQbPOK7zHHXbPt8rX24COqODXeI3sIf0fCXG7H/A==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "linux"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-netbsd-arm64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-arm64/-/typescript-netbsd-arm64-7.0.2.tgz",
-            "integrity": "sha512-+polYF4MF04aPpO5FTkHran9yUQDSXqy5GiSDKpsll5jy3l3+g9QLhpf39T+ePtefhXLOGrLl0QIjkQP6VnelA==",
-            "cpu": [
-                "arm64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "netbsd"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-netbsd-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-netbsd-x64/-/typescript-netbsd-x64-7.0.2.tgz",
-            "integrity": "sha512-8YIT0EHM/3dq10ZOVF/A7pc/YSMtbcecct4rWtexrnSCHOPcpC2KTLXfTCR6vDpnSiY12heNb1GiN/wu+T/FyA==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "netbsd"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-openbsd-arm64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-arm64/-/typescript-openbsd-arm64-7.0.2.tgz",
-            "integrity": "sha512-APT8+ClYnuYm1u9+kgGXoMj2VzWzcymwh2gNSQVySHfkRDGOTVkoWLjCmOQSaO+PoqQ57B0flRp9SA+7GnnkzQ==",
-            "cpu": [
-                "arm64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "openbsd"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-openbsd-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-openbsd-x64/-/typescript-openbsd-x64-7.0.2.tgz",
-            "integrity": "sha512-yX7s+Q0Dln0Dt9tEzZsAjXXR/+ytBM7AlglaqyeMPxQszJ1JhlJdZ6jLA+IzldHtflX81em7lDao1xXu+aRRkg==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "openbsd"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-sunos-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-sunos-x64/-/typescript-sunos-x64-7.0.2.tgz",
-            "integrity": "sha512-dLJDGaLZ1D4HPQn62u1n8mBDkJREwMsAkCdkwd4Ieqw+x3TUyTsqY0YiBCtE6H6OzzgGk3iuZ3vFWRS+E8/d1g==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "sunos"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-win32-arm64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-arm64/-/typescript-win32-arm64-7.0.2.tgz",
-            "integrity": "sha512-Gyl1Vy6OsWesLzmq+EP0Fb7b4Nid5232AvcA2SFcdYreldpNtYFFofPjnt62y9hQy7VTaZp65ICJjuAQRaVcIQ==",
-            "cpu": [
-                "arm64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "win32"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/@typescript/typescript-win32-x64": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/@typescript/typescript-win32-x64/-/typescript-win32-x64-7.0.2.tgz",
-            "integrity": "sha512-0BQ3HkAHHlKLSp1qRvf3SUhGpGsDuhB/jgFw75guyqbxJqEaS0Cw/VFO8i2nHglJUzQCRtMMR/IBAKE3ETMC4g==",
-            "cpu": [
-                "x64"
-            ],
-            "dev": true,
-            "license": "Apache-2.0",
-            "optional": true,
-            "os": [
-                "win32"
-            ],
-            "engines": {
-                "node": ">=16.20.0"
-            }
-        },
-        "node_modules/ansi-regex": {
-            "version": "5.0.1",
-            "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-            "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=8"
-            }
-        },
-        "node_modules/ansi-styles": {
-            "version": "4.3.0",
-            "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-            "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "color-convert": "^2.0.1"
-            },
-            "engines": {
-                "node": ">=8"
-            },
-            "funding": {
-                "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-            }
-        },
-        "node_modules/chownr": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
-            "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
-            "dev": true,
-            "license": "BlueOak-1.0.0",
-            "engines": {
-                "node": ">=18"
-            }
-        },
-        "node_modules/cliui": {
-            "version": "8.0.1",
-            "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
-            "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
-            "dev": true,
-            "license": "ISC",
-            "dependencies": {
-                "string-width": "^4.2.0",
-                "strip-ansi": "^6.0.1",
-                "wrap-ansi": "^7.0.0"
-            },
-            "engines": {
-                "node": ">=12"
-            }
-        },
-        "node_modules/cmake-js": {
-            "version": "8.0.0",
-            "resolved": "https://registry.npmjs.org/cmake-js/-/cmake-js-8.0.0.tgz",
-            "integrity": "sha512-YbUP88RDwCvoQkZhRtGURYm9RIpWdtvZuhT87fKNoLjk8kIFIFeARpKfuZQGdwfH99GZpUmqSfcDrK62X7lTgg==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "debug": "^4.4.3",
-                "fs-extra": "^11.3.3",
-                "node-api-headers": "^1.8.0",
-                "rc": "1.2.8",
-                "semver": "^7.7.3",
-                "tar": "^7.5.6",
-                "url-join": "^4.0.1",
-                "which": "^6.0.0",
-                "yargs": "^17.7.2"
-            },
-            "bin": {
-                "cmake-js": "bin/cmake-js"
-            },
-            "engines": {
-                "node": "^20.17.0 || >=22.9.0"
-            }
-        },
-        "node_modules/color-convert": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-            "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "color-name": "~1.1.4"
-            },
-            "engines": {
-                "node": ">=7.0.0"
-            }
-        },
-        "node_modules/color-name": {
-            "version": "1.1.4",
-            "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-            "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-            "dev": true,
-            "license": "MIT"
-        },
-        "node_modules/debug": {
-            "version": "4.4.3",
-            "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
-            "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "ms": "^2.1.3"
-            },
-            "engines": {
-                "node": ">=6.0"
-            },
-            "peerDependenciesMeta": {
-                "supports-color": {
-                    "optional": true
-                }
-            }
-        },
-        "node_modules/deep-extend": {
-            "version": "0.6.0",
-            "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
-            "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=4.0.0"
-            }
-        },
-        "node_modules/emoji-regex": {
-            "version": "8.0.0",
-            "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-            "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
-            "dev": true,
-            "license": "MIT"
-        },
-        "node_modules/escalade": {
-            "version": "3.2.0",
-            "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
-            "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=6"
-            }
-        },
-        "node_modules/fs-extra": {
-            "version": "11.4.1",
-            "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.4.1.tgz",
-            "integrity": "sha512-KYAb4c9BJQI6QqGKthV68OHe0badztdXJWKo0WtBA9IuCFPTKvE5ZdUBglP833aMjhaSPNO4A5j/EkzZtGlKjA==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "graceful-fs": "^4.2.0",
-                "jsonfile": "^6.0.1",
-                "universalify": "^2.0.0"
-            },
-            "engines": {
-                "node": ">=14.14"
-            }
-        },
-        "node_modules/get-caller-file": {
-            "version": "2.0.5",
-            "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
-            "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
-            "dev": true,
-            "license": "ISC",
-            "engines": {
-                "node": "6.* || 8.* || >= 10.*"
-            }
-        },
-        "node_modules/graceful-fs": {
-            "version": "4.2.11",
-            "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
-            "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
-            "dev": true,
-            "license": "ISC"
-        },
-        "node_modules/ini": {
-            "version": "1.3.8",
-            "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
-            "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
-            "dev": true,
-            "license": "ISC"
-        },
-        "node_modules/is-fullwidth-code-point": {
-            "version": "3.0.0",
-            "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
-            "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=8"
-            }
-        },
-        "node_modules/isexe": {
-            "version": "4.0.0",
-            "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",
-            "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",
-            "dev": true,
-            "license": "BlueOak-1.0.0",
-            "engines": {
-                "node": ">=20"
-            }
-        },
-        "node_modules/jsonfile": {
-            "version": "6.2.1",
-            "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
-            "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "universalify": "^2.0.0"
-            },
-            "optionalDependencies": {
-                "graceful-fs": "^4.1.6"
-            }
-        },
-        "node_modules/minimist": {
-            "version": "1.2.8",
-            "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
-            "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
-            "dev": true,
-            "license": "MIT",
-            "funding": {
-                "url": "https://github.com/sponsors/ljharb"
-            }
-        },
-        "node_modules/minipass": {
-            "version": "7.1.3",
-            "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
-            "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
-            "dev": true,
-            "license": "BlueOak-1.0.0",
-            "engines": {
-                "node": ">=16 || 14 >=14.17"
-            }
-        },
-        "node_modules/minizlib": {
-            "version": "3.1.0",
-            "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
-            "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "minipass": "^7.1.2"
-            },
-            "engines": {
-                "node": ">= 18"
-            }
-        },
-        "node_modules/ms": {
-            "version": "2.1.3",
-            "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
-            "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
-            "dev": true,
-            "license": "MIT"
-        },
-        "node_modules/node-addon-api": {
-            "version": "8.9.2",
-            "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.9.2.tgz",
-            "integrity": "sha512-VijLXbi3UACN69I0JVXJsX4tjACjNoQDgv2gTF6sx2wWEi8tkSg2eX8p5gSIFi8z2+DL3oHmY6OyKce38SDolg==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": "^18 || ^20 || >= 21"
-            }
-        },
-        "node_modules/node-api-headers": {
-            "version": "1.9.0",
-            "resolved": "https://registry.npmjs.org/node-api-headers/-/node-api-headers-1.9.0.tgz",
-            "integrity": "sha512-2oNILP4jXwRB4ywnYKjVk1YyJ96n2D4EOVJO6S3oYZ5PtbJrw3Yt9TpAuX3nBLMuzn74rnfGQrv13pS9vC+YiA==",
-            "dev": true,
-            "license": "MIT"
-        },
-        "node_modules/node-gyp-build": {
-            "version": "4.8.4",
-            "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz",
-            "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==",
-            "license": "MIT",
-            "bin": {
-                "node-gyp-build": "bin.js",
-                "node-gyp-build-optional": "optional.js",
-                "node-gyp-build-test": "build-test.js"
-            }
-        },
-        "node_modules/rc": {
-            "version": "1.2.8",
-            "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
-            "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
-            "dev": true,
-            "license": "(BSD-2-Clause OR MIT OR Apache-2.0)",
-            "dependencies": {
-                "deep-extend": "^0.6.0",
-                "ini": "~1.3.0",
-                "minimist": "^1.2.0",
-                "strip-json-comments": "~2.0.1"
-            },
-            "bin": {
-                "rc": "cli.js"
-            }
-        },
-        "node_modules/require-directory": {
-            "version": "2.1.1",
-            "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
-            "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=0.10.0"
-            }
-        },
-        "node_modules/semver": {
-            "version": "7.8.5",
-            "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
-            "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
-            "dev": true,
-            "license": "ISC",
-            "bin": {
-                "semver": "bin/semver.js"
-            },
-            "engines": {
-                "node": ">=10"
-            }
-        },
-        "node_modules/string-width": {
-            "version": "4.2.3",
-            "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-            "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "emoji-regex": "^8.0.0",
-                "is-fullwidth-code-point": "^3.0.0",
-                "strip-ansi": "^6.0.1"
-            },
-            "engines": {
-                "node": ">=8"
-            }
-        },
-        "node_modules/strip-ansi": {
-            "version": "6.0.1",
-            "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-            "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "ansi-regex": "^5.0.1"
-            },
-            "engines": {
-                "node": ">=8"
-            }
-        },
-        "node_modules/strip-json-comments": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
-            "integrity": "sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">=0.10.0"
-            }
-        },
-        "node_modules/tar": {
-            "version": "7.5.22",
-            "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.22.tgz",
-            "integrity": "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA==",
-            "dev": true,
-            "license": "BlueOak-1.0.0",
-            "dependencies": {
-                "@isaacs/fs-minipass": "^4.0.0",
-                "chownr": "^3.0.0",
-                "minipass": "^7.1.2",
-                "minizlib": "^3.1.0",
-                "yallist": "^5.0.0"
-            },
-            "engines": {
-                "node": ">=18"
-            }
-        },
-        "node_modules/typescript": {
-            "version": "7.0.2",
-            "resolved": "https://registry.npmjs.org/typescript/-/typescript-7.0.2.tgz",
-            "integrity": "sha512-8FYau96o3NKOhbjKi/qNvG/W5jhzxkbdm5sj9AbZ/5T5sWqn3hJgLfGx27sRKZWTvyzCP8dLRBTf5tBTSRVUNA==",
-            "dev": true,
-            "license": "Apache-2.0",
-            "bin": {
-                "tsc": "bin/tsc"
-            },
-            "engines": {
-                "node": ">=16.20.0"
-            },
-            "optionalDependencies": {
-                "@typescript/typescript-aix-ppc64": "7.0.2",
-                "@typescript/typescript-darwin-arm64": "7.0.2",
-                "@typescript/typescript-darwin-x64": "7.0.2",
-                "@typescript/typescript-freebsd-arm64": "7.0.2",
-                "@typescript/typescript-freebsd-x64": "7.0.2",
-                "@typescript/typescript-linux-arm": "7.0.2",
-                "@typescript/typescript-linux-arm64": "7.0.2",
-                "@typescript/typescript-linux-loong64": "7.0.2",
-                "@typescript/typescript-linux-mips64el": "7.0.2",
-                "@typescript/typescript-linux-ppc64": "7.0.2",
-                "@typescript/typescript-linux-riscv64": "7.0.2",
-                "@typescript/typescript-linux-s390x": "7.0.2",
-                "@typescript/typescript-linux-x64": "7.0.2",
-                "@typescript/typescript-netbsd-arm64": "7.0.2",
-                "@typescript/typescript-netbsd-x64": "7.0.2",
-                "@typescript/typescript-openbsd-arm64": "7.0.2",
-                "@typescript/typescript-openbsd-x64": "7.0.2",
-                "@typescript/typescript-sunos-x64": "7.0.2",
-                "@typescript/typescript-win32-arm64": "7.0.2",
-                "@typescript/typescript-win32-x64": "7.0.2"
-            }
-        },
-        "node_modules/undici-types": {
-            "version": "6.21.0",
-            "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-            "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
-            "dev": true,
-            "license": "MIT"
-        },
-        "node_modules/universalify": {
-            "version": "2.0.1",
-            "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
-            "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
-            "dev": true,
-            "license": "MIT",
-            "engines": {
-                "node": ">= 10.0.0"
-            }
-        },
-        "node_modules/url-join": {
-            "version": "4.0.1",
-            "resolved": "https://registry.npmjs.org/url-join/-/url-join-4.0.1.tgz",
-            "integrity": "sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==",
-            "dev": true,
-            "license": "MIT"
-        },
-        "node_modules/which": {
-            "version": "6.0.1",
-            "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",
-            "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",
-            "dev": true,
-            "license": "ISC",
-            "dependencies": {
-                "isexe": "^4.0.0"
-            },
-            "bin": {
-                "node-which": "bin/which.js"
-            },
-            "engines": {
-                "node": "^20.17.0 || >=22.9.0"
-            }
-        },
-        "node_modules/wrap-ansi": {
-            "version": "7.0.0",
-            "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-            "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "ansi-styles": "^4.0.0",
-                "string-width": "^4.1.0",
-                "strip-ansi": "^6.0.0"
-            },
-            "engines": {
-                "node": ">=10"
-            },
-            "funding": {
-                "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-            }
-        },
-        "node_modules/y18n": {
-            "version": "5.0.8",
-            "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
-            "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
-            "dev": true,
-            "license": "ISC",
-            "engines": {
-                "node": ">=10"
-            }
-        },
-        "node_modules/yallist": {
-            "version": "5.0.0",
-            "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
-            "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
-            "dev": true,
-            "license": "BlueOak-1.0.0",
-            "engines": {
-                "node": ">=18"
-            }
-        },
-        "node_modules/yargs": {
-            "version": "17.7.3",
-            "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.3.tgz",
-            "integrity": "sha512-GZtjxm/J/4TSxuL3FNYjCmLktBTnIw/rVmKSIyKeYAZpmJB2ig9VauCC5xsa82GNKVKDAqpOn3KVzNt0zmrU0g==",
-            "dev": true,
-            "license": "MIT",
-            "dependencies": {
-                "cliui": "^8.0.1",
-                "escalade": "^3.1.1",
-                "get-caller-file": "^2.0.5",
-                "require-directory": "^2.1.1",
-                "string-width": "^4.2.3",
-                "y18n": "^5.0.5",
-                "yargs-parser": "^21.1.1"
-            },
-            "engines": {
-                "node": ">=12"
-            }
-        },
-        "node_modules/yargs-parser": {
-            "version": "21.1.1",
-            "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
-            "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
-            "dev": true,
-            "license": "ISC",
-            "engines": {
-                "node": ">=12"
-            }
-        }
-    }
-}
@@ -1,58 +0,0 @@
-{
-    "name": "opendht",
-    "version": "0.1.0",
-    "description": "Distributed hash table for Node.js",
-    "license": "MIT",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/savoirfairelinux/opendht.git",
-        "directory": "nodejs"
-    },
-    "publishConfig": {
-        "access": "public",
-        "registry": "https://registry.npmjs.org/"
-    },
-    "type": "module",
-    "main": "index.js",
-    "types": "index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./index.d.ts",
-            "import": "./index.js"
-        },
-        "./package.json": "./package.json"
-    },
-    "files": [
-        "index.js",
-        "index.d.ts",
-        "crypto.js",
-        "README.md",
-        "examples/dhtnode.js",
-        "examples/dhtnode.ts",
-        "prebuilds/"
-    ],
-    "engines": {
-        "node": ">=22.9.0"
-    },
-    "scripts": {
-        "build": "cmake-js compile",
-        "postbuild": "npm run build:examples",
-        "build:examples": "tsc --strict --types node --target es2024 --module Node16 --moduleResolution Node16 --rootDir examples --outDir examples examples/dhtnode.ts",
-        "dhtnode": "node examples/dhtnode.js",
-        "prepack": "npm run build:examples",
-        "bundle": "node scripts/bundle.js",
-        "package": "npm run bundle && npm pack --pack-destination dist",
-        "test:package": "node scripts/test-package.js",
-        "test": "node --test test/*.test.js",
-        "typecheck": "tsc --noEmit --strict --types node --target es2024 --module Node16 --moduleResolution Node16 test/types.ts examples/dhtnode.ts"
-    },
-    "dependencies": {
-        "node-gyp-build": "^4.8.4"
-    },
-    "devDependencies": {
-        "@types/node": "^22.20.5",
-        "cmake-js": "^8.0.0",
-        "node-addon-api": "^8.8.0",
-        "typescript": "^7.0.2"
-    }
-}
@@ -1,105 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const root = path.resolve(import.meta.dirname, '..');
-const repository = path.dirname(root);
-const input = path.resolve(process.argv[2] || path.join(root, 'build/Release/opendht.node'));
-const target = `${process.platform}-${process.arch}`;
-const output = path.join(root, 'prebuilds', target);
-const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'opendht-bundle-'));
-const run = (command, args) => execFileSync(command, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit'] });
-
-function copyNotices(dependencies) {
-    const directory = path.join(output, 'licenses');
-    fs.mkdirSync(directory, { recursive: true });
-    fs.copyFileSync(path.join(repository, 'LICENSE'), path.join(directory, 'OpenDHT-LICENSE.txt'));
-    const copied = new Set();
-    for (const dependency of dependencies) {
-        const real = fs.realpathSync(dependency);
-        if (!path.relative(repository, real).startsWith('..')) continue;
-        let name;
-        let notices;
-        if (process.platform === 'darwin') {
-            const match = real.match(/^(.*\/Cellar\/([^/]+)\/[^/]+)\//);
-            if (!match) throw new Error(`Cannot locate license notices for ${dependency}`);
-            name = match[2];
-            notices = fs.readdirSync(match[1]).filter(file => /^(COPYING|LICENSE|COPYRIGHT)([._-]|$)/i.test(file))
-                .map(file => path.join(match[1], file));
-        } else if (process.platform === 'linux' && /^libllhttp\.so(?:\.|$)/.test(path.basename(real))) {
-            name = 'llhttp';
-            notices = [path.join(repository, 'resources', 'llhttp-LICENSE-MIT')];
-        } else if (process.platform === 'linux') {
-            let owner;
-            try { owner = run('dpkg-query', ['-S', real]); }
-            catch { owner = run('dpkg-query', ['-S', real.replace(/^\/usr\//, '/')]); }
-            name = owner.split('\n')[0].split(': ')[0].split(':')[0];
-            notices = [path.join('/usr/share/doc', name, 'copyright')];
-        } else {
-            const installed = process.env.VCPKG_INSTALLED_DIR;
-            const triplet = process.env.VCPKG_DEFAULT_TRIPLET || 'x64-windows-release';
-            if (!installed) throw new Error('VCPKG_INSTALLED_DIR is required for Windows dependency notices');
-            const share = path.join(installed, triplet, 'share');
-            for (const entry of fs.readdirSync(share)) {
-                const copyright = path.join(share, entry, 'copyright');
-                if (fs.existsSync(copyright)) fs.copyFileSync(copyright, path.join(directory, `${entry}-copyright.txt`));
-            }
-            break;
-        }
-        if (!notices.length) throw new Error(`Missing license notices for ${name}`);
-        if (copied.has(name)) continue;
-        for (const notice of notices) fs.copyFileSync(notice, path.join(directory, `${name}-${path.basename(notice)}.txt`));
-        copied.add(name);
-    }
-}
-
-function fixMachO(file) {
-    const commands = run('otool', ['-l', file]);
-    const rpaths = [...commands.matchAll(/cmd LC_RPATH\s+cmdsize \d+\s+path (.+?) \(offset \d+\)/g)];
-    for (const rpath of new Set(rpaths.map(match => match[1]))) run('install_name_tool', ['-delete_rpath', rpath, file]);
-    const dependencies = [...run('otool', ['-L', file]).matchAll(/^\s+(.+?) \(compatibility version/gm)];
-    for (const [, dependency] of dependencies) {
-        if (!/^(@loader_path\/|\/usr\/lib\/|\/System\/Library\/)/.test(dependency)) {
-            throw new Error(`Non-relocatable dependency in ${path.basename(file)}: ${dependency}`);
-        }
-    }
-    run('codesign', ['--force', '--sign', '-', file]);
-}
-
-try {
-    if (!['darwin', 'linux', 'win32'].includes(process.platform)) throw new Error(`Unsupported platform ${target}`);
-    if (!fs.existsSync(input)) throw new Error(`Build the Release addon first: ${input}`);
-    if (process.platform === 'linux' && !process.report.getReport().header.glibcVersionRuntime) {
-        throw new Error('Linux prebuilds currently require glibc');
-    }
-    const directories = [path.dirname(input), ...(process.env.OPENDHT_LIBRARY_PATH || '').split(path.delimiter).filter(Boolean)];
-    const dependencyList = path.join(temporary, 'dependencies.json');
-    run('cmake', [`-DADDON=${input}`, `-DOUTPUT=${dependencyList}`, `-DSEARCH_DIRECTORIES=${directories.join(';')}`,
-        '-P', path.join(import.meta.dirname, 'dependencies.cmake')]);
-    const dependencies = JSON.parse(fs.readFileSync(dependencyList, 'utf8'));
-    fs.rmSync(output, { recursive: true, force: true });
-    fs.mkdirSync(output, { recursive: true });
-    const binary = path.join(output, process.platform === 'linux' ? 'node.napi.glibc.node' : 'node.napi.node');
-    fs.copyFileSync(input, binary);
-    if (process.platform === 'darwin') {
-        run('dylibbundler', ['-b', '-of', '-ns', '-x', binary, '-d', `${output}/`, '-p', '@loader_path/', '-s', path.dirname(input)]);
-        for (const file of fs.readdirSync(output)) fixMachO(path.join(output, file));
-    } else {
-        for (const dependency of dependencies) fs.copyFileSync(dependency, path.join(output, path.basename(dependency)));
-        if (process.platform === 'linux') {
-            for (const file of fs.readdirSync(output)) run('patchelf', ['--set-rpath', '$ORIGIN', path.join(output, file)]);
-        }
-    }
-    copyNotices(dependencies);
-    fs.writeFileSync(path.join(output, 'manifest.json'), JSON.stringify({
-        platform: process.platform,
-        arch: process.arch,
-        napi: 8,
-        libraries: fs.readdirSync(output).filter(file => /\.(node|dll|dylib)$|\.so(\.|$)/.test(file)).sort(),
-    }, null, 2) + '\n');
-    fs.mkdirSync(path.join(root, 'dist'), { recursive: true });
-    console.log(`Bundled ${target}: ${output}`);
-} finally {
-    fs.rmSync(temporary, { recursive: true, force: true });
-}
@@ -1,39 +0,0 @@
-cmake_minimum_required(VERSION 3.21)
-
-if(NOT EXISTS "${ADDON}" OR NOT DEFINED OUTPUT)
-    message(FATAL_ERROR "ADDON and OUTPUT are required")
-endif()
-
-set(pre_exclude)
-set(post_exclude)
-if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
-    list(APPEND pre_exclude "^/usr/lib/" "^/System/Library/")
-    list(APPEND post_exclude "^/usr/lib/" "^/System/Library/")
-elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux")
-    list(APPEND pre_exclude "^ld-linux" "^lib(c|m|dl|rt|pthread|resolv|util|gcc_s|stdc\\+\\+)\\.so")
-elseif(CMAKE_HOST_WIN32)
-    list(APPEND pre_exclude "[Nn][Oo][Dd][Ee]\\.exe" "[Aa][Pp][Ii]-[Mm][Ss]-.*" "[Ee][Xx][Tt]-[Mm][Ss]-.*")
-    list(APPEND post_exclude ".*[Ss][Yy][Ss][Tt][Ee][Mm]32[/\\\\].*")
-endif()
-
-file(GET_RUNTIME_DEPENDENCIES
-    MODULES "${ADDON}"
-    DIRECTORIES ${SEARCH_DIRECTORIES}
-    RESOLVED_DEPENDENCIES_VAR dependencies
-    UNRESOLVED_DEPENDENCIES_VAR unresolved
-    CONFLICTING_DEPENDENCIES_PREFIX conflicts
-    PRE_EXCLUDE_REGEXES ${pre_exclude}
-    POST_EXCLUDE_REGEXES ${post_exclude}
-)
-if(unresolved OR conflicts_FILENAMES)
-    message(FATAL_ERROR "Unresolved dependencies: ${unresolved}; conflicting dependencies: ${conflicts_FILENAMES}")
-endif()
-
-set(result "[]")
-set(index 0)
-foreach(dependency IN LISTS dependencies)
-    file(TO_CMAKE_PATH "${dependency}" dependency)
-    string(JSON result SET "${result}" ${index} "\"${dependency}\"")
-    math(EXPR index "${index} + 1")
-endforeach()
-file(WRITE "${OUTPUT}" "${result}\n")
@@ -1,38 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const root = path.resolve(import.meta.dirname, '..');
-const npm = process.env.npm_execpath;
-if (!npm) throw new Error('Run this check with npm run test:package');
-fs.mkdirSync(path.join(root, 'dist'), { recursive: true });
-let archive = process.argv[2] ? path.resolve(process.argv[2]) : path.join(root, 'dist',
-    JSON.parse(execFileSync(process.execPath, [npm, 'pack', '--json', '--pack-destination', 'dist'],
-        { cwd: root, encoding: 'utf8' }))[0].filename);
-if (fs.statSync(archive).isDirectory()) {
-    const archives = fs.readdirSync(archive).filter(file => file.endsWith('.tgz'));
-    if (archives.length !== 1) throw new Error('Expected exactly one npm archive');
-    archive = path.join(archive, archives[0]);
-}
-const consumer = fs.mkdtempSync(path.join(os.tmpdir(), 'opendht-consumer-'));
-const env = { ...process.env, PREBUILDS_ONLY: '1' };
-for (const variable of ['OPENDHT_NODE_BINDING', 'NODE_PATH', 'LD_LIBRARY_PATH', 'DYLD_LIBRARY_PATH', 'DYLD_FALLBACK_LIBRARY_PATH']) delete env[variable];
-const excluded = [path.join(root, 'build'), ...(process.env.OPENDHT_LIBRARY_PATH || '').split(path.delimiter).filter(Boolean)];
-const pathKey = Object.keys(env).find(key => key.toLowerCase() === 'path');
-if (pathKey) env[pathKey] = env[pathKey].split(path.delimiter)
-    .filter(entry => !excluded.some(directory => path.resolve(entry).toLowerCase().startsWith(path.resolve(directory).toLowerCase())))
-    .join(path.delimiter);
-try {
-    execFileSync(process.execPath, [npm, 'install', '--prefix', consumer, '--ignore-scripts', '--omit=dev', '--no-audit', '--no-fund', archive],
-        { cwd: consumer, env, stdio: 'inherit' });
-    const { name } = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
-    const installed = path.join(consumer, 'node_modules', ...name.split('/'));
-    execFileSync(process.execPath, ['--input-type=module', '-e', 'import load from "node-gyp-build"; console.log(load.path(process.cwd()))'],
-        { cwd: installed, env, stdio: 'inherit' });
-    fs.cpSync(path.join(root, 'test'), path.join(installed, 'test'), { recursive: true });
-    execFileSync(process.execPath, [npm, 'test'], { cwd: installed, env, stdio: 'inherit' });
-    console.log(`Installed archive verified: ${archive}`);
-} finally {
-    fs.rmSync(consumer, { recursive: true, force: true });
-}
@@ -1,549 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFile } from 'node:child_process';
-import { EventEmitter, once } from 'node:events';
-import { createServer } from 'node:http';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import { Worker } from 'node:worker_threads';
-import { DhtRunner, hash, version } from '../index.js';
-
-const moduleURL = new URL('../index.js', import.meta.url).href;
-const exampleURL = new URL('../examples/dhtnode.js', import.meta.url);
-const example = fileURLToPath(exampleURL);
-
-function startNode() {
-    const runner = new DhtRunner();
-    runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-    return runner;
-}
-
-test('hashes strings and binary data without truncating NUL bytes', () => {
-    assert.match(version, /^\d+\./);
-    assert.equal(hash('hello'), 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d');
-    assert.equal(hash('hello'), hash(Buffer.from('hello')));
-    assert.notEqual(hash('hello\0world'), hash('hello'));
-    assert.throws(() => hash(42), TypeError);
-});
-
-test('runner lifecycle and argument validation', async () => {
-    const runner = new DhtRunner();
-    assert.equal(runner.isRunning(), false);
-    assert.throws(() => runner.get(hash('idle')), /running/i);
-    assert.throws(() => runner.getAll(hash('idle')), /running/i);
-    assert.throws(() => runner.run({ port: -1 }), RangeError);
-    assert.throws(() => runner.run({ port: 65536 }), RangeError);
-    assert.throws(() => runner.run({ port: 1.5 }), RangeError);
-    runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-    try {
-        assert.equal(runner.isRunning(), true);
-        assert.ok(runner.getBoundPort() > 0);
-        assert.match(runner.getNodeId(), /^[0-9a-f]{40}$/);
-        assert.throws(() => runner.run(), /already/i);
-        assert.throws(() => runner.get('short'), /hash/i);
-        assert.throws(() => runner.get('z'.repeat(40)), /hash/i);
-        assert.throws(() => runner.put(hash('bad'), 'text'), TypeError);
-        assert.throws(() => runner.put(hash('bad'), Buffer.alloc(0), { id: 1 }), TypeError);
-        assert.throws(() => runner.put(hash('bad'), Buffer.alloc(0), { id: -1n }), RangeError);
-        assert.throws(() => runner.put(hash('bad'), Buffer.alloc(0), { id: 1n << 64n }), RangeError);
-        assert.throws(() => runner.put(hash('bad'), Buffer.alloc(0), { type: 65536 }), RangeError);
-    } finally {
-        const closing = runner.close();
-        assert.equal(runner.close(), closing);
-        await closing;
-    }
-    assert.equal(runner.isRunning(), false);
-    assert.throws(() => runner.run(), /closed/i);
-    assert.throws(() => runner.get(hash('closed')), /closed/i);
-});
-
-test('closing an idle runner is supported', async () => {
-    const runner = new DhtRunner();
-    await runner.close();
-    await runner.close();
-    assert.equal(runner.isRunning(), false);
-});
-
-test('runner reports per-family connectivity changes and snapshots', { timeout: 15000 }, async () => {
-    const runner = new DhtRunner();
-    const peer = startNode();
-    const changes = [];
-    runner.on('statusChanged', status => changes.push(status));
-    try {
-        assert.deepEqual(runner.getStatus(), { ipv4: 'disconnected', ipv6: 'disconnected' });
-        runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-        const connected = new Promise((resolve, reject) => {
-            const signal = AbortSignal.timeout(10000);
-            signal.addEventListener('abort', () => reject(signal.reason), { once: true });
-            runner.on('statusChanged', status => {
-                if (status.ipv4 === 'connected') resolve(status);
-            });
-        });
-        runner.bootstrap('127.0.0.1', peer.getBoundPort());
-        peer.bootstrap('127.0.0.1', runner.getBoundPort());
-        const status = await connected;
-        assert.equal(status.ipv4, 'connected');
-        assert.ok(['disconnected', 'connecting', 'connected'].includes(status.ipv6));
-        assert.deepEqual(runner.getStatus(), status);
-        status.ipv4 = 'changed by consumer';
-        assert.equal(runner.getStatus().ipv4, 'connected');
-        await runner.close();
-        const count = changes.length;
-        await new Promise(resolve => setImmediate(resolve));
-        assert.equal(changes.length, count);
-        assert.deepEqual(runner.getStatus(), { ipv4: 'disconnected', ipv6: 'disconnected' });
-    } finally {
-        await Promise.all([runner.close(), peer.close()]);
-    }
-});
-
-test('invalid bind addresses produce JS exceptions', async () => {
-    const runner = new DhtRunner();
-    try {
-        assert.throws(() => runner.run({ ipv4: '192.0.2.1', ipv6: '2001:db8::1' }));
-    } finally {
-        await runner.close();
-    }
-});
-
-test('two loopback nodes exchange binary values and cancel listeners', { timeout: 20000 }, async () => {
-    const writer = startNode();
-    const reader = startNode();
-    const events = new EventEmitter();
-    const key = hash('node-addon-api integration');
-    const payload = Buffer.from([0, 1, 255, 0, 42]);
-    let subscription;
-    let retainedValue;
-    try {
-        writer.bootstrap('127.0.0.1', reader.getBoundPort());
-        reader.bootstrap('127.0.0.1', writer.getBoundPort());
-        subscription = reader.listen(key, (value, expired) => {
-            if (!expired) events.emit('value', value);
-        });
-        const received = once(events, 'value', { signal: AbortSignal.timeout(10000) });
-        assert.equal(await writer.put(key, payload, {
-            id: 18446744073709551614n,
-            type: 0,
-            userType: 'nodejs-test',
-            permanent: true,
-        }), true);
-        const [value] = await received;
-        assert.equal(value.id, 18446744073709551614n);
-        assert.equal(value.type, 0);
-        assert.ok(Buffer.isBuffer(value.data));
-        assert.deepEqual(value.data, payload);
-        assert.equal(value.userType, 'nodejs-test');
-        assert.equal(typeof value.seq, 'number');
-        assert.equal(value.owner, null);
-        assert.equal(value.isSigned, false);
-        assert.equal(value.isEncrypted, false);
-        value.data.fill(7);
-        const values = await reader.getAll(key);
-        retainedValue = values.find(candidate => candidate.id === value.id);
-        assert.ok(retainedValue);
-        assert.deepEqual(retainedValue.data, payload);
-        subscription.cancel();
-        subscription.cancel();
-    } finally {
-        subscription?.cancel();
-        await Promise.all([writer.close(), reader.close()]);
-    }
-    assert.deepEqual(retainedValue.data, payload);
-});
-
-test('close settles pending operations and suppresses queued listener deliveries', { timeout: 10000 }, async () => {
-    const runner = startNode();
-    let deliveries = 0;
-    const subscription = runner.listen(hash('closing'), () => deliveries++);
-    const pending = runner.getAll(hash('unreachable'));
-    const settled = assert.rejects(pending, { code: 'ERR_DHT_CLOSED' });
-    await runner.close();
-    await settled;
-    subscription.cancel();
-    assert.equal(deliveries, 0);
-});
-
-test('get iterators settle pending reads on cancellation and reject on runner close', { timeout: 10000 }, async () => {
-    const runner = startNode();
-    try {
-        const cancelled = runner.get(hash('cancel get'));
-        assert.equal(cancelled[Symbol.asyncIterator](), cancelled);
-        const pending = [cancelled.next(), cancelled.next()];
-        await cancelled.return();
-        cancelled.cancel();
-        assert.deepEqual(await Promise.all(pending), [
-            { value: undefined, done: true },
-            { value: undefined, done: true },
-        ]);
-        assert.deepEqual(await cancelled.next(), { value: undefined, done: true });
-
-        const closing = runner.get(hash('close get'));
-        const rejected = assert.rejects(closing.next(), { code: 'ERR_DHT_CLOSED' });
-        await runner.close();
-        await rejected;
-        await assert.rejects(closing.next(), { code: 'ERR_DHT_CLOSED' });
-    } finally {
-        await runner.close();
-    }
-});
-
-test('async listeners deliver queued values and cancel on loop exit', { timeout: 15000 }, async () => {
-    const writer = startNode();
-    const reader = startNode();
-    const key = hash('async listener');
-    let iterator;
-    try {
-        writer.bootstrap('127.0.0.1', reader.getBoundPort());
-        reader.bootstrap('127.0.0.1', writer.getBoundPort());
-        iterator = reader.listen(key);
-        assert.equal(iterator[Symbol.asyncIterator](), iterator);
-        const pending = iterator.next();
-        assert.equal(await writer.put(key, Buffer.from('first'), { id: 1n }), true);
-        const first = await pending;
-        assert.equal(first.done, false);
-        assert.equal(first.value.expired, false);
-        assert.equal(first.value.value.id, 1n);
-        assert.equal(first.value.value.data.toString(), 'first');
-
-        assert.equal(await writer.put(key, Buffer.from('second'), { id: 2n }), true);
-        for await (const { value, expired } of iterator) {
-            assert.equal(expired, false);
-            assert.equal(value.id, 2n);
-            assert.equal(value.data.toString(), 'second');
-            break;
-        }
-        assert.deepEqual(await iterator.next(), { value: undefined, done: true });
-        iterator.cancel();
-    } finally {
-        iterator?.cancel();
-        await Promise.all([writer.close(), reader.close()]);
-    }
-});
-
-test('async listener cancellation settles concurrent reads and drops buffered values', { timeout: 10000 }, async () => {
-    const runner = startNode();
-    const peer = startNode();
-    const key = hash('async cancellation');
-    let iterator;
-    try {
-        runner.bootstrap('127.0.0.1', peer.getBoundPort());
-        peer.bootstrap('127.0.0.1', runner.getBoundPort());
-        iterator = runner.listen(key);
-        const pending = [iterator.next(), iterator.next()];
-        iterator.cancel();
-        iterator.cancel();
-        assert.deepEqual(await Promise.all(pending), [
-            { value: undefined, done: true },
-            { value: undefined, done: true },
-        ]);
-        assert.equal(await runner.put(key, Buffer.from('cancelled'), { id: 3n }), true);
-        assert.deepEqual(await iterator.next(), { value: undefined, done: true });
-
-        const buffered = runner.listen(key);
-        await runner.getAll(key);
-        await buffered.return();
-        assert.deepEqual(await buffered.next(), { value: undefined, done: true });
-    } finally {
-        iterator?.cancel();
-        await Promise.all([runner.close(), peer.close()]);
-    }
-});
-
-test('async listener throw, disposal, and runner close settle pending reads', { timeout: 10000 }, async () => {
-    const runner = startNode();
-    try {
-        const thrown = runner.listen(hash('async throw'));
-        const pendingThrow = thrown.next();
-        const failure = new Error('consumer failed');
-        await assert.rejects(thrown.throw(failure), error => error === failure);
-        assert.deepEqual(await pendingThrow, { value: undefined, done: true });
-        assert.deepEqual(await thrown.next(), { value: undefined, done: true });
-
-        const disposed = runner.listen(hash('async dispose'));
-        const pendingDispose = disposed.next();
-        await disposed[Symbol.asyncDispose]();
-        assert.deepEqual(await pendingDispose, { value: undefined, done: true });
-
-        const closing = runner.listen(hash('async close'));
-        const pendingClose = [closing.next(), closing.next()];
-        const close = runner.close();
-        assert.equal(runner.close(), close);
-        assert.deepEqual(await Promise.all(pendingClose), [
-            { value: undefined, done: true },
-            { value: undefined, done: true },
-        ]);
-        await close;
-        assert.deepEqual(await closing.next(), { value: undefined, done: true });
-        assert.throws(() => runner.listen(hash('closed iterator')), /closed/i);
-    } finally {
-        await runner.close();
-    }
-});
-
-test('proxy configuration validates option types before starting', async () => {
-    const runner = new DhtRunner();
-    try {
-        assert.throws(() => runner.run({ proxyServer: 42 }), TypeError);
-        assert.throws(() => runner.run({ proxyUserAgent: false }), TypeError);
-        assert.throws(() => runner.run({ proxyUserAgent: 'client\r\nInjected: header' }), TypeError);
-        assert.throws(() => runner.run({ proxyServer: 'http://127.0.0.1\0' }), TypeError);
-        assert.throws(() => runner.run({ proxyServer: 'ftp://127.0.0.1' }), /http/i);
-        assert.throws(() => runner.run({ proxyServer: 'not a URL' }), /url/i);
-        assert.equal(runner.isRunning(), false);
-        runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1', proxyServer: '' });
-        assert.ok(runner.getBoundPort() > 0);
-    } finally {
-        await runner.close();
-    }
-});
-
-test('proxy configuration routes operations through HTTP with a custom user agent', { timeout: 15000 }, async () => {
-    const runner = new DhtRunner();
-    const requests = [];
-    const values = new Map();
-    let streamNextGet = false;
-    let streamResponse;
-    const server = createServer(async (request, response) => {
-        response.setHeader('content-type', 'application/json');
-        if (request.url === '/') {
-            response.end(JSON.stringify({
-                node_id: hash('proxy fixture'),
-                ipv4: { good: 1 },
-                ipv6: {},
-                public_ip: '127.0.0.1',
-            }));
-            return;
-        }
-        requests.push({ method: request.method, url: request.url, userAgent: request.headers['user-agent'] });
-        if (request.url === `/key/${hash('proxy failure')}`) {
-            response.statusCode = 500;
-            response.end();
-            return;
-        }
-        if (request.method === 'POST') {
-            const chunks = [];
-            for await (const chunk of request) chunks.push(chunk);
-            const value = JSON.parse(Buffer.concat(chunks).toString());
-            values.set(request.url, value);
-            response.end(JSON.stringify(value));
-        } else {
-            const value = values.get(request.url);
-            const body = value ? `${JSON.stringify(value)}\n` : '';
-            if (streamNextGet) {
-                streamNextGet = false;
-                streamResponse = response;
-                response.write(body);
-            } else response.end(body);
-        }
-    });
-    server.listen(0, '127.0.0.1');
-    try {
-        await once(server, 'listening');
-        runner.run({
-            proxyServer: `http://127.0.0.1:${server.address().port}`,
-            proxyUserAgent: 'opendht-node-test/1.0',
-            persistPath: '',
-        });
-        const key = hash('proxy configuration');
-        const payload = Buffer.from([0, 255, 42]);
-        assert.equal(await runner.put(key, payload, { id: 42n }), true);
-        const received = await runner.getAll(key);
-        assert.equal(received.length, 1);
-        assert.equal(received[0].id, 42n);
-        assert.deepEqual(received[0].data, payload);
-
-        streamNextGet = true;
-        const iterator = runner.get(key);
-        const first = await iterator.next();
-        assert.equal(first.done, false);
-        assert.equal(first.value.id, 42n);
-        assert.deepEqual(first.value.data, payload);
-        assert.equal(streamResponse.writableEnded, false);
-        streamResponse.end();
-        assert.deepEqual(await iterator.next(), { value: undefined, done: true });
-        assert.deepEqual(await iterator.next(), { value: undefined, done: true });
-        assert.deepEqual(requests.map(request => request.method), ['POST', 'GET', 'GET']);
-        assert.ok(requests.every(request => request.url === `/key/${key}`));
-        assert.ok(requests.every(request => request.userAgent === 'opendht-node-test/1.0'));
-
-        const empty = runner.get(hash('proxy empty'));
-        assert.deepEqual(await empty.next(), { value: undefined, done: true });
-        const failed = runner.get(hash('proxy failure'));
-        await assert.rejects(failed.next(), { code: 'ERR_DHT_GET_FAILED' });
-        await assert.rejects(runner.getAll(hash('proxy failure')), { code: 'ERR_DHT_GET_FAILED' });
-
-        const all = [];
-        for await (const value of runner.get(key)) all.push(value);
-        assert.equal(all.length, 1);
-        assert.deepEqual(all[0].data, payload);
-
-        streamNextGet = true;
-        const cancelled = runner.get(key);
-        for await (const value of cancelled) {
-            assert.equal(value.id, 42n);
-            break;
-        }
-        assert.equal(streamResponse.writableEnded, false);
-        assert.deepEqual(await cancelled.next(), { value: undefined, done: true });
-        streamResponse.end();
-    } finally {
-        streamResponse?.end();
-        await runner.close();
-        await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
-    }
-});
-
-test('worker termination cleans up native runners', { timeout: 10000 }, async () => {
-    const source = `
-        import { parentPort } from 'node:worker_threads';
-        import { DhtRunner, hash } from ${JSON.stringify(moduleURL)};
-        const runner = new DhtRunner();
-        runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-        runner.listen(hash('worker'), () => {});
-        parentPort.postMessage('ready');
-    `;
-    const worker = new Worker(new URL(`data:text/javascript,${encodeURIComponent(source)}`));
-    try {
-        await once(worker, 'message');
-    } finally {
-        await worker.terminate();
-    }
-});
-
-test('listener callbacks may cancel themselves and close the runner', { timeout: 10000 }, async () => {
-    const runner = startNode();
-    const key = hash('reentrant listener');
-    let deliveries = 0;
-    let finish;
-    const received = new Promise(resolve => { finish = resolve; });
-    const subscription = runner.listen(key, () => {
-        deliveries++;
-        subscription.cancel();
-        finish(runner.close());
-    });
-    const puts = [];
-    for (let index = 0; index < 3000; index++) {
-        puts.push(runner.put(key, Buffer.from('value'), { id: BigInt(index + 1) }).catch(error => {
-            assert.equal(error.code, 'ERR_DHT_CLOSED');
-        }));
-    }
-    try {
-        await received;
-        await Promise.all(puts);
-        assert.equal(deliveries, 1);
-    } finally {
-        await runner.close();
-    }
-});
-
-test('unref and garbage collection do not strand native threads', { timeout: 20000 }, async () => {
-    for (const finish of ['runner.unref();', 'runner = null; setImmediate(() => global.gc());']) {
-        await promisify(execFile)(process.execPath, ['--input-type=module', '--expose-gc', '-e', `
-            import { DhtRunner } from ${JSON.stringify(moduleURL)};
-            let runner = new DhtRunner();
-            runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-            ${finish}
-        `], { timeout: 8000 });
-    }
-});
-
-test('callback queue completes bursts beyond the former event limit', { timeout: 15000 }, async () => {
-    const runner = startNode();
-    const key = hash('unbounded callback queue');
-    const errors = [];
-    const count = 3000;
-    runner.on('error', error => errors.push(error));
-    const puts = [];
-    try {
-        for (let index = 0; index < count; index++)
-            puts.push(runner.put(key, Buffer.from('value'), { id: BigInt(index + 1) }));
-        const results = await Promise.all(puts);
-        assert.equal(results.length, count);
-        assert.ok(results.every(result => typeof result === 'boolean'));
-        assert.equal(runner.isRunning(), true);
-        assert.deepEqual(errors, []);
-    } finally {
-        await runner.close();
-    }
-});
-
-test('dhtnode example prints help and validates its port', async () => {
-    const { stdout } = await promisify(execFile)(process.execPath, [example, '--help']);
-    assert.match(stdout, /Usage:.*dhtnode/);
-    assert.match(stdout, /bootstrap/);
-    await assert.rejects(promisify(execFile)(process.execPath, [example, '--port', '65536']), error => {
-        assert.equal(error.code, 1);
-        assert.match(error.stderr, /port/i);
-        return true;
-    });
-});
-
-test('dhtnode example accepts piped commands and shuts down on EOF', { timeout: 20000 }, async () => {
-    const peer = startNode();
-    try {
-        const execution = promisify(execFile)(process.execPath, [example,
-            '--port', '0', '--ipv4', '127.0.0.1',
-            '--bootstrap', '127.0.0.1', '--bootstrap-port', String(peer.getBoundPort()),
-        ], { timeout: 15000 });
-        let output = '';
-        let sentReads = false;
-        execution.child.stdout.on('data', data => {
-            output += data;
-            if (!sentReads && /Stored example/.test(output) && /Stored signed/.test(output)) {
-                sentReads = true;
-                execution.child.stdin.end('get example\nget signed\ncancel example\n');
-            }
-        });
-        execution.child.stdin.write('listen example\nput example hello world\nsign signed signed message\n');
-        const { stdout, stderr } = await execution;
-        assert.equal(stderr, '');
-        assert.match(stdout, /Node [0-9a-f]{40}/);
-        assert.match(stdout, /hello world/);
-        assert.match(stdout, /signed message.*\[signed\]/);
-        assert.match(stdout, /Cancelled example/);
-        assert.match(stdout, /Connectivity: IPv4 connected, IPv6 (disconnected|connecting|connected)/);
-    } finally {
-        await peer.close();
-    }
-});
-
-test('dhtnode example handles commands and quit while a get is pending', { timeout: 10000 }, async () => {
-    const execution = promisify(execFile)(process.execPath, ['--input-type=module', '-e', `
-        import { DhtRunner } from ${JSON.stringify(moduleURL)};
-        const close = DhtRunner.prototype.close;
-        let rejectGet;
-        DhtRunner.prototype.getAll = function () {
-            console.log('Get pending');
-            return new Promise((resolve, reject) => { rejectGet = reject; });
-        };
-        DhtRunner.prototype.close = function () {
-            rejectGet?.(new Error('DHT runner is closed'));
-            return close.call(this);
-        };
-        await import(${JSON.stringify(exampleURL.href)});
-    `, '--',
-        '--port', '0', '--ipv4', '127.0.0.1', '--ipv6', '::1',
-    ], { timeout: 8000 });
-    let output = '';
-    execution.child.stdout.on('data', data => {
-        output += data;
-        if (/get KEY \| put KEY TEXT/.test(output)) execution.child.stdin.end('quit\n');
-    });
-    execution.child.stdin.write('get waiting\nhelp\n');
-    const { stdout, stderr } = await execution;
-    assert.match(stdout, /Get pending/);
-    assert.match(stdout, /get KEY \| put KEY TEXT/);
-    assert.equal(stderr, '');
-});
-
-test('dhtnode example shuts down on SIGTERM', { timeout: 10000 }, async () => {
-    if (process.platform === 'win32') return;
-    const execution = promisify(execFile)(process.execPath, [example, '--port', '0', '--ipv4', '127.0.0.1'], { timeout: 8000 });
-    let output = '';
-    execution.child.stdout.on('data', data => {
-        output += data;
-        if (/Node [0-9a-f]{40}/.test(output)) execution.child.kill('SIGTERM');
-    });
-    const { stderr } = await execution;
-    assert.equal(stderr, '');
-});
@@ -1,93 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { Certificate, DhtRunner, Identity, PrivateKey, PublicKey, hash } from '../index.js';
-
-const payload = Buffer.from([0, 255, 1, 0, 42]);
-
-test('RSA keys sign, encrypt, and survive password-protected serialization', async () => {
-    const key = await PrivateKey.generate({ algorithm: 'rsa', bits: 2048 });
-    const publicKey = key.getPublicKey();
-    assert.match(publicKey.getId(), /^[0-9a-f]{40}$/);
-    assert.match(publicKey.getLongId(), /^[0-9a-f]{64}$/);
-    const signature = key.sign(payload);
-    assert.equal(publicKey.checkSignature(payload, signature), true);
-    assert.equal(publicKey.checkSignature(Buffer.from('other'), signature), false);
-    assert.deepEqual(key.decrypt(publicKey.encrypt(payload)), payload);
-    const restored = new PrivateKey(key.serialize('test password'), 'test password');
-    const restoredPublic = new PublicKey(publicKey.serialize());
-    assert.equal(restoredPublic.getLongId(), publicKey.getLongId());
-    assert.equal(restoredPublic.checkSignature(payload, restored.sign(payload)), true);
-    assert.deepEqual(restored.decrypt(restoredPublic.encrypt(payload)), payload);
-    assert.throws(() => new PrivateKey(key.serialize('password'), 'wrong password'));
-    assert.throws(() => key.decrypt(Buffer.from('invalid ciphertext')));
-    assert.throws(() => key.serialize('bad\0password'), TypeError);
-});
-
-test('EC keys sign and invalid crypto inputs raise JS errors', async () => {
-    const key = await PrivateKey.generate();
-    const restored = new PrivateKey(key.serialize());
-    assert.equal(restored.getPublicKey().checkSignature(payload, key.sign(payload)), true);
-    const largePayload = Buffer.alloc(16 * 1024 * 1024 + 1, 42);
-    assert.equal(restored.getPublicKey().checkSignature(largePayload, key.sign(largePayload)), true);
-    assert.throws(() => key.getPublicKey().encrypt(payload));
-    for (const Type of [PrivateKey, PublicKey, Certificate]) {
-        assert.throws(() => new Type(Buffer.alloc(0)));
-        assert.throws(() => new Type(Buffer.from('not a key or certificate')));
-        assert.throws(() => new Type(null), TypeError);
-    }
-    assert.throws(() => PrivateKey.generate({ algorithm: 'unknown' }), TypeError);
-    assert.throws(() => PrivateKey.generate({ algorithm: 'rsa', bits: 1 }), RangeError);
-    assert.throws(() => PrivateKey.generate({ algorithm: 'rsa', bits: 2048.5 }), RangeError);
-    assert.throws(() => key.sign('not bytes'), TypeError);
-    assert.throws(() => PrivateKey.prototype.sign.call({}, payload), TypeError);
-});
-
-test('identities own matching keys and certificates and support import', async () => {
-    const identity = await Identity.generate('nodejs crypto');
-    const certificate = new Certificate(identity.certificate.serialize());
-    const key = new PrivateKey(identity.privateKey.serialize());
-    const restored = new Identity(key, certificate);
-    assert.equal(restored.certificate.getLongId(), key.getPublicKey().getLongId());
-    assert.equal(certificate.getPublicKey().checkSignature(payload, key.sign(payload)), true);
-    assert.throws(() => new Identity({}, certificate), TypeError);
-    const other = await PrivateKey.generate();
-    assert.throws(() => new Identity(other, certificate), /match/i);
-});
-
-test('signed and encrypted values round-trip between authenticated nodes', { timeout: 30000 }, async () => {
-    const writerIdentity = await Identity.generate('writer');
-    const readerIdentity = await Identity.generate('reader', { algorithm: 'rsa', bits: 2048 });
-    const writer = new DhtRunner();
-    const reader = new DhtRunner();
-    try {
-        writer.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1', identity: writerIdentity });
-        reader.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1', identity: readerIdentity });
-        writer.bootstrap('127.0.0.1', reader.getBoundPort());
-        reader.bootstrap('127.0.0.1', writer.getBoundPort());
-        const signedKey = hash('nodejs signed value');
-        assert.equal(await writer.putSigned(signedKey, payload, { id: 41n }), true);
-        const signed = await reader.getAll(signedKey);
-        assert.ok(signed.some(value => value.data.equals(payload) && value.isSigned));
-        assert.equal(signed[0].owner, writerIdentity.certificate.getLongId());
-        const encryptedKey = hash('nodejs encrypted value');
-        assert.equal(await writer.putEncrypted(encryptedKey, payload, readerIdentity.certificate.getPublicKey(), { id: 42n }), true);
-        const decrypted = await reader.getAll(encryptedKey);
-        assert.ok(decrypted.some(value => value.data.equals(payload)));
-        assert.throws(() => writer.putEncrypted(encryptedKey, payload, {}), TypeError);
-        assert.throws(() => writer.putEncrypted(encryptedKey, payload, writerIdentity.certificate.getPublicKey()), /RSA/i);
-    } finally {
-        await Promise.all([writer.close(), reader.close()]);
-    }
-});
-
-test('signed operations require an identity and reject stopped runners', async () => {
-    const runner = new DhtRunner();
-    try {
-        assert.throws(() => runner.run({ identity: {} }), TypeError);
-        runner.run({ port: 0, ipv4: '127.0.0.1', ipv6: '::1' });
-        assert.throws(() => runner.putSigned(hash('unsigned'), payload), /identity/i);
-    } finally {
-        await runner.close();
-    }
-    assert.throws(() => runner.putSigned(hash('closed'), payload), /closed/i);
-});
@@ -1,34 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { test } from 'node:test';
-
-const root = path.resolve(import.meta.dirname, '..');
-
-test('package exposes ESM-only named exports', () => {
-    const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
-    assert.equal(manifest.type, 'module');
-    assert.equal(manifest.exports['.'].import, './index.js');
-    assert.equal(manifest.exports['.'].require, undefined);
-    const stdout = execFileSync(process.execPath, ['--input-type=module', '-e', `
-        import { DhtRunner, hash } from ${JSON.stringify(manifest.name)};
-        console.log(hash('hello'));
-        const runner = new DhtRunner();
-        await runner.close();
-    `], { cwd: root, encoding: 'utf8' });
-    assert.equal(stdout.trim(), 'aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d');
-});
-
-test('npm archive contains runtime files and excludes development artifacts', () => {
-    const npm = process.env.npm_execpath;
-    assert.ok(npm, 'Run the package contract with npm test');
-    const [archive] = JSON.parse(execFileSync(process.execPath,
-        [npm, 'pack', '--dry-run', '--json', '--ignore-scripts'],
-        { cwd: root, encoding: 'utf8' }));
-    const files = archive.files.map(file => file.path);
-    for (const file of ['index.js', 'index.d.ts', 'crypto.js', 'README.md', 'examples/dhtnode.js', 'examples/dhtnode.ts']) assert.ok(files.includes(file), file);
-    assert.equal(files.some(file => /^(build[^/]*|node_modules|test|scripts)\//.test(file)), false);
-    assert.equal(files.some(file => /\.(cpp|h|tsbuildinfo)$/.test(file)), false);
-    assert.ok(files.every(file => /^(index\.js|index\.d\.ts|crypto\.js|README\.md|package\.json|examples\/dhtnode\.(js|ts)|prebuilds\/)/.test(file)));
-});
@@ -1,56 +0,0 @@
-import { Certificate, DhtRunner, Identity, PrivateKey, PublicKey, hash, version } from '../index.js';
-import type { ConnectivityStatus, ListenEvent, ListenerIterator, NodeStatus, Value, ValueIterator } from '../index.js';
-
-async function exercise(): Promise<void> {
-    const privateKey: PrivateKey = await PrivateKey.generate({ algorithm: 'rsa', bits: 2048 });
-    const publicKey: PublicKey = new PublicKey(privateKey.getPublicKey().serialize());
-    const identity: Identity = await Identity.generate('typed identity');
-    const restored = new Identity(identity.privateKey, new Certificate(identity.certificate.serialize()));
-    const valid: boolean = publicKey.checkSignature(Buffer.alloc(0), privateKey.sign(Buffer.alloc(0)));
-    const plaintext: Buffer = privateKey.decrypt(publicKey.encrypt(Buffer.from('secret')));
-    const runner = new DhtRunner();
-    runner.on('error', (error: Error) => { throw error; });
-    runner.on('statusChanged', status => {
-        const ipv4: NodeStatus = status.ipv4;
-        const ipv6: NodeStatus = status.ipv6;
-        void [ipv4, ipv6];
-    });
-    const status: ConnectivityStatus = runner.getStatus();
-    runner.run({ port: 0, network: 1, persistPath: '', identity: restored });
-    runner.bootstrap('127.0.0.1', runner.getBoundPort(4));
-    const key: string = hash(new Uint8Array([0, 255]));
-    const accepted: boolean = await runner.put(key, Buffer.from(version), { id: 42n, permanent: true });
-    const signed: boolean = await runner.putSigned(key, plaintext);
-    const encrypted: boolean = await runner.putEncrypted(key, plaintext, publicKey);
-    const values: Value[] = await runner.getAll(key);
-    const get: ValueIterator<Value> = runner.get(key);
-    for await (const value of get) {
-        const payload: Buffer = value.data;
-        void payload;
-    }
-    const listener = runner.listen(key, (value, expired) => {
-        const payload: Buffer = value.data;
-        const id: bigint = value.id;
-        void [payload, id, expired];
-    });
-    runner.ref().unref();
-    listener.cancel();
-    const iterator: ListenerIterator = runner.listen(key);
-    for await (const event of iterator) {
-        const typed: ListenEvent = event;
-        const value: Value = typed.value;
-        const expired: boolean = typed.expired;
-        void [value, expired];
-        break;
-    }
-    iterator.cancel();
-    await iterator.return();
-    await iterator[Symbol.asyncDispose]();
-    await runner[Symbol.asyncDispose]();
-    const proxy = new DhtRunner();
-    proxy.run({ proxyServer: 'https://proxy.example.com', proxyUserAgent: 'typed-client/1.0' });
-    await proxy.close();
-    void [accepted, values, valid, signed, encrypted, status];
-}
-
-void exercise;
@@ -1,22 +0,0 @@
-This software is licensed under the MIT License.
-
-Copyright Fedor Indutny, 2018.
-
-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.
@@ -1,70 +0,0 @@
-# Building and Testing the Rust Crate
-
-The `opendht` crate links to the native OpenDHT C library. Cargo does not build
-or bundle that library. Install Rust and the native dependencies described in
-the [OpenDHT build guide](../BUILD.md).
-
-## Install the Native Library
-
-From the root of an OpenDHT source checkout, enable the C bindings:
-
-```sh
-cmake -S . -B build-bindings -DOPENDHT_C=ON -DBUILD_TESTING=ON
-cmake --build build-bindings
-ctest --test-dir build-bindings -R test_c --output-on-failure
-cmake --install build-bindings
-```
-
-Installation may require administrator privileges, depending on the install
-prefix. Set `CMAKE_INSTALL_PREFIX` when configuring to choose another location.
-The linker and runtime loader must be able to find the installed libraries.
-Applications can then depend on `opendht` from crates.io as shown in the
-[README](README.md).
-
-## Use an Uninstalled Native Build
-
-You can use the native build directly by setting its library search paths.
-For example, from the repository root on macOS:
-
-```sh
-export LIBRARY_PATH="$PWD/build-bindings${LIBRARY_PATH:+:$LIBRARY_PATH}"
-export DYLD_LIBRARY_PATH="$PWD/build-bindings${DYLD_LIBRARY_PATH:+:$DYLD_LIBRARY_PATH}"
-export RUSTFLAGS="-L native=$PWD/build-bindings"
-cargo test --manifest-path rust/Cargo.toml --all-targets
-```
-
-On Linux use `LD_LIBRARY_PATH` instead of `DYLD_LIBRARY_PATH`; on Windows add
-the native DLL directory to `PATH`. For an application outside this checkout,
-use absolute paths to the native build and run Cargo in the application directory.
-
-When linking an AddressSanitizer native build, use the same compiler runtime.
-For example, with Clang:
-
-```sh
-export RUSTFLAGS="-L native=$PWD/build-bindings -C linker=clang -C link-arg=-fsanitize=address"
-```
-
-## Build and Test the Crate
-
-With the native library available, run from the `rust` directory:
-
-```sh
-cargo build --all-targets
-cargo test --all-targets
-cargo test --doc
-cargo test --all-features --all-targets
-cargo test --all-features --doc
-```
-
-## Run the Examples
-
-From the `rust` directory:
-
-```sh
-cargo run --example dhtnode
-cargo run --features async --example dhtnode_async
-cargo run --features serde --example dhtnode_async
-```
-
-The callback example contacts a public bootstrap server. The async example uses
-two loopback nodes; enabling `serde` also demonstrates typed MessagePack records.
@@ -1,30 +1,11 @@
 [package]
 name = "opendht"
-version = "0.6.0"
+version = "0.2.0"
 authors = ["Sébastien Blin <sebastien.blin@savoirfairelinux.com>", "Adrien Beraud <adrien.beraud@savoirfairelinux.com>"]
 edition = "2024"
-description = "Rust bindings for OpenDHT"
-license = "MIT"
-license-file = "../LICENSE"
-repository = "https://github.com/savoirfairelinux/opendht"
-
-[features]
-async = ["dep:futures-channel", "dep:futures-core"]
-serde = ["async", "dep:serde", "dep:rmp-serde"]
-
-[[example]]
-name = "dhtnode_async"
-required-features = ["async"]

 [dependencies]
 libc="0.2"
 os_socketaddr="0.2.3"
-futures-channel = { version = "0.3", optional = true }
-futures-core = { version = "0.3", optional = true }
-serde = { version = "1", optional = true }
-rmp-serde = { version = "1", optional = true }

-[dev-dependencies]
-futures = "0.3"
-serde = { version = "1", features = ["derive"] }
-serde_bytes = "0.11"
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -1,152 +1,97 @@
-# OpenDHT: a Distributed Hash Table
+# Rust Bindings for OpenDHT

-OpenDHT is a Kademlia-based distributed hash table for storing and retrieving
-small values over a peer-to-peer network without a central server. Common uses
-include peer discovery, service announcements, and decentralized applications.
+## Build and Test

-The `opendht` crate provides Rust bindings to [OpenDHT](https://opendht.net), with
-callback-based and runtime-independent async APIs. Capabilities include signed
-and encrypted values, filtered reads, metadata queries, and typed MessagePack
-records through Serde.
+Install Rust and the native OpenDHT C library. From this directory:

-## Get Started
-
-Add the crate to your dependencies:
-
-```toml
-[dependencies]
-opendht = "0.6"
+```sh
+cargo build --all-targets
+cargo test --all-targets
+cargo test --doc
+cargo run --example dhtnode
 ```

-The native OpenDHT library with C bindings must be installed separately; it is
-not bundled with the crate. See the
-[build guide](https://github.com/savoirfairelinux/opendht/blob/master/rust/BUILD.md)
-for native installation, library paths, and source builds.
+To use an uninstalled native build, set its library search paths. For example,
+from the repository root on macOS:

-`DhtRunner` manages a node, `InfoHash` identifies a DHT key, and `Value` contains
-the payload and metadata stored under that key. `put` publishes values, `get`
-retrieves them, and `listen` subscribes to value updates and expiration events.
+```sh
+cmake -S . -B build-bindings -DOPENDHT_C=ON -DBUILD_TESTING=ON
+cmake --build build-bindings
+ctest --test-dir build-bindings -R test_c --output-on-failure
+LIBRARY_PATH="$PWD/build-bindings" \
+DYLD_LIBRARY_PATH="$PWD/build-bindings" \
+RUSTFLAGS="-L native=$PWD/build-bindings" \
+cargo test --manifest-path rust/Cargo.toml --all-targets
+```

-This example starts a node on an OS-assigned port, bootstraps into the public
-network, and listens for a value it publishes.
+On Linux use `LD_LIBRARY_PATH` instead of `DYLD_LIBRARY_PATH`; on Windows add
+the native DLL directory to `PATH`. When linking an AddressSanitizer native
+build, use the same compiler runtime, for example
+`RUSTFLAGS="-L native=$PWD/build-bindings -C linker=clang -C link-arg=-fsanitize=address"`.
+
+## Ownership and Errors
+
+Startup, crypto import/generation, serialization, and fallible settings return
+`std::io::Result`. Public-key `pack()` exports bytes; `unpack(bytes)` replaces a
+key only after successful import. Crypto methods accept binary buffers, including
+embedded NULs. Passwords and other C strings reject embedded NULs.
+
+Callbacks are owned `Send + 'static` closures, not borrowed `&mut` closures.
+Use `move` captures and channels or `Arc` for shared application state. Native
+handles are thread-bound; send copied data through channels rather than moving
+a runner or value handle between threads. Handles own stable native pointers
+and can be moved out of or back into their Rust boxes on the same thread.
+Callback panics are contained at the
+FFI boundary; a panicking value callback stops its operation.
+
+`Value::boxed()` creates an independent copy, including payload and metadata,
+so a retained value does not alias mutable native storage or in-flight puts.

 ```rust
 use opendht::{DhtRunner, InfoHash, Value};
-use std::{sync::mpsc, time::Duration};
+use std::sync::mpsc;

-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut runner = DhtRunner::new();
-    runner.run(0)?;
-    runner.bootstrap("bootstrap.jami.net", 4222)?;
-
-    let key = InfoHash::get("my-app/hello");
-    let (sender, receiver) = mpsc::channel();
-    let listener = runner.listen(&key, move |value, expired| {
-        if !expired {
-            let _ = sender.send(value);
-        }
-        true
-    })?;
-
-    runner.put(&key, Value::new("Hello from Rust!"), |_| {}, false);
-    let value = receiver.recv_timeout(Duration::from_secs(5))?;
-    println!("{}", String::from_utf8_lossy(value.as_slice()));
-
-    runner.cancel_listen(&key, listener);
-    runner.join()?;
-    Ok(())
-}
+let mut runner = DhtRunner::new();
+runner.run(0)?;
+let hash = InfoHash::get("example");
+let (sent, received) = mpsc::channel();
+let token = runner.listen(&hash, move |value, expired| {
+		if !expired { let _ = sent.send(value.as_bytes()); }
+		true
+})?;
+runner.put(&hash, Value::new("hello"), |_| {}, false);
+let bytes = received.recv_timeout(std::time::Duration::from_secs(5))?;
+runner.cancel_listen(&hash, token);
+runner.join()?;
+# Ok::<(), Box<dyn std::error::Error>>(())
 ```

-A bootstrap server supplies initial peers. Applications can use public
-bootstrap servers or known peers on a private network. Values expire, and their
-availability depends on participating nodes; the DHT does not provide durable
-storage guarantees.
+`join()` waits for native callbacks, releases registrations, and permits restart.
+Do not invoke it from a DHT callback. `shutdown(callback)` requests graceful
+shutdown; wait for its callback before `join()` when persistence is required.
+Dropping a listener token frees only the token; explicitly call `cancel_listen`
+to remove the registration, or call `join()` to stop all operations. Pending
+get/put/query completions are reported as failure when the runner stops.

-## Optional Features
+For non-threaded operation set `config.threaded = false` and repeatedly call
+`loop_once()`. Priority operations can take an iteration before normal work.
+`run_bind` selects IPv4/IPv6 bind addresses; `bound_port` reports OS-assigned ports.

-| Feature | Capabilities |
-|---------|--------------|
-| Default | Callback-based `DhtRunner`, binary values, keys, certificates, and signed/encrypted operations. |
-| `async` | `aio::AsyncDhtRunner` with publication futures, bounded read/update streams, and automatic listener cancellation on drop. |
-| `serde` | Serde-backed MessagePack records with `put_typed`, `get_typed`, and `listen_typed`. Enables `async`. |
+## Extended APIs

-Enable `async` in the dependency configuration:
-
-```toml
-[dependencies]
-opendht = { version = "0.6", features = ["async"] }
-futures = "0.3"
-```
-
-Create the adapter with `AsyncDhtRunner::new(runner)` after starting a
-`DhtRunner`. The adapter is runtime-independent and thread-bound; use a local
-executor or Tokio's `LocalSet`. Dropping a listener stream cancels its
-subscription. Streams use bounded buffers and report `WouldBlock` on overflow.
-
-This example waits for a bootstrap peer, publishes a value with `.await`, and
-reads matching values as a stream:
-
-```rust,no_run
-use futures::{executor::block_on, TryStreamExt};
-use opendht::{aio::AsyncDhtRunner, DhtRunner, InfoHash, Value};
-use std::{io, net::ToSocketAddrs};
-
-fn main() -> io::Result<()> {
-    let mut runner = DhtRunner::new();
-    runner.run(0)?;
-    let runner = AsyncDhtRunner::new(runner);
-    let peers: Vec<_> = ("bootstrap.jami.net", 4222).to_socket_addrs()?.collect();
-
-    block_on(async {
-        runner.bootstrap(&peers).await?;
-        let key = InfoHash::get("my-app/hello-async");
-        runner.put(&key, Value::new("Hello from async Rust!"), false).await?;
-
-        let mut values = runner.get(&key);
-        while let Some(value) = values.try_next().await? {
-            println!("{}", String::from_utf8_lossy(value.as_slice()));
-        }
-
-        runner.shutdown().await?;
-        runner.join()
-    })
-}
-```
-
-### Typed Records
-
-The `serde` feature adds typed async operations and also enables `async`.
-`put_typed` serializes records implementing `Serialize`; `get_typed` and
-`listen_typed` decode records implementing `DeserializeOwned`. Typed reads retain
-the decoded record alongside its original payload and native metadata.
-
-Structs are serialized as compact MessagePack arrays. Field order is part of
-the wire format and must remain compatible across schema changes. `serde_bytes`
-encodes binary fields using MessagePack's binary representation.
-
-## Working With Values
-
-GET and LISTEN callbacks and async streams deliver owned `Box<Value>` instances.
-Received values implement `Send` but not `Sync`; they can be retained after the
-runner stops, moved to another thread, modified, and republished. `as_slice()`
-borrows the payload without copying; `as_bytes()` allocates a separate `Vec<u8>`.
-
-Values expose metadata including IDs, types, sequence numbers, and owner keys.
-Filters select values by metadata, and queries return selected metadata fields.
-
-`DhtRunner::listen` returns a token that must be passed to `cancel_listen` to
-unsubscribe. Dropping the token does not cancel the registration; dropping an
-async listener stream does.
-
-`join()` stops the runner and waits for its threads to exit. It must not be
-called from a callback. For graceful shutdown and configured state persistence,
-wait for `shutdown` to complete before calling `join()`.
-
-## Learn More
-
- [API reference](https://docs.rs/opendht)
- [Callback example](https://github.com/savoirfairelinux/opendht/blob/master/rust/examples/dhtnode.rs)
- [Async and typed two-node example](https://github.com/savoirfairelinux/opendht/blob/master/rust/examples/dhtnode_async.rs)
- [Build and test guide](https://github.com/savoirfairelinux/opendht/blob/master/rust/BUILD.md)
- [OpenDHT project and issue tracker](https://github.com/savoirfairelinux/opendht)
+- Values expose explicit IDs, user types, value types, sequence numbers,
+	push priorities, and push types.
+- Keys and certificates support persistence; identities support RSA and EC
+	generation. Private keys support binary signing and RSA decryption.
+- `get_filtered`, `listen_filtered`, and `query` accept native SQL-like filters,
+	such as `WHERE value_type=17`, `WHERE seq=7`, and
+	`SELECT id,user_type WHERE value_type=17`.
+	Projected fields are optional owned values in `QueryResult`.
+- `register_type` installs native type policy and expiration settings.
+- Configuration accepts owned status and certificate-store callbacks.
+	Certificate lookup/registration and connectivity changes are exposed.
+- Push token/topic/platform setters forward native settings.
+	`push_notification_received` returns a `PushNotification`; call `poll()` for
+	the native result. In non-threaded mode continue driving `loop_once()`.
+	Disabled builds return `IgnoredDisabled`; stopped runners return the native
+	ignored outcome. Push tokens remain valid after the runner stops.
@@ -1,80 +0,0 @@
-use futures::{executor::block_on, StreamExt, TryStreamExt};
-use opendht::{aio::AsyncDhtRunner, DhtRunner, DhtRunnerConfig, InfoHash, Value};
-use std::error::Error;
-use std::io;
-use std::net::SocketAddr;
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let mut source = DhtRunner::new();
-    let mut destination = DhtRunner::new();
-    source.run_bind("127.0.0.1", "::1", 0, DhtRunnerConfig::new())?;
-    destination.run_bind("127.0.0.1", "::1", 0, DhtRunnerConfig::new())?;
-    let address = SocketAddr::from(([127, 0, 0, 1], destination.bound_port(libc::AF_INET as _)));
-    let source = AsyncDhtRunner::new(source);
-    let destination = AsyncDhtRunner::new(destination);
-
-    block_on(async {
-        source.bootstrap(&[address]).await?;
-        let hash = InfoHash::get("async example");
-        let mut updates = destination.listen(&hash)?;
-        source
-            .put(&hash, Value::with_id(b"hello from Rust async", 42), false)
-            .await?;
-        let event = updates
-            .next()
-            .await
-            .ok_or_else(|| io::Error::other("listener ended before receiving a value"))??;
-        println!(
-            "LISTEN {}: {} (expired: {})",
-            event.value.id(),
-            String::from_utf8_lossy(event.value.as_slice()),
-            event.expired,
-        );
-        drop(updates);
-
-        let values: Vec<_> = destination.get(&hash).try_collect().await?;
-        println!("GET: {} values", values.len());
-
-        #[cfg(feature = "serde")]
-        {
-            #[derive(Debug, serde::Serialize, serde::Deserialize)]
-            struct Service {
-                version: u32,
-                name: String,
-                port: u16,
-                #[serde(with = "serde_bytes")]
-                payload: Vec<u8>,
-            }
-
-            let hash = InfoHash::get("typed async example");
-            let mut updates = destination.listen_typed::<Service>(&hash)?;
-            let record = Service {
-                version: 1,
-                name: "chat".into(),
-                port: 4222,
-                payload: vec![0, 0x80, 0xff],
-            };
-            source.put_typed(&hash, &record, false).await?;
-            let event = updates.next().await.ok_or_else(|| {
-                io::Error::other("typed listener ended before receiving a value")
-            })??;
-            println!(
-                "TYPED LISTEN {}: {:?}",
-                event.value.raw.id(),
-                event.value.data
-            );
-            drop(updates);
-            let values: Vec<_> = destination
-                .get_typed::<Service>(&hash)
-                .try_collect()
-                .await?;
-            println!("TYPED GET: {} records", values.len());
-        }
-
-        source.shutdown().await?;
-        destination.shutdown().await?;
-        source.join()?;
-        destination.join()?;
-        Ok(())
-    })
-}
@@ -1,429 +0,0 @@
-//! Runtime-independent futures and bounded streams, enabled by the `async` feature.
-//!
-//! Runners and listeners stay on their creating thread. Use a local executor or
-//! Tokio `LocalSet`; received values own their native storage and can be
-//! transferred between threads without another payload copy.
-
-use crate::{DhtRunner, InfoHash, OpToken, PkId, QueryResult, Value};
-use futures_channel::{mpsc, oneshot};
-use futures_core::Stream;
-use std::cell::RefCell;
-use std::future::Future;
-use std::io;
-use std::net::SocketAddr;
-use std::pin::Pin;
-use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-use std::task::{Context, Poll};
-
-/// A listener update; expiration events retain the expired value's metadata.
-pub struct ValueEvent {
-    pub value: Box<Value>,
-    pub expired: bool,
-}
-
-/// A native completion mapped to an I/O result.
-///
-/// Operations start immediately, before this future is polled. Dropping it
-/// abandons the result but does not undo a put, ping, bootstrap, or shutdown.
-#[must_use = "operations run immediately; await their result or explicitly drop it"]
-pub struct Operation {
-    receiver: oneshot::Receiver<io::Result<()>>,
-}
-
-impl Future for Operation {
-    type Output = io::Result<()>;
-
-    fn poll(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.receiver).poll(context).map(|outcome| {
-            outcome.unwrap_or_else(|_| Err(stopped("DHT operation ended without completion")))
-        })
-    }
-}
-
-fn operation() -> (oneshot::Sender<io::Result<()>>, Operation) {
-    let (sender, receiver) = oneshot::channel();
-    (sender, Operation { receiver })
-}
-
-fn outcome(success: bool) -> io::Result<()> {
-    if success {
-        Ok(())
-    } else {
-        Err(io::Error::other(
-            "DHT operation failed or the runner stopped",
-        ))
-    }
-}
-
-fn stopped(message: &'static str) -> io::Error {
-    io::Error::new(io::ErrorKind::Interrupted, message)
-}
-
-#[derive(Clone)]
-struct StreamCompletion(Arc<Mutex<Option<oneshot::Sender<io::Result<()>>>>>);
-
-impl StreamCompletion {
-    fn finish(&self, result: io::Result<()>) {
-        let sender = self
-            .0
-            .lock()
-            .unwrap_or_else(|error| error.into_inner())
-            .take();
-        if let Some(sender) = sender {
-            let _ = sender.send(result);
-        }
-    }
-}
-
-struct StreamSender<T> {
-    values: mpsc::Sender<T>,
-    completion: StreamCompletion,
-}
-
-impl<T> StreamSender<T> {
-    fn send(&mut self, value: io::Result<T>) -> bool {
-        let value = match value {
-            Ok(value) => value,
-            Err(error) => {
-                self.completion.finish(Err(error));
-                return false;
-            }
-        };
-        match self.values.try_send(value) {
-            Ok(()) => true,
-            Err(error) => {
-                if error.is_full() {
-                    self.completion.finish(Err(io::Error::new(
-                        io::ErrorKind::WouldBlock,
-                        "DHT stream capacity exceeded; restart the operation to resynchronize",
-                    )));
-                }
-                false
-            }
-        }
-    }
-}
-
-/// A bounded get or query stream.
-///
-/// Buffered items precede a terminal error. Native failure, runner shutdown,
-/// and buffer overflow are never reported as successful EOF.
-/// Dropping the stream stops delivery; native work stops at its next callback
-/// or when the runner is joined.
-#[must_use = "streams must be polled to receive values and completion errors"]
-pub struct OperationStream<T> {
-    values: mpsc::Receiver<T>,
-    completion: oneshot::Receiver<io::Result<()>>,
-    completed: bool,
-    outcome: Option<io::Result<()>>,
-}
-
-impl<T: Unpin> Stream for OperationStream<T> {
-    type Item = io::Result<T>;
-
-    fn poll_next(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let stream = self.get_mut();
-        if !stream.completed
-            && let Poll::Ready(result) = Pin::new(&mut stream.completion).poll(context)
-        {
-            stream.completed = true;
-            stream.outcome = Some(
-                result.unwrap_or_else(|_| Err(stopped("DHT stream ended without completion"))),
-            );
-            stream.values.close();
-        }
-        match Pin::new(&mut stream.values).poll_next(context) {
-            Poll::Ready(Some(value)) => Poll::Ready(Some(Ok(value))),
-            Poll::Ready(None) if stream.completed => {
-                Poll::Ready(stream.outcome.take().and_then(Result::err).map(Err))
-            }
-            _ => Poll::Pending,
-        }
-    }
-}
-
-fn stream_channel<T>(capacity: usize) -> (StreamSender<T>, OperationStream<T>) {
-    let (values, receiver) = mpsc::channel(capacity - 1);
-    let (completed, completion) = oneshot::channel();
-    (
-        StreamSender {
-            values,
-            completion: StreamCompletion(Arc::new(Mutex::new(Some(completed)))),
-        },
-        OperationStream {
-            values: receiver,
-            completion,
-            completed: false,
-            outcome: None,
-        },
-    )
-}
-
-struct RunnerState {
-    runner: RefCell<Box<DhtRunner>>,
-    stopping: Arc<AtomicBool>,
-}
-
-impl Drop for RunnerState {
-    fn drop(&mut self) {
-        self.stopping.store(true, Ordering::SeqCst);
-    }
-}
-
-/// A listener registration that cancels itself when dropped or terminated.
-///
-/// The runner is retained until this registration is dropped. Calling `join()`
-/// stops all registrations and makes pending listeners report an error.
-#[must_use = "dropping a listener cancels its native registration"]
-pub struct Listener {
-    state: Rc<RunnerState>,
-    hash: InfoHash,
-    token: Option<Box<OpToken>>,
-    stream: OperationStream<ValueEvent>,
-}
-
-impl Listener {
-    fn cancel(&mut self) {
-        if let Some(token) = self.token.take() {
-            self.state
-                .runner
-                .borrow_mut()
-                .cancel_listen(&self.hash, token);
-        }
-    }
-}
-
-impl Stream for Listener {
-    type Item = io::Result<ValueEvent>;
-
-    fn poll_next(mut self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let result = Pin::new(&mut self.stream).poll_next(context);
-        if matches!(result, Poll::Ready(None) | Poll::Ready(Some(Err(_)))) {
-            self.cancel();
-        }
-        result
-    }
-}
-
-impl Drop for Listener {
-    fn drop(&mut self) {
-        self.cancel();
-    }
-}
-
-/// A shared, thread-bound async adapter for an already configured runner.
-///
-/// Clones share a runner without making native handles `Send` or `Sync`.
-/// Native calls are short; futures and streams never hold a mutable runner
-/// borrow while waiting. The default stream capacity is 64 items.
-///
-/// ```compile_fail
-/// use opendht::{aio::AsyncDhtRunner, DhtRunner};
-/// let runner = AsyncDhtRunner::new(DhtRunner::new());
-/// std::thread::spawn(move || runner.join().unwrap());
-/// ```
-#[derive(Clone)]
-pub struct AsyncDhtRunner {
-    state: Rc<RunnerState>,
-    capacity: usize,
-}
-
-impl AsyncDhtRunner {
-    pub fn new(runner: Box<DhtRunner>) -> Self {
-        Self::with_capacity(runner, 64).expect("default stream capacity is valid")
-    }
-
-    /// Set the maximum number of queued values per get, query, or listener.
-    /// A slow consumer receives `WouldBlock` and the stream terminates.
-    pub fn with_capacity(runner: Box<DhtRunner>, capacity: usize) -> io::Result<Self> {
-        if capacity == 0 {
-            return Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "stream capacity must be positive",
-            ));
-        }
-        Ok(Self {
-            state: Rc::new(RunnerState {
-                runner: RefCell::new(runner),
-                stopping: Arc::new(AtomicBool::new(false)),
-            }),
-            capacity,
-        })
-    }
-
-    pub fn put(&self, hash: &InfoHash, value: Box<Value>, permanent: bool) -> Operation {
-        let (sender, pending) = operation();
-        self.state.runner.borrow_mut().put(
-            hash,
-            value,
-            move |success| {
-                let _ = sender.send(outcome(success));
-            },
-            permanent,
-        );
-        pending
-    }
-
-    pub fn put_signed(&self, hash: &InfoHash, value: Box<Value>, permanent: bool) -> Operation {
-        let (sender, pending) = operation();
-        self.state.runner.borrow_mut().put_signed(
-            hash,
-            value,
-            move |success| {
-                let _ = sender.send(outcome(success));
-            },
-            permanent,
-        );
-        pending
-    }
-
-    pub fn put_encrypted(
-        &self,
-        hash: &InfoHash,
-        recipient: &PkId,
-        value: Box<Value>,
-        permanent: bool,
-    ) -> Operation {
-        let (sender, pending) = operation();
-        self.state.runner.borrow_mut().put_encrypted(
-            hash,
-            recipient,
-            value,
-            move |success| {
-                let _ = sender.send(outcome(success));
-            },
-            permanent,
-        );
-        pending
-    }
-
-    pub fn ping(&self, address: SocketAddr) -> Operation {
-        let (sender, pending) = operation();
-        self.state
-            .runner
-            .borrow_mut()
-            .ping(address, move |success| {
-                let _ = sender.send(outcome(success));
-            });
-        pending
-    }
-
-    /// Bootstrap pre-resolved addresses concurrently; one successful peer suffices.
-    /// DNS resolution is left to the application's executor.
-    pub fn bootstrap(&self, addresses: &[SocketAddr]) -> Operation {
-        let (sender, pending) = operation();
-        if addresses.is_empty() {
-            let _ = sender.send(Err(io::Error::new(
-                io::ErrorKind::InvalidInput,
-                "at least one bootstrap address is required",
-            )));
-            return pending;
-        }
-        let completion = StreamCompletion(Arc::new(Mutex::new(Some(sender))));
-        let remaining = Arc::new(std::sync::atomic::AtomicUsize::new(addresses.len()));
-        for &address in addresses {
-            let completion = completion.clone();
-            let remaining = remaining.clone();
-            self.state
-                .runner
-                .borrow_mut()
-                .ping(address, move |success| {
-                    if success {
-                        completion.finish(Ok(()));
-                    }
-                    if remaining.fetch_sub(1, Ordering::SeqCst) == 1 {
-                        completion.finish(outcome(false));
-                    }
-                });
-        }
-        pending
-    }
-
-    pub fn get(&self, hash: &InfoHash) -> OperationStream<Box<Value>> {
-        let (mut sender, stream) = stream_channel(self.capacity);
-        let completion = sender.completion.clone();
-        self.state.runner.borrow_mut().get(
-            hash,
-            move |value| sender.send(Ok(value)),
-            move |success| completion.finish(outcome(success)),
-        );
-        stream
-    }
-
-    pub fn get_filtered(
-        &self,
-        hash: &InfoHash,
-        filter: &str,
-    ) -> io::Result<OperationStream<Box<Value>>> {
-        let (mut sender, stream) = stream_channel(self.capacity);
-        let completion = sender.completion.clone();
-        self.state.runner.borrow_mut().get_filtered(
-            hash,
-            filter,
-            move |value| sender.send(Ok(value)),
-            move |success| completion.finish(outcome(success)),
-        )?;
-        Ok(stream)
-    }
-
-    pub fn query(&self, hash: &InfoHash, query: &str) -> io::Result<OperationStream<QueryResult>> {
-        let (mut sender, stream) = stream_channel(self.capacity);
-        let completion = sender.completion.clone();
-        self.state.runner.borrow_mut().query(
-            hash,
-            query,
-            move |row| sender.send(Ok(row)),
-            move |success| completion.finish(outcome(success)),
-        )?;
-        Ok(stream)
-    }
-
-    pub fn listen(&self, hash: &InfoHash) -> io::Result<Listener> {
-        self.listen_filtered(hash, "")
-    }
-
-    pub fn listen_filtered(&self, hash: &InfoHash, filter: &str) -> io::Result<Listener> {
-        let (mut sender, stream) = stream_channel(self.capacity);
-        let token = self.state.runner.borrow_mut().listen_filtered(
-            hash,
-            filter,
-            move |value, expired| sender.send(Ok(ValueEvent { value, expired })),
-        )?;
-        Ok(Listener {
-            state: self.state.clone(),
-            hash: InfoHash { d: hash.d },
-            token: Some(token),
-            stream,
-        })
-    }
-
-    /// Request graceful shutdown. Call `join()` after this future succeeds when
-    /// persistence is required. Joining first reports an interrupted shutdown.
-    pub fn shutdown(&self) -> Operation {
-        let (sender, pending) = operation();
-        let stopping = self.state.stopping.clone();
-        self.state.runner.borrow_mut().shutdown(move || {
-            let result = if stopping.load(Ordering::SeqCst) {
-                Err(stopped("runner joined before graceful shutdown completed"))
-            } else {
-                Ok(())
-            };
-            let _ = sender.send(result);
-        });
-        pending
-    }
-
-    /// Drive a non-threaded runner without waiting for any async operation.
-    pub fn loop_once(&self) -> io::Result<()> {
-        self.state.runner.borrow_mut().loop_once()
-    }
-
-    /// Stop the runner and wait for native callbacks. This is a blocking call,
-    /// not an async wait, and must not be invoked from a native DHT callback.
-    pub fn join(&self) -> io::Result<()> {
-        self.state.stopping.store(true, Ordering::SeqCst);
-        self.state.runner.borrow_mut().join()
-    }
-}
@@ -272,7 +272,7 @@ extern "C" fn get_handler_cb(value: *const ffi::Value, ptr: *mut c_void) -> bool
    }
    callback(false, || unsafe {
        let handler = ptr as *mut GetHandler;
-        (*handler).get_cb(Value::copy_from_received(value).expect("value copy failed"))
+        (*handler).get_cb(Value::from_raw(ffi::dht_value_copy(value)).expect("value copy failed"))
    })
 }

@@ -308,7 +308,7 @@ extern "C" fn listen_handler(value: *const ffi::Value, expired: bool, ptr: *mut
    callback(false, || unsafe {
        let handler = ptr as *mut ListenHandler;
        (*handler).cb(
-            Value::copy_from_received(value).expect("value copy failed"),
+            Value::from_raw(ffi::dht_value_copy(value)).expect("value copy failed"),
            expired,
        )
    })
@@ -537,7 +537,6 @@ impl DhtRunner {
        result(unsafe { ffi::dht_runner_connectivity_changed(self.as_ptr()) })
    }

-    /// Deliver owned values that callbacks may mutate or move to another thread.
    pub fn get(
        &mut self,
        h: &InfoHash,
@@ -677,8 +676,7 @@ impl DhtRunner {
        unsafe { ffi::dht_runner_cancel_put(self.as_ptr(), h, vid) }
    }

-    /// Registers an owned callback receiving ordinary owned `Box<Value>` objects.
-    /// It is released after cancellation or `join()`.
+    /// Registers an owned callback. It is released after cancellation or `join()`.
    /// Borrowed callbacks cannot outlive their stack frame:
    ///
    /// ```compile_fail
@@ -26,13 +26,13 @@ pub struct Blob {
    _thread_bound: std::marker::PhantomData<*mut ()>,
 }

-#[repr(C, align(4))]
+#[repr(C)]
 #[derive(PartialEq)]
 pub struct InfoHash {
    pub d: [u8; HASH_LEN],
 }

-#[repr(C, align(4))]
+#[repr(C)]
 pub struct PkId {
    pub d: [u8; PKID_LEN],
 }
@@ -40,12 +40,6 @@ mod infohash;
 mod pkid;
 mod value;

-#[cfg(feature = "async")]
-pub mod aio;
-
-#[cfg(feature = "serde")]
-pub mod typed;
-
 pub use blob::Blob;
 pub use dhtrunner::{
    DhtNodeConfig, DhtRunner, DhtRunnerConfig, DhtSecureConfig, NodeStatus, OpToken,
@@ -1,201 +0,0 @@
-//! MessagePack-encoded typed operations, enabled by the `serde` feature.
-//!
-//! This feature enables `async` and adds methods to [`AsyncDhtRunner`]. Values
-//! use compact MessagePack payloads, with no binding-specific envelope or
-//! implicit schema version. Structs are encoded as arrays in field order.
-//! Applications can include a version field in their records and use
-//! `serde_bytes` for binary fields rather than arrays of integers.
-//!
-//! ```no_run
-//! use futures::TryStreamExt;
-//! use opendht::{aio::AsyncDhtRunner, InfoHash};
-//! use serde::{Deserialize, Serialize};
-//!
-//! #[derive(Debug, Serialize, Deserialize)]
-//! struct Service {
-//!     version: u32,
-//!     name: String,
-//!     port: u16,
-//!     #[serde(with = "serde_bytes")]
-//!     payload: Vec<u8>,
-//! }
-//!
-//! async fn exchange(
-//!     runner: &AsyncDhtRunner,
-//!     key: &InfoHash,
-//! ) -> Result<(), Box<dyn std::error::Error>> {
-//!     let mut updates = runner.listen_typed::<Service>(key)?;
-//!     let record = Service {
-//!         version: 1, name: "chat".into(), port: 4222, payload: vec![0, 0x80, 0xff],
-//!     };
-//!     runner.put_typed(key, &record, false).await?;
-//!     if let Some(event) = updates.try_next().await? {
-//!         println!("{}: {:?}", event.value.raw.id(), event.value.data);
-//!     }
-//!     drop(updates);
-//!     let records: Vec<_> = runner.get_typed::<Service>(key).try_collect().await?;
-//!     Ok(())
-//! }
-//! ```
-
-use crate::aio::{AsyncDhtRunner, ValueEvent};
-use crate::{InfoHash, Value};
-use futures_core::Stream;
-use serde::{de::DeserializeOwned, Serialize};
-use std::error::Error;
-use std::fmt;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
-/// A decoded record together with its original payload and native metadata.
-pub struct TypedValue<T> {
-    pub data: T,
-    pub raw: Box<Value>,
-}
-
-impl<T: fmt::Debug> fmt::Debug for TypedValue<T> {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter
-            .debug_struct("TypedValue")
-            .field("data", &self.data)
-            .field("id", &self.raw.id())
-            .field("seq", &self.raw.seq())
-            .finish_non_exhaustive()
-    }
-}
-
-/// A decoded listener update, including whether the record expired.
-#[derive(Debug)]
-pub struct TypedEvent<T> {
-    pub value: TypedValue<T>,
-    pub expired: bool,
-}
-
-/// Typed operations distinguish native failures from payload format errors.
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum TypedError {
-    Operation(io::Error),
-    Serialize(rmp_serde::encode::Error),
-    Deserialize {
-        id: u64,
-        source: rmp_serde::decode::Error,
-    },
-}
-
-impl fmt::Display for TypedError {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Operation(error) => write!(formatter, "DHT operation failed: {error}"),
-            Self::Serialize(error) => write!(formatter, "could not serialize typed value: {error}"),
-            Self::Deserialize { id, source } => {
-                write!(formatter, "could not deserialize DHT value {id}: {source}")
-            }
-        }
-    }
-}
-
-impl Error for TypedError {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        match self {
-            Self::Operation(error) => Some(error),
-            Self::Serialize(error) => Some(error),
-            Self::Deserialize { source, .. } => Some(source),
-        }
-    }
-}
-
-impl<T: DeserializeOwned> TryFrom<Box<Value>> for TypedValue<T> {
-    type Error = TypedError;
-
-    fn try_from(raw: Box<Value>) -> Result<Self, Self::Error> {
-        let data =
-            rmp_serde::from_slice(raw.as_slice()).map_err(|source| TypedError::Deserialize {
-                id: raw.id(),
-                source,
-            })?;
-        Ok(Self { data, raw })
-    }
-}
-
-impl<T: DeserializeOwned> TryFrom<ValueEvent> for TypedEvent<T> {
-    type Error = TypedError;
-
-    fn try_from(event: ValueEvent) -> Result<Self, Self::Error> {
-        Ok(Self {
-            value: event.value.try_into()?,
-            expired: event.expired,
-        })
-    }
-}
-
-struct DecodeStream<Source: Stream, Output> {
-    source: Source,
-    decode: fn(Source::Item) -> Result<Output, TypedError>,
-}
-
-impl<Source: Stream + Unpin, Output> Stream for DecodeStream<Source, Output> {
-    type Item = Result<Output, TypedError>;
-
-    fn poll_next(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let stream = self.get_mut();
-        Pin::new(&mut stream.source)
-            .poll_next(context)
-            .map(|item| item.map(stream.decode))
-    }
-}
-
-fn decode<Input, Output: TryFrom<Input, Error = TypedError>>(
-    input: io::Result<Input>,
-) -> Result<Output, TypedError> {
-    input.map_err(TypedError::Operation)?.try_into()
-}
-
-impl AsyncDhtRunner {
-    /// Serialize a record as MessagePack and publish it when this future is polled.
-    ///
-    /// Unlike untyped `put`, this operation is lazy. Serialization failure does
-    /// not start a native put. Dropping it after publication starts does not
-    /// undo the put. Use the untyped API to customize value IDs and metadata.
-    pub async fn put_typed<T: Serialize + ?Sized>(
-        &self,
-        hash: &InfoHash,
-        value: &T,
-        permanent: bool,
-    ) -> Result<(), TypedError> {
-        let bytes = rmp_serde::to_vec(value).map_err(TypedError::Serialize)?;
-        self.put(hash, Value::from_bytes(&bytes), permanent)
-            .await
-            .map_err(TypedError::Operation)
-    }
-
-    /// Start a get and decode each MessagePack payload on the consumer's thread.
-    ///
-    /// A malformed or incompatible record yields a per-value error; polling can
-    /// continue to subsequent records. Native errors remain terminal. The stream
-    /// does not borrow the runner or hash, and records need not be `Unpin`.
-    pub fn get_typed<T: DeserializeOwned>(
-        &self,
-        hash: &InfoHash,
-    ) -> impl Stream<Item = Result<TypedValue<T>, TypedError>> + Unpin + use<T> {
-        DecodeStream {
-            source: self.get(hash),
-            decode: decode::<_, TypedValue<T>>,
-        }
-    }
-
-    /// Listen for MessagePack records, preserving metadata and expiration events.
-    ///
-    /// Decode errors do not cancel the registration. Dropping this stream does
-    /// cancel it, including when a short-circuiting consumer stops on an error.
-    pub fn listen_typed<T: DeserializeOwned>(
-        &self,
-        hash: &InfoHash,
-    ) -> io::Result<impl Stream<Item = Result<TypedEvent<T>, TypedError>> + Unpin + use<T>> {
-        Ok(DecodeStream {
-            source: self.listen(hash)?,
-            decode: decode::<_, TypedEvent<T>>,
-        })
-    }
-}
@@ -14,40 +14,7 @@ pub use crate::ffi::DataView;

 native_handle!(Value, dht_value_unref);

-/// Rust owns an unaliased native value: constructors allocate it, received
-/// values are deep-copied once, and boxed() deep-copies explicitly. Puts consume
-/// the handle before native code retains it. Shared owner keys are const and
-/// their lazy fingerprints are initialized before received values cross threads.
-/// Mutation requires exclusive access; native storage may be freed on any thread.
-/// Value is Send, not Sync.
-unsafe impl Send for Value {}
-
-impl AsRef<[u8]> for Value {
-    fn as_ref(&self) -> &[u8] {
-        self.as_slice()
-    }
-}
-
-impl fmt::Debug for Value {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        formatter
-            .debug_struct("Value")
-            .field("id", &self.id())
-            .field("seq", &self.seq())
-            .finish_non_exhaustive()
-    }
-}
-
 impl Value {
-    pub(crate) unsafe fn copy_from_received(value: *const ffi::Value) -> io::Result<Box<Self>> {
-        let value = unsafe { Self::from_raw(ffi::dht_value_copy(value))? };
-        if let Some(owner) = value.owner() {
-            owner.id();
-            owner.long_id();
-        }
-        Ok(value)
-    }
-
    pub fn with_id(data: &[u8], id: u64) -> Box<Value> {
        unsafe {
            Self::from_raw(ffi::dht_value_with_id_new(data.as_ptr(), data.len(), id))
@@ -74,16 +41,13 @@ impl Value {
    }

    pub fn as_bytes(&self) -> Vec<u8> {
-        self.as_slice().to_vec()
-    }
-
-    /// Borrow the payload without allocating or copying it.
-    pub fn as_slice(&self) -> &[u8] {
-        let view = self.dataview();
-        if view.size == 0 {
-            &[]
-        } else {
-            unsafe { slice::from_raw_parts(view.data, view.size) }
+        unsafe {
+            let dv = ffi::dht_value_get_data(self.as_ptr());
+            if dv.size == 0 {
+                return Vec::new();
+            }
+            let slice = slice::from_raw_parts(dv.data, dv.size);
+            slice.to_vec()
        }
    }

@@ -99,8 +63,12 @@ impl Value {
        unsafe { PublicKey::from_raw(ffi::dht_value_get_owner(self.as_ptr())).ok() }
    }

-    pub fn user_type(&self) -> Result<&str, str::Utf8Error> {
-        unsafe { CStr::from_ptr(ffi::dht_value_get_user_type(self.as_ptr())).to_str() }
+    pub fn user_type(&self) -> Result<String, str::Utf8Error> {
+        unsafe {
+            Ok(CStr::from_ptr(ffi::dht_value_get_user_type(self.as_ptr()))
+                .to_str()?
+                .to_owned())
+        }
    }

    pub fn set_user_type(&mut self, value: &str) -> io::Result<()> {
@@ -135,8 +103,12 @@ impl Value {
            ffi::dht_value_set_priority(self.as_ptr(), value);
        }
    }
-    pub fn push_type(&self) -> Result<&str, str::Utf8Error> {
-        unsafe { CStr::from_ptr(ffi::dht_value_get_push_type(self.as_ptr())).to_str() }
+    pub fn push_type(&self) -> Result<String, str::Utf8Error> {
+        unsafe {
+            Ok(CStr::from_ptr(ffi::dht_value_get_push_type(self.as_ptr()))
+                .to_str()?
+                .to_owned())
+        }
    }
    pub fn set_push_type(&mut self, value: &str) -> io::Result<()> {
        let value = CString::new(value)?;
@@ -159,33 +131,3 @@ impl fmt::Display for Value {
        }
    }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn value_moves_between_threads_without_copying_payload() {
-        let mut value = Value::from_bytes(b"native\0payload\xff");
-        value.set_user_type("borrowed metadata").unwrap();
-        let view = unsafe { ffi::dht_value_get_data(value.as_ptr()) };
-        let value = std::thread::spawn(move || {
-            value.set_seq(7);
-            value
-        })
-        .join()
-        .unwrap();
-        assert_eq!(value.as_slice().as_ptr(), view.data);
-        assert_eq!(value.as_slice(), b"native\0payload\xff");
-        assert_eq!(value.seq(), 7);
-        let user_type: &str = value.user_type().unwrap();
-        assert_eq!(user_type, "borrowed metadata");
-    }
-
-    #[test]
-    fn empty_value_payload_is_borrowed_safely() {
-        let value = Value::from_bytes(&[]);
-        assert!(value.as_slice().is_empty());
-        assert_eq!(value.as_slice(), &[]);
-    }
-}
@@ -55,6 +55,7 @@ fn native_handles_can_move_out_of_their_boxes() {
    let token = *runner
        .listen(&hash, move |value, expired| {
            if !expired {
+                let value = *value;
                sent.send(value.as_bytes()).unwrap();
            }
            true
@@ -245,7 +246,7 @@ fn shutdown_owns_its_callback_and_contains_panics() {
 fn startup_errors_reach_rust() {
    let socket4 = std::net::UdpSocket::bind("0.0.0.0:0").unwrap();
    let port = socket4.local_addr().unwrap().port();
-    let _socket6 = std::net::UdpSocket::bind((std::net::Ipv6Addr::LOCALHOST, port)).unwrap();
+    let _socket6 = std::net::UdpSocket::bind((std::net::Ipv6Addr::UNSPECIFIED, port)).unwrap();
    assert!(DhtRunner::new().run(port).is_err());
 }

@@ -480,566 +481,3 @@ fn threaded_signed_and_encrypted_roundtrips() {
        runner.join().unwrap();
    }
 }
-
-#[test]
-fn callbacks_move_mutable_values_without_copying() {
-    let mut runner = DhtRunner::new();
-    let mut config = DhtRunnerConfig::new();
-    config.threaded = false;
-    runner.run_config(0, config).unwrap();
-    let hash = InfoHash::get("single Value callback ownership");
-    let (listen_sent, listen_received) = mpsc::channel();
-    let _token = runner
-        .listen(&hash, move |mut value: Box<Value>, expired| {
-            if !expired {
-                value.set_seq(8);
-                let pointer = value.as_slice().as_ptr() as usize;
-                let _ = listen_sent.send((pointer, value));
-            }
-            true
-        })
-        .unwrap();
-    let mut value = Value::with_id(b"immutable\0payload\xff", 42);
-    value.set_seq(7);
-    value.set_user_type("application/immutable").unwrap();
-    value.set_push_type("call").unwrap();
-    runner.put(&hash, value, |_| {}, false);
-    runner.loop_once().unwrap();
-
-    let (get_sent, get_received) = mpsc::channel();
-    runner.get(
-        &hash,
-        move |value: Box<Value>| {
-            let pointer = value.as_slice().as_ptr() as usize;
-            let _ = get_sent.send((pointer, value));
-            true
-        },
-        |_| {},
-    );
-    runner.loop_once().unwrap();
-    runner.join().unwrap();
-
-    for (received, expected_seq) in [(listen_received, 8), (get_received, 7)] {
-        let (pointer, value) = received.recv_timeout(Duration::from_secs(5)).unwrap();
-        let value = std::thread::spawn(move || {
-            let mut value = value;
-            assert_eq!(value.as_slice().as_ptr() as usize, pointer);
-            assert_eq!(value.as_slice(), b"immutable\0payload\xff");
-            assert_eq!(value.id(), 42);
-            assert_eq!(value.seq(), expected_seq);
-            let user_type: &str = value.user_type().unwrap();
-            assert_eq!(user_type, "application/immutable");
-            let push_type: &str = value.push_type().unwrap();
-            assert_eq!(push_type, "call");
-            value.set_seq(9);
-            assert_eq!(value.as_slice().as_ptr() as usize, pointer);
-            value
-        })
-        .join()
-        .unwrap();
-        let mut editable = value.boxed();
-        editable.set_seq(10);
-        assert_eq!(value.seq(), 9);
-        assert_eq!(editable.seq(), 10);
-    }
-}
-
-#[cfg(feature = "async")]
-mod asynchronous {
-    use super::*;
-    use futures::{executor::block_on, future, Future, StreamExt, TryStreamExt};
-    use opendht::aio::AsyncDhtRunner;
-    use std::pin::pin;
-    use std::time::Instant;
-
-    fn nonthreaded(capacity: usize) -> AsyncDhtRunner {
-        let mut runner = DhtRunner::new();
-        let mut config = DhtRunnerConfig::new();
-        config.threaded = false;
-        runner.run_bind("127.0.0.1", "::1", 0, config).unwrap();
-        runner.register_type(17, "async test", 1, false).unwrap();
-        AsyncDhtRunner::with_capacity(runner, capacity).unwrap()
-    }
-
-    fn drive<Output>(runner: &AsyncDhtRunner, operation: impl Future<Output = Output>) -> Output {
-        let mut operation = pin!(operation);
-        let deadline = Instant::now() + Duration::from_secs(15);
-        block_on(future::poll_fn(|context| {
-            assert!(Instant::now() < deadline, "async operation timed out");
-            runner.loop_once().unwrap();
-            context.waker().wake_by_ref();
-            operation.as_mut().poll(context)
-        }))
-    }
-
-    fn wait<Output>(operation: impl Future<Output = Output>) -> Output {
-        let (finished, stopped) = mpsc::channel();
-        let (expired, deadline) = futures::channel::oneshot::channel();
-        let watchdog = std::thread::spawn(move || {
-            if stopped.recv_timeout(Duration::from_secs(20)).is_err() {
-                let _ = expired.send(());
-            }
-        });
-        let outcome = block_on(future::select(Box::pin(operation), deadline));
-        let _ = finished.send(());
-        watchdog.join().unwrap();
-        match outcome {
-            future::Either::Left((output, _)) => output,
-            future::Either::Right(_) => panic!("async operation timed out"),
-        }
-    }
-
-    #[test]
-    fn async_listener_preserves_owned_metadata() {
-        let runner = nonthreaded(8);
-        let hash = InfoHash::get("async metadata");
-        let mut listener = runner.listen_filtered(&hash, "WHERE seq=7").unwrap();
-        let mut value = Value::with_id(b"async\0binary\xff", 42);
-        value.set_value_type(17);
-        value.set_seq(7);
-        value.set_priority(2);
-        value.set_user_type("application/async").unwrap();
-        value.set_push_type("call").unwrap();
-        let _pending = runner.put(&hash, value, false);
-        let event = drive(&runner, listener.next()).unwrap().unwrap();
-        assert!(!event.expired);
-        assert_eq!(event.value.as_slice(), b"async\0binary\xff");
-        assert_eq!(event.value.id(), 42);
-        assert_eq!(event.value.value_type(), 17);
-        assert_eq!(event.value.seq(), 7);
-        assert_eq!(event.value.priority(), 2);
-        assert_eq!(event.value.user_type().unwrap(), "application/async");
-        assert_eq!(event.value.push_type().unwrap(), "call");
-        assert!(event.value.owner().is_none());
-        assert!(event.value.recipient().is_zero());
-        let event = std::thread::spawn(move || event).join().unwrap();
-        assert_eq!(event.value.as_slice(), b"async\0binary\xff");
-        drop(listener);
-        runner.loop_once().unwrap();
-        runner.join().unwrap();
-    }
-
-    #[test]
-    fn async_listener_delivers_expiration_events() {
-        let runner = nonthreaded(8);
-        let hash = InfoHash::get("async expiration");
-        let mut listener = runner.listen(&hash).unwrap();
-        let mut value = Value::with_id(b"expires", 42);
-        value.set_value_type(17);
-        let _pending = runner.put(&hash, value, false);
-        assert!(!drive(&runner, listener.next()).unwrap().unwrap().expired);
-        let event = drive(&runner, listener.next()).unwrap().unwrap();
-        assert!(event.expired);
-        assert_eq!(event.value.id(), 42);
-        assert_eq!(event.value.as_slice(), b"expires");
-        drop(listener);
-        runner.join().unwrap();
-    }
-
-    #[test]
-    fn async_overflow_is_reported_after_buffered_values() {
-        let runner = nonthreaded(1);
-        let hash = InfoHash::get("async overflow");
-        let mut listener = runner.listen(&hash).unwrap();
-        for id in 1..=3 {
-            let _pending = runner.put(&hash, Value::with_id(b"queued", id), false);
-            runner.loop_once().unwrap();
-        }
-        assert_eq!(
-            drive(&runner, listener.next()).unwrap().unwrap().value.id(),
-            1
-        );
-        let error = drive(&runner, listener.next()).unwrap().err().unwrap();
-        assert_eq!(error.kind(), std::io::ErrorKind::WouldBlock);
-        assert!(drive(&runner, listener.next()).is_none());
-        drop(listener);
-        runner.join().unwrap();
-    }
-
-    #[test]
-    fn async_listener_retains_runner_until_drop() {
-        let released = Arc::new(AtomicUsize::new(0));
-        let counter = DropCounter(released.clone());
-        let mut native = DhtRunner::new();
-        let mut config = DhtRunnerConfig::new();
-        config.threaded = false;
-        config.set_status_callback(move |_, _| {
-            let _ = &counter;
-        });
-        native.run_config(0, config).unwrap();
-        let runner = AsyncDhtRunner::new(native);
-        let listener = runner.listen(&InfoHash::get("retained runner")).unwrap();
-        drop(runner);
-        assert_eq!(released.load(Ordering::SeqCst), 0);
-        drop(listener);
-        assert_eq!(released.load(Ordering::SeqCst), 1);
-    }
-
-    #[test]
-    fn async_join_completes_pending_operations_and_streams() {
-        let runner = nonthreaded(8);
-        let hash = InfoHash::get("async shutdown failures");
-        let put = runner.put(&hash, Value::new("pending"), false);
-        let mut values = runner.get(&hash);
-        let mut query = runner.query(&hash, "SELECT id").unwrap();
-        let mut listener = runner.listen(&hash).unwrap();
-        let ping = runner.ping("127.0.0.1:9".parse().unwrap());
-        let bootstrap = runner.bootstrap(&["127.0.0.1:9".parse().unwrap()]);
-        let shutdown = runner.shutdown();
-        runner.join().unwrap();
-        assert!(wait(put).is_err());
-        assert!(wait(ping).is_err());
-        assert!(wait(bootstrap).is_err());
-        assert!(wait(shutdown).is_err());
-        assert!(wait(values.next()).unwrap().is_err());
-        assert!(wait(values.next()).is_none());
-        assert!(wait(query.next()).unwrap().is_err());
-        assert!(wait(query.next()).is_none());
-        assert!(wait(listener.next()).unwrap().is_err());
-        assert!(wait(listener.next()).is_none());
-        drop(listener);
-    }
-
-    #[test]
-    fn async_stream_reports_runner_destruction() {
-        let runner = nonthreaded(8);
-        let mut values = runner.get(&InfoHash::get("dropped async runner"));
-        drop(runner);
-        assert!(wait(values.next()).unwrap().is_err());
-        assert!(wait(values.next()).is_none());
-    }
-
-    #[test]
-    fn async_invalid_inputs_and_dropped_operations() {
-        assert!(AsyncDhtRunner::with_capacity(DhtRunner::new(), 0).is_err());
-        let runner = nonthreaded(8);
-        let hash = InfoHash::get("async cancellation");
-        let error = wait(runner.bootstrap(&[])).unwrap_err();
-        assert_eq!(error.kind(), std::io::ErrorKind::InvalidInput);
-        assert!(runner.get_filtered(&hash, "WHERE user_type=\0").is_err());
-        assert!(runner.listen_filtered(&hash, "WHERE user_type=\0").is_err());
-        assert!(runner.query(&hash, "SELECT\0 id").is_err());
-        let mut invalid = runner.get_filtered(&hash, "WHERE invalid=1").unwrap();
-        assert!(wait(invalid.next()).unwrap().is_err());
-        assert!(wait(invalid.next()).is_none());
-        drop(runner.get(&hash));
-        drop(runner.query(&hash, "SELECT id").unwrap());
-        drop(runner.put(&hash, Value::new("abandoned"), false));
-        drop(runner.ping("127.0.0.1:9".parse().unwrap()));
-        let listener = runner.listen(&hash).unwrap();
-        drop(listener);
-        runner.loop_once().unwrap();
-        runner.join().unwrap();
-    }
-
-    #[test]
-    fn async_threaded_network_roundtrips() {
-        let mut nodes = Vec::new();
-        for name in ["async source", "async destination"] {
-            let mut runner = DhtRunner::new();
-            let mut config = DhtRunnerConfig::new();
-            config.dht_config.id = Some(DhtIdentity::new(name).unwrap());
-            runner.run_bind("127.0.0.1", "::1", 0, config).unwrap();
-            nodes.push(runner);
-        }
-        let destination_native = nodes.pop().unwrap();
-        let address = (
-            [127, 0, 0, 1],
-            destination_native.bound_port(libc::AF_INET as _),
-        )
-            .into();
-        let recipient = destination_native.public_key().unwrap().long_id();
-        let signer = nodes.last().unwrap().public_key().unwrap().id();
-        let source = AsyncDhtRunner::new(nodes.pop().unwrap());
-        let destination = AsyncDhtRunner::new(destination_native);
-        wait(source.bootstrap(&["127.0.0.1:9".parse().unwrap(), address])).unwrap();
-
-        for mode in ["plain", "signed", "encrypted"] {
-            let hash = InfoHash::get(mode);
-            let mut listener = destination.listen(&hash).unwrap();
-            let mut value = Value::with_id(b"async network\0value", 42);
-            value.set_seq(7);
-            let put = match mode {
-                "signed" => source.put_signed(&hash, value, false),
-                "encrypted" => source.put_encrypted(&hash, &recipient, value, false),
-                _ => source.put(&hash, value, false),
-            };
-            wait(put).unwrap();
-            let event = wait(listener.next()).unwrap().unwrap();
-            assert!(!event.expired);
-            assert_eq!(event.value.as_slice(), b"async network\0value");
-            if mode != "plain" {
-                assert!(event.value.owner().is_some());
-                assert!(event.value.owner().unwrap().id() == signer);
-                let event = std::thread::spawn(move || event).join().unwrap();
-                assert!(event.value.owner().unwrap().id() == signer);
-            }
-            drop(listener);
-            if mode == "signed" {
-                let values: Vec<_> = wait(
-                    destination
-                        .get_filtered(&hash, "WHERE seq=7")
-                        .unwrap()
-                        .try_collect(),
-                )
-                .unwrap();
-                assert!(values
-                    .iter()
-                    .any(|value| value.id() == 42 && value.seq() == 7));
-            }
-            let values: Vec<_> = wait(destination.get(&hash).try_collect()).unwrap();
-            assert!(values
-                .iter()
-                .any(|value| value.as_slice() == b"async network\0value"));
-            let rows: Vec<_> =
-                wait(destination.query(&hash, "SELECT id").unwrap().try_collect()).unwrap();
-            assert!(rows.iter().any(|row| row.id == Some(42)));
-        }
-
-        wait(source.shutdown()).unwrap();
-        wait(destination.shutdown()).unwrap();
-        source.join().unwrap();
-        destination.join().unwrap();
-    }
-
-    #[cfg(feature = "serde")]
-    mod typed {
-        use super::*;
-        use opendht::typed::TypedError;
-        use serde::{Deserialize, Serialize};
-        use std::error::Error;
-        use std::marker::PhantomPinned;
-
-        #[derive(Debug, PartialEq, Serialize, Deserialize)]
-        struct Record {
-            version: u32,
-            name: String,
-            ports: Vec<u16>,
-            #[serde(with = "serde_bytes")]
-            payload: Vec<u8>,
-        }
-
-        fn record() -> Record {
-            Record {
-                version: 1,
-                name: "node-\u{03bb}\0".into(),
-                ports: vec![4222, 8443],
-                payload: vec![0, 0x80, 0xff, 1],
-            }
-        }
-
-        #[test]
-        fn typed_listener_decodes_compact_msgpack_binary() {
-            #[derive(Debug, PartialEq, Deserialize)]
-            struct Packet {
-                #[serde(with = "serde_bytes")]
-                payload: Vec<u8>,
-            }
-
-            let runner = nonthreaded(8);
-            let hash = InfoHash::get("typed MessagePack binary fixture");
-            let mut listener = runner.listen_typed::<Packet>(&hash).unwrap();
-            let fixture = [0x91, 0xc4, 0x04, 0x00, 0x80, 0xff, 0x01];
-            let _pending = runner.put(&hash, Value::with_id(&fixture, 42), false);
-            let event = drive(&runner, listener.next()).unwrap().unwrap();
-            assert_eq!(event.value.raw.as_slice(), fixture);
-            assert_eq!(event.value.data.payload, [0, 0x80, 0xff, 1]);
-            drop(listener);
-            runner.join().unwrap();
-        }
-
-        #[test]
-        fn typed_listener_preserves_metadata_and_expiration() {
-            let runner = nonthreaded(8);
-            let hash = InfoHash::get("typed metadata");
-            let mut listener = runner.listen_typed::<Record>(&hash).unwrap();
-            let mut value = Value::with_id(&rmp_serde::to_vec(&record()).unwrap(), 42);
-            value.set_value_type(17);
-            value.set_seq(7);
-            value.set_user_type("application/typed-test").unwrap();
-            let _pending = runner.put(&hash, value, false);
-            let event = drive(&runner, listener.next()).unwrap().unwrap();
-            assert!(!event.expired);
-            assert_eq!(event.value.data, record());
-            assert_eq!(event.value.raw.id(), 42);
-            assert_eq!(event.value.raw.value_type(), 17);
-            assert_eq!(event.value.raw.seq(), 7);
-            assert_eq!(
-                event.value.raw.user_type().unwrap(),
-                "application/typed-test"
-            );
-            assert_eq!(
-                rmp_serde::from_slice::<Record>(event.value.raw.as_slice()).unwrap(),
-                record()
-            );
-            let event = drive(&runner, listener.next()).unwrap().unwrap();
-            assert!(event.expired);
-            assert_eq!(event.value.data, record());
-            assert_eq!(event.value.raw.id(), 42);
-            drop(listener);
-            runner.join().unwrap();
-        }
-
-        #[test]
-        fn typed_decode_errors_do_not_end_listener() {
-            let runner = nonthreaded(8);
-            let hash = InfoHash::get("typed mixed payloads");
-            let mut listener = runner.listen_typed::<Record>(&hash).unwrap();
-            for (id, payload) in [(1, [0xc1].as_slice()), (2, [0x11].as_slice())] {
-                let _pending = runner.put(&hash, Value::with_id(payload, id), false);
-                let error = drive(&runner, listener.next()).unwrap().err().unwrap();
-                assert!(error.source().is_some());
-                assert!(
-                    matches!(error, TypedError::Deserialize { id: value_id, .. } if value_id == id)
-                );
-            }
-            let _pending = runner.put(
-                &hash,
-                Value::with_id(&rmp_serde::to_vec(&record()).unwrap(), 3),
-                false,
-            );
-            let event = drive(&runner, listener.next()).unwrap().unwrap();
-            assert_eq!(event.value.raw.id(), 3);
-            assert_eq!(event.value.data, record());
-            runner.join().unwrap();
-            let error = wait(listener.next()).unwrap().err().unwrap();
-            assert!(matches!(error, TypedError::Operation(_)));
-            assert!(wait(listener.next()).is_none());
-        }
-
-        #[test]
-        fn typed_put_distinguishes_serialization_and_native_errors() {
-            struct Unserializable;
-
-            impl Serialize for Unserializable {
-                fn serialize<Serializer>(
-                    &self,
-                    _: Serializer,
-                ) -> Result<Serializer::Ok, Serializer::Error>
-                where
-                    Serializer: serde::Serializer,
-                {
-                    Err(serde::ser::Error::custom(
-                        "intentional serialization failure",
-                    ))
-                }
-            }
-
-            let runner = AsyncDhtRunner::new(DhtRunner::new());
-            let hash = InfoHash::get("typed put errors");
-            let error = wait(runner.put_typed(&hash, &Unserializable, false)).unwrap_err();
-            assert!(error.source().is_some());
-            assert!(matches!(error, TypedError::Serialize(_)));
-            let error = wait(runner.put_typed(&hash, &record(), false)).unwrap_err();
-            assert!(error.source().is_some());
-            assert!(matches!(error, TypedError::Operation(_)));
-            runner.join().unwrap();
-        }
-
-        #[test]
-        fn typed_streams_support_non_unpin_records_and_detached_lifetimes() {
-            #[derive(Serialize, Deserialize)]
-            struct PinnedRecord {
-                message: String,
-                #[serde(skip)]
-                _pin: PhantomPinned,
-            }
-
-            let runner = nonthreaded(8);
-            let hash = InfoHash::get("typed pinned records");
-            let mut listener = runner.listen_typed::<PinnedRecord>(&hash).unwrap();
-            let value = PinnedRecord {
-                message: "owned".into(),
-                _pin: PhantomPinned,
-            };
-            let _pending = runner.put(
-                &hash,
-                Value::from_bytes(&rmp_serde::to_vec(&value).unwrap()),
-                false,
-            );
-            let event = drive(&runner, listener.next()).unwrap().unwrap();
-            assert_eq!(event.value.data.message, "owned");
-            drop(listener);
-            let mut values = runner.get_typed::<PinnedRecord>(&InfoHash::get("temporary hash"));
-            drop(runner);
-            assert!(matches!(
-                wait(values.next()).unwrap(),
-                Err(TypedError::Operation(_))
-            ));
-            assert!(wait(values.next()).is_none());
-        }
-
-        #[test]
-        fn typed_listener_inherits_bounded_stream_errors() {
-            let runner = nonthreaded(1);
-            let hash = InfoHash::get("typed overflow");
-            let mut listener = runner.listen_typed::<Record>(&hash).unwrap();
-            for id in 1..=3 {
-                let _pending = runner.put(
-                    &hash,
-                    Value::with_id(&rmp_serde::to_vec(&record()).unwrap(), id),
-                    false,
-                );
-                runner.loop_once().unwrap();
-            }
-            assert_eq!(
-                drive(&runner, listener.next())
-                    .unwrap()
-                    .unwrap()
-                    .value
-                    .raw
-                    .id(),
-                1
-            );
-            let error = drive(&runner, listener.next()).unwrap().err().unwrap();
-            assert!(
-                matches!(error, TypedError::Operation(error) if error.kind() == std::io::ErrorKind::WouldBlock)
-            );
-            assert!(drive(&runner, listener.next()).is_none());
-            drop(listener);
-            runner.join().unwrap();
-        }
-
-        #[test]
-        fn typed_threaded_put_get_listen_roundtrip() {
-            let mut source = DhtRunner::new();
-            let mut destination = DhtRunner::new();
-            source
-                .run_bind("127.0.0.1", "::1", 0, DhtRunnerConfig::new())
-                .unwrap();
-            destination
-                .run_bind("127.0.0.1", "::1", 0, DhtRunnerConfig::new())
-                .unwrap();
-            let address = ([127, 0, 0, 1], destination.bound_port(libc::AF_INET as _)).into();
-            let source = AsyncDhtRunner::new(source);
-            let destination = AsyncDhtRunner::new(destination);
-            wait(source.bootstrap(&[address])).unwrap();
-            let hash = InfoHash::get("typed network record");
-            let mut listener = destination.listen_typed::<Record>(&hash).unwrap();
-            wait(source.put_typed(&hash, &record(), false)).unwrap();
-            let event = wait(listener.next()).unwrap().unwrap();
-            assert_eq!(event.value.data, record());
-            assert_eq!(event.value.raw.as_slice().first(), Some(&0x94));
-            assert!(event
-                .value
-                .raw
-                .as_slice()
-                .ends_with(&[0xc4, 0x04, 0x00, 0x80, 0xff, 0x01]));
-            let id = event.value.raw.id();
-            drop(listener);
-            let values: Vec<_> =
-                wait(destination.get_typed::<Record>(&hash).try_collect()).unwrap();
-            assert!(values
-                .iter()
-                .any(|value| value.data == record() && value.raw.id() == id));
-            let values: Vec<_> = wait(destination.get(&hash).try_collect()).unwrap();
-            assert!(values.iter().any(|value| {
-                rmp_serde::from_slice::<Record>(value.as_slice()).unwrap() == record()
-            }));
-            wait(source.shutdown()).unwrap();
-            wait(destination.shutdown()).unwrap();
-            source.join().unwrap();
-            destination.join().unwrap();
-        }
-    }
-}
@@ -97,7 +97,7 @@ std::string
 DhtProxyServer::ServerStats::toString() const
 {
    auto ret = fmt::format("Listens: {}, Puts: {}, PushListeners: {}\n"
-                           "Push requests in the last {}: [Android: {}], [iOS: {}], [Unified: {}], [Huawei: {}]\n"
+                           "Push requests in the last {}: [Android: {}], [iOS: {}], [Unified: {}]\n"
                           "Requests: {} per second.",
                           listenCount,
                           putCount,
@@ -106,7 +106,6 @@ DhtProxyServer::ServerStats::toString() const
                           androidPush.toString(),
                           iosPush.toString(),
                           unifiedPush.toString(),
-                           huaweiPush.toString(),
                           requestRate);
    if (nodeInfo) {
        auto& ipv4 = nodeInfo->ipv4;
@@ -132,7 +131,6 @@ DhtProxyServer::ServerStats::toJson() const
    result["androidPush"] = androidPush.toJson();
    result["iosPush"] = iosPush.toJson();
    result["unifiedPush"] = unifiedPush.toJson();
-    result["huaweiPush"] = huaweiPush.toJson();
    result["requestRate"] = requestRate;
    if (nodeInfo)
        result["nodeInfo"] = nodeInfo->toJson();
@@ -641,7 +639,6 @@ DhtProxyServer::updateStats(std::shared_ptr<NodeInfo> info) const
        stats.androidPush = androidPush_;
        stats.iosPush = iosPush_;
        stats.unifiedPush = unifiedPush_;
-        stats.huaweiPush = huaweiPush_;
    }
 #endif
    stats.serverStartTime = serverStartTime_;
@@ -867,8 +864,6 @@ DhtProxyServer::getTypeFromString(const std::string& type)
        return PushType::iOS;
    else if (type == "unifiedpush")
        return PushType::UnifiedPush;
-    else if (type == "huawei")
-        return PushType::Huawei;
    return PushType::None;
 }

@@ -1280,25 +1275,15 @@ DhtProxyServer::sendPushNotification(
            Json::Value tokens(Json::arrayValue);
            tokens[0] = token;
            notification["tokens"] = std::move(tokens);
-            // gorush platform codes: 1 = iOS (APNs), 2 = Android (FCM), 3 = Huawei (HMS)
-            notification["platform"] = type == PushType::Android  ? 2
-                                       : type == PushType::Huawei ? 3
-                                                                  : 1;
+            notification["platform"] = type == PushType::Android ? 2 : 1;
+            notification["data"] = std::move(json);
            auto priority = highPriority ? "high" : "normal";
-            if (type == PushType::Huawei) {
-                // HMS carries the payload as a serialized JSON string in its own field:
-                // the generic "data" object is ignored for this platform by gorush.
-                notification["huawei_data"] = Json::writeString(jsonBuilder_, json);
-                notification["huawei_ttl"] = "86400s"; // time to live = 24 hours
-                notification["priority"] = priority;
-            } else if (type == PushType::Android) {
-                notification["data"] = std::move(json);
+            if (type == PushType::Android) {
                Json::Value androidConfig(Json::objectValue);
                androidConfig["priority"] = priority;
                androidConfig["ttl"] = "86400s"; // time to live = 24 hours
                notification["android"] = std::move(androidConfig);
            } else {
-                notification["data"] = std::move(json);
                notification["priority"] = priority;
                const auto expiration = std::chrono::system_clock::now() + std::chrono::hours(24);
                uint32_t exp = std::chrono::duration_cast<std::chrono::seconds>(expiration.time_since_epoch()).count();
@@ -1351,9 +1336,6 @@ DhtProxyServer::sendPushNotification(
        case PushType::UnifiedPush:
            unifiedPush_.increment(highPriority);
            break;
-        case PushType::Huawei:
-            huaweiPush_.increment(highPriority);
-            break;
        default:
            break;
        }
@@ -8,15 +8,10 @@
 #include <stdio.h>
 #include <string.h>

-#ifdef _MSC_VER
-#include <gnutls/gnutls.h>
+#ifdef _WIN32
+#include <stdlib.h>
 #endif

-_Static_assert(_Alignof(dht_infohash) == _Alignof(uint32_t), "InfoHash alignment must match uint32_t");
-_Static_assert(_Alignof(dht_pkid) == _Alignof(uint32_t), "PkId alignment must match uint32_t");
-_Static_assert(sizeof(dht_infohash) == HASH_LEN, "InfoHash size must remain unchanged");
-_Static_assert(sizeof(dht_pkid) == 32, "PkId size must remain unchanged");
-
 static void
 done_cb(bool ok, void* user_data)
 {
@@ -50,19 +45,18 @@ released_cb(void* user_data)
 int
 main(void)
 {
-#ifdef _MSC_VER
-    int crypto_error = gnutls_global_init();
-    if (crypto_error != GNUTLS_E_SUCCESS) {
-        fprintf(stderr, "Failed to initialize GnuTLS: %s\n", gnutls_strerror(crypto_error));
-        return 1;
-    }
+#ifdef _WIN32
+    _set_error_mode(_OUT_TO_STDERR);
 #endif
+    setvbuf(stdout, NULL, _IONBF, 0);
+    puts("C bindings: invalid crypto inputs");
    const uint8_t invalid[] = {1, 2, 3};
    assert(dht_publickey_import(invalid, sizeof(invalid)) == NULL);
    assert(dht_privatekey_import(invalid, sizeof(invalid), "") == NULL);
    assert(dht_certificate_import(invalid, sizeof(invalid)) == NULL);
    assert(dht_privatekey_generate(1) == NULL);

+    puts("C bindings: infohash roundtrip");
    dht_infohash hash;
    dht_infohash_get_from_string(&hash, "binding regression");
    assert(!dht_infohash_is_zero(&hash));
@@ -70,26 +64,7 @@ main(void)
    dht_infohash_from_hex_null(&restored, dht_infohash_print(&hash));
    assert(memcmp(&hash, &restored, sizeof(hash)) == 0);

-    struct {
-        uint8_t prefix;
-        dht_infohash hash;
-        dht_pkid pkid;
-    } embedded = {0};
-    assert((uintptr_t) &embedded.hash % _Alignof(uint32_t) == 0);
-    assert((uintptr_t) &embedded.pkid % _Alignof(uint32_t) == 0);
-    dht_infohash_get_from_string(&embedded.hash, "abc");
-    assert(!dht_infohash_is_zero(&embedded.hash));
-    assert(strcmp(dht_infohash_print(&embedded.hash), "a9993e364706816aba3e25717850c26c9cd0d89d") == 0);
-    dht_infohash_from_hex_null(&embedded.hash, "a9993e364706816aba3e25717850c26c9cd0d89d");
-    dht_infohash_from_hex(&restored, dht_infohash_print(&embedded.hash));
-    assert(memcmp(&embedded.hash, &restored, sizeof(restored)) == 0);
-    dht_infohash_zero(&embedded.hash);
-    assert(dht_infohash_is_zero(&embedded.hash));
-    dht_infohash_random(&embedded.hash);
-    assert(!dht_infohash_is_zero(&embedded.hash));
-    assert(strcmp(dht_pkid_print(&embedded.pkid),
-                  "0000000000000000000000000000000000000000000000000000000000000000") == 0);
-
+    puts("C bindings: value ownership and metadata");
    dht_value* value = dht_value_with_id_new(invalid, sizeof(invalid), 42);
    assert(value != NULL);
    assert(dht_value_get_id(value) == 42);
@@ -110,6 +85,7 @@ main(void)
    assert(strcmp(dht_value_get_push_type(copy), "audioCall") == 0);
    dht_value_unref(copy);

+    puts("C bindings: RSA signing and key persistence");
    dht_privatekey* private_key = dht_privatekey_generate(2048);
    assert(private_key != NULL);
    dht_publickey* public_key = dht_privatekey_get_publickey(private_key);
@@ -132,6 +108,7 @@ main(void)
    dht_privatekey_delete(private_key);
    dht_publickey_delete(public_key);

+    puts("C bindings: identity and certificate roundtrip");
    dht_identity identity = dht_identity_generate("binding regression", NULL);
    assert(identity.privatekey && identity.certificate);
    packed = dht_certificate_export(identity.certificate);
@@ -143,6 +120,7 @@ main(void)
    dht_blob_delete(packed);
    dht_identity_delete(&identity);

+    puts("C bindings: runner lifecycle and callbacks");
    dht_runner_config config;
    dht_runner_config_default(&config);
    config.threaded = false;
@@ -166,9 +144,6 @@ main(void)
    assert(dht_runner_run(runner, 0) == 0);
    assert(dht_runner_join(runner) == 0);
    dht_runner_delete(runner);
-#ifdef _MSC_VER
-    gnutls_global_deinit();
-#endif
    puts("C binding regressions passed");
    return 0;
 }
@@ -1,6 +1,6 @@
 {
  "name": "opendht",
-  "version-string": "4.5.0-rc.1",
+  "version-string": "4.4.2",
  "port-version": 1,
  "description": "OpenDHT: A lightweight C++17 Distributed Hash Table library.",
  "homepage": "https://opendht.net",