correct to zig

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @zshipko

.github/dependabot.yml

@@ -9,8 +9,33 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
-    ignore:
-      - dependency-name: "wasmtime"
-      - dependency-name: "wasi-common"
-      - dependency-name: "wiggle"
 
+  - package-ecosystem: "pip"
+    directory: "python"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "mix"
+    directory: "elixir"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "npm"
+    directory: "node"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "composer"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "bundler"
+    directory: "ruby"
+    schedule:
+      interval: "weekly"
+
+  - package-ecosystem: "gomod"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/browser-ci.yml

@@ -0,0 +1,36 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-node.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - browser/**
+  workflow_dispatch:
+
+name: Browser CI
+
+jobs:
+  node:
+    name: Browser
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Node env
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Test Browser Runtime
+        run: |
+          cd browser
+          npm i
+          npm run test

.github/workflows/ci-cpp.yml

@@ -0,0 +1,39 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-cpp.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - cpp/**
+  workflow_dispatch:
+
+name: C++ CI
+
+jobs:
+  cpp:
+    name: C++
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Install C++ SDK deps
+        if: ${{ matrix.os == 'macos-latest' }}
+        run: |
+          brew install jsoncpp googletest pkg-config
+      - name: Install C++ SDK deps
+        if: ${{ matrix.os == 'ubuntu-latest' }}
+        run: |
+          sudo apt-get install g++ libjsoncpp-dev libgtest-dev pkg-config
+      - name: Run C++ tests
+        run: |
+          cd cpp
+          LD_LIBRARY_PATH=/usr/local/lib make example
+          LD_LIBRARY_PATH=/usr/local/lib make test

.github/workflows/ci-dotnet.yml

@@ -0,0 +1,34 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-dotnet.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - dotnet/**
+  workflow_dispatch:
+
+name: .NET CI
+
+jobs:
+  dotnet:
+    name: .NET
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v3.0.3
+        with:
+           dotnet-version: 7.x
+      - name: Test .NET Sdk
+        run: |
+          cd dotnet
+          LD_LIBRARY_PATH=/usr/local/lib dotnet test ./Extism.sln

.github/workflows/ci-elixir.yml

@@ -0,0 +1,41 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-elixir.yml
+      - manifest/**
+      - runtime/**
+      - rust/**
+      - elixir/**
+  workflow_dispatch:
+
+name: Elixir CI
+
+jobs:
+  elixir:
+    name: Elixir
+    runs-on: ${{ matrix.os }}
+    env:
+      MIX_ENV: test
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Elixir Host SDK
+        if: ${{ runner.os != 'macOS' }}
+        uses: erlef/setup-beam@v1
+        with:
+          experimental-otp: true
+          otp-version: '25.0.4'
+          elixir-version: '1.14.0'
+
+      - name: Test Elixir Host SDK
+        if: ${{ runner.os != 'macOS' }}
+        run: |
+         cd elixir
+         LD_LIBRARY_PATH=/usr/local/lib mix do deps.get, test

.github/workflows/ci-go.yml

@@ -0,0 +1,39 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-go.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - extism.go
+      - extism_test.go
+      - go.mod
+      - libextism.pc 
+      - go/**
+  workflow_dispatch:
+
+name: Go CI
+
+jobs:
+  go:
+    name: Go
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Go env
+        uses: actions/setup-go@v3
+
+      - name: Test Go Host SDK
+        run: |
+          go version
+          cd go
+          LD_LIBRARY_PATH=/usr/local/lib go run main.go
+          LD_LIBRARY_PATH=/usr/local/lib go test

.github/workflows/ci-haskell.yml

@@ -0,0 +1,47 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-haskell.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - haskell/**
+  workflow_dispatch:
+
+name: Haskell CI
+
+jobs:
+  haskell:
+    name: Haskell
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Haskell env
+        uses: haskell/actions/setup@v2
+        with:
+          enable-stack: false
+      - name: Cache Haskell
+        id: cache-haskell
+        uses: actions/cache@v3
+        with:
+          path: ./haskell/dist-newstyle
+          key: ${{ runner.os }}-haskell-${{ hashFiles('haskell/**') }}
+      - name: Build Haskell Host SDK
+        if: steps.cache-haskell.outputs.cache-hit != 'true'
+        run: |
+          cd haskell
+          cabal update
+          LD_LIBRARY_PATH=/usr/local/lib cabal build
+      - name: Test Haskell SDK
+        run: |
+          cd haskell
+          cabal update
+          LD_LIBRARY_PATH=/usr/local/lib cabal test

.github/workflows/ci-java.yml

@@ -0,0 +1,37 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-java.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - java/**
+  workflow_dispatch:
+
+name: Java CI
+
+jobs:
+  java:
+    name: Java
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        version: [11, 17]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Set up Java
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin'
+          java-version: '${{ matrix.version }}'
+      - name: Test Java
+        run: |
+          cd java
+          mvn --batch-mode -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn verify
+

.github/workflows/ci-node.yml

@@ -0,0 +1,38 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-node.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - node/**
+  workflow_dispatch:
+
+name: Node CI
+
+jobs:
+  node:
+    name: Node
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Node env
+        uses: actions/setup-node@v3
+        with:
+          node-version: 18
+
+      - name: Test Node Host SDK
+        run: |
+          cd node
+          npm i
+          LD_LIBRARY_PATH=/usr/local/lib npm run build
+          LD_LIBRARY_PATH=/usr/local/lib npm run example
+          LD_LIBRARY_PATH=/usr/local/lib npm run test

.github/workflows/ci-ocaml.yml

@@ -0,0 +1,50 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-ocaml.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - ocaml/**
+      - dune-project
+      - extism.opam
+  workflow_dispatch:
+
+name: OCaml CI
+
+jobs:
+  ocaml:
+    name: OCaml
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup OCaml env
+        uses: ocaml/setup-ocaml@v2
+        with:
+          ocaml-compiler: ocaml-base-compiler.5.0.0
+      - name: Cache OCaml
+        id: cache-ocaml
+        uses: actions/cache@v3
+        with:
+          path: _build
+          key: ${{ runner.os }}-ocaml-${{ hashFiles('ocaml/**.ml') }}-${{ hashFiles('dune-project') }}
+      - name: Build OCaml Host SDK
+        if: steps.cache-ocaml.outputs.cache-hit != 'true'
+        run: |
+          opam install -y --deps-only .
+          cd ocaml
+          LD_LIBRARY_PATH=/usr/local/lib opam exec -- dune build
+      - name: Test OCaml Host SDK
+        run: |
+          opam install -y --deps-only .
+          cd ocaml
+          LD_LIBRARY_PATH=/usr/local/lib opam exec -- dune exec ./bin/main.exe ../wasm/code.wasm count_vowels -- --input "qwertyuiop"
+          LD_LIBRARY_PATH=/usr/local/lib opam exec -- dune runtest

.github/workflows/ci-php.yml

@@ -0,0 +1,42 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-php.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - php/**
+      - composer.json
+      - composer.lock
+  workflow_dispatch:
+
+name: PHP CI
+
+jobs:
+  php:
+    name: PHP
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup PHP env
+        uses: shivammathur/setup-php@v2
+        with:
+          php-version: "8.1"
+          extensions: ffi
+          tools: composer
+        env:
+          fail-fast: true
+
+      - name: Test PHP SDK
+        run: |
+          cd php/example
+          composer install
+          php index.php

.github/workflows/ci-python.yml

@@ -0,0 +1,40 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-python.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - python/**
+  workflow_dispatch:
+
+name: Python CI
+
+jobs:
+  python:
+    name: Python
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Python env
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.9"
+          check-latest: true
+      - name: Install Poetry
+        uses: snok/install-poetry@v1
+      - name: Test Python Host SDK
+        run: |
+          cd python
+          cp ../README.md .
+          poetry install --no-dev
+          poetry run python example.py
+          poetry run python -m unittest discover

.github/workflows/ci-ruby.yml

@@ -0,0 +1,38 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-ruby.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - ruby/**
+  workflow_dispatch:
+
+name: Ruby CI
+
+jobs:
+  ruby:
+    name: Ruby
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Ruby env
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.0"
+
+      - name: Test Ruby Host SDK
+        run: |
+          cd ruby
+          bundle install
+          ruby example.rb
+          rake test
+

.github/workflows/ci-rust.yml

@@ -0,0 +1,105 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-rust.yml
+      - manifest/**
+      - runtime/**
+      - rust/**
+      - libextism/**
+  workflow_dispatch:
+
+name: Rust CI
+
+env:
+  RUNTIME_CRATE: extism-runtime
+  LIBEXTISM_CRATE: libextism
+  RUST_SDK_CRATE: extism
+
+jobs:
+  lib:
+    name: Extism runtime lib
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - name: Cache Rust environment
+        uses: Swatinem/rust-cache@v1
+      - name: Cache libextism
+        id: cache-libextism
+        uses: actions/cache@v3
+        with:
+          path: target/release/libextism.*
+          key: ${{ runner.os }}-libextism-${{ hashFiles('runtime/**') }}-${{ hashFiles('manifest/**') }}
+      - name: Cache target
+        id: cache-target
+        uses: actions/cache@v3
+        with:
+          path: target/**
+          key: ${{ runner.os }}-target-${{ env.GITHUB_SHA }}
+      - name: Build
+        if: steps.cache-libextism.outputs.cache-hit != 'true'
+        shell: bash
+        run: cargo build --release -p ${{ env.LIBEXTISM_CRATE }}
+      - name: Upload artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: libextism-${{ matrix.os }}
+          path: |
+              target/release/libextism.*
+  lint_and_test:
+    name: Extism runtime lint and test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          override: true
+      - name: Cache Rust environment
+        uses: Swatinem/rust-cache@v1
+      - name: Cache target
+        id: cache-target
+        uses: actions/cache@v3
+        with:
+          path: target/**
+          key: ${{ runner.os }}-target-${{ env.GITHUB_SHA }}
+      - name: Format
+        run: cargo fmt --check -p ${{ env.RUNTIME_CRATE }}
+      - name: Lint
+        run: cargo clippy --release --all-features --no-deps -p ${{ env.RUNTIME_CRATE }}
+      - name: Test
+        run: cargo test --all-features --release -p ${{ env.RUNTIME_CRATE }}
+
+  rust:
+    name: Rust
+    needs: lib
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Test Rust Host SDK
+        run: LD_LIBRARY_PATH=/usr/local/lib cargo test --release -p ${{ env.RUST_SDK_CRATE }}

.github/workflows/ci-zig.yml

@@ -0,0 +1,34 @@
+on: 
+  pull_request:
+    paths:
+      - .github/actions/extism/**
+      - .github/workflows/ci-zig.yml
+      - manifest/**
+      - runtime/**
+      - libextism/**
+      - zig/**
+  workflow_dispatch:
+
+name: Zig CI
+
+jobs:
+  zig:
+    name: Zig
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        rust:
+          - stable
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v3
+      - uses: ./.github/actions/extism
+      - name: Setup Zig env
+        uses: goto-bus-stop/setup-zig@v2
+
+      - name: Test Zig Host SDK
+        run: |
+          zig version
+          cd zig
+          LD_LIBRARY_PATH=/usr/local/lib zig build test

.github/workflows/ci.yml

@@ -1,124 +1,25 @@
-on:
-  pull_request:
-    paths:
-      - .github/actions/extism/**
-      - .github/workflows/ci-rust.yml
-      - convert/**
-      - manifest/**
-      - runtime/**
-      - rust/**
-      - libextism/**
-  workflow_dispatch:
+on: [pull_request, workflow_dispatch]
 
-name: Rust CI
-
-env:
-  RUNTIME_CRATE: extism
-  LIBEXTISM_CRATE: libextism
+name: CI
 
 jobs:
-  lib:
-    name: Extism runtime lib
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-        rust:
-          - stable
+  sdk_api_coverage:
+    name: SDK API Coverage Report
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout sources
         uses: actions/checkout@v3
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
+      - name: Setup Python env
+        uses: actions/setup-python@v4
         with:
-          toolchain: stable
-          override: true
-      - name: Cache Rust environment
-        uses: Swatinem/rust-cache@v1
-      - name: Cache libextism
-        id: cache-libextism
-        uses: actions/cache@v3
-        with:
-          path: target/release/libextism.*
-          key: ${{ runner.os }}-libextism-${{ hashFiles('runtime/**') }}-${{ hashFiles('manifest/**') }}-${{ hashFiles('convert/**') }}
-      - name: Cache target
-        id: cache-target
-        uses: actions/cache@v3
-        with:
-          path: target/**
-          key: ${{ runner.os }}-target-${{ github.sha }}
-      - name: Build
-        if: steps.cache-libextism.outputs.cache-hit != 'true'
-        shell: bash
-        run: cargo build --release -p ${{ env.LIBEXTISM_CRATE }}
-      - name: Upload artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: libextism-${{ matrix.os }}
-          path: |
-              target/release/libextism.*
-  lint_and_test:
-    name: Extism runtime lint and test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest]
-        rust:
-          - stable
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-      - name: Cache Rust environment
-        uses: Swatinem/rust-cache@v1
-      - name: Cache target
-        id: cache-target
-        uses: actions/cache@v3
-        with:
-          path: target/**
-          key: ${{ runner.os }}-target-${{ github.sha }}
-      - name: Format
-        run: cargo fmt --check
-      - name: Lint
-        run: cargo clippy --all --release --all-features --no-deps -- -D "clippy::all"
-      - name: Test
-        run: cargo test --release
-      - name: Test all features
-        run: cargo test --all-features --release
-      - name: Test no features
-        run: cargo test --no-default-features --release
-  bench:
-    name: Benchmarking
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        rust:
-          - stable
-    steps:
-      - name: Checkout sources
-        uses: actions/checkout@v3
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          override: true
-      - name: Cache Rust environment
-        uses: Swatinem/rust-cache@v1
-      - name: Cache target
-        id: cache-target
-        uses: actions/cache@v3
-        with:
-          path: target/**
-          key: ${{ runner.os }}-target-${{ github.sha }}
-      - run: cargo install cargo-criterion
-      - run:
-          cargo criterion
-      - run: |
-          git fetch
-          git checkout main
-          cargo criterion
+          python-version: "3.9"
+          check-latest: true
+      - name: Install dependencies
+        run: |
+          sudo apt-get install ripgrep
+          pip3 install pycparser
+      - name: Run coverage script
+        id: coverage
+        run: |
+          python scripts/sdk_coverage.py
+

.github/workflows/kernel.yml

@@ -1,51 +0,0 @@
-on:
-  workflow_dispatch:
-  pull_request:
-    paths:
-      - kernel/**
-
-name: Kernel
-
-jobs:
-  kernel:
-    name: Build extism-runtime.wasm
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install Rust
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          target: wasm32-unknown-unknown
-      - uses: Swatinem/rust-cache@v2
-
-      - name: install wasm-tools
-        uses: bytecodealliance/actions/wasm-tools/setup@v1
-
-      - name: Install deps
-        run: |
-          sudo apt install wabt --yes
-
-      - name: Build kernel
-        shell: bash
-        continue-on-error: true
-        run: |
-          cd kernel
-          sh build.sh
-          git diff --exit-code
-          export GIT_EXIT_CODE=$?
-
-      - uses: peter-evans/create-pull-request@v5
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        if: ${{ env.GIT_EXIT_CODE }} != 0
-        with:
-          author: "zshipko <zshipko@users.noreply.github.com>"
-          title: "update(kernel): extism-runtime.wasm in ${{ github.event.pull_request.head.ref }}"
-          body: "Automated PR to update `runtime/src/extism-runtime.wasm` in PR #${{ github.event.number }}"
-          base: "${{ github.event.pull_request.head.ref }}"
-          branch: "update-kernel--${{ github.event.pull_request.head.ref }}"
-          commit-message: "update(kernel): extism-runtime.wasm in ${{ github.event.pull_request.head.ref }}"
-          delete-branch: true

.github/workflows/release-dotnet-native.yaml

@@ -1,6 +1,4 @@
 on:
-  release:
-    types: [published, edited]
   workflow_dispatch:
 
 name: Release .NET Native NuGet Packages
@@ -12,64 +10,20 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          filter: tree:0
-
       - name: Setup .NET Core SDK
         uses: actions/setup-dotnet@v3.0.3
         with:
            dotnet-version: 7.x
-      - name: download release
-        run: |
-          tag='${{ github.ref }}'
-          tag="${tag/refs\/tags\//}"
-          gh release download "$tag" -p 'libextism-*.tar.gz'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - uses: dawidd6/action-download-artifact@v2
+        with:
+          workflow: release.yml
+          name: release-artifacts
       - name: Extract Archive
-        run: |      
-          extract_archive() {
-              # Check if both pattern and destination are provided
-              if [ -z "$1" ] || [ -z "$2" ]; then
-                  echo "Usage: $0 <filename_pattern> <destination_directory>"
-                  return 1
-              fi
-          
-              # Set the filename pattern and destination directory
-              filename_pattern="$1"
-              destination_directory="$2"
-          
-              # Find the archive file with the specified pattern
-              archive_file=$(ls $filename_pattern 2>/dev/null)
-          
-              # Check if an archive file is found
-              if [ -n "$archive_file" ]; then
-                  echo "Found archive file: $archive_file"
-          
-                  # Create the destination directory if it doesn't exist
-                  mkdir -p "$destination_directory"
-          
-                  # Extract the archive to the specified destination
-                  tar -xzvf "$archive_file" -C "$destination_directory"
-          
-                  echo "Extraction complete. Contents placed in: $destination_directory"
-              else
-                  echo "No matching archive file found with the pattern: $filename_pattern"
-              fi
-          }
-          
-          extract_archive "libextism-x86_64-pc-windows-msvc-*.tar.gz" "nuget/runtimes/win-x64/native/"
-          extract_archive "libextism-aarch64-apple-darwin-*.tar.gz" "nuget/runtimes/osx-arm64/native/"
-          extract_archive "libextism-x86_64-apple-darwin-*.tar.gz" "nuget/runtimes/osx-x64/native/"
-          extract_archive "libextism-x86_64-unknown-linux-gnu-*.tar.gz" "nuget/runtimes/linux-x64/native/"
-          extract_archive "libextism-aarch64-unknown-linux-gnu-*.tar.gz" "nuget/runtimes/linux-arm64/native/"
-          extract_archive "libextism-aarch64-unknown-linux-musl-*.tar.gz" "nuget/runtimes/linux-musl-arm64/native/"
-
-      - name: Pack NuGet packages
         run: |
-          find ./nuget -type f -name "*.csproj" -exec dotnet pack {} -o release-artifacts \;
-
-      - name: Publish NuGet packages
+          tar -xvzf libextism-x86_64-pc-windows-msvc-v*.tar.gz --directory dotnet/nuget/runtimes
+          mv dotnet/nuget/runtimes/extism.dll dotnet/nuget/runtimes/win-x64.dll
+      - name: Publish win-x64
         run: |
-          dotnet nuget push --source https://api.nuget.org/v3/index.json ./release-artifacts/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }}
+          cd dotnet/nuget
+          dotnet pack -o dist
+          dotnet nuget push --source https://api.nuget.org/v3/index.json ./dist/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }}

.github/workflows/release-dotnet.yaml

@@ -0,0 +1,32 @@
+on:
+  workflow_dispatch:
+
+name: Release .NET SDK
+
+jobs:
+  release-sdks:
+    name: release-dotnet
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install extism shared library
+        shell: bash
+        run: |
+          mkdir -p /home/runner/.local/bin/  
+          export PATH="/home/runner/.local/bin/:$PATH"
+          curl https://raw.githubusercontent.com/extism/cli/main/install.sh | sh
+          extism --sudo --prefix /usr/local install
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v3.0.3
+        with:
+           dotnet-version: 7.x
+      - name: Test .NET Sdk
+        run: |
+          cd dotnet
+          LD_LIBRARY_PATH=/usr/local/lib dotnet test ./Extism.sln
+      - name: Publish .NET Sdk
+        run: |
+          cd dotnet/src/Extism.Sdk/
+          dotnet pack -c Release
+          dotnet nuget push --source https://api.nuget.org/v3/index.json ./bin/Release/*.nupkg --api-key ${{ secrets.NUGET_API_KEY }}

.github/workflows/release-elixir.yaml

@@ -0,0 +1,34 @@
+on:
+  workflow_dispatch:
+
+name: Release Elixir SDK
+
+jobs:
+  release-sdks:
+    name: release-elixir
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Install extism shared library
+        shell: bash
+        run: |
+          mkdir -p /home/runner/.local/bin/  
+          export PATH="/home/runner/.local/bin/:$PATH"
+          curl https://raw.githubusercontent.com/extism/cli/main/install.sh | sh
+          extism --sudo --prefix /usr/local install
+      - name: Setup Elixir Host SDK
+        uses: erlef/setup-beam@v1
+        with:
+          experimental-otp: true
+          otp-version: '25.0.4'
+          elixir-version: '1.14.0'
+
+      - name: Publish Elixir Host SDK to hex.pm
+        env:
+          HEX_API_KEY: ${{ secrets.HEX_PM_API_TOKEN }}
+        run: |
+          cd elixir
+          cp ../LICENSE .
+          make publish
+  

.github/workflows/release-haskell.yaml

@@ -0,0 +1,17 @@
+on:
+  workflow_dispatch:
+
+name: Release Rust SDK
+
+jobs:
+  release-sdks:
+    name: release-rust
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      
+      - uses: cachix/haskell-release-action@v1
+        with:
+          - hackage-token: "${{ secrets.HACKAGE_TOKEN }}"
+          - work-dir: ./haskell

.github/workflows/release-java.yml

@@ -0,0 +1,22 @@
+name: Publish package to the Maven Central Repository
+on:
+  workflow_dispatch:
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Java
+        uses: actions/setup-java@v3
+        with:
+          java-version: '11'
+          distribution: 'adopt'
+      - name: Publish package
+        env:
+          JRELEASER_NEXUS2_USERNAME: ${{ secrets.JRELEASER_NEXUS2_USERNAME }}
+          JRELEASER_NEXUS2_PASSWORD: ${{ secrets.JRELEASER_NEXUS2_PASSWORD }}
+          JRELEASER_GPG_PASSPHRASE: ${{ secrets.JRELEASER_GPG_PASSPHRASE }}
+          JRELEASER_GPG_SECRET_KEY: ${{ secrets.JRELEASER_GPG_SECRET_KEY }}
+          JRELEASER_GPG_PUBLIC_KEY: ${{ secrets.JRELEASER_GPG_PUBLIC_KEY }}
+          JRELEASER_GITHUB_TOKEN: "dummy"
+        run: mvn -Prelease clean jreleaser:prepare deploy jreleaser:deploy -DaltDeploymentRepository=local::default::file:./target/staging-deploy

.github/workflows/release-node.yaml

@@ -0,0 +1,30 @@
+on:
+  workflow_dispatch:
+
+name: Release Node SDK
+
+jobs:
+  release-sdks:
+    name: release-node
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Node env
+        uses: actions/setup-node@v3
+        with:
+          node-version: 16
+          registry-url: "https://registry.npmjs.org"
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_API_TOKEN }}
+          CI: true
+
+      - name: Release Node Host SDK
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_API_TOKEN }}
+          CI: true
+        run: |
+          cd node
+          make publish
+  

.github/workflows/release-python.yaml

@@ -1,8 +1,7 @@
-name: Release Python SDK
-
 on:
-  release:
-    types: [published, edited]
+  workflow_dispatch:
+
+name: Release Python SDK
 
 jobs:
   release-sdks:
@@ -12,30 +11,26 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v3
 
-      - name: Install poetry
-        run: pipx install poetry
-
-      - uses: actions/setup-python@v4
+      - name: Setup Python env
+        uses: actions/setup-python@v4
         with:
-          python-version: '3.10'
+          python-version: "3.9"
+          check-latest: true
+      - name: Run image
+        uses: abatilo/actions-poetry@v2
 
-      - name: install twine
+      - name: Build Python Host SDK
         run: |
-          pip install twine
+          cd python
+          cp ../LICENSE .
+          make clean
+          poetry install --no-dev
+          poetry build
 
-      - name: download release
-        run: |
-          tag='${{ github.ref }}'
-          tag="${tag/refs\/tags\//}"
-          mkdir dist
-          cd dist
-          gh release download "$tag" -p 'extism_sys-*'
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Release Python Host SDK
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: ${{ secrets.PYPI_API_USER }}
+          password: ${{ secrets.PYPI_API_TOKEN }}
+          packages_dir: python/dist/
 
-      - name: upload release
-        run: |
-          twine upload dist/*
-        env:
-          TWINE_USERNAME: ${{ secrets.PYPI_API_USER }}
-          TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/release-ruby.yaml

@@ -0,0 +1,25 @@
+on:
+  workflow_dispatch:
+
+name: Release Ruby SDK
+
+jobs:
+  release-sdks:
+    name: release-ruby
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup Ruby
+        uses: actions/setup-ruby@v1
+        with:
+          ruby-version: '3.1' # Version range or exact version of a Ruby version to use, using semvers version range syntax.
+
+      - name: Publish Ruby Gem
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_TOKEN }}
+        run: |
+          cd ruby
+          make publish RUBYGEMS_API_KEY=$RUBYGEMS_API_KEY
+      

.github/workflows/release-rust.yaml

@@ -1,33 +1,16 @@
 on:
-  release:
-    types: [published, edited]
   workflow_dispatch:
 
-name: Release Runtime/Rust SDK
+name: Release Rust SDK
 
 jobs:
-  release-runtime:
+  release-sdks:
     name: release-rust
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v3
-        with:
-          ref: '${{ github.ref }}'
-
-      - name: Set version
-        shell: bash
-        run: |
-          version="${{ github.ref }}"
-          if [[ "$version" = "refs/heads/main" ]]; then
-            version="0.0.0-dev"
-          else
-            version="${version/refs\/tags\/v/}"
-          fi
-          sed -i -e "s/0.0.0+replaced-by-ci/${version}/g" Cargo.toml
-          pyproject="$(cat extism-maturin/pyproject.toml)"
-          <<<"$pyproject" >extism-maturin/pyproject.toml sed -e 's/^version = "0.0.0.replaced-by-ci"/version = "'"$version"'"/g'
-
+      
       - name: Setup Rust env
         uses: actions-rs/toolchain@v1
         with:
@@ -36,50 +19,17 @@ jobs:
           override: true
           target: ${{ matrix.target }}
 
-      - name: Release Rust convert-macros Crate
+      - name: Release Rust Host SDK
         env:
           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_API_TOKEN }}
         run: |
-          version=$(cargo metadata --format-version=1 | jq -r '.packages[] | select(.name == "extism") | .version')
+          # order of crate publication matter: manifest, runtime, rust
 
-          if ! &>/dev/null curl -sLIf https://crates.io/api/v1/crates/extism-convert-macros/${version}/download; then
-            cargo publish --manifest-path convert-macros/Cargo.toml --allow-dirty
-          else
-            echo "already published ${version}"
-          fi
+          cargo publish --manifest-path manifest/Cargo.toml
+          # allow for crates.io to update so dependant crates can locate extism-manifest
+          sleep 5 
 
-      - name: Release Rust Convert Crate
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_API_TOKEN }}
-        run: |
-          version=$(cargo metadata --format-version=1 | jq -r '.packages[] | select(.name == "extism") | .version')
-
-          if ! &>/dev/null curl -sLIf https://crates.io/api/v1/crates/extism-convert/${version}/download; then
-            cargo publish --manifest-path convert/Cargo.toml --allow-dirty
-          else
-            echo "already published ${version}"
-          fi
-
-      - name: Release Rust Manifest Crate
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_API_TOKEN }}
-        run: |
-          version=$(cargo metadata --format-version=1 | jq -r '.packages[] | select(.name == "extism") | .version')
-
-          if ! &>/dev/null curl -sLIf https://crates.io/api/v1/crates/extism-manifest/${version}/download; then
-            cargo publish --manifest-path manifest/Cargo.toml --allow-dirty
-          else
-            echo "already published ${version}"
-          fi
-
-      - name: Release Runtime
-        env:
-          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_API_TOKEN }}
-        run: |
-          version=$(cargo metadata --format-version=1 | jq -r '.packages[] | select(.name == "extism") | .version')
-
-          if ! &>/dev/null curl -sLIf https://crates.io/api/v1/crates/extism/${version}/download; then
-            cargo publish --manifest-path runtime/Cargo.toml --allow-dirty
-          else
-            echo "already published ${version}"
-          fi
+          cargo publish --manifest-path runtime/Cargo.toml --no-verify
+          cargo publish --manifest-path rust/Cargo.toml
+      
+  

.github/workflows/release.yml

@@ -1,162 +1,52 @@
 on:
+  release:
+    types: [created]
   workflow_dispatch:
-  push:
-    branches: [ main, "v*" ]
-    tags:
-      - 'v*'
 
 name: Release
 
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
+env:
+  RUNTIME_MANIFEST: runtime/Cargo.toml
+  RUNTIME_CRATE: libextism
+  RUSTFLAGS: -C target-feature=-crt-static
+  ARTIFACT_DIR: release-artifacts
 
 jobs:
-  release:
-    name: ${{ matrix.os }} ${{ matrix.target }}
-    runs-on: ${{ matrix.os }}-latest
-    env:
-      RUNTIME_MANIFEST: runtime/Cargo.toml
-      RUNTIME_CRATE: libextism
-      RUSTFLAGS: -C target-feature=-crt-static
-      ARTIFACT_DIR: release-artifacts-${{ matrix.os }}-${{ matrix.target }}
+  release-linux:
+    name: linux
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        include:
-          - os: 'macos'
-            target: 'x86_64-apple-darwin'
-            artifact: 'libextism.dylib'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'macos'
-            target: 'aarch64-apple-darwin'
-            artifact: 'libextism.dylib'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'ubuntu'
-            target: 'aarch64-unknown-linux-gnu'
-            artifact: 'libextism.so'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'ubuntu'
-            target: 'aarch64-unknown-linux-musl'
-            artifact: 'libextism.so'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'ubuntu'
-            target: 'x86_64-unknown-linux-gnu'
-            artifact: 'libextism.so'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'ubuntu'
-            target: 'x86_64-unknown-linux-musl'
-            artifact: 'libextism.so'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: ''
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'windows'
-            target: 'x86_64-pc-windows-gnu'
-            artifact: 'extism.dll'
-            static-artifact: 'libextism.a'
-            static-dll-artifact: 'libextism.dll.a'
-            pc-in: 'extism.pc.in'
-            static-pc-in: 'extism-static.pc.in'
-          - os: 'windows'
-            target: 'x86_64-pc-windows-msvc'
-            artifact: 'extism.dll'
-            static-artifact: 'extism.lib'
-            static-dll-artifact: 'extism.dll.lib'
-            pc-in: ''
-            static-pc-in: ''
-
+        target:
+          [
+            aarch64-unknown-linux-gnu,
+            aarch64-unknown-linux-musl,
+            x86_64-unknown-linux-gnu,
+          ]
+          # i686-unknown-linux-gnu,
+    if: always()
     steps:
       - name: Checkout
         uses: actions/checkout@v3
 
-      - name: Set version
-        shell: bash
-        run: |
-          version="${{ github.ref }}"
-          if [[ "$version" = "refs/heads/main" ]]; then
-            version="0.0.0-dev"
-          else
-            version="${version/refs\/tags\/v/}"
-          fi
-          sed -i -e "s/0.0.0+replaced-by-ci/${version}/g" Cargo.toml
-          pyproject="$(cat extism-maturin/pyproject.toml)"
-          <<<"$pyproject" >extism-maturin/pyproject.toml sed -e 's/^version = "0.0.0.replaced-by-ci"/version = "'"$version"'"/g'
-
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
         with:
-          target: ${{ matrix.target }}
-          override: true
           toolchain: stable
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          prefix-key: "${{matrix.os}}-${{matrix.target}}"
-          save-if: ${{ github.ref == 'refs/heads/main' }}
-          cache-on-failure: "true"
-
-      - name: Build Target (${{ matrix.os }} ${{ matrix.target }})
-        if: ${{ matrix.os != 'windows' }}
-        run: |
-          cargo install cross
-          cross build --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
-
-      - name: Build Target (${{ matrix.os }} ${{ matrix.target }})
-        if: ${{ matrix.os == 'windows' }}
-        run: |
-          cargo build --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
-
-      - uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-
-      - name: Build wheels
-        uses: PyO3/maturin-action@v1
-        # maturin's cffi integration struggles with gnu headers on windows.
-        # there's partial work towards fixing this in `extism-maturin/build.rs`, but it's
-        # not sufficient to get it to work. omit it for now!
-        if: ${{ matrix.target != 'x86_64-pc-windows-gnu' && matrix.target != 'aarch64-unknown-linux-gnu' }}
-        with:
+          profile: minimal
+          override: true
           target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter -m extism-maturin/Cargo.toml
-          sccache: 'true'
-          manylinux: auto
 
-      - name: Build GNU Linux wheels
-        uses: PyO3/maturin-action@v1
-        # One of our deps, "ring", needs a newer sysroot than what "manylinux: auto" provides.
-        if: ${{ matrix.target == 'aarch64-unknown-linux-gnu' }}
+      - name: Build Target (${{ matrix.target }})
+        uses: actions-rs/cargo@v1
         with:
-          target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter -m extism-maturin/Cargo.toml
-          sccache: 'true'
-          manylinux: 2_28
-
-      - name: Add pkg-config files except on MSVC
-        if: ${{ matrix.target != 'x86_64-pc-windows-msvc' }}
-        shell: bash
-        run: |
-          SRC_DIR=target/${{ matrix.target }}/release
-          cp libextism/extism*.pc.in ${SRC_DIR}
+          use-cross: true
+          command: build
+          args: --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
 
       - name: Prepare Artifact
-        shell: bash
         run: |
+          EXT=so
           SRC_DIR=target/${{ matrix.target }}/release
           DEST_DIR=${{ env.ARTIFACT_DIR }}
           RELEASE_NAME=libextism-${{ matrix.target }}-${{ github.ref_name }}
@@ -166,64 +56,161 @@ jobs:
           # compress the shared library & create checksum
           cp runtime/extism.h ${SRC_DIR}
           cp LICENSE ${SRC_DIR}
-          tar -C ${SRC_DIR} -czvf ${ARCHIVE} extism.h \
-            ${{ matrix.artifact }} ${{ matrix.static-artifact }}  \
-            ${{ matrix.pc-in }} ${{ matrix.static-pc-in }} \
-            ${{ matrix.static-dll-artifact }}
+          tar -C ${SRC_DIR} -czvf ${ARCHIVE} libextism.${EXT} extism.h
           ls -ll ${ARCHIVE}
-
-          if &>/dev/null which shasum; then
-            shasum -a 256 ${ARCHIVE} > ${CHECKSUM}
-          else
-            # windows doesn't have shasum available, so we use certutil instead.
-            certutil -hashfile ${ARCHIVE} SHA256 >${CHECKSUM}
-          fi
+          shasum -a 256 ${ARCHIVE} > ${CHECKSUM}
 
           # copy archive and checksum into release artifact directory
           mkdir -p ${DEST_DIR}
           cp ${ARCHIVE} ${DEST_DIR}
           cp ${CHECKSUM} ${DEST_DIR}
 
-          # copy any built wheels.
-          if [ -e dist/*.whl ]; then
-            cp dist/*.whl ${DEST_DIR}
-          fi
-
-          ls -ll ${DEST_DIR}
+          ls ${DEST_DIR}
 
       - name: Upload Artifact to Summary
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v3
         with:
           name: ${{ env.ARTIFACT_DIR }}
-          path: ${{ env.ARTIFACT_DIR }}
+          path: |
+            *.tar.gz
+            *.txt
 
-      - name: Upload Artifact to Draft Release
+      - name: Upload Artifact to Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            *.tar.gz
+            *.txt
+
+  release-macos:
+    name: macos
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        target: [x86_64-apple-darwin, aarch64-apple-darwin]
+    if: always()
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+          target: ${{ matrix.target }}
+
+      - name: Build Target (${{ matrix.target }})
+        uses: actions-rs/cargo@v1
+        with:
+          use-cross: true
+          command: build
+          args: --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
+
+      - name: Prepare Artifact
+        run: |
+          EXT=dylib
+          SRC_DIR=target/${{ matrix.target }}/release
+          DEST_DIR=${{ env.ARTIFACT_DIR }}
+          RELEASE_NAME=libextism-${{ matrix.target }}-${{ github.ref_name }}
+          ARCHIVE=${RELEASE_NAME}.tar.gz
+          CHECKSUM=${RELEASE_NAME}.checksum.txt
+
+          # compress the shared library & create checksum
+          cp runtime/extism.h ${SRC_DIR}
+          cp LICENSE ${SRC_DIR}
+          tar -C ${SRC_DIR} -czvf ${ARCHIVE} libextism.${EXT} extism.h
+          ls -ll ${ARCHIVE}
+          shasum -a 256 ${ARCHIVE} > ${CHECKSUM}
+
+          # copy archive and checksum into release artifact directory
+          mkdir -p ${DEST_DIR}
+          cp ${ARCHIVE} ${DEST_DIR}
+          cp ${CHECKSUM} ${DEST_DIR}
+
+          ls ${DEST_DIR}
+
+      - name: Upload Artifact to Summary
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.ARTIFACT_DIR }}
+          path: |
+            *.tar.gz
+            *.txt
+
+      - name: Upload Artifact to Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: |
+            *.tar.gz
+            *.txt
+
+  release-windows:
+    name: windows
+    runs-on: windows-latest
+    strategy:
+      matrix:
+        target:
+          [x86_64-pc-windows-gnu, x86_64-pc-windows-msvc]
+          # i686-pc-windows-gnu,
+          # i686-pc-windows-msvc,
+          # aarch64-pc-windows-msvc
+    if: always()
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          profile: minimal
+          override: true
+          target: ${{ matrix.target }}
+
+      - name: Build Target (${{ matrix.target }})
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --target ${{ matrix.target }} -p ${{ env.RUNTIME_CRATE }}
+
+      - name: Prepare Artifact
+        shell: bash
+        run: |
+          EXT=dll
+          SRC_DIR=target/${{ matrix.target }}/release
+          DEST_DIR=${{ env.ARTIFACT_DIR }}
+          RELEASE_NAME=libextism-${{ matrix.target }}-${{ github.ref_name }}
+          ARCHIVE=${RELEASE_NAME}.tar.gz
+          CHECKSUM=${RELEASE_NAME}.checksum.txt
+
+          # compress the shared library & create checksum
+          cp runtime/extism.h ${SRC_DIR}
+          cp LICENSE ${SRC_DIR}
+          tar -C ${SRC_DIR} -czvf ${ARCHIVE} extism.${EXT} extism.h
+          ls -ll ${ARCHIVE}
+
+          certutil -hashfile ${ARCHIVE} SHA256 >${CHECKSUM}
+
+          # copy archive and checksum into release artifact directory
+          mkdir -p ${DEST_DIR}
+          cp ${ARCHIVE} ${DEST_DIR}
+          cp ${CHECKSUM} ${DEST_DIR}
+
+          ls ${DEST_DIR}
+
+      - name: Upload Artifact to Summary
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.ARTIFACT_DIR }}
+          path: |
+            *.tar.gz
+            *.txt
+
+      - name: Upload Artifact to Release
         uses: softprops/action-gh-release@v1
         with:
-          draft: true
-          files: |
-            ${{ env.ARTIFACT_DIR }}/*
-        if: startsWith(github.ref, 'refs/tags/')
-
-  release-latest:
-    name: create latest release
-    runs-on: ubuntu-latest
-    needs: [release]
-    if: github.ref == 'refs/heads/main'
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          pattern: release-artifacts-*
-          merge-multiple: true
-
-      - uses: "marvinpinto/action-automatic-releases@latest"
-        with:
-          repo_token: "${{ secrets.GITHUB_TOKEN }}"
-          automatic_release_tag: "latest"
-          prerelease: true
-          title: "Development Build"
           files: |
             *.tar.gz
             *.txt
-            *.whl
-        if: github.ref == 'refs/heads/main'

.gitignore

@@ -15,8 +15,6 @@ python/poetry.lock
 c/main
 cpp/test/test
 cpp/example
-.dub
-dub.selections.json
 go/main
 ruby/.bundle/
 ruby/.yardoc
@@ -32,20 +30,9 @@ rust/test.log
 duniverse
 _build
 php/Extism.php
-python/docs
 dist-newstyle
 .stack-work
 vendor
 zig/zig-*
 zig/example-out/
 zig/*.log
-java/*.iml
-java/*.log
-java/.idea
-java/.DS_Store
-extism-maturin/src/extism.h
-runtime/*.log
-libextism/example
-libextism/extism*.pc
-*.cwasm
-test-cache

.ocamlformat

@@ -0,0 +1 @@
+version = 0.24.1

Cargo.toml

@@ -1,18 +1,8 @@
 [workspace]
-resolver = "2"
-members = ["extism-maturin", "manifest", "runtime", "libextism", "convert", "convert-macros"]
-exclude = ["kernel"]
-
-[workspace.package]
-edition = "2021"
-authors = ["The Extism Authors", "oss@extism.org"]
-license = "BSD-3-Clause"
-homepage = "https://extism.org"
-repository = "https://github.com/extism/extism"
-version = "0.0.0+replaced-by-ci"
-
-[workspace.dependencies]
-extism = { path = "./runtime", version = "0.0.0+replaced-by-ci" }
-extism-convert = { path = "./convert", version = "0.0.0+replaced-by-ci" }
-extism-convert-macros = { path = "./convert-macros", version = "0.0.0+replaced-by-ci" }
-extism-manifest = { path = "./manifest", version = "0.0.0+replaced-by-ci" }
+members = [
+  "manifest",
+  "runtime",
+  "rust",
+  "libextism",
+  "elixir/native/extism_nif"
+]

DEVELOPING.md

@@ -1,117 +0,0 @@
-# HACKING 
-
-## cutting releases
-
-### goals
-
-Cutting a release should be a boring, rote process with as little excitement as
-possible. Following the processes in this document, we should be able to cut a
-release at any time without worrying about producing bad artifacts. Our process
-should let us resolve build issues without affecting library users.
-
-### branching
-
-1. The `main` branch represents the next major version of the library.
-2. Previous major versions should be tracked using `v0.x`, `v1.x`, `v2.x`, used
-   for backporting changes as necessary.
-3. Libraries should generate a `latest` release using, e.g.,
-   `marvinpinto/action-automatic-releases` on changes to the `main` branch.
-
-### tag and release process
-
-1. Pick a target semver value. Prepend the semver value with `v`: `v1.2.3`.
-   Increment the minor version for additive changes and patch for bugfixes.
-   - For trickier changes, consider using release candidates: `rc0`, `rc1`, etc.
-2. Create an empty git commit for the tag to point at: `git commit -m 'v1.2.3-rc1' --allow-empty`.
-3. Create a new tag against that commit: `v1.2.3-rc1`.
-4. Push the changes to the library: `git push origin main v1.2.3-rc1`.
-    - You can separate these steps: `git push origin main` followed by `git push origin v1.2.3-rc1`,
-      if you want to make absolutely sure the commit you're pushing builds correctly before tagging it.
-5. Wait for the tag `build` workflow to complete.
-    - The `build` workflow should create a _draft_ release (using `softprops/action-gh-release` with `draft`
-      set to `true`) and upload built artifacts to the release.
-6. Once the workflow is complete, do whatever testing is necessary using the artifacts.
-    - TODO: We can add automation to this step so that we test on downstream deps automatically: e.g., if we
-      build a new kernel, we _should_ be able to trigger tests in the `python-sdk` _using_ that new kernel.
-7. Once we're confident the release is good, go to the releases page for the library and edit the draft release.
-    - If the release is a release candidate (`rc0..N`), make sure to mark the release as a "prerelease".
-    - Publish the draft release.
-    - This kicks off the publication workflow: taking the artifacts built during the `build` workflow and publishing
-      them to any necessary registry or repository.
-        - In extism, this publishes `extism-maturin` to PyPI as `extism-sys` and the dotnet packages to nuget.
-        - In `python-sdk`, this publishes `extism` to PyPI.
-        - In `js-sdk`, this publishes `@extism/extism` (and `extism`) to NPM.
-
-> **Note**
-> If you're at all worried about a release, use a private fork of the target library repo to test the release first (e.g., `extism/dev-extism`.)
-
-#### CLI flow
-
-For official releases:
-
-```
-$ git commit -m 'v9.9.9' --allow-empty
-$ git tag v9.9.9
-$ git push origin main v9.9.9
-$ gh run watch
-$ gh release edit v9.9.9 --tag v9.9.9 --title 'v9.9.9' --draft=false
-$ gh run watch
-```
-
-For prereleases:
-
-```
-$ git commit -m 'v9.9.9' --allow-empty
-$ git tag v9.9.9
-$ git push origin main v9.9.9
-$ gh run watch
-$ gh release edit v9.9.9 --tag v9.9.9 --title 'v9.9.9' --draft=false --prerelease
-$ gh run watch
-```
-
-### implementation
-
-Libraries should:
-
-- Provide a `ci` workflow, triggered on PR and `workflow_dispatch`.
-    - This workflow should exercise the tests, linting, and documentation generation of the library.
-- Provide a `build` workflow, triggered on `v*` tags and merges to `main`
-    - This workflow should produce artifacts and attach them to a draft release (if operating on a tag) or a `latest` release (if operating on `main`.)
-    - Artifacts include: source tarballs, checksums, shared objects, and documentation.
-- Provide a `release` workflow, triggered on github releases:
-    - This workflow should expect artifacts from the draft release to be available.
-    - Artifacts from the release should be published to their final destination as part of this workflow: tarballs to NPM, documentation to Cloudflare R2/Amazon S3/$yourFavoriteBucket.
-
-### A rough list of libraries and downstreams
-
-```mermaid
-flowchart TD;
-    A["runtime"] --> B["libextism"];
-    B --> C["extism-maturin"];
-    B --> X["nuget-extism"];
-    C --> D["python-sdk"];
-    B --> E["ruby-sdk"];
-    A --> F["go-sdk"];
-    G["plugins"] --> B;
-    G --> D;
-    G --> E;
-    G --> F;
-    G --> H["js-sdk"];
-    F --> I["cli"];
-    G --> J["dotnet-sdk"];
-    X --> J;
-    G --> K["cpp-sdk"];
-    G --> L["zig-sdk"];
-    B --> L;
-    G --> M["haskell-sdk"];
-    B --> M;
-    G --> N["php-sdk"];
-    B --> N;
-    G --> O["elixir-sdk"];
-    B --> O;
-    G --> P["d-sdk"];
-    B --> P;
-    G --> Q["ocaml-sdk"];
-    B --> Q;
-```
-

Makefile

@@ -1,15 +1,11 @@
 DEST?=/usr/local
 SOEXT=so
-AEXT=a
 FEATURES?=default
 DEFAULT_FEATURES?=yes
-RUST_TARGET?=
-EXTRA_LIBS=
 
 UNAME := $(shell uname -s)
 ifeq ($(UNAME),Darwin)
 	SOEXT=dylib
-	EXTRA_LIBS=-framework Security
 endif
 
 ifeq ($(DEFAULT_FEATURES),no)
@@ -22,44 +18,21 @@ else
 	FEATURE_FLAGS=--features $(FEATURES)
 endif
 
-ifeq ($(RUST_TARGET),)
-	TARGET_FLAGS=
-else
-	TARGET_FLAGS=--target $(RUST_TARGET)
-endif
-
 build:
-	cargo build --release $(FEATURE_FLAGS) --manifest-path libextism/Cargo.toml $(TARGET_FLAGS)
-	sed -e "s%@CMAKE_INSTALL_PREFIX@%$(DEST)%" libextism/extism.pc.in > libextism/extism.pc
-	sed -e "s%@CMAKE_INSTALL_PREFIX@%$(DEST)%" \
-	    -e "s%Libs: %Libs: $(EXTRA_LIBS) %" libextism/extism-static.pc.in > libextism/extism-static.pc
-
-bench:
-	@(cargo criterion $(TARGET_FLAGS) || echo 'For nicer output use cargo-criterion: `cargo install cargo-criterion` - using `cargo bench`') && cargo bench $(TARGET_FLAGS)
-
-.PHONY: kernel
-kernel:
-	cd kernel && bash build.sh
+	cargo build --release $(FEATURE_FLAGS) --manifest-path libextism/Cargo.toml
 
 lint:
-	cargo clippy --release --no-deps --manifest-path runtime/Cargo.toml $(TARGET_FLAGS)
+	cargo clippy --release --no-deps --manifest-path runtime/Cargo.toml
 
 debug:
-	RUSTFLAGS=-g RUST_TARGET=$(RUST_TARGET) $(MAKE) build
+	RUSTFLAGS=-g $(MAKE) build
 
 install:
-	echo $(RUST_TARGET)
-	mkdir -p $(DEST)/lib $(DEST)/include $(DEST)/lib/pkgconfig
+	mkdir -p $(DEST)/lib $(DEST)/include
 	install runtime/extism.h $(DEST)/include/extism.h
-	if [ -f target/$(RUST_TARGET)/release/libextism.$(SOEXT) ]; then \
-	    install target/$(RUST_TARGET)/release/libextism.$(SOEXT) $(DEST)/lib/libextism.$(SOEXT); \
-	fi
-	install target/$(RUST_TARGET)/release/libextism.$(AEXT) $(DEST)/lib/libextism.$(AEXT)
-	install libextism/extism.pc $(DEST)/lib/pkgconfig/extism.pc
-	install libextism/extism-static.pc $(DEST)/lib/pkgconfig/extism-static.pc
+	install target/release/libextism.$(SOEXT) $(DEST)/lib/libextism.$(SOEXT)
 
 uninstall:
-	rm -f $(DEST)/include/extism.h $(DEST)/lib/libextism.$(SOEXT) $(DEST)/lib/libextism.$(AEXT) \
-	$(DEST)/lib/pkgconfig/extism*.pc
+	rm -f $(DEST)/include/extism.h $(DEST)/lib/libextism.$(SOEXT)
 
 

README.md

@@ -1,188 +1,62 @@
-<div align="center">
-    <a href="https://extism.org">
-    <picture>
-        <source media="(prefers-color-scheme: dark)" srcset=".github/assets/logo-horizontal-darkmode.png">
-        <img alt="Extism - the WebAssembly framework" width="75%" style="max-width: 600px" src=".github/assets/logo-horizontal.png">
-    </picture>
-    </a>
+### _Welcome!_
 
-[![Discord](https://img.shields.io/discord/1011124058408112148?color=%23404eed&label=Community%20Chat&logo=Discord&logoColor=%23404eed)](https://extism.org/discord)
-![GitHub Org's stars](https://img.shields.io/github/stars/extism)
-![Downloads](https://img.shields.io/crates/d/extism-manifest)
-![GitHub License](https://img.shields.io/github/license/extism/extism)
-![GitHub release (with filter)](https://img.shields.io/github/v/release/extism/extism)
+**Please note:** this project still under active development. It's usable, but expect some rough edges while work is underway. If you're interested in working on or building with Extism, please join our [Discord](https://discord.gg/cx3usBCWnc) and let us know - we are happy to help get you started.
 
-</div>
+[![Discord](https://img.shields.io/discord/1011124058408112148?color=%23404eed&label=Community%20Chat&logo=Discord&logoColor=%23404eed)](https://discord.gg/cx3usBCWnc)
 
-# Overview
+# [Extism](https://extism.org)
 
-Extism is a lightweight framework for building with WebAssembly (Wasm). It
-supports running Wasm code on servers, the edge, CLIs, IoT, browsers and
-everything in between. Extism is designed to be "universal" in that it supports
-a common interface, no matter where it runs.
+The universal plug-in system. Run WebAssembly extensions inside your app. Use idiomatic Host SDKs for [<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/go.svg" width="18" height="18" />  Go](https://extism.org/docs/integrate-into-your-codebase/go-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/ruby.svg" width="18" height="18" />  Ruby](https://extism.org/docs/integrate-into-your-codebase/ruby-host-sdk), [<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/python.svg" width="18" height="18" />  Python](https://extism.org/docs/integrate-into-your-codebase/python-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/nodedotjs.svg" width="18" height="18" />  Node](https://extism.org/docs/integrate-into-your-codebase/node-host-sdk), [<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/rust.svg" width="18" height="18" /> Rust](https://extism.org/docs/integrate-into-your-codebase/rust-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/c.svg" width="18" height="18" /> C](https://extism.org/docs/integrate-into-your-codebase/c-host-sdk), [<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/cplusplus.svg" width="18" height="18" /> C++](https://extism.org/docs/integrate-into-your-codebase/cpp-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/ocaml.svg" width="18" height="18" /> OCaml](https://extism.org/docs/integrate-into-your-codebase/ocaml-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/haskell.svg" width="18" height="18" /> Haskell](https://extism.org/docs/integrate-into-your-codebase/haskell-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/php.svg" width="18" height="18" /> PHP](https://extism.org/docs/integrate-into-your-codebase/php-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/elixir.svg" width="18" height="18" /> Elixir / <img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/erlang.svg" width="18" height="18" /> Erlang](https://extism.org/docs/integrate-into-your-codebase/elixir-or-erlang-host-sdk), 
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/dotnet.svg" width="18" height="18" /> .NET](https://extism.org/docs/integrate-into-your-codebase/dotnet-host-sdk),
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/oracle.svg" width="18" height="18" /> Java](https://extism.org/docs/integrate-into-your-codebase/java-host-sdk),
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/zig.svg" width="18" height="18" /> Zig](https://extism.org/docs/integrate-into-your-codebase/zig-host-sdk) &amp; more (others coming soon). 
 
-> **Note:** One of the primary use cases for Extism is **building extensible
-> software & plugins**. You want to be able to execute arbitrary, untrusted code
-> from your users? Extism makes this safe and practical to do.
+Plug-in development kits (PDK) for plug-in authors supported in
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/rust.svg" width="18" height="18" /> Rust](https://github.com/extism/rust-pdk),
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/assemblyscript.svg" width="18" height="18" /> AssemblyScript](https://github.com/extism/assemblyscript-pdk),
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/go.svg" width="18" height="18" /> Go](https://github.com/extism/go-pdk),
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/c.svg" width="18" height="18" />
+C / <img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/cplusplus.svg" width="18" height="18" /> C++](https://github.com/extism/c-pdk),
+[<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/haskell.svg" width="18" height="18" /> Haskell](https://github.com/extism/haskell-pdk),
+and [<img src="https://cdn.rawgit.com/simple-icons/simple-icons/develop/icons/zig.svg" width="18" height="18" /> Zig](https://github.com/extism/zig-pdk).
 
-Additionally, Extism adds some extra utilities on top of standard Wasm runtimes.
-For example, we support persistent memory/module-scope variables, secure &
-host-controlled HTTP without WASI, runtime limiters & timers, simpler host
-function linking, and more. Extism users build:
+<p align="center">
+  <img style="width: 70%;" src="https://user-images.githubusercontent.com/7517515/210286900-39b144fd-1b26-4dd0-b7a9-2b5755bc174d.png" alt="Extism embedded SDK language support"/>
+</p>
 
-- plug-in systems
-- FaaS platforms
-- code generators
-- web applications
-- & much more...
 
-# Supported Targets
+Add a flexible, secure, and _bLaZiNg FaSt_ plug-in system to your project. Server, desktop, mobile, web, database -- you name it. Enable users to write and execute safe extensions to your software in **3 easy steps:**
 
-We currently provide releases for the following targets:
+### 1. Import
 
-- aarch64-apple-darwin
-- aarch64-unknown-linux-gnu
-- aarch64-unknown-linux-musl
-- x86_64-apple-darwin
-- x86_64-pc-windows-gnu
-- x86_64-pc-windows-msvc
-- x86_64-unknown-linux-gnu
-- x86_64-unknown-linux-musl
+Import an Extism Host SDK into your code as a library dependency.
 
-For Android we suggest taking a look at the [Chicory SDK](https://github.com/extism/chicory-sdk) for a pure Java
-Extism runtime.
+### 2. Integrate 
 
-# Run WebAssembly In Your App
+Identify the place(s) in your code where some arbitrary logic should run (the plug-in!), returning your code some results.
 
-Pick a SDK to import into your program, and refer to the documentation to get
-started:
+### 3. Execute
 
-| Type        | Language                                                                                       | Source Code                                                             | Package                                                                 |
-| ----------- | ---------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| Rust SDK    | <img alt="Rust SDK" src="https://extism.org/img/sdk-languages/rust.svg" width="50px"/>         | https://github.com/extism/extism/tree/main/runtime                      | [Crates.io](https://crates.io/crates/extism)                            |
-| JS SDK      | <img alt="JS SDK" src="https://extism.org/img/sdk-languages/js.svg" width="50px"/>             | https://github.com/extism/js-sdk <br/>(supports Web, Node, Deno & Bun!) | [NPM](https://www.npmjs.com/package/@extism/extism)                     |
-| Elixir SDK  | <img alt="Elixir SDK" src="https://extism.org/img/sdk-languages/elixir.svg" width="50px"/>     | https://github.com/extism/elixir-sdk                                    | [Hex](https://hex.pm/packages/extism)                                   |
-| Go SDK      | <img alt="Go SDK" src="https://extism.org/img/sdk-languages/go.svg" width="50px"/>             | https://github.com/extism/go-sdk                                        | [Go mod](https://pkg.go.dev/github.com/extism/go-sdk)                   |
-| Haskell SDK | <img alt="Haskell SDK" src="https://extism.org/img/sdk-languages/haskell.svg" width="50px"/>   | https://github.com/extism/haskell-sdk                                   | [Hackage](https://hackage.haskell.org/package/extism)                   |
-| Java SDK    | <img alt="Java SDK" src="https://extism.org/img/sdk-languages/java-android.svg" width="50px"/> | https://github.com/extism/java-sdk                                      | [Sonatype](https://central.sonatype.com/artifact/org.extism.sdk/extism) |
-| .NET SDK    | <img alt=".NET SDK" src="https://extism.org/img/sdk-languages/dotnet.svg" width="50px"/>       | https://github.com/extism/dotnet-sdk <br/>(supports C# & F#!)           | [Nuget](https://www.nuget.org/packages/Extism.Sdk)                      |
-| OCaml SDK   | <img alt="OCaml SDK" src="https://extism.org/img/sdk-languages/ocaml.svg" width="50px"/>       | https://github.com/extism/ocaml-sdk                                     | [opam](https://opam.ocaml.org/packages/extism/)                         |
-| Perl SDK    | <img alt="Perl SDK" src="https://extism.org/img/sdk-languages/perl.svg" width="50px"/>         | https://github.com/extism/perl-sdk                                      | [CPAN](https://metacpan.org/pod/Extism)                                 |
-| PHP SDK     | <img alt="PHP SDK" src="https://extism.org/img/sdk-languages/php.svg" width="50px"/>           | https://github.com/extism/php-sdk                                       | [Packagist](https://packagist.org/packages/extism/extism)               |
-| Python SDK  | <img alt="Python SDK" src="https://extism.org/img/sdk-languages/python.svg" width="50px"/>     | https://github.com/extism/python-sdk                                    | [PyPi](https://pypi.org/project/extism/)                                |
-| Ruby SDK    | <img alt="Ruby SDK" src="https://extism.org/img/sdk-languages/ruby.svg" width="50px"/>         | https://github.com/extism/ruby-sdk                                      | [RubyGems](https://rubygems.org/gems/extism)                            |
-| Zig SDK     | <img alt="Zig SDK" src="https://extism.org/img/sdk-languages/zig.svg" width="50px"/>           | https://github.com/extism/zig-sdk                                       | N/A                                                                     |
-| C SDK       | <img alt="C SDK" src="https://extism.org/img/sdk-languages/c.svg" width="50px"/>               | https://github.com/extism/extism/tree/main/libextism                    | N/A                                                                     |
-| C++ SDK     | <img alt="C++ SDK" src="https://extism.org/img/sdk-languages/cpp.svg" width="50px"/>           | https://github.com/extism/cpp-sdk                                       | N/A                                                                     |
+Load WebAssembly modules at any time in your app's lifetime and Extism will execute them in a secure sandbox, fully isolated from your program's memory.
 
-# Compile WebAssembly to run in Extism Hosts
-
-Extism Hosts (running the SDK) must execute WebAssembly code that has a
-[PDK, or Plug-in Development Kit](https://extism.org/docs/concepts/pdk), library
-compiled in to the `.wasm` binary. PDKs make it easy for plug-in / extension
-code authors to read input from the host and return data back, read provided
-configuration, set/get variables, make outbound HTTP calls if allowed, and more.
-
-Pick a PDK to import into your Wasm program, and refer to the documentation to
-get started:
-
-| Type               | Language                                                                                                   | Source Code                                                   | Package                                                   |
-| ------------------ | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------- | --------------------------------------------------------- |
-| Rust PDK           | <img alt="Rust PDK" src="https://extism.org/img/sdk-languages/rust.svg" width="50px"/>                     | https://github.com/extism/rust-pdk                            | [Crates.io](https://crates.io/crates/extism-pdk)          |
-| JS PDK             | <img alt="JS PDK" src="https://extism.org/img/sdk-languages/js.svg" width="50px"/>                         | https://github.com/extism/js-pdk                              | N/A                                                       |
-| Python PDK         | <img alt="Python PDK" src="https://extism.org/img/sdk-languages/python.svg" width="50px"/>                 | https://github.com/extism/python-pdk                          | N/A                                                       |
-| Go PDK             | <img alt="Go PDK" src="https://extism.org/img/sdk-languages/go.svg" width="50px"/>                         | https://github.com/extism/go-pdk                              | [Go mod](https://pkg.go.dev/github.com/extism/go-pdk)     |
-| Haskell PDK        | <img alt="Haskell PDK" src="https://extism.org/img/sdk-languages/haskell.svg" width="50px"/>               | https://github.com/extism/haskell-pdk                         | [Hackage](https://hackage.haskell.org/package/extism-pdk) |
-| AssemblyScript PDK | <img alt="AssemblyScript PDK" src="https://extism.org/img/sdk-languages/assemblyscript.svg" width="50px"/> | https://github.com/extism/assemblyscript-pdk                  | [NPM](https://www.npmjs.com/package/@extism/as-pdk)       |
-| .NET PDK           | <img alt=".NET PDK" src="https://extism.org/img/sdk-languages/dotnet.svg" width="50px"/>                   | https://github.com/extism/dotnet-pdk <br/>(supports C# & F#!) | [Nuget](https://www.nuget.org/packages/Extism.Pdk)        |
-| C PDK              | <img alt="C PDK" src="https://extism.org/img/sdk-languages/c.svg" width="50px"/>                           | https://github.com/extism/c-pdk                               | N/A                                                       |
-| C++ PDK            | <img alt="C++ PDK" src="https://extism.org/img/sdk-languages/cpp.svg" width="50px"/>                       | https://github.com/extism/cpp-pdk                             | N/A                                                       |
-| Zig PDK            | <img alt="Zig PDK" src="https://extism.org/img/sdk-languages/zig.svg" width="50px"/>                       | https://github.com/extism/zig-pdk                             | N/A                                                       |
-
-# Generating Bindings
-
-It's often very useful to define a schema to describe the function signatures
-and types you want to use between Extism SDK and PDK languages.
-
-[XTP Bindgen](https://github.com/dylibso/xtp-bindgen) is an open source
-framework to generate PDK bindings for Extism plug-ins. It's used by the
-[XTP Platform](https://www.getxtp.com/), but can be used outside of the platform
-to define any Extism compatible plug-in system.
-
-## 1. Install the `xtp` CLI.
-
-See installation instructions
-[here](https://docs.xtp.dylibso.com/docs/cli#installation).
-
-## 2. Create a schema using our OpenAPI-inspired IDL:
-
-```yaml
-version: v1-draft
-exports: 
-  CountVowels:
-      input: 
-          type: string
-          contentType: text/plain; charset=utf-8
-      output:
-          $ref: "#/components/schemas/VowelReport"
-          contentType: application/json
-# components.schemas defined in example-schema.yaml...
-```
-
-> See an example in [example-schema.yaml](./example-schema.yaml), or a full
-> "kitchen sink" example on
-> [the docs page](https://docs.xtp.dylibso.com/docs/concepts/xtp-schema/).
-
-## 3. Generate bindings to use from your plugins:
-
-```
-xtp plugin init --schema-file ./example-schema.yaml
-  > 1. TypeScript                      
-    2. Go                              
-    3. Rust                            
-    4. Python                          
-    5. C#                              
-    6. Zig                             
-    7. C++                             
-    8. GitHub Template                 
-    9. Local Template
-```
-
-This will create an entire boilerplate plugin project for you to get started
-with. Implement the empty function(s), and run `xtp plugin build` to compile
-your plugin.
-
-> For more information about XTP Bindgen, see the
-> [dylibso/xtp-bindgen](https://github.com/dylibso/xtp-bindgen) repository and
-> the official
-> [XTP Schema documentation](https://docs.xtp.dylibso.com/docs/concepts/xtp-schema).
-
-# Support
-
-## Discord
-
-If you experience any problems or have any questions, please join our
-[Discord](https://extism.org/discord) and let us know. Our community is very
-responsive and happy to help get you started.
+--- 
 
 ## Usage
 
-Head to the [project website](https://extism.org) for more information and docs.
-Also, consider reading an [overview](https://extism.org/docs/overview) of Extism
-and its goals & approach.
+Head to the [project website](https://extism.org) for more information and docs. Also, consider reading an [overview](https://extism.org/docs/overview) of Extism and its goals & approach.
 
 ## Contribution
 
-Thank you for considering a contribution to Extism, we are happy to help you
-make a PR or find something to work on!
+Thank you for considering a contribution to Extism, we are happy to help you make a PR or find something to work on! 
 
-The easiest way to start would be to join the
-[Discord](https://extism.org/discord) or open an issue on the
-[`extism/proposals`](https://github.com/extism/proposals) issue tracker, which
-can eventually become an Extism Improvement Proposal (EIP).
-
-For more information, please read the
-[Contributing](https://extism.org/docs/concepts/contributing) guide.
+The easiest way to start would be to join the [Discord](https://discord.gg/cx3usBCWnc) or open an issue on the [`extism/proposals`](https://github.com/extism/proposals) issue tracker, which can eventually become an Extism Improvement Proposal (EIP).
 
 ---
 
@@ -191,8 +65,9 @@ For more information, please read the
 Extism is an open-source product from the team at:
 
 <p align="left">
-  <a href="https://dylibso.com" _target="blanks"><img width="200px" src="https://user-images.githubusercontent.com/7517515/198204119-5afdebb9-a5d8-4322-bd2a-46179c8d7b24.svg"/></a>
+  <a href="https://dylib.so" _target="blanks"><img width="200px" src="https://user-images.githubusercontent.com/7517515/198204119-5afdebb9-a5d8-4322-bd2a-46179c8d7b24.svg"/></a>
 </p>
 
-_Reach out and tell us what you're building! We'd love to help:_
-<a href="mailto:hello@dylibso.com">hello@dylibso.com</a>
+
+
+_Reach out and tell us what you're building! We'd love to help._

browser/.gitignore

@@ -0,0 +1,130 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+.cache
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*

browser/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "printWidth": 120,
+  "trailingComma": "all",
+  "singleQuote": true
+}

browser/Makefile

@@ -0,0 +1,28 @@
+.PHONY: test
+
+prepare:
+	npm install
+
+build:
+	npm run build
+
+test: prepare
+	npm run test
+
+clean:
+	echo "No clean implemented"
+
+publish: clean prepare build
+	npm publish
+
+format:
+	npx prettier --write src
+
+lint:
+	npx prettier --check src
+
+docs:
+	npx typedoc --out doc src
+
+show-docs: docs
+	open doc/index.html

browser/build.js

@@ -0,0 +1,23 @@
+const { build } = require("esbuild");
+const { peerDependencies } = require('./package.json')
+
+const sharedConfig = {
+    entryPoints: ["src/index.ts"],
+    bundle: true,
+    minify: false,
+    drop: [], // preseve debugger statements
+    external: Object.keys(peerDependencies || {}),
+};
+
+build({
+    ...sharedConfig,
+    platform: 'node', // for CJS
+    outfile: "dist/index.js",
+});
+
+build({
+    ...sharedConfig,
+    outfile: "dist/index.esm.js",
+    platform: 'neutral', // for ESM
+    format: "esm",
+});

browser/index.html

@@ -0,0 +1,238 @@
+<html>
+  <head>
+    <script src="https://unpkg.com/babel-standalone@6/babel.min.js"></script>
+    <script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
+    <script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js" crossorigin></script>
+    <style>
+      #main {
+        width: 100%;
+      }
+      .manifest {
+        display: flex; /* or inline-flex */
+        flex-direction: row;
+        flex-wrap: nowrap;
+        width: 100%;
+      }
+      .urlInput {
+        width: 600px;
+      }
+      .funcName {
+        width: 150px;
+      }
+      .textAreas {
+        display: flex; /* or inline-flex */
+        flex-direction: row;
+        flex-wrap: nowrap;
+        width: 100%;
+        height: 300px;
+      }
+      .inputBox {
+        width: 100%;
+        height: 100%; 
+      }
+      .inputBox > textarea {
+        width: 100%;
+        height: 100%; 
+      }
+      .outputBox {
+        width: 100%;
+        height: 100%; 
+      }
+      .outputBox > textarea {
+        width: 100%;
+        height: 100%; 
+      }
+      .space {
+        height: 80px;
+      }
+      .dragAreas {
+        display: flex; /* or inline-flex */
+        flex-direction: row;
+        flex-wrap: nowrap;
+        width: 100%;
+        height: 200px;
+      }
+      .dragInput {
+        width: 100%;
+        height: 100%; 
+        border-style: dotted;
+        border-color: #000;
+      }
+      .dragOutput {
+        width: 100%;
+        height: 100%; 
+      }
+      .dropZone {
+        width: 100%;
+        height: 100%; 
+      } 
+      .outputImage {
+        width: 100%;
+        height: 100%; 
+      }
+      
+    </style>
+
+    <script type="text/babel">
+      function getBase64(file, cb) {
+        var reader = new FileReader();
+        reader.readAsDataURL(file);
+        reader.onload = function () {
+          cb(reader.result)
+        };
+        reader.onerror = function (error) {
+          console.log("error")
+        };
+      }
+
+      function arrayTob64(buffer) {
+        var binary = '';
+        var bytes = [].slice.call(buffer);
+        bytes.forEach((b) => binary += String.fromCharCode(b));
+        return window.btoa(binary);
+      }
+
+
+      class App extends React.Component {
+        state = {
+          url: "https://raw.githubusercontent.com/extism/extism/main/wasm/code.wasm",
+          input: new Uint8Array(),
+          output: new Uint8Array(),
+          func_name: "count_vowels",
+          functions: []
+        }
+
+        async loadFunctions(url) {
+            let plugin = await this.extismContext.newPlugin({ "wasm": [ { "path": url } ] }) 
+            let functions = Object.keys(await plugin.getExports())
+            console.log("funcs ", functions)
+            this.setState({functions})
+        }
+
+        componentDidMount() {
+          this.loadFunctions(this.state.url)
+        }
+
+        constructor(props) {
+          super(props)
+          this.extismContext = props.extismContext
+        }
+
+        handleInputChange(e) {
+          e.preventDefault();
+          this.setState({ [e.target.name]: e.target.value })
+          if (e.target.name === "url") {
+            this.loadFunctions(e.target.value)
+          }
+        }
+
+        onInputKeyPress(e) {
+          if (e.keyCode == 13 && e.shiftKey == true) {
+            e.preventDefault()
+            this.handleOnRun()
+          }
+        }
+
+        async handleOnRun(e) {
+          e && e.preventDefault && e.preventDefault();
+          let plugin = await this.extismContext.newPlugin({ "wasm": [ { "path": this.state.url } ] }) 
+          let result = await plugin.call(this.state.func_name, this.state.input)
+          let output = result
+          this.setState({output})
+        }
+
+        nop = (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+        };
+        handleDrop = e => {
+          e.preventDefault();
+          e.stopPropagation();
+          let files = [...e.dataTransfer.files];
+          if (files && files.length == 1) {
+            let file = files[0]
+            console.log(file)
+            file.arrayBuffer().then(b => {
+              this.setState({input: new Uint8Array(b)})
+              this.handleOnRun()
+            })
+          } else {
+            throw Error("Only one file please")
+          }
+        };
+
+        render() {
+          const funcOptions = this.state.functions.map(f => <option value={f}>{f}</option>)
+          let image = null
+          if (this.state.output) {
+              image = <img src={`data:image/png;base64,${arrayTob64(this.state.output)}`}/>
+          }
+
+          return <div className="app">
+            <div className="manifest">
+              <div>
+                <label>WASM Url: </label>
+                <input type="text" name="url" className="urlInput" value={this.state.url} onChange={this.handleInputChange.bind(this)} />
+              </div>
+              <div>
+                <label>Function: </label>
+                <select type="text" name="func_name" className="funcName" value={this.state.func_name} onChange={this.handleInputChange.bind(this)}>
+                  {funcOptions}
+                </select>
+              </div>
+              <div>
+                <button onClick={this.handleOnRun.bind(this)}>Run</button>
+              </div>
+            </div>
+            <div className="textAreas">
+              <div className="inputBox">
+                <h3>Text Input</h3>
+                <textarea name="input" value={this.state.input} onChange={this.handleInputChange.bind(this)} onKeyDown={this.onInputKeyPress.bind(this)}></textarea>
+              </div>
+              <div className="outputBox">
+                <h3>Text Output</h3>
+                <textarea name="output" value={new TextDecoder().decode(this.state.output)} ></textarea>
+              </div>
+            </div>
+            <div className="space" />
+            <div className="dragAreas">
+              <div className="dragInput">
+                <h3>Image Input</h3>
+                <div className="dropZone"
+                  onDrop={this.handleDrop.bind(this)}
+                  onDragOver={this.nop.bind(this)}
+                  onDragEnter={this.nop.bind(this)}
+                  onDragLeave={this.nop.bind(this)}
+                >
+                </div>
+              </div>
+              <div className="dragOutput">
+                <h3>Image Output</h3>
+                <div className="outputImage">
+                  {image}
+                </div>
+              </div>
+            </div>
+          </div>
+        }
+      }
+      window.App = App
+    </script>
+
+    <script type="module">
+      import {ExtismContext} from './dist/index.esm.js'
+      const e = React.createElement;
+
+      window.onload = () => {
+        const domContainer = document.getElementById('main');
+        console.log(domContainer)
+        const root = ReactDOM.createRoot(domContainer);
+        const extismContext = new ExtismContext()
+        root.render(e(App, {extismContext}));
+      }
+    </script>
+  </head>
+  <body>
+    <div id="main"></div>
+  </body>
+</html>

browser/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+};

browser/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@extism/runtime-browser",
+  "version": "0.2.2",
+  "description": "Extism runtime in the browser",
+  "scripts": {
+    "build": "node build.js && tsc --emitDeclarationOnly --outDir dist",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "lint": "tslint -p tsconfig.json",
+    "test": "jest --config jest.config.js"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "module": "dist/index.esm.js",
+  "main": "dist/index.js",
+  "typings": "dist/src/index.d.ts",
+  "author": "The Extism Authors <oss@extism.org>",
+  "license": "BSD-3-Clause",
+  "devDependencies": {
+    "@types/jest": "^29.2.2",
+    "esbuild": "^0.15.13",
+    "jest": "^29.2.2",
+    "prettier": "^2.7.1",
+    "ts-jest": "^29.0.3",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0",
+    "typedoc": "^0.23.20",
+    "typescript": "^4.8.4"
+  },
+  "dependencies": {
+    "@bjorn3/browser_wasi_shim": "^0.2.1"
+  }
+}

browser/src/allocator.ts

@@ -0,0 +1,104 @@
+type MemoryBlock = { offset: bigint; length: bigint };
+
+export default class Allocator {
+  currentIndex: bigint;
+  active: Record<number, MemoryBlock>;
+  freed: MemoryBlock[];
+  memory: Uint8Array;
+
+  constructor(n: number) {
+    this.currentIndex = BigInt(1);
+    this.active = {};
+    this.freed = [];
+    this.memory = new Uint8Array(n);
+  }
+
+  reset() {
+    this.currentIndex = BigInt(1);
+    this.active = {};
+    this.freed = [];
+  }
+
+  alloc(length: bigint): bigint {
+    for (var i = 0; i < this.freed.length; i++) {
+      let block = this.freed[i];
+      if (block.length === length) {
+        this.active[Number(block.offset)] = block;
+        this.freed.splice(i, 1);
+        return block.offset;
+      } else if (block.length > length + BigInt(64)) {
+        const newBlock = { offset: block.offset, length };
+        block.offset += length;
+        block.length -= length;
+        return newBlock.offset;
+      }
+    }
+
+    // Resize memory if needed
+    // TODO: put a limit on the memory size
+    if (BigInt(this.memory.length) < this.currentIndex + length) {
+      const tmp = new Uint8Array(Number(this.currentIndex + length + BigInt(64)));
+      tmp.set(this.memory);
+      this.memory = tmp;
+    }
+
+    const offset = this.currentIndex;
+    this.currentIndex += length;
+    this.active[Number(offset)] = { offset, length };
+    return offset;
+  }
+
+  getBytes(offset: bigint): Uint8Array | null {
+    const block = this.active[Number(offset)];
+    if (!block) {
+      return null;
+    }
+
+    return new Uint8Array(this.memory.buffer, Number(offset), Number(block.length));
+  }
+
+  getString(offset: bigint): string | null {
+    const bytes = this.getBytes(offset);
+    if (bytes === null) {
+      return null;
+    }
+
+    return new TextDecoder().decode(bytes);
+  }
+
+  allocBytes(data: Uint8Array): bigint {
+    const offs = this.alloc(BigInt(data.length));
+    const bytes = this.getBytes(offs);
+    if (bytes === null) {
+      this.free(offs);
+      return BigInt(0);
+    }
+
+    bytes.set(data);
+    return offs;
+  }
+
+  allocString(data: string): bigint {
+    const bytes = new TextEncoder().encode(data);
+    return this.allocBytes(bytes);
+  }
+
+  getLength(offset: bigint): bigint {
+    const block = this.active[Number(offset)];
+    if (!block) {
+      return BigInt(0);
+    }
+
+    return block.length;
+  }
+
+  free(offset: bigint) {
+    const block = this.active[Number(offset)];
+    if (!block) {
+      return;
+    }
+
+    delete this.active[Number(offset)];
+    this.freed.push(block);
+  }
+}

browser/src/context.ts

@@ -0,0 +1,45 @@
+import { Manifest, PluginConfig, ManifestWasmFile, ManifestWasmData } from './manifest';
+import ExtismPlugin from './plugin';
+
+/**
+ * Can be a {@link Manifest} or just the raw bytes of the WASM module as an ArrayBuffer.
+ * We recommend using {@link Manifest}
+ */
+type ManifestData = Manifest | ArrayBuffer;
+
+/**
+ * A Context is needed to create plugins. The Context
+ * is where your plugins live. Freeing the context
+ * frees all of the plugins in its scope.
+ */
+export default class ExtismContext {
+  /**
+   * Create a plugin managed by this context
+   *
+   * @param manifest - The {@link ManifestData} describing the plugin code and config
+   * @param config - Config details for the plugin
+   * @returns A new Plugin scoped to this Context
+   */
+  async newPlugin(manifest: ManifestData, config?: PluginConfig) {
+    let moduleData: ArrayBuffer | null = null;
+    if (manifest instanceof ArrayBuffer) {
+      moduleData = manifest;
+    } else if ((manifest as Manifest).wasm) {
+      const wasmData = (manifest as Manifest).wasm;
+      if (wasmData.length > 1) throw Error('This runtime only supports one module in Manifest.wasm');
+      const wasm = wasmData[0];
+      if ((wasm as ManifestWasmData).data) {
+        moduleData = (wasm as ManifestWasmData).data;
+      } else if ((wasm as ManifestWasmFile).path) {
+        const response = await fetch((wasm as ManifestWasmFile).path);
+        moduleData = await response.arrayBuffer();
+        console.dir(moduleData);
+      }
+    }
+    if (!moduleData) {
+      throw Error(`Unsure how to interpret manifest ${manifest}`);
+    }
+
+    return new ExtismPlugin(moduleData, config);
+  }
+}

browser/src/index.test.ts

@@ -0,0 +1,23 @@
+import { ExtismContext } from './';
+import fs from 'fs';
+import path from 'path';
+
+function parse(bytes: Uint8Array): any {
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+
+describe('', () => {
+  it('can load and call a plugin', async () => {
+    const data = fs.readFileSync(path.join(__dirname, '..', 'data', 'code.wasm'));
+    const ctx = new ExtismContext();
+    const plugin = await ctx.newPlugin({ wasm: [{ data: data }] });
+    const functions = await plugin.getExports();
+    expect(Object.keys(functions).filter((x) => !x.startsWith('__') && x !== 'memory')).toEqual(['count_vowels']);
+    let output = await plugin.call('count_vowels', 'this is a test');
+    expect(parse(output)).toEqual({ count: 4 });
+    output = await plugin.call('count_vowels', 'this is a test again');
+    expect(parse(output)).toEqual({ count: 7 });
+    output = await plugin.call('count_vowels', 'this is a test thrice');
+    expect(parse(output)).toEqual({ count: 6 });
+  });
+});

browser/src/index.ts

@@ -0,0 +1,3 @@
+import ExtismContext from './context';
+
+export { ExtismContext };

browser/src/manifest.ts

@@ -0,0 +1,40 @@
+/**
+ * Represents a path or url to a WASM module
+ */
+export type ManifestWasmFile = {
+  path: string;
+  name?: string;
+  hash?: string;
+};
+
+/**
+ * Represents the raw bytes of a WASM file loaded into memory
+ */
+export type ManifestWasmData = {
+  data: Uint8Array;
+  name?: string;
+  hash?: string;
+};
+
+/**
+ * {@link ExtismPlugin} Config
+ */
+export type PluginConfig = Map<string, string>;
+
+/**
+ * The WASM to load as bytes or a path
+ */
+export type ManifestWasm = ManifestWasmFile | ManifestWasmData;
+
+/**
+ * The manifest which describes the {@link ExtismPlugin} code and
+ * runtime constraints.
+ *
+ * @see [Extism > Concepts > Manifest](https://extism.org/docs/concepts/manifest)
+ */
+export type Manifest = {
+  wasm: Array<ManifestWasm>;
+  //memory?: ManifestMemory;
+  config?: PluginConfig;
+  allowed_hosts?: Array<string>;
+};

browser/src/plugin.ts

@@ -0,0 +1,184 @@
+import Allocator from './allocator';
+import { PluginConfig } from './manifest';
+//@ts-ignore TODO add types to this library
+import { WASI, File } from "@bjorn3/browser_wasi_shim";
+
+export default class ExtismPlugin {
+  moduleData: ArrayBuffer;
+  allocator: Allocator;
+  config?: PluginConfig;
+  vars: Record<string, Uint8Array>;
+  input: Uint8Array;
+  output: Uint8Array;
+  module?: WebAssembly.WebAssemblyInstantiatedSource;
+
+  constructor(moduleData: ArrayBuffer, config?: PluginConfig) {
+    this.moduleData = moduleData;
+    this.allocator = new Allocator(1024 * 1024);
+    this.config = config;
+    this.vars = {};
+    this.input = new Uint8Array();
+    this.output = new Uint8Array();
+  }
+
+  async getExports(): Promise<WebAssembly.Exports> {
+    const module = await this._instantiateModule();
+    return module.instance.exports;
+  }
+
+  async getImports(): Promise<WebAssembly.ModuleImportDescriptor[]> {
+    const module = await this._instantiateModule();
+    return WebAssembly.Module.imports(module.module);
+  }
+
+  async getInstance(): Promise<WebAssembly.Instance> {
+    const module = await this._instantiateModule();
+    return module.instance;
+  }
+
+  async call(func_name: string, input: Uint8Array | string): Promise<Uint8Array> {
+    const module = await this._instantiateModule();
+
+    if (typeof input === 'string') {
+      this.input = new TextEncoder().encode(input);
+    } else if (input instanceof Uint8Array) {
+      this.input = input;
+    } else {
+      throw new Error('input should be string or Uint8Array');
+    }
+
+    this.allocator.reset();
+
+    let func = module.instance.exports[func_name];
+    if (!func) {
+      throw Error(`function does not exist ${func_name}`);
+    }
+    //@ts-ignore
+    func();
+    return this.output;
+  }
+
+  async _instantiateModule(): Promise<WebAssembly.WebAssemblyInstantiatedSource> {
+    if (this.module) {
+      return this.module;
+    }
+    const environment = this.makeEnv();
+    const args: Array<string> = [];
+    const envVars: Array<string> = [];
+    let fds = [
+        new File([]), // stdin
+        new File([]), // stdout
+        new File([]), // stderr
+    ];
+    let wasi = new WASI(args, envVars, fds);
+    let env = {
+      wasi_snapshot_preview1: wasi.wasiImport,
+      env: environment
+    };
+    this.module = await WebAssembly.instantiate(this.moduleData, env);
+    return this.module;
+  }
+
+  makeEnv(): any {
+    const plugin = this;
+    return {
+      extism_alloc(n: bigint): bigint {
+        return plugin.allocator.alloc(n);
+      },
+      extism_free(n: bigint) {
+        plugin.allocator.free(n);
+      },
+      extism_load_u8(n: bigint): number {
+        return plugin.allocator.memory[Number(n)];
+      },
+      extism_load_u64(n: bigint): bigint {
+        let cast = new DataView(plugin.allocator.memory.buffer, Number(n));
+        return cast.getBigUint64(0, true);
+      },
+      extism_store_u8(offset: bigint, n: number) {
+        plugin.allocator.memory[Number(offset)] = Number(n);
+      },
+      extism_store_u64(offset: bigint, n: bigint) {
+        const tmp = new DataView(plugin.allocator.memory.buffer, Number(offset));
+        tmp.setBigUint64(0, n, true);
+      },
+      extism_input_length(): bigint {
+        return BigInt(plugin.input.length);
+      },
+      extism_input_load_u8(i: bigint): number {
+        return plugin.input[Number(i)];
+      },
+      extism_input_load_u64(idx: bigint): bigint {
+        let cast = new DataView(plugin.input.buffer, Number(idx));
+        return cast.getBigUint64(0, true);
+      },
+      extism_output_set(offset: bigint, length: bigint) {
+        const offs = Number(offset);
+        const len = Number(length);
+        plugin.output = plugin.allocator.memory.slice(offs, offs + len);
+      },
+      extism_error_set(i: bigint) {
+        throw plugin.allocator.getString(i);
+      },
+      extism_config_get(i: bigint): bigint {
+        if (typeof plugin.config === 'undefined') {
+          return BigInt(0);
+        }
+        const key = plugin.allocator.getString(i);
+        if (key === null) {
+          return BigInt(0);
+        }
+        const value = plugin.config.get(key);
+        if (typeof value === 'undefined') {
+          return BigInt(0);
+        }
+        return plugin.allocator.allocString(value);
+      },
+      extism_var_get(i: bigint): bigint {
+        const key = plugin.allocator.getString(i);
+        if (key === null) {
+          return BigInt(0);
+        }
+        const value = plugin.vars[key];
+        if (typeof value === 'undefined') {
+          return BigInt(0);
+        }
+        return plugin.allocator.allocBytes(value);
+      },
+      extism_var_set(n: bigint, i: bigint) {
+        const key = plugin.allocator.getString(n);
+        if (key === null) {
+          return;
+        }
+        const value = plugin.allocator.getBytes(i);
+        if (value === null) {
+          return;
+        }
+        plugin.vars[key] = value;
+      },
+      extism_http_request(n: bigint, i: bigint): number {
+        debugger;
+        return 0;
+      },
+      extism_length(i: bigint): bigint {
+        return plugin.allocator.getLength(i);
+      },
+      extism_log_warn(i: bigint) {
+        const s = plugin.allocator.getString(i);
+        console.warn(s);
+      },
+      extism_log_info(i: bigint) {
+        const s = plugin.allocator.getString(i);
+        console.log(s);
+      },
+      extism_log_debug(i: bigint) {
+        const s = plugin.allocator.getString(i);
+        console.debug(s);
+      },
+      extism_log_error(i: bigint) {
+        const s = plugin.allocator.getString(i);
+        console.error(s);
+      },
+    };
+  }
+}

browser/tsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+      "target": "es2016", 
+      "module": "commonjs",  
+      "esModuleInterop": true,
+      "forceConsistentCasingInFileNames": true,
+      "declaration": true,
+      "strict": true,                   
+      "skipLibCheck": true,
+      "allowJs": true
+    },
+    "exclude": ["node_modules", "dist", "**/*.test.ts"]
+  }

browser/tslint.json

@@ -0,0 +1,6 @@
+{
+    "extends": [
+        "tslint:recommended",
+        "tslint-config-prettier"
+    ]
+}

c/Makefile

@@ -0,0 +1,2 @@
+build:
+	clang -g -o main main.c -lextism -L .

c/main.c

@@ -9,10 +9,6 @@
 #include <sys/stat.h>
 #include <unistd.h>
 
-void log_handler(const char *line, ExtismSize length) {
-  fwrite(line, length, 1, stderr);
-}
-
 void hello_world(ExtismCurrentPlugin *plugin, const ExtismVal *inputs,
                  uint64_t n_inputs, ExtismVal *outputs, uint64_t n_outputs,
                  void *data) {
@@ -28,8 +24,6 @@ void hello_world(ExtismCurrentPlugin *plugin, const ExtismVal *inputs,
   outputs[0].v.i64 = inputs[0].v.i64;
 }
 
-void free_data(void *x) { puts("Freeing userdata"); }
-
 uint8_t *read_file(const char *filename, size_t *len) {
 
   FILE *fp = fopen(filename, "rb");
@@ -59,34 +53,30 @@ int main(int argc, char *argv[]) {
     exit(1);
   }
 
-  extism_log_custom("extism=trace,cranelift=trace");
+  ExtismContext *ctx = extism_context_new();
 
   size_t len = 0;
   uint8_t *data = read_file("../wasm/code-functions.wasm", &len);
-  ExtismValType inputs[] = {EXTISM_PTR};
-  ExtismValType outputs[] = {EXTISM_PTR};
-  ExtismFunction *f =
-      extism_function_new("hello_world", inputs, 1, outputs, 1, hello_world,
-                          "Hello, again!", free_data);
-
-  char *errmsg = NULL;
-  ExtismPlugin *plugin = extism_plugin_new(
-      data, len, (const ExtismFunction **)&f, 1, true, &errmsg);
+  ExtismValType inputs[] = {I64};
+  ExtismValType outputs[] = {I64};
+  ExtismFunction *f = extism_function_new("hello_world", inputs, 1, outputs, 1,
+                                          hello_world, "Hello, again!", NULL);
+  ExtismPlugin plugin =
+      extism_plugin_new(ctx, data, len, (const ExtismFunction **)&f, 1, true);
   free(data);
-  if (plugin == NULL) {
-    puts(errmsg);
-    extism_plugin_new_error_free(errmsg);
+  if (plugin < 0) {
+    puts(extism_error(ctx, -1));
     exit(1);
   }
-
-  assert(extism_plugin_call(plugin, "count_vowels", (uint8_t *)argv[1],
+  assert(extism_plugin_call(ctx, plugin, "count_vowels", (uint8_t *)argv[1],
                             strlen(argv[1])) == 0);
-  ExtismSize out_len = extism_plugin_output_length(plugin);
-  const uint8_t *output = extism_plugin_output_data(plugin);
+  ExtismSize out_len = extism_plugin_output_length(ctx, plugin);
+  const uint8_t *output = extism_plugin_output_data(ctx, plugin);
   write(STDOUT_FILENO, output, out_len);
   write(STDOUT_FILENO, "\n", 1);
-  extism_plugin_free(plugin);
+
+  extism_plugin_free(ctx, plugin);
   extism_function_free(f);
-  extism_log_drain(log_handler);
+  extism_context_free(ctx);
   return 0;
 }

composer.json

@@ -0,0 +1,49 @@
+{
+  "name": "extism/extism",
+  "description": "Make your software programmable. Run WebAssembly extensions in your app using the first off-the-shelf, universal plug-in system.",
+  "license": "BSD-3-Clause",
+  "type": "library",
+  "keywords": [
+    "WebAssembly",
+    "plugin-system",
+    "runtime",
+    "plug-in"
+  ],
+  "authors": [
+    {
+      "name": "The Extism Authors",
+      "email": "oss@extism.org",
+      "homepage": "https://extism.org"
+    },
+    {
+      "name": "Dylibso, Inc.",
+      "email": "oss@dylib.so",
+      "homepage": "https://dylib.so"
+    }
+  ],
+  "require": {
+    "php": "^7.4 || ^8",
+    "ircmaxell/ffime": "dev-master"
+  },
+  "suggest": {},
+  "minimum-stability": "dev",
+  "prefer-stable": true,
+  "autoload": {
+    "psr-4": {
+      "Extism\\": "php/src/"
+    },
+    "files": [
+      "php/src/Context.php",
+      "php/src/Plugin.php"
+    ]
+  },
+  "autoload-dev": {
+    "psr-4": {}
+  },
+  "config": {
+    "sort-packages": true
+  },
+  "extra": {},
+  "scripts": {},
+  "scripts-descriptions": {}
+}

composer.lock

@@ -0,0 +1,163 @@
+{
+    "_readme": [
+        "This file locks the dependencies of your project to a known state",
+        "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
+        "This file is @generated automatically"
+    ],
+    "content-hash": "0e0352cd3a96e03fd9c964888deedb29",
+    "packages": [
+        {
+            "name": "ircmaxell/ffime",
+            "version": "dev-master",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/ircmaxell/FFIMe.git",
+                "reference": "5f648f95ecf23262a2e58f4e4c9001bd1b5f9c98"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/ircmaxell/FFIMe/zipball/5f648f95ecf23262a2e58f4e4c9001bd1b5f9c98",
+                "reference": "5f648f95ecf23262a2e58f4e4c9001bd1b5f9c98",
+                "shasum": ""
+            },
+            "require": {
+                "ircmaxell/php-c-parser": "dev-master",
+                "ircmaxell/php-object-symbolresolver": "dev-master",
+                "php": ">=8.0"
+            },
+            "require-dev": {
+                "phpunit/phpunit": "^8.0"
+            },
+            "default-branch": true,
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "FFIMe\\": "lib/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Anthony Ferrara",
+                    "email": "ircmaxell@gmail.com"
+                }
+            ],
+            "description": "Make life easy when working with 7.4's FFI",
+            "support": {
+                "issues": "https://github.com/ircmaxell/FFIMe/issues",
+                "source": "https://github.com/ircmaxell/FFIMe/tree/master"
+            },
+            "time": "2022-09-01T18:56:19+00:00"
+        },
+        {
+            "name": "ircmaxell/php-c-parser",
+            "version": "dev-master",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/ircmaxell/php-c-parser.git",
+                "reference": "55e0a4fdf88d6e955d928860e1e107a68492c1cf"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/ircmaxell/php-c-parser/zipball/55e0a4fdf88d6e955d928860e1e107a68492c1cf",
+                "reference": "55e0a4fdf88d6e955d928860e1e107a68492c1cf",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.4"
+            },
+            "require-dev": {
+                "ircmaxell/php-yacc": "dev-master",
+                "phpunit/phpunit": "^8.0"
+            },
+            "default-branch": true,
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "PHPCParser\\": "lib/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Anthony Ferrara",
+                    "email": "ircmaxell@gmail.com"
+                },
+                {
+                    "name": "Bob Weinand",
+                    "email": "bobwei9@hotmail.com"
+                }
+            ],
+            "description": "Parse C when using PHP",
+            "support": {
+                "issues": "https://github.com/ircmaxell/php-c-parser/issues",
+                "source": "https://github.com/ircmaxell/php-c-parser/tree/master"
+            },
+            "time": "2022-08-27T17:37:14+00:00"
+        },
+        {
+            "name": "ircmaxell/php-object-symbolresolver",
+            "version": "dev-master",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/ircmaxell/php-object-symbolresolver.git",
+                "reference": "3734df2b22d7c8273ee6f6f2155fddde6056d057"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/ircmaxell/php-object-symbolresolver/zipball/3734df2b22d7c8273ee6f6f2155fddde6056d057",
+                "reference": "3734df2b22d7c8273ee6f6f2155fddde6056d057",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.4"
+            },
+            "default-branch": true,
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "PHPObjectSymbolResolver\\": "lib/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Anthony Ferrara",
+                    "email": "ircmaxell@gmail.com"
+                },
+                {
+                    "name": "Bob Weinand",
+                    "email": "bobwei9@hotmail.com"
+                }
+            ],
+            "description": "An object file (ELF, Mach-O) parser",
+            "support": {
+                "issues": "https://github.com/ircmaxell/php-object-symbolresolver/issues",
+                "source": "https://github.com/ircmaxell/php-object-symbolresolver/tree/master"
+            },
+            "time": "2022-08-14T19:30:20+00:00"
+        }
+    ],
+    "packages-dev": [],
+    "aliases": [],
+    "minimum-stability": "dev",
+    "stability-flags": {
+        "ircmaxell/ffime": 20
+    },
+    "prefer-stable": true,
+    "prefer-lowest": false,
+    "platform": {
+        "php": "^7.4 || ^8"
+    },
+    "platform-dev": [],
+    "plugin-api-version": "2.3.0"
+}

convert-macros/Cargo.toml

@@ -1,26 +0,0 @@
-[package]
-name = "extism-convert-macros"
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-homepage.workspace = true
-repository.workspace = true
-version.workspace = true
-description = "Macros to remove boilerplate with Extism"
-
-[lib]
-proc-macro = true
-
-[features]
-extism-path = []
-extism-pdk-path = []
-
-[dependencies]
-manyhow.version = "0.11.0"
-proc-macro-crate = "3.1.0"
-proc-macro2 = "1.0.78"
-quote = "1.0.35"
-syn = { version = "2.0.48", features = ["derive"] }
-
-[dev-dependencies]
-trybuild = "1.0.89"

convert-macros/src/lib.rs

@@ -1,108 +0,0 @@
-use std::iter;
-
-use manyhow::{ensure, error_message, manyhow, Result};
-use proc_macro_crate::{crate_name, FoundCrate};
-use quote::{format_ident, quote, ToTokens};
-use syn::{parse_quote, Attribute, DeriveInput, Path};
-
-/// Tries to resolve the path to `extism_convert` dynamically, falling back to feature flags when unsuccessful.
-fn convert_path() -> Path {
-    match (
-        crate_name("extism"),
-        crate_name("extism-convert"),
-        crate_name("extism-pdk"),
-    ) {
-        (Ok(FoundCrate::Name(name)), ..) => {
-            let ident = format_ident!("{name}");
-            parse_quote!(::#ident::convert)
-        }
-        (_, Ok(FoundCrate::Name(name)), ..) | (.., Ok(FoundCrate::Name(name))) => {
-            let ident = format_ident!("{name}");
-            parse_quote!(::#ident)
-        }
-        (Ok(FoundCrate::Itself), ..) => parse_quote!(::extism::convert),
-        (_, Ok(FoundCrate::Itself), ..) => parse_quote!(::extism_convert),
-        (.., Ok(FoundCrate::Itself)) => parse_quote!(::extism_pdk),
-        _ if cfg!(feature = "extism-path") => parse_quote!(::extism::convert),
-        _ if cfg!(feature = "extism-pdk-path") => parse_quote!(::extism_pdk),
-        _ => parse_quote!(::extism_convert),
-    }
-}
-
-fn extract_encoding(attrs: &[Attribute]) -> Result<Path> {
-    let encodings: Vec<_> = attrs
-        .iter()
-        .filter(|attr| attr.path().is_ident("encoding"))
-        .collect();
-    ensure!(!encodings.is_empty(), "encoding needs to be specified"; try = "`#[encoding(Json)]`");
-    ensure!(encodings.len() < 2, encodings[1], "only one encoding can be specified"; try = "remove `{}`", encodings[1].to_token_stream());
-
-    Ok(encodings[0].parse_args().map_err(
-        |e| error_message!(e.span(), "{e}"; note= "expects a path"; try = "`#[encoding(Json)]`"),
-    )?)
-}
-
-#[manyhow]
-#[proc_macro_derive(ToBytes, attributes(encoding))]
-pub fn to_bytes(
-    DeriveInput {
-        attrs,
-        ident,
-        generics,
-        ..
-    }: DeriveInput,
-) -> Result {
-    let encoding = extract_encoding(&attrs)?;
-    let convert = convert_path();
-
-    let (_, type_generics, _) = generics.split_for_impl();
-
-    let mut generics = generics.clone();
-    generics.make_where_clause().predicates.push(
-        parse_quote!(for<'__to_bytes_b> #encoding<&'__to_bytes_b Self>: #convert::ToBytes<'__to_bytes_b>)
-    );
-    generics.params = iter::once(parse_quote!('__to_bytes_a))
-        .chain(generics.params)
-        .collect();
-    let (impl_generics, _, where_clause) = generics.split_for_impl();
-
-    Ok(quote! {
-        impl #impl_generics #convert::ToBytes<'__to_bytes_a> for #ident #type_generics #where_clause
-        {
-            type Bytes = ::std::vec::Vec<u8>;
-
-            fn to_bytes(&self) -> Result<Self::Bytes, #convert::Error> {
-                #convert::ToBytes::to_bytes(&#encoding(self)).map(|__bytes| __bytes.as_ref().to_vec())
-            }
-        }
-
-    })
-}
-
-#[manyhow]
-#[proc_macro_derive(FromBytes, attributes(encoding))]
-pub fn from_bytes(
-    DeriveInput {
-        attrs,
-        ident,
-        mut generics,
-        ..
-    }: DeriveInput,
-) -> Result {
-    let encoding = extract_encoding(&attrs)?;
-    let convert = convert_path();
-    generics
-        .make_where_clause()
-        .predicates
-        .push(parse_quote!(#encoding<Self>: #convert::FromBytesOwned));
-    let (impl_generics, type_generics, where_clause) = generics.split_for_impl();
-    Ok(quote! {
-        impl #impl_generics #convert::FromBytesOwned for #ident #type_generics #where_clause
-        {
-            fn from_bytes_owned(__data: &[u8]) -> Result<Self, #convert::Error> {
-                <#encoding<Self> as #convert::FromBytesOwned>::from_bytes_owned(__data).map(|__encoding| __encoding.0)
-            }
-        }
-
-    })
-}

convert-macros/tests/ui.rs

@@ -1,5 +0,0 @@
-#[test]
-fn ui() {
-    let t = trybuild::TestCases::new();
-    t.compile_fail("tests/ui/*.rs");
-}

convert-macros/tests/ui/invalid-encoding.rs

@@ -1,23 +0,0 @@
-use extism_convert_macros::ToBytes;
-
-#[derive(ToBytes)]
-struct MissingEncoding;
-
-#[derive(ToBytes)]
-#[encoding]
-struct EmptyAttr;
-
-#[derive(ToBytes)]
-#[encoding = "string"]
-struct EqNoParen;
-
-#[derive(ToBytes)]
-#[encoding(something, else)]
-struct NotAPath;
-
-#[derive(ToBytes)]
-#[encoding(Multiple)]
-#[encoding(Encodings)]
-struct MultipleEncodings;
-
-fn main() {}

convert-macros/tests/ui/invalid-encoding.stderr

@@ -1,44 +0,0 @@
-error: encoding needs to be specified
-
-         = try: `#[encoding(Json)]`
- --> tests/ui/invalid-encoding.rs:3:10
-  |
-3 | #[derive(ToBytes)]
-  |          ^^^^^^^
-  |
-  = note: this error originates in the derive macro `ToBytes` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error: expected attribute arguments in parentheses: #[encoding(...)]
-
-         = note: expects a path
-         = try: `#[encoding(Json)]`
- --> tests/ui/invalid-encoding.rs:7:3
-  |
-7 | #[encoding]
-  |   ^^^^^^^^
-
-error: expected parentheses: #[encoding(...)]
-
-         = note: expects a path
-         = try: `#[encoding(Json)]`
-  --> tests/ui/invalid-encoding.rs:11:12
-   |
-11 | #[encoding = "string"]
-   |            ^
-
-error: unexpected token
-
-         = note: expects a path
-         = try: `#[encoding(Json)]`
-  --> tests/ui/invalid-encoding.rs:15:21
-   |
-15 | #[encoding(something, else)]
-   |                     ^
-
-error: only one encoding can be specified
-
-         = try: remove `#[encoding(Encodings)]`
-  --> tests/ui/invalid-encoding.rs:20:1
-   |
-20 | #[encoding(Encodings)]
-   | ^^^^^^^^^^^^^^^^^^^^^^

convert/Cargo.toml

@@ -1,31 +0,0 @@
-[package]
-name = "extism-convert"
-readme = "./README.md"
-edition.workspace = true
-authors.workspace = true
-license.workspace = true
-homepage.workspace = true
-repository.workspace = true
-version.workspace = true
-description = "Traits to make Rust types usable with Extism"
-
-[dependencies]
-anyhow = "1.0.75"
-base64 = "~0.22"
-bytemuck = {version = "1.14.0", optional = true }
-prost = { version = "0.13.1", optional = true }
-protobuf = { version = "3.2.0", optional = true }
-rmp-serde = { version = "1.1.2", optional = true }
-serde = "1.0.186"
-serde_json = "1.0.105"
-extism-convert-macros.workspace = true
-
-[dev-dependencies]
-serde = { version = "1.0.186", features = ["derive"] }
-
-[features]
-default = ["msgpack", "prost", "raw"]
-msgpack = ["rmp-serde"]
-raw = ["bytemuck"]
-extism-path = ["extism-convert-macros/extism-path"]
-extism-pdk-path = ["extism-convert-macros/extism-pdk-path"]

convert/README.md

@@ -1,12 +0,0 @@
-# extism-convert
-
-The [extism-convert](https://crates.io/crates/extism-convert) crate is used by the [Rust SDK](https://crates.io/crates/extism) and [Rust PDK](https://crates.io/crates/extism-pdk) to provide a shared interface for
-encoding and decoding values that can be passed to Extism function calls.
-
-A set of types (Json, Msgpack, Protobuf) that can be used to specify a serde encoding are also provided. These are
-similar to [axum extractors](https://docs.rs/axum/latest/axum/extract/index.html#intro) - they are
-implemented as a tuple struct with a single field that is meant to be extracted using pattern matching.
-
-## Documentation
-
-See [extism-convert on docs.rs](https://docs.rs/extism-convert/latest/extism_convert/) for in-depth documentation.

convert/src/encoding.rs

@@ -1,187 +0,0 @@
-use crate::*;
-
-use base64::Engine;
-
-/// The `encoding` macro can be used to create newtypes that implement a particular encoding for the
-/// inner value.
-///
-/// For example, the following line creates a new JSON encoding using serde_json:
-///
-/// ```
-/// extism_convert::encoding!(MyJson, serde_json::to_vec, serde_json::from_slice);
-/// ```
-///
-/// This will create a struct `struct MyJson<T>(pub T)` and implement [`ToBytes`] using [`serde_json::to_vec`]
-/// and [`FromBytesOwned`] using [`serde_json::from_slice`]
-#[macro_export]
-macro_rules! encoding {
-    ($pub:vis $name:ident, $to_vec:expr, $from_slice:expr) => {
-        #[doc = concat!(stringify!($name), " encoding")]
-        #[derive(Debug)]
-        $pub struct $name<T>(pub T);
-
-        impl<T> $name<T> {
-            pub fn into_inner(self) -> T {
-                self.0
-            }
-        }
-
-        impl<T> From<T> for $name<T> {
-            fn from(data: T) -> Self {
-                Self(data)
-            }
-        }
-
-        impl<T: serde::de::DeserializeOwned> $crate::FromBytesOwned for $name<T> {
-            fn from_bytes_owned(data: &[u8]) -> std::result::Result<Self, $crate::Error> {
-                let x = $from_slice(data)?;
-                std::result::Result::Ok($name(x))
-            }
-        }
-
-        impl<'a, T: serde::Serialize> $crate::ToBytes<'a> for $name<T> {
-            type Bytes = Vec<u8>;
-
-            fn to_bytes(&self) -> std::result::Result<Self::Bytes, $crate::Error> {
-                let enc = $to_vec(&self.0)?;
-                std::result::Result::Ok(enc)
-            }
-        }
-    };
-}
-
-encoding!(pub Json, serde_json::to_vec, serde_json::from_slice);
-
-#[cfg(feature = "msgpack")]
-encoding!(pub Msgpack, rmp_serde::to_vec, rmp_serde::from_slice);
-
-impl ToBytes<'_> for serde_json::Value {
-    type Bytes = Vec<u8>;
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(serde_json::to_vec(self)?)
-    }
-}
-
-impl FromBytesOwned for serde_json::Value {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(serde_json::from_slice(data)?)
-    }
-}
-
-/// Base64 conversion
-///
-/// When using `Base64` with `ToBytes` any type that implement `AsRef<[T]>` may be used as the inner value,
-/// but only `Base64<String>` and `Base64<Vec>` may be used with `FromBytes`
-///
-/// A value wrapped in `Base64` will automatically be encoded/decoded using base64, the inner value should not
-/// already be base64 encoded.
-#[derive(Debug)]
-pub struct Base64<T: AsRef<[u8]>>(pub T);
-
-impl<T: AsRef<[u8]>> From<T> for Base64<T> {
-    fn from(data: T) -> Self {
-        Self(data)
-    }
-}
-
-impl<T: AsRef<[u8]>> ToBytes<'_> for Base64<T> {
-    type Bytes = String;
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(base64::engine::general_purpose::STANDARD.encode(&self.0))
-    }
-}
-
-impl FromBytesOwned for Base64<Vec<u8>> {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Base64(
-            base64::engine::general_purpose::STANDARD.decode(data)?,
-        ))
-    }
-}
-
-impl FromBytesOwned for Base64<String> {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Base64(String::from_utf8(
-            base64::engine::general_purpose::STANDARD.decode(data)?,
-        )?))
-    }
-}
-
-/// Protobuf encoding
-///
-/// Allows for `prost` Protobuf messages to be used as arguments to Extism plugin calls
-#[cfg(feature = "prost")]
-#[derive(Debug)]
-pub struct Prost<T: prost::Message>(pub T);
-
-#[cfg(feature = "prost")]
-impl<T: prost::Message> From<T> for Prost<T> {
-    fn from(data: T) -> Self {
-        Self(data)
-    }
-}
-
-#[cfg(feature = "prost")]
-impl<T: prost::Message> ToBytes<'_> for Prost<T> {
-    type Bytes = Vec<u8>;
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.0.encode_to_vec())
-    }
-}
-
-#[cfg(feature = "prost")]
-impl<T: Default + prost::Message> FromBytesOwned for Prost<T> {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Prost(T::decode(data)?))
-    }
-}
-
-/// Protobuf encoding
-///
-/// Allows for `rust-protobuf` Protobuf messages to be used as arguments to Extism plugin calls
-#[cfg(feature = "protobuf")]
-pub struct Protobuf<T: protobuf::Message>(pub T);
-
-#[cfg(feature = "protobuf")]
-impl<T: protobuf::Message> ToBytes<'_> for Protobuf<T> {
-    type Bytes = Vec<u8>;
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.0.write_to_bytes()?)
-    }
-}
-
-#[cfg(feature = "protobuf")]
-impl<T: Default + protobuf::Message> FromBytesOwned for Protobuf<T> {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Protobuf(T::parse_from_bytes(data)?))
-    }
-}
-
-/// Raw does no conversion, it just copies the memory directly.
-/// Note: This will only work for types that implement [bytemuck::Pod](https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html)
-#[cfg(all(feature = "raw", target_endian = "little"))]
-pub struct Raw<'a, T: bytemuck::Pod>(pub &'a T);
-
-#[cfg(all(feature = "raw", target_endian = "little"))]
-impl<'a, T: bytemuck::Pod> ToBytes<'a> for Raw<'a, T> {
-    type Bytes = &'a [u8];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(bytemuck::bytes_of(self.0))
-    }
-}
-
-#[cfg(all(feature = "raw", target_endian = "little"))]
-impl<'a, T: bytemuck::Pod> FromBytes<'a> for Raw<'a, T> {
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error> {
-        let x = bytemuck::try_from_bytes(data).map_err(|x| Error::msg(x.to_string()))?;
-        Ok(Raw(x))
-    }
-}
-
-#[cfg(all(feature = "raw", target_endian = "big"))]
-compile_error!("The raw feature is only supported on little endian targets");

convert/src/from_bytes.rs

@@ -1,174 +0,0 @@
-use crate::*;
-
-pub use extism_convert_macros::FromBytes;
-
-/// `FromBytes` is used to define how a type should be decoded when working with
-/// Extism memory. It is used for plugin output and host function input.
-///
-/// `FromBytes` can be derived by delegating encoding to generic type implementing
-/// `FromBytes`, e.g., [`Json`], [`Msgpack`].
-///
-/// ```
-/// use extism_convert::{Json, FromBytes};
-/// use serde::Deserialize;
-///
-/// #[derive(FromBytes, Deserialize, PartialEq, Debug)]
-/// #[encoding(Json)]
-/// struct Struct {
-///     hello: String,
-/// }
-///
-/// assert_eq!(Struct::from_bytes(br#"{"hello":"hi"}"#)?, Struct { hello: "hi".into() });
-/// # Ok::<(), extism_convert::Error>(())
-/// ```
-///
-/// Custom encodings can also be used, through new-types with a single generic
-/// argument, i.e., `Type<T>(T)`, that implement `FromBytesOwned` for the struct.
-///
-/// ```
-/// use std::str::{self, FromStr};
-/// use std::convert::Infallible;
-/// use extism_convert::{Error, FromBytes, FromBytesOwned};
-///
-/// // Custom serialization using `FromStr`
-/// struct StringEnc<T>(T);
-/// impl<T: FromStr> FromBytesOwned for StringEnc<T> where Error: From<<T as FromStr>::Err> {
-///     fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-///         Ok(Self(str::from_utf8(data)?.parse()?))
-///     }
-/// }
-///
-/// #[derive(FromBytes, PartialEq, Debug)]
-/// #[encoding(StringEnc)]
-/// struct Struct {
-///     hello: String,
-/// }
-///
-/// impl FromStr for Struct {
-///     type Err = Infallible;
-///     fn from_str(s: &str) -> Result<Self, Infallible> {
-///         Ok(Self { hello: s.to_owned() })
-///     }
-/// }
-///
-/// assert_eq!(Struct::from_bytes(b"hi")?, Struct { hello: "hi".into() });
-/// # Ok::<(), extism_convert::Error>(())
-/// ```
-pub trait FromBytes<'a>: Sized {
-    /// Decode a value from a slice of bytes
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error>;
-}
-
-/// `FromBytesOwned` is similar to [`FromBytes`] but it doesn't borrow from the input slice.
-/// [`FromBytes`] is automatically implemented for all types that implement `FromBytesOwned`.
-///
-/// `FromBytesOwned` can be derived through [`#[derive(FromBytes)]`](FromBytes).
-pub trait FromBytesOwned: Sized {
-    /// Decode a value from a slice of bytes, the resulting value should not borrow the input
-    /// data.
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error>;
-}
-
-impl<'a> FromBytes<'a> for &'a [u8] {
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error> {
-        Ok(data)
-    }
-}
-
-impl<'a> FromBytes<'a> for &'a str {
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error> {
-        Ok(std::str::from_utf8(data)?)
-    }
-}
-
-impl<'a, T: FromBytesOwned> FromBytes<'a> for T {
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error> {
-        T::from_bytes_owned(data)
-    }
-}
-
-impl FromBytesOwned for Box<[u8]> {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(data.to_vec().into_boxed_slice())
-    }
-}
-
-impl FromBytesOwned for Vec<u8> {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(data.to_vec())
-    }
-}
-
-impl FromBytesOwned for String {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(std::str::from_utf8(data)?.to_string())
-    }
-}
-
-impl FromBytesOwned for f64 {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Self::from_le_bytes(data.try_into()?))
-    }
-}
-
-impl FromBytesOwned for f32 {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Self::from_le_bytes(data.try_into()?))
-    }
-}
-
-impl FromBytesOwned for i64 {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Self::from_le_bytes(data.try_into()?))
-    }
-}
-
-impl FromBytesOwned for i32 {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Self::from_le_bytes(data.try_into()?))
-    }
-}
-
-impl FromBytesOwned for u64 {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Self::from_le_bytes(data.try_into()?))
-    }
-}
-
-impl FromBytesOwned for u32 {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        Ok(Self::from_le_bytes(data.try_into()?))
-    }
-}
-
-impl FromBytesOwned for bool {
-    fn from_bytes_owned(data: &[u8]) -> Result<Self, Error> {
-        if let Some(x) = data.first() {
-            Ok(*x != 0)
-        } else {
-            Err(Error::msg("Expected one byte to read boolean value"))
-        }
-    }
-}
-
-impl FromBytesOwned for () {
-    fn from_bytes_owned(_: &[u8]) -> Result<Self, Error> {
-        Ok(())
-    }
-}
-
-impl<'a, T: FromBytes<'a>> FromBytes<'a> for std::io::Cursor<T> {
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error> {
-        Ok(std::io::Cursor::new(T::from_bytes(data)?))
-    }
-}
-
-impl<'a, T: FromBytes<'a>> FromBytes<'a> for Option<T> {
-    fn from_bytes(data: &'a [u8]) -> Result<Self, Error> {
-        if data.is_empty() {
-            return Ok(None);
-        }
-
-        T::from_bytes(data).map(Some)
-    }
-}

convert/src/lib.rs

@@ -1,38 +0,0 @@
-//! The [extism-convert](https://crates.io/crates/extism-convert) crate is used by the [Rust SDK](https://crates.io/crates/extism) and [Rust PDK](https://crates.io/crates/extism-pdk) to provide a shared interface for
-//! encoding and decoding values that can be passed to Extism function calls.
-//!
-//! A set of types (Json, Msgpack) that can be used to specify a serde encoding are also provided. These are
-//! similar to [axum extractors](https://docs.rs/axum/latest/axum/extract/index.html#intro) - they are
-//! implemented as a tuple struct with a single field that is meant to be extracted using pattern matching.
-
-// Makes proc-macros able to resolve `::extism_convert` correctly
-extern crate self as extism_convert;
-
-pub use anyhow::Error;
-
-mod encoding;
-
-mod from_bytes;
-mod memory_handle;
-mod to_bytes;
-
-pub use encoding::{Base64, Json};
-
-#[cfg(feature = "msgpack")]
-pub use encoding::Msgpack;
-
-#[cfg(feature = "prost")]
-pub use encoding::Prost;
-
-#[cfg(feature = "protobuf")]
-pub use encoding::Protobuf;
-
-#[cfg(all(feature = "raw", target_endian = "little"))]
-pub use encoding::Raw;
-
-pub use from_bytes::{FromBytes, FromBytesOwned};
-pub use memory_handle::MemoryHandle;
-pub use to_bytes::ToBytes;
-
-#[cfg(test)]
-mod tests;

convert/src/memory_handle.rs

@@ -1,42 +0,0 @@
-/// `MemoryHandle` describes where in memory a block of data is stored
-#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord)]
-pub struct MemoryHandle {
-    /// The offset of the region in Extism linear memory
-    pub offset: u64,
-
-    /// The length of the memory region
-    pub length: u64,
-}
-
-impl MemoryHandle {
-    /// Create a new `MemoryHandle` from an offset in memory and length
-    ///
-    /// # Safety
-    /// This function is unsafe because the specified memory region may not be valid.
-    pub unsafe fn new(offset: u64, length: u64) -> MemoryHandle {
-        MemoryHandle { offset, length }
-    }
-
-    /// `NULL` equivalent
-    pub fn null() -> MemoryHandle {
-        MemoryHandle {
-            offset: 0,
-            length: 0,
-        }
-    }
-
-    /// Get the offset of a memory handle
-    pub fn offset(&self) -> u64 {
-        self.offset
-    }
-
-    /// Get the length of the memory region
-    pub fn len(&self) -> usize {
-        self.length as usize
-    }
-
-    /// Returns `true` when the length is 0
-    pub fn is_empty(&self) -> bool {
-        self.length == 0
-    }
-}

convert/src/tests.rs

@@ -1,101 +0,0 @@
-use crate::*;
-
-#[derive(serde::Serialize, serde::Deserialize, Debug, PartialEq)]
-struct Testing {
-    a: String,
-    b: i64,
-    c: f32,
-}
-
-#[test]
-fn roundtrip_json() {
-    let x = Testing {
-        a: "foobar".to_string(),
-        b: 123,
-        c: 456.7,
-    };
-    let bytes = Json(&x).to_bytes().unwrap();
-    let Json(y): Json<Testing> = FromBytes::from_bytes(&bytes).unwrap();
-    assert_eq!(x, y);
-}
-
-#[test]
-#[cfg(feature = "msgpack")]
-fn roundtrip_msgpack() {
-    let x = Testing {
-        a: "foobar".to_string(),
-        b: 123,
-        c: 456.7,
-    };
-    let bytes = Msgpack(&x).to_bytes().unwrap();
-    let Msgpack(y): Msgpack<Testing> = FromBytes::from_bytes(&bytes).unwrap();
-    assert_eq!(x, y);
-}
-
-#[test]
-fn roundtrip_base64() {
-    let bytes = Base64("this is a test").to_bytes().unwrap();
-    let Base64(s): Base64<String> = FromBytes::from_bytes(bytes.as_bytes()).unwrap();
-    assert_eq!(s, "this is a test");
-}
-
-#[test]
-fn rountrip_option() {
-    // `None` case
-    let e0: Option<Json<Testing>> = FromBytes::from_bytes(&[]).unwrap();
-    let b = e0.to_bytes().unwrap();
-    let e1: Option<Json<Testing>> = FromBytes::from_bytes(&b).unwrap();
-    assert!(e0.is_none());
-    assert_eq!(e0.is_none(), e1.is_none());
-
-    // `Some` case
-    let x = Testing {
-        a: "foobar".to_string(),
-        b: 123,
-        c: 456.7,
-    };
-    let bytes = Json(&x).to_bytes().unwrap();
-    let y: Option<Json<Testing>> = FromBytes::from_bytes(&bytes).unwrap();
-    let b = ToBytes::to_bytes(&y).unwrap();
-    let z: Option<Json<Testing>> = FromBytes::from_bytes(&b).unwrap();
-    assert_eq!(y.unwrap().0, z.unwrap().0);
-}
-
-#[test]
-fn check_bool() {
-    // `None` case
-    let a = true.to_bytes().unwrap();
-    let b = false.to_bytes().unwrap();
-    assert_ne!(a, b);
-
-    assert_eq!(a, [1]);
-    assert_eq!(b, [0]);
-}
-
-#[cfg(all(feature = "raw", target_endian = "little"))]
-mod raw_tests {
-    use crate::*;
-
-    #[test]
-    fn test_raw() {
-        #[derive(Debug, Clone, Copy, PartialEq)]
-        struct TestRaw {
-            a: i32,
-            b: f64,
-            c: bool,
-        }
-        unsafe impl bytemuck::Pod for TestRaw {}
-        unsafe impl bytemuck::Zeroable for TestRaw {}
-        let x = TestRaw {
-            a: 123,
-            b: 45678.91011,
-            c: true,
-        };
-        let raw = Raw(&x).to_bytes().unwrap();
-        let y = Raw::from_bytes(raw).unwrap();
-        assert_eq!(&x, y.0);
-
-        let y: Result<Raw<[u8; std::mem::size_of::<TestRaw>()]>, Error> = Raw::from_bytes(raw);
-        assert!(y.is_ok());
-    }
-}

convert/src/to_bytes.rs

@@ -1,184 +0,0 @@
-use crate::*;
-
-pub use extism_convert_macros::ToBytes;
-
-/// `ToBytes` is used to define how a type should be encoded when working with
-/// Extism memory. It is used for plugin input and host function output.
-///
-/// `ToBytes` can be derived by delegating encoding to generic type implementing
-/// `ToBytes`, e.g., [`Json`], [`Msgpack`].
-///
-/// ```
-/// use extism_convert::{Json, ToBytes};
-/// use serde::Serialize;
-///
-/// #[derive(ToBytes, Serialize)]
-/// #[encoding(Json)]
-/// struct Struct {
-///     hello: String,
-/// }
-///
-/// assert_eq!(Struct { hello: "hi".into() }.to_bytes()?, br#"{"hello":"hi"}"#);
-/// # Ok::<(), extism_convert::Error>(())
-/// ```
-///
-/// But custom types can also be used, as long as they are new-types with a single
-/// generic argument, i.e., `Type<T>(T)`, that implement `ToBytes` for the struct.
-///
-/// ```
-/// use extism_convert::{Error, ToBytes};
-///
-/// // Custom serialization using `ToString`
-/// struct StringEnc<T>(T);
-/// impl<T: ToString> ToBytes<'_> for StringEnc<&T> {
-///     type Bytes = String;
-///     
-///     fn to_bytes(&self) -> Result<String, Error> {
-///         Ok(self.0.to_string())
-///     }
-/// }
-///
-/// #[derive(ToBytes)]
-/// #[encoding(StringEnc)]
-/// struct Struct {
-///     hello: String,
-/// }
-///
-/// impl ToString for Struct {
-///    fn to_string(&self) -> String {
-///        self.hello.clone()     
-///    }
-/// }
-///
-/// assert_eq!(Struct { hello: "hi".into() }.to_bytes()?, b"hi");
-/// # Ok::<(), Error>(())
-/// ```
-pub trait ToBytes<'a> {
-    /// A configurable byte slice representation, allows any type that implements `AsRef<[u8]>`
-    type Bytes: AsRef<[u8]>;
-
-    /// `to_bytes` converts a value into `Self::Bytes`
-    fn to_bytes(&self) -> Result<Self::Bytes, Error>;
-}
-
-impl ToBytes<'_> for () {
-    type Bytes = [u8; 0];
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok([])
-    }
-}
-
-impl ToBytes<'_> for Vec<u8> {
-    type Bytes = Vec<u8>;
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.clone())
-    }
-}
-
-impl ToBytes<'_> for String {
-    type Bytes = String;
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.clone())
-    }
-}
-
-impl<'a> ToBytes<'a> for &'a [u8] {
-    type Bytes = &'a [u8];
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self)
-    }
-}
-
-impl<'a> ToBytes<'a> for &'a str {
-    type Bytes = &'a str;
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self)
-    }
-}
-
-impl ToBytes<'_> for f64 {
-    type Bytes = [u8; 8];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.to_le_bytes())
-    }
-}
-
-impl ToBytes<'_> for f32 {
-    type Bytes = [u8; 4];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.to_le_bytes())
-    }
-}
-
-impl ToBytes<'_> for i64 {
-    type Bytes = [u8; 8];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.to_le_bytes())
-    }
-}
-
-impl ToBytes<'_> for i32 {
-    type Bytes = [u8; 4];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.to_le_bytes())
-    }
-}
-
-impl ToBytes<'_> for u64 {
-    type Bytes = [u8; 8];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.to_le_bytes())
-    }
-}
-
-impl ToBytes<'_> for u32 {
-    type Bytes = [u8; 4];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok(self.to_le_bytes())
-    }
-}
-
-impl ToBytes<'_> for bool {
-    type Bytes = [u8; 1];
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        Ok([*self as u8])
-    }
-}
-
-impl<'a, T: ToBytes<'a>> ToBytes<'a> for &'a T {
-    type Bytes = T::Bytes;
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        <T as ToBytes>::to_bytes(self)
-    }
-}
-
-impl<'a, T: ToBytes<'a>> ToBytes<'a> for Option<T> {
-    type Bytes = Vec<u8>;
-
-    fn to_bytes(&self) -> Result<Self::Bytes, Error> {
-        match self {
-            Some(x) => x.to_bytes().map(|x| x.as_ref().to_vec()),
-            None => Ok(vec![]),
-        }
-    }
-}
-
-#[test]
-fn test() {
-    use extism_convert::{Json, ToBytes};
-    use serde::Serialize;
-
-    #[derive(ToBytes, Serialize)]
-    #[encoding(Json)]
-    struct Struct {
-        hello: String,
-    }
-}

cpp/Makefile

@@ -0,0 +1,15 @@
+FLAGS=`pkg-config --cflags --libs jsoncpp gtest` -lextism -lpthread
+
+build-example:
+	$(CXX) -std=c++14 -o example -I. example.cpp $(FLAGS)
+	
+.PHONY: example
+example: build-example
+	./example
+
+build-test:
+	$(CXX) -std=c++14 -o test/test -I. test/test.cpp $(FLAGS)
+
+.PHONY: test
+test: build-test
+	cd test && ./test

cpp/example.cpp

@@ -0,0 +1,45 @@
+#define EXTISM_NO_JSON
+#include "extism.hpp"
+
+#include <cstring>
+#include <fstream>
+#include <iostream>
+
+using namespace extism;
+
+std::vector<uint8_t> read(const char *filename) {
+  std::ifstream file(filename, std::ios::binary);
+  return std::vector<uint8_t>((std::istreambuf_iterator<char>(file)),
+                              std::istreambuf_iterator<char>());
+}
+
+int main(int argc, char *argv[]) {
+  auto wasm = read("../wasm/code-functions.wasm");
+  Context context = Context();
+  std::string tmp = "Testing";
+
+  // A lambda can be used as a host function
+  auto hello_world = [&tmp](CurrentPlugin plugin,
+                            const std::vector<Val> &inputs,
+                            std::vector<Val> &outputs, void *user_data) {
+    std::cout << "Hello from C++" << std::endl;
+    std::cout << (const char *)user_data << std::endl;
+    std::cout << tmp << std::endl;
+    outputs[0].v = inputs[0].v;
+  };
+
+  std::vector<Function> functions = {
+      Function("hello_world", {ValType::I64}, {ValType::I64}, hello_world,
+               (void *)"Hello again!",
+               [](void *x) { std::cout << "Free user data" << std::endl; }),
+  };
+
+  Plugin plugin = context.plugin(wasm, true, functions);
+
+  const char *input = argc > 1 ? argv[1] : "this is a test";
+  ExtismSize length = strlen(input);
+
+  extism::Buffer output = plugin.call("count_vowels", (uint8_t *)input, length);
+  std::cout << (char *)output.data << std::endl;
+  return 0;
+}

cpp/extism.hpp

@@ -0,0 +1,501 @@
+#pragma once
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#ifndef EXTISM_NO_JSON
+#if __has_include(<jsoncpp/json/json.h>)
+#include <jsoncpp/json/json.h>
+#else
+#include <json/json.h>
+#endif
+#endif // EXTISM_NO_JSON
+
+extern "C" {
+#include <extism.h>
+}
+
+namespace extism {
+
+typedef std::map<std::string, std::string> Config;
+
+template <typename T> class ManifestKey {
+  bool is_set = false;
+
+public:
+  T value;
+  ManifestKey(T x, bool is_set = false) : is_set(is_set) { value = x; }
+
+  void set(T x) {
+    value = x;
+    is_set = true;
+  }
+
+  bool empty() const { return is_set == false; }
+};
+
+class Wasm {
+  std::string _path;
+  std::string _url;
+  // TODO: add base64 encoded raw data
+  ManifestKey<std::string> _hash =
+      ManifestKey<std::string>(std::string(), false);
+
+public:
+  // Create Wasm pointing to a path
+  static Wasm path(std::string s, std::string hash = std::string()) {
+    Wasm w;
+    w._path = s;
+    if (!hash.empty()) {
+      w._hash.set(hash);
+    }
+    return w;
+  }
+
+  // Create Wasm pointing to a URL
+  static Wasm url(std::string s, std::string hash = std::string()) {
+    Wasm w;
+    w._url = s;
+    if (!hash.empty()) {
+      w._hash.set(hash);
+    }
+    return w;
+  }
+
+#ifndef EXTISM_NO_JSON
+  Json::Value json() const {
+    Json::Value doc;
+
+    if (!this->_path.empty()) {
+      doc["path"] = this->_path;
+    } else if (!this->_url.empty()) {
+      doc["url"] = this->_url;
+    }
+
+    if (!this->_hash.empty()) {
+      doc["hash"] = this->_hash.value;
+    }
+
+    return doc;
+  }
+#endif
+};
+
+class Manifest {
+public:
+  Config config;
+  std::vector<Wasm> wasm;
+  ManifestKey<std::vector<std::string>> allowed_hosts;
+  ManifestKey<std::map<std::string, std::string>> allowed_paths;
+  ManifestKey<uint64_t> timeout_ms;
+
+  // Empty manifest
+  Manifest()
+      : timeout_ms(0, false), allowed_hosts(std::vector<std::string>(), false),
+        allowed_paths(std::map<std::string, std::string>(), false) {}
+
+  // Create manifest with a single Wasm from a path
+  static Manifest path(std::string s, std::string hash = std::string()) {
+    Manifest m;
+    m.add_wasm_path(s, hash);
+    return m;
+  }
+
+  // Create manifest with a single Wasm from a URL
+  static Manifest url(std::string s, std::string hash = std::string()) {
+    Manifest m;
+    m.add_wasm_url(s, hash);
+    return m;
+  }
+
+#ifndef EXTISM_NO_JSON
+  std::string json() const {
+    Json::Value doc;
+    Json::Value wasm;
+    for (auto w : this->wasm) {
+      wasm.append(w.json());
+    }
+
+    doc["wasm"] = wasm;
+
+    if (!this->config.empty()) {
+      Json::Value conf;
+
+      for (auto k : this->config) {
+        conf[k.first] = k.second;
+      }
+      doc["config"] = conf;
+    }
+
+    if (!this->allowed_hosts.empty()) {
+      Json::Value h;
+
+      for (auto s : this->allowed_hosts.value) {
+        h.append(s);
+      }
+      doc["allowed_hosts"] = h;
+    }
+
+    if (!this->allowed_paths.empty()) {
+      Json::Value h;
+      for (auto k : this->allowed_paths.value) {
+        h[k.first] = k.second;
+      }
+      doc["allowed_paths"] = h;
+    }
+
+    if (!this->timeout_ms.empty()) {
+      doc["timeout_ms"] = Json::Value(this->timeout_ms.value);
+    }
+
+    Json::FastWriter writer;
+    return writer.write(doc);
+  }
+#endif
+
+  // Add Wasm from path
+  void add_wasm_path(std::string s, std::string hash = std::string()) {
+    Wasm w = Wasm::path(s, hash);
+    this->wasm.push_back(w);
+  }
+
+  // Add Wasm from URL
+  void add_wasm_url(std::string u, std::string hash = std::string()) {
+    Wasm w = Wasm::url(u, hash);
+    this->wasm.push_back(w);
+  }
+
+  // Add host to allowed hosts
+  void allow_host(std::string host) {
+    if (this->allowed_hosts.empty()) {
+      this->allowed_hosts.set(std::vector<std::string>{});
+    }
+    this->allowed_hosts.value.push_back(host);
+  }
+
+  // Add path to allowed paths
+  void allow_path(std::string src, std::string dest = std::string()) {
+    if (this->allowed_paths.empty()) {
+      this->allowed_paths.set(std::map<std::string, std::string>{});
+    }
+
+    if (dest.empty()) {
+      dest = src;
+    }
+    this->allowed_paths.value[src] = dest;
+  }
+
+  // Set timeout
+  void set_timeout_ms(uint64_t ms) { this->timeout_ms = ms; }
+
+  // Set config key/value
+  void set_config(std::string k, std::string v) { this->config[k] = v; }
+};
+
+class Error : public std::runtime_error {
+public:
+  Error(std::string msg) : std::runtime_error(msg) {}
+};
+
+class Buffer {
+public:
+  Buffer(const uint8_t *ptr, ExtismSize len) : data(ptr), length(len) {}
+  const uint8_t *data;
+  ExtismSize length;
+
+  std::string string() { return (std::string)(*this); }
+
+  std::vector<uint8_t> vector() { return (std::vector<uint8_t>)(*this); }
+
+  operator std::string() { return std::string((const char *)data, length); }
+  operator std::vector<uint8_t>() {
+    return std::vector<uint8_t>(data, data + length);
+  }
+};
+
+typedef ExtismValType ValType;
+typedef ExtismValUnion ValUnion;
+typedef ExtismVal Val;
+
+class CurrentPlugin {
+  ExtismCurrentPlugin *pointer;
+
+public:
+  CurrentPlugin(ExtismCurrentPlugin *p) : pointer(p) {}
+
+  uint8_t *memory() { return extism_current_plugin_memory(this->pointer); }
+  ExtismSize memory_length(uint64_t offs) {
+    return extism_current_plugin_memory_length(this->pointer, offs);
+  }
+
+  uint64_t alloc(ExtismSize size) {
+    return extism_current_plugin_memory_alloc(this->pointer, size);
+  }
+
+  void free(uint64_t offs) {
+    extism_current_plugin_memory_free(this->pointer, offs);
+  }
+};
+
+typedef std::function<void(CurrentPlugin, const std::vector<Val> &,
+                           std::vector<Val> &, void *user_data)>
+    FunctionType;
+
+struct UserData {
+  FunctionType func;
+  void *user_data = NULL;
+  std::function<void(void *)> free_user_data;
+};
+
+static void function_callback(ExtismCurrentPlugin *plugin,
+                              const ExtismVal *inputs, ExtismSize n_inputs,
+                              ExtismVal *outputs, ExtismSize n_outputs,
+                              void *user_data) {
+  UserData *data = (UserData *)user_data;
+  const std::vector<Val> inp(inputs, inputs + n_inputs);
+  std::vector<Val> outp(outputs, outputs + n_outputs);
+  data->func(CurrentPlugin(plugin), inp, outp, data->user_data);
+
+  for (ExtismSize i = 0; i < n_outputs; i++) {
+    outputs[i] = outp[i];
+  }
+}
+
+static void free_user_data(void *user_data) {
+  UserData *data = (UserData *)user_data;
+  if (data->user_data != NULL && data->free_user_data != NULL) {
+    data->free_user_data(data->user_data);
+  }
+}
+
+class Function {
+  std::shared_ptr<ExtismFunction> func;
+  std::string name;
+  UserData user_data;
+
+public:
+  Function(std::string name, const std::vector<ValType> inputs,
+           const std::vector<ValType> outputs, FunctionType f,
+           void *user_data = NULL, std::function<void(void *)> free = nullptr)
+      : name(name) {
+    this->user_data.func = f;
+    this->user_data.user_data = user_data;
+    this->user_data.free_user_data = free;
+    auto ptr = extism_function_new(
+        this->name.c_str(), inputs.data(), inputs.size(), outputs.data(),
+        outputs.size(), function_callback, &this->user_data, free_user_data);
+    this->func = std::shared_ptr<ExtismFunction>(ptr, extism_function_free);
+  }
+
+  Function(const Function &f) { this->func = f.func; }
+
+  ExtismFunction *get() { return this->func.get(); }
+};
+
+class Plugin {
+  std::shared_ptr<ExtismContext> context;
+  ExtismPlugin plugin;
+  std::vector<Function> functions;
+
+public:
+  // Create a new plugin
+  Plugin(std::shared_ptr<ExtismContext> ctx, const uint8_t *wasm,
+         ExtismSize length, bool with_wasi = false,
+         std::vector<Function> functions = std::vector<Function>())
+      : functions(functions) {
+    std::vector<const ExtismFunction *> ptrs;
+    for (auto i : this->functions) {
+      ptrs.push_back(i.get());
+    }
+    this->plugin = extism_plugin_new(ctx.get(), wasm, length, ptrs.data(),
+                                     ptrs.size(), with_wasi);
+    if (this->plugin < 0) {
+      const char *err = extism_error(ctx.get(), -1);
+      throw Error(err == nullptr ? "Unable to load plugin" : err);
+    }
+    this->context = ctx;
+  }
+
+#ifndef EXTISM_NO_JSON
+  // Create a new plugin from Manifest
+  Plugin(std::shared_ptr<ExtismContext> ctx, const Manifest &manifest,
+         bool with_wasi = false, std::vector<Function> functions = {}) {
+    std::vector<const ExtismFunction *> ptrs;
+    for (auto i : this->functions) {
+      ptrs.push_back(i.get());
+    }
+
+    auto buffer = manifest.json();
+    this->plugin =
+        extism_plugin_new(ctx.get(), (const uint8_t *)buffer.c_str(),
+                          buffer.size(), ptrs.data(), ptrs.size(), with_wasi);
+    if (this->plugin < 0) {
+      const char *err = extism_error(ctx.get(), -1);
+      throw Error(err == nullptr ? "Unable to load plugin from manifest" : err);
+    }
+    this->context = ctx;
+  }
+#endif
+
+  ~Plugin() {
+    extism_plugin_free(this->context.get(), this->plugin);
+    this->plugin = -1;
+  }
+
+  ExtismPlugin id() const { return this->plugin; }
+
+  ExtismContext *get_context() const { return this->context.get(); }
+
+  void update(const uint8_t *wasm, size_t length, bool with_wasi = false,
+              std::vector<Function> functions = {}) {
+    this->functions = functions;
+    std::vector<const ExtismFunction *> ptrs;
+    for (auto i : this->functions) {
+      ptrs.push_back(i.get());
+    }
+    bool b = extism_plugin_update(this->context.get(), this->plugin, wasm,
+                                  length, ptrs.data(), ptrs.size(), with_wasi);
+    if (!b) {
+      const char *err = extism_error(this->context.get(), -1);
+      throw Error(err == nullptr ? "Unable to update plugin" : err);
+    }
+  }
+
+#ifndef EXTISM_NO_JSON
+  void update(const Manifest &manifest, bool with_wasi = false,
+              std::vector<Function> functions = {}) {
+    this->functions = functions;
+    std::vector<const ExtismFunction *> ptrs;
+    for (auto i : this->functions) {
+      ptrs.push_back(i.get());
+    }
+    auto buffer = manifest.json();
+    bool b = extism_plugin_update(
+        this->context.get(), this->plugin, (const uint8_t *)buffer.c_str(),
+        buffer.size(), ptrs.data(), ptrs.size(), with_wasi);
+    if (!b) {
+      const char *err = extism_error(this->context.get(), -1);
+      throw Error(err == nullptr ? "Unable to update plugin" : err);
+    }
+  }
+
+  void config(const Config &data) {
+    Json::Value conf;
+
+    for (auto k : data) {
+      conf[k.first] = k.second;
+    }
+
+    Json::FastWriter writer;
+    auto s = writer.write(conf);
+    this->config(s);
+  }
+#endif
+
+  void config(const char *json, size_t length) {
+    bool b = extism_plugin_config(this->context.get(), this->plugin,
+                                  (const uint8_t *)json, length);
+    if (!b) {
+      const char *err = extism_error(this->context.get(), this->plugin);
+      throw Error(err == nullptr ? "Unable to update plugin config" : err);
+    }
+  }
+
+  void config(const std::string &json) {
+    this->config(json.c_str(), json.size());
+  }
+
+  // Call a plugin
+  Buffer call(const std::string &func, const uint8_t *input,
+              ExtismSize input_length) const {
+    int32_t rc = extism_plugin_call(this->context.get(), this->plugin,
+                                    func.c_str(), input, input_length);
+    if (rc != 0) {
+      const char *error = extism_error(this->context.get(), this->plugin);
+      if (error == nullptr) {
+        throw Error("extism_call failed");
+      }
+
+      throw Error(error);
+    }
+
+    ExtismSize length =
+        extism_plugin_output_length(this->context.get(), this->plugin);
+    const uint8_t *ptr =
+        extism_plugin_output_data(this->context.get(), this->plugin);
+    return Buffer(ptr, length);
+  }
+
+  // Call a plugin function with std::vector<uint8_t> input
+  Buffer call(const std::string &func,
+              const std::vector<uint8_t> &input) const {
+    return this->call(func, input.data(), input.size());
+  }
+
+  // Call a plugin function with string input
+  Buffer call(const std::string &func,
+              const std::string &input = std::string()) const {
+    return this->call(func, (const uint8_t *)input.c_str(), input.size());
+  }
+
+  // Returns true if the specified function exists
+  bool function_exists(const std::string &func) const {
+    return extism_plugin_function_exists(this->context.get(), this->plugin,
+                                         func.c_str());
+  }
+};
+
+class Context {
+public:
+  std::shared_ptr<ExtismContext> pointer;
+
+  // Create a new context;
+  Context() {
+    this->pointer = std::shared_ptr<ExtismContext>(extism_context_new(),
+                                                   extism_context_free);
+  }
+
+  // Create plugin from uint8_t*
+  Plugin plugin(const uint8_t *wasm, size_t length, bool with_wasi = false,
+                std::vector<Function> functions = {}) const {
+    return Plugin(this->pointer, wasm, length, with_wasi, functions);
+  }
+
+  // Create plugin from std::string
+  Plugin plugin(const std::string &str, bool with_wasi = false,
+                std::vector<Function> functions = {}) const {
+    return Plugin(this->pointer, (const uint8_t *)str.c_str(), str.size(),
+                  with_wasi, functions);
+  }
+
+  // Create plugin from uint8_t vector
+  Plugin plugin(const std::vector<uint8_t> &data, bool with_wasi = false,
+                std::vector<Function> functions = {}) const {
+    return Plugin(this->pointer, data.data(), data.size(), with_wasi,
+                  functions);
+  }
+
+#ifndef EXTISM_NO_JSON
+  // Create plugin from Manifest
+  Plugin plugin(const Manifest &manifest, bool with_wasi = false,
+                std::vector<Function> functions = {}) const {
+    return Plugin(this->pointer, manifest, with_wasi, functions);
+  }
+#endif
+
+  // Remove all plugins
+  void reset() { extism_context_reset(this->pointer.get()); }
+};
+
+// Set global log file for plugins
+inline bool set_log_file(const char *filename, const char *level) {
+  return extism_log_file(filename, level);
+}
+
+// Get libextism version
+inline std::string version() { return std::string(extism_version()); }
+} // namespace extism

cpp/test/test.cpp

@@ -0,0 +1,73 @@
+#include "../extism.hpp"
+
+#include <fstream>
+
+#include <gtest/gtest.h>
+
+std::vector<uint8_t> read(const char *filename) {
+  std::ifstream file(filename, std::ios::binary);
+  return std::vector<uint8_t>((std::istreambuf_iterator<char>(file)),
+                              std::istreambuf_iterator<char>());
+}
+
+namespace {
+using namespace extism;
+
+TEST(Context, Basic) {
+  Context context;
+  ASSERT_NE(context.pointer, nullptr);
+}
+
+TEST(Plugin, Manifest) {
+  Context context;
+  Manifest manifest = Manifest::path("code.wasm");
+  manifest.set_config("a", "1");
+
+  ASSERT_NO_THROW(Plugin plugin = context.plugin(manifest));
+  Plugin plugin = context.plugin(manifest);
+
+  Buffer buf = plugin.call("count_vowels", "this is a test");
+  ASSERT_EQ((std::string)buf, "{\"count\": 4}");
+}
+
+TEST(Plugin, BadManifest) {
+  Context context;
+  Manifest manifest;
+  ASSERT_THROW(Plugin plugin = context.plugin(manifest), Error);
+}
+
+TEST(Plugin, Bytes) {
+  Context context;
+  auto wasm = read("code.wasm");
+  ASSERT_NO_THROW(Plugin plugin = context.plugin(wasm));
+  Plugin plugin = context.plugin(wasm);
+
+  Buffer buf = plugin.call("count_vowels", "this is another test");
+  ASSERT_EQ(buf.string(), "{\"count\": 6}");
+}
+
+TEST(Plugin, UpdateConfig) {
+  Context context;
+  auto wasm = read("code.wasm");
+  Plugin plugin = context.plugin(wasm);
+
+  Config config;
+  config["abc"] = "123";
+  ASSERT_NO_THROW(plugin.config(config));
+}
+
+TEST(Plugin, FunctionExists) {
+  Context context;
+  auto wasm = read("code.wasm");
+  Plugin plugin = context.plugin(wasm);
+
+  ASSERT_FALSE(plugin.function_exists("bad_function"));
+  ASSERT_TRUE(plugin.function_exists("count_vowels"));
+}
+
+}; // namespace
+
+int main(int argc, char **argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}

dotnet/.gitignore

@@ -1,10 +1,7 @@
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
 ##
-## Get latest from `dotnet new gitignore`
-
-# dotenv files
-.env
+## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore
 
 # User-specific files
 *.rsuser
@@ -402,7 +399,6 @@ FodyWeavers.xsd
 
 # JetBrains Rider
 *.sln.iml
-.idea
 
 ##
 ## Visual studio for Mac
@@ -480,5 +476,4 @@ $RECYCLE.BIN/
 # Windows shortcuts
 *.lnk
 
-# Vim temporary swap files
-*.swp
+nuget/runtimes/win-x64.dll

dotnet/Extism.sln

@@ -0,0 +1,37 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.4.33110.190
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Extism.Sdk", "src\Extism.Sdk\Extism.Sdk.csproj", "{1FAA7B6E-249C-4E4C-AE7A-A493A9D24475}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Extism.Sdk.Tests", "test\Extism.Sdk\Extism.Sdk.Tests.csproj", "{DB440D61-C781-4C59-9223-9A79CC9FB4E7}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Extism.Sdk.Sample", "samples\Extism.Sdk.Sample\Extism.Sdk.Sample.csproj", "{2232E572-E8BA-46A1-AF31-E4168960DB75}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1FAA7B6E-249C-4E4C-AE7A-A493A9D24475}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1FAA7B6E-249C-4E4C-AE7A-A493A9D24475}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1FAA7B6E-249C-4E4C-AE7A-A493A9D24475}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1FAA7B6E-249C-4E4C-AE7A-A493A9D24475}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DB440D61-C781-4C59-9223-9A79CC9FB4E7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DB440D61-C781-4C59-9223-9A79CC9FB4E7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DB440D61-C781-4C59-9223-9A79CC9FB4E7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DB440D61-C781-4C59-9223-9A79CC9FB4E7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2232E572-E8BA-46A1-AF31-E4168960DB75}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2232E572-E8BA-46A1-AF31-E4168960DB75}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2232E572-E8BA-46A1-AF31-E4168960DB75}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2232E572-E8BA-46A1-AF31-E4168960DB75}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {2B6BF267-F2A5-4CB5-8DFD-F11CC8787E6B}
+	EndGlobalSection
+EndGlobal

dotnet/nuget/Extism.runtime.win.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+        <NoBuild>true</NoBuild>
+        <IncludeBuildOutput>false</IncludeBuildOutput>
+    </PropertyGroup>
+
+    <PropertyGroup>
+        <PackageId>Extism.runtime.win-x64</PackageId>
+        <Version>0.2.0</Version>
+        <Authors>Extism Contributors</Authors>
+        <Description>Internal implementation package for Extism to work on Windows x64</Description>
+        <Tags>extism, wasm, plugin</Tags>
+        <PackageLicenseExpression>BSD-3-Clause</PackageLicenseExpression>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Content Include="runtimes/win-x64.dll"
+            CopyToOutputDirectory="Always"
+            Pack="true"
+            PackagePath="runtimes\win-x64\native\extism.dll" />
+    </ItemGroup>
+</Project>

dotnet/nuget/runtimes/expected.txt

@@ -0,0 +1 @@
+win-x64.dll

dotnet/samples/Extism.Sdk.Sample/Extism.Sdk.Sample.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="..\..\..\wasm\code.wasm" Link="code.wasm">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Extism.Sdk\Extism.Sdk.csproj" />
+  </ItemGroup>
+
+
+</Project>

dotnet/samples/Extism.Sdk.Sample/Program.cs

@@ -0,0 +1,11 @@
+using Extism.Sdk.Native;
+using System.Text;
+
+var context = new Context();
+var wasm = await File.ReadAllBytesAsync("./code.wasm");
+using var plugin = context.CreatePlugin(wasm, withWasi: true);
+
+var output = Encoding.UTF8.GetString(
+    plugin.CallFunction("count_vowels", Encoding.UTF8.GetBytes("Hello World!"))
+);
+Console.WriteLine(output); // prints {"count": 3}

dotnet/samples/Extism.Sdk.Sample/README.md

@@ -0,0 +1,5 @@
+## Example 1
+
+This example shows how you can use the library in the most basic way. 
+It loads up the sample wasm plugin and lets you to pass inputs to it and show the ouput. 
+**Please note that on Windows you have to manually copy the `extism.dll` file to the ouput directory.**

dotnet/src/Directory.build.props

@@ -0,0 +1,24 @@
+<!-- Recommended practices for publishing nuget packages from: https://devblogs.microsoft.com/dotnet/producing-packages-with-source-link/ -->
+
+<Project>
+    <PropertyGroup>
+        <!-- Publish the repository URL in the built .nupkg (in the NuSpec <Repository> element) -->
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+
+        <!-- Embed source files that are not tracked by the source control manager in the PDB -->
+        <EmbedUntrackedSources>true</EmbedUntrackedSources>
+
+        <!-- Recommended: Embed symbols containing Source Link in the main file (exe/dll) -->
+        <DebugType>embedded</DebugType>
+
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    </PropertyGroup>
+
+    <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
+        <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+    </ItemGroup>
+</Project>

dotnet/src/Extism.Sdk/Context.cs

@@ -0,0 +1,184 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace Extism.Sdk.Native;
+
+/// <summary>
+/// Represents an Extism context through which you can load <see cref="Plugin"/>s.
+/// </summary>
+public class Context : IDisposable
+{
+    private const int DisposedMarker = 1;
+
+    private int _disposed;
+
+    /// <summary>
+    /// Initialize a new Extism Context.
+    /// </summary>
+    public Context()
+    {
+        NativeHandle = LibExtism.extism_context_new();
+    }
+
+    /// <summary>
+    /// Native pointer to the Extism Context.
+    /// </summary>
+    internal IntPtr NativeHandle { get; }
+
+    /// <summary>
+    /// Loads an Extism <see cref="Plugin"/>.
+    /// </summary>
+    /// <param name="wasm">A WASM module (wat or wasm) or a JSON encoded manifest.</param>
+    /// <param name="withWasi">Enable/Disable WASI.</param>
+    public Plugin CreatePlugin(ReadOnlySpan<byte> wasm, bool withWasi)
+    {
+        CheckNotDisposed();
+
+        unsafe
+        {
+            fixed (byte* wasmPtr = wasm)
+            {
+                var plugin = LibExtism.extism_plugin_new(NativeHandle, wasmPtr, wasm.Length, null, 0, withWasi);
+                return new Plugin(this, plugin);
+            }
+        }
+    }
+
+    /// <summary>
+    /// Remove all plugins from this <see cref="Context"/>'s registry.
+    /// </summary>
+    public void Reset()
+    {
+        CheckNotDisposed();
+
+        LibExtism.extism_context_reset(NativeHandle);
+    }
+
+    /// <summary>
+    /// Get this this <see cref="Context"/>'s last error.
+    /// </summary>
+    /// <returns></returns>
+    internal string? GetError()
+    {
+        CheckNotDisposed();
+
+        var result = LibExtism.extism_error(NativeHandle, -1);
+        return Marshal.PtrToStringUTF8(result);
+    }
+
+    /// <summary>
+    /// Frees all resources held by this Context.
+    /// </summary>
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref _disposed, DisposedMarker) == DisposedMarker)
+        {
+            // Already disposed.
+            return;
+        }
+
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Throw an appropriate exception if the plugin has been disposed.
+    /// </summary>
+    /// <exception cref="ObjectDisposedException"></exception>
+    protected void CheckNotDisposed()
+    {
+        Interlocked.MemoryBarrier();
+        if (_disposed == DisposedMarker)
+        {
+            ThrowDisposedException();
+        }
+    }
+
+    [DoesNotReturn]
+    private static void ThrowDisposedException()
+    {
+        throw new ObjectDisposedException(nameof(Context));
+    }
+
+    /// <summary>
+    /// Frees all resources held by this Context.
+    /// </summary>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            // Free up any managed resources here
+        }
+
+        // Free up unmanaged resources
+        LibExtism.extism_context_free(NativeHandle);
+    }
+
+    /// <summary>
+    /// Destructs the current Context and frees all resources used by it.
+    /// </summary>
+    ~Context()
+    {
+        Dispose(false);
+    }
+
+    /// <summary>
+    /// Get the Extism version string.
+    /// </summary>
+    public static string GetExtismVersion()
+    {
+        var pointer = LibExtism.extism_version();
+        return Marshal.PtrToStringUTF8(pointer);
+    }
+
+    /// <summary>
+    /// Set Extism's log file and level. This is applied for all <see cref="Context"/>s.
+    /// </summary>
+    /// <param name="logPath">Log file; can be 'stdout' or 'stderr' to write logs to the console.</param>
+    /// <param name="level">The log level to write at.</param>
+    public static bool SetExtismLogFile(string logPath, LogLevel level)
+    {
+        var logLevel = level switch
+        {
+            LogLevel.Error => LibExtism.LogLevels.Error,
+            LogLevel.Warning => LibExtism.LogLevels.Warn,
+            LogLevel.Info => LibExtism.LogLevels.Info,
+            LogLevel.Debug => LibExtism.LogLevels.Debug,
+            LogLevel.Trace => LibExtism.LogLevels.Trace,
+            _ => throw new NotImplementedException(),
+        };
+
+        return LibExtism.extism_log_file(logPath, logLevel);
+    }
+}
+
+/// <summary>
+/// Extism Log Levels
+/// </summary>
+public enum LogLevel
+{
+    /// <summary>
+    /// Designates very serious errors.
+    /// </summary>
+    Error,
+
+    /// <summary>
+    /// Designates hazardous situations.
+    /// </summary>
+    Warning,
+
+    /// <summary>
+    /// Designates useful information.
+    /// </summary>
+    Info,
+
+    /// <summary>
+    /// Designates lower priority information.
+    /// </summary>
+    Debug,
+
+    /// <summary>
+    /// Designates very low priority, often extremely verbose, information.
+    /// </summary>
+    Trace
+}

dotnet/src/Extism.Sdk/Exception.cs

@@ -0,0 +1,40 @@
+namespace Extism.Sdk.Native;
+
+using System;
+
+/// <summary>
+/// Represents errors that occur during calling Extism functions.
+/// </summary>
+public class ExtismException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExtismException"/> class.
+    /// </summary>
+    public ExtismException()
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExtismException"/> class with a specified error message.
+    /// </summary>
+    /// <param name="message">The message that describes the error .</param>
+    public ExtismException(string message)
+        : base(message)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ExtismException"/> class
+    /// with a specified error message and a reference to the inner exception
+    /// that is the cause of this exception.
+    /// </summary>
+    /// <param name="message">The message that describes the error .</param>
+    /// <param name="innerException">
+    ///  The exception that is the cause of the current exception, or a null reference
+    ///  (Nothing in Visual Basic) if no inner exception is specified.
+    /// </param>
+    public ExtismException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+}

dotnet/src/Extism.Sdk/Extism.Sdk.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>netstandard2.1</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+		<LangVersion>10</LangVersion>
+	</PropertyGroup>
+
+	<PropertyGroup>
+		<PackageId>Extism.Sdk</PackageId>
+		<Version>0.2.0</Version>
+		<Authors>Extism Contributors</Authors>
+		<Description>Extism SDK that allows hosting Extism plugins in .NET apps.</Description>
+		<Tags>extism, wasm, plugin</Tags>
+		<PackageLicenseExpression>BSD-3-Clause</PackageLicenseExpression>
+		<PackageReadmeFile>README.md</PackageReadmeFile>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<None Include="README.md" Pack="true" PackagePath="\"/>
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+	</ItemGroup>
+</Project>

dotnet/src/Extism.Sdk/LibExtism.cs

@@ -0,0 +1,174 @@
+using System.Runtime.InteropServices;
+
+namespace Extism.Sdk.Native;
+
+/// <summary>
+/// Functions exposed by the native Extism library.
+/// </summary>
+internal static class LibExtism
+{
+    /// <summary>
+    /// Create a new context.
+    /// </summary>
+    /// <returns>A pointer to the newly created context.</returns>
+    [DllImport("extism")]
+    public static extern IntPtr extism_context_new();
+
+    /// <summary>
+    /// Remove a context from the registry and free associated memory.
+    /// </summary>
+    /// <param name="context"></param>
+    [DllImport("extism")]
+    public static extern void extism_context_free(IntPtr context);
+
+    /// <summary>
+    /// Load a WASM plugin.
+    /// </summary>
+    /// <param name="context">Pointer to the context the plugin will be associated with.</param>
+    /// <param name="wasm">A WASM module (wat or wasm) or a JSON encoded manifest.</param>
+    /// <param name="wasmSize">The length of the `wasm` parameter.</param>
+    /// <param name="functions">Array of host function pointers.</param>
+    /// <param name="nFunctions">Number of host functions.</param>
+    /// <param name="withWasi">Enables/disables WASI.</param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe public static extern IntPtr extism_plugin_new(IntPtr context, byte* wasm, int wasmSize, IntPtr *functions, int nFunctions, bool withWasi);
+
+    /// <summary>
+    /// Update a plugin, keeping the existing ID.
+    /// Similar to <see cref="extism_plugin_new"/> but takes an `plugin` argument to specify which plugin to update.
+    /// Memory for this plugin will be reset upon update.
+    /// </summary>
+    /// <param name="context">Pointer to the context the plugin is associated with.</param>
+    /// <param name="plugin">Pointer to the plugin you want to update.</param>
+    /// <param name="wasm">A WASM module (wat or wasm) or a JSON encoded manifest.</param>
+    /// <param name="wasmLength">The length of the `wasm` parameter.</param>
+    /// <param name="functions">Array of host function pointers.</param>
+    /// <param name="nFunctions">Number of host functions.</param>
+    /// <param name="withWasi">Enables/disables WASI.</param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe public static extern bool extism_plugin_update(IntPtr context, IntPtr plugin, byte* wasm, int wasmLength, IntPtr *functions, int nFunctions, bool withWasi);
+
+    /// <summary>
+    /// Remove a plugin from the registry and free associated memory.
+    /// </summary>
+    /// <param name="context">Pointer to the context the plugin is associated with.</param>
+    /// <param name="plugin">Pointer to the plugin you want to free.</param>
+    [DllImport("extism")]
+    public static extern void extism_plugin_free(IntPtr context, IntPtr plugin);
+
+    /// <summary>
+    /// Remove all plugins from the registry.
+    /// </summary>
+    /// <param name="context"></param>
+    [DllImport("extism")]
+    public static extern void extism_context_reset(IntPtr context);
+
+    /// <summary>
+    /// Update plugin config values, this will merge with the existing values.
+    /// </summary>
+    /// <param name="context">Pointer to the context the plugin is associated with.</param>
+    /// <param name="plugin">Pointer to the plugin you want to update the configurations for.</param>
+    /// <param name="json">The configuration JSON encoded in UTF8.</param>
+    /// <param name="jsonLength">The length of the `json` parameter.</param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe public static extern bool extism_plugin_config(IntPtr context, IntPtr plugin, byte* json, int jsonLength);
+
+    /// <summary>
+    /// Returns true if funcName exists.
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="plugin"></param>
+    /// <param name="funcName"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    public static extern bool extism_plugin_function_exists(IntPtr context, IntPtr plugin, string funcName);
+
+    /// <summary>
+    /// Call a function.
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="plugin"></param>
+    /// <param name="funcName">The function to call.</param>
+    /// <param name="data">Input data.</param>
+    /// <param name="dataLen">The length of the `data` parameter.</param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe public static extern int extism_plugin_call(IntPtr context, IntPtr plugin, string funcName, byte* data, int dataLen);
+
+    /// <summary>
+    /// Get the error associated with a Context or Plugin, if plugin is -1 then the context error will be returned.
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="plugin">A plugin pointer, or -1 for the context error.</param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    public static extern IntPtr extism_error(IntPtr context, nint plugin);
+
+    /// <summary>
+    /// Get the length of a plugin's output data.
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="plugin"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    public static extern long extism_plugin_output_length(IntPtr context, IntPtr plugin);
+
+    /// <summary>
+    /// Get the plugin's output data.
+    /// </summary>
+    /// <param name="context"></param>
+    /// <param name="plugin"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    public static extern IntPtr extism_plugin_output_data(IntPtr context, IntPtr plugin);
+
+    /// <summary>
+    /// Set log file and level.
+    /// </summary>
+    /// <param name="filename"></param>
+    /// <param name="logLevel"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    public static extern bool extism_log_file(string filename, string logLevel);
+
+    /// <summary>
+    /// Get the Extism version string.
+    /// </summary>
+    /// <returns></returns>
+    [DllImport("extism", EntryPoint = "extism_version")]
+    public static extern IntPtr extism_version();
+
+    /// <summary>
+    /// Extism Log Levels
+    /// </summary>
+    public static class LogLevels
+    {
+        /// <summary>
+        /// Designates very serious errors.
+        /// </summary>
+        public const string Error = "Error";
+
+        /// <summary>
+        /// Designates hazardous situations.
+        /// </summary>
+        public const string Warn = "Warn";
+
+        /// <summary>
+        /// Designates useful information.
+        /// </summary>
+        public const string Info = "Info";
+
+        /// <summary>
+        /// Designates lower priority information.
+        /// </summary>
+        public const string Debug = "Debug";
+
+        /// <summary>
+        /// Designates very low priority, often extremely verbose, information.
+        /// </summary>
+        public const string Trace = "Trace";
+    }
+}

dotnet/src/Extism.Sdk/Plugin.cs

@@ -0,0 +1,189 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+
+namespace Extism.Sdk.Native;
+
+/// <summary>
+/// Represents a WASM Extism plugin.
+/// </summary>
+public class Plugin : IDisposable
+{
+    private const int DisposedMarker = 1;
+
+    private readonly Context _context;
+    private int _disposed;
+
+    internal Plugin(Context context, IntPtr handle)
+    {
+        _context = context;
+        NativeHandle = handle;
+    }
+
+    /// <summary>
+    /// A pointer to the native Plugin struct.
+    /// </summary>
+    internal IntPtr NativeHandle { get; }
+
+    /// <summary>
+    /// Update a plugin, keeping the existing ID.
+    /// </summary>
+    /// <param name="wasm">The plugin WASM bytes.</param>
+    /// <param name="withWasi">Enable/Disable WASI.</param>
+    unsafe public bool Update(ReadOnlySpan<byte> wasm, bool withWasi)
+    {
+        CheckNotDisposed();
+
+        fixed (byte* wasmPtr = wasm)
+        {
+            return LibExtism.extism_plugin_update(_context.NativeHandle, NativeHandle, wasmPtr, wasm.Length, null, 0, withWasi);
+        }
+    }
+
+    /// <summary>
+    ///  Update plugin config values, this will merge with the existing values.
+    /// </summary>
+    /// <param name="json">The configuration JSON encoded in UTF8.</param>
+    unsafe public bool SetConfig(ReadOnlySpan<byte> json)
+    {
+        CheckNotDisposed();
+
+        fixed (byte* jsonPtr = json)
+        {
+            return LibExtism.extism_plugin_config(_context.NativeHandle, NativeHandle, jsonPtr, json.Length);
+        }
+    }
+
+    /// <summary>
+    /// Checks if a specific function exists in the current plugin.
+    /// </summary>
+    public bool FunctionExists(string name)
+    {
+        CheckNotDisposed();
+
+        return LibExtism.extism_plugin_function_exists(_context.NativeHandle, NativeHandle, name);
+    }
+
+    /// <summary>
+    /// Calls a function in the current plugin and returns a status.
+    /// If the status represents an error, call <see cref="GetError"/> to get the error.
+    /// Othewise, call <see cref="OutputData"/> to get the function's output data.
+    /// </summary>
+    /// <param name="functionName">Name of the function in the plugin to invoke.</param>
+    /// <param name="data">A buffer to provide as input to the function.</param>
+    /// <returns>The exit code of the function.</returns>
+    /// <exception cref="ExtismException"></exception>
+    unsafe public ReadOnlySpan<byte> CallFunction(string functionName, ReadOnlySpan<byte> data)
+    {
+        CheckNotDisposed();
+
+        fixed (byte* dataPtr = data)
+        {
+            int response = LibExtism.extism_plugin_call(_context.NativeHandle, NativeHandle, functionName, dataPtr, data.Length);
+            if (response == 0) {
+                return OutputData();
+            } else {
+                var errorMsg = GetError();
+                if (errorMsg != null) {
+                    throw new ExtismException(errorMsg);
+                } else {
+                    throw new ExtismException("Call to Extism failed");
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Get the length of a plugin's output data.
+    /// </summary>
+    /// <returns></returns>
+    internal int OutputLength()
+    {
+        CheckNotDisposed();
+
+        return (int)LibExtism.extism_plugin_output_length(_context.NativeHandle, NativeHandle);
+    }
+
+    /// <summary>
+    /// Get the plugin's output data.
+    /// </summary>
+    internal ReadOnlySpan<byte> OutputData()
+    {
+        CheckNotDisposed();
+
+        var length = OutputLength();
+
+        unsafe
+        {
+            var ptr = LibExtism.extism_plugin_output_data(_context.NativeHandle, NativeHandle).ToPointer();
+            return new Span<byte>(ptr, length);
+        }
+    }
+
+    /// <summary>
+    /// Get the error associated with the current plugin.
+    /// </summary>
+    /// <returns></returns>
+    internal string? GetError()
+    {
+        CheckNotDisposed();
+
+        var result = LibExtism.extism_error(_context.NativeHandle, NativeHandle);
+        return Marshal.PtrToStringUTF8(result);
+    }
+
+    /// <summary>
+    /// Frees all resources held by this Plugin.
+    /// </summary>
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref _disposed, DisposedMarker) == DisposedMarker)
+        {
+            // Already disposed.
+            return;
+        }
+
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// Throw an appropriate exception if the plugin has been disposed.
+    /// </summary>
+    /// <exception cref="ObjectDisposedException"></exception>
+    protected void CheckNotDisposed()
+    {
+        Interlocked.MemoryBarrier();
+        if (_disposed == DisposedMarker)
+        {
+            ThrowDisposedException();
+        }
+    }
+
+    [DoesNotReturn]
+    private static void ThrowDisposedException()
+    {
+        throw new ObjectDisposedException(nameof(Plugin));
+    }
+
+    /// <summary>
+    /// Frees all resources held by this Plugin.
+    /// </summary>
+    protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            // Free up any managed resources here
+        }
+
+        // Free up unmanaged resources
+        LibExtism.extism_plugin_free(_context.NativeHandle, NativeHandle);
+    }
+
+    /// <summary>
+    /// Destructs the current Plugin and frees all resources used by it.
+    /// </summary>
+    ~Plugin()
+    {
+        Dispose(false);
+    }
+}

dotnet/src/Extism.Sdk/README.md

@@ -0,0 +1,2 @@
+## Extism.Sdk
+Extism SDK that allows hosting Extism plugins in .NET apps.

dotnet/test/Extism.Sdk/BasicTests.cs

@@ -0,0 +1,24 @@
+using Extism.Sdk.Native;
+
+using System.Reflection;
+using System.Text;
+
+using Xunit;
+
+namespace Extism.Sdk.Tests;
+
+public class BasicTests
+{
+    [Fact]
+    public void CountHelloWorldVowels()
+    {
+        using var context = new Context();
+
+        var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!;
+        var wasm = File.ReadAllBytes(Path.Combine(binDirectory, "code.wasm"));
+        using var plugin = context.CreatePlugin(wasm, withWasi: true);
+
+        var response = plugin.CallFunction("count_vowels", Encoding.UTF8.GetBytes("Hello World"));
+        Assert.Equal("{\"count\": 3}", Encoding.UTF8.GetString(response));
+    }
+}

dotnet/test/Extism.Sdk/Extism.Sdk.Tests.csproj

@@ -0,0 +1,35 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<TargetFramework>net7.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+
+		<IsPackable>false</IsPackable>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+		<PackageReference Include="xunit" Version="2.4.2" />
+		<PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+			<PrivateAssets>all</PrivateAssets>
+		</PackageReference>
+		<PackageReference Include="coverlet.collector" Version="3.1.2">
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+			<PrivateAssets>all</PrivateAssets>
+		</PackageReference>
+	</ItemGroup>
+
+	<ItemGroup>
+		<None Include="..\..\..\wasm\code.wasm" Link="code.wasm">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</None>
+	</ItemGroup>
+
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\src\Extism.Sdk\Extism.Sdk.csproj" />
+	</ItemGroup>
+
+</Project>

dune

@@ -0,0 +1 @@
+(dirs ocaml)

dune-project

@@ -0,0 +1,46 @@
+(lang dune 3.2)
+
+(name extism)
+
+(generate_opam_files true)
+
+(source
+ (github extism/extism))
+
+(authors "Extism Authors <oss@extism.org>")
+
+(maintainers "Extism Authors <oss@extism.org>")
+
+(license BSD-3-Clause)
+
+(documentation https://github.com/extism/extism)
+
+(package
+ (name extism)
+ (synopsis "Extism bindings")
+ (description "Bindings to Extism, the universal plugin system")
+ (depends 
+  (ocaml (>= 4.14.1)) 
+  (dune (>= 3.2))
+  (ctypes-foreign (>= 0.18.0))
+  (bigstringaf (>= 0.9.0))
+  (ppx_yojson_conv (>= 0.15.0))
+  extism-manifest
+  (ppx_inline_test (>= 0.15.0))
+  (cmdliner (>= 1.1.1))
+ )
+ (tags
+  (topics wasm plugin)))
+
+(package
+ (name extism-manifest)
+ (synopsis "Extism manifest bindings")
+ (description "Bindings to the Extism manifest format")
+ (depends 
+  (ocaml (>= 4.14.1)) 
+  (dune (>= 3.2))
+  (ppx_yojson_conv (>= 0.15.0))
+  (base64 (>= 3.5.0))
+ )
+ (tags
+  (topics wasm plugin)))

elixir/.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

elixir/.gitignore

@@ -0,0 +1,28 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+extism-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/
+
+/priv/

elixir/Makefile

@@ -0,0 +1,27 @@
+.PHONY: test
+
+prepare:
+	mix deps.get
+	mix compile
+
+test: prepare
+	mix test
+
+clean:
+	mix clean
+
+publish: clean prepare
+	mix hex.build
+	mix hex.publish --yes
+
+format:
+	mix format
+
+lint:
+	mix format --check-formatted
+
+docs:
+	mix docs
+
+show-docs: docs
+	open doc/index.html

elixir/README.md

@@ -0,0 +1,73 @@
+# Extism
+
+Extism Host SDK for Elixir and Erlang
+
+## Docs
+
+Read the [docs on hexdocs.pm](https://hexdocs.pm/extism/).
+
+## Installation
+
+You can find this package on [hex.pm](https://hex.pm/packages/extism).
+
+```elixir
+def deps do
+  [
+    {:extism, "~> 0.1.0"}
+  ]
+end
+```
+
+## Getting Started
+
+### Example
+
+```elixir
+# Create a context for which plugins can be allocated and cleaned
+ctx = Extism.Context.new()
+
+# point to some wasm code, this is the count_vowels example that ships with extism
+manifest = %{ wasm: [ %{ path: "/Users/ben/code/extism/wasm/code.wasm" } ]}
+{:ok, plugin} = Extism.Context.new_plugin(ctx, manifest, false)
+# {:ok,
+# %Extism.Plugin{
+#   resource: 0,
+#   reference: #Reference<0.520418104.1263009793.80956>
+# }}
+{:ok, output} = Extism.Plugin.call(plugin, "count_vowels", "this is a test")
+# {:ok, "{\"count\": 4}"}
+{:ok, result} = JSON.decode(output)
+# {:ok, %{"count" => 4}}
+
+# free up the context and any plugins we allocated
+Extism.Context.free(ctx)
+```
+
+### Modules
+
+The two primary modules you should learn are:
+
+* [Extism.Context](Extism.Context.html)
+* [Extism.Plugin](Extism.Plugin.html)
+
+#### Context
+
+The [Context](Extism.Context.html) can be thought of as a session. You need a context to interact with the Extism runtime. The context holds your plugins and when you free the context, it frees your plugins. It's important to free up your context and plugins when you are done with them.
+
+```elixir
+ctx = Extism.Context.new()
+# frees all the plugins 
+Extism.Context.reset(ctx)
+# frees the context and all its plugins
+Extism.Context.free(ctx)
+```
+
+#### Plugin
+
+The [Plugin](Extism.Plugin.html) represents an instance of your WASM program from the given manifest.
+The key method to know here is [Extism.Plugin#call](Extism.Plugin.html#call/3) which takes a function name to invoke and some input data, and returns the results from the plugin.
+
+```elixir
+{:ok, plugin} = Extism.Context.new_plugin(ctx, manifest, false)
+{:ok, output} = Extism.Plugin.call(plugin, "count_vowels", "this is a test")
+```

elixir/lib/extism.ex

@@ -0,0 +1,5 @@
+defmodule Extism do
+  def set_log_file(filepath, level) do
+    Extism.Native.set_log_file(filepath, level)
+  end
+end

elixir/lib/extism/context.ex

@@ -0,0 +1,64 @@
+defmodule Extism.Context do
+  @moduledoc """
+  A Context is needed to create plugins. The Context is where your plugins
+  live. Freeing the context frees all of the plugins in its scope.
+  """
+
+  defstruct [
+    # The actual NIF Resource. A pointer in this case
+    ptr: nil
+  ]
+
+  def wrap_resource(ptr) do
+    %__MODULE__{
+      ptr: ptr
+    }
+  end
+
+  @doc """
+  Creates a new context.
+  """
+  def new() do
+    ptr = Extism.Native.context_new()
+    Extism.Context.wrap_resource(ptr)
+  end
+
+  @doc """
+  Resets the context. This has the effect of freeing all the plugins created so far.
+  """
+  def reset(ctx) do
+    Extism.Native.context_reset(ctx.ptr)
+  end
+
+  @doc """
+  Frees the context from memory and all of its plugins.
+  """
+  def free(ctx) do
+    Extism.Native.context_free(ctx.ptr)
+  end
+
+  @doc """
+  Create a new plugin from a WASM module or manifest
+
+  ## Examples:
+
+      iex> ctx = Extism.Context.new()
+      iex> manifest = %{ wasm: [ %{ path: "/Users/ben/code/extism/wasm/code.wasm" } ]}
+      iex> {:ok, plugin} =  Extism.Context.new_plugin(ctx, manifest, false)
+
+  ## Parameters
+
+    - ctx: The Context to manage this plugin
+    - manifest: The String or Map of the WASM module or [manifest](https://extism.org/docs/concepts/manifest)
+    - wasi: A bool you set to true if you want WASI support
+
+  """
+  def new_plugin(ctx, manifest, wasi \\ false) do
+    {:ok, manifest_payload} = JSON.encode(manifest)
+
+    case Extism.Native.plugin_new_with_manifest(ctx.ptr, manifest_payload, wasi) do
+      {:error, err} -> {:error, err}
+      res -> {:ok, Extism.Plugin.wrap_resource(ctx, res)}
+    end
+  end
+end

elixir/lib/extism/native.ex

@@ -0,0 +1,21 @@
+defmodule Extism.Native do
+  @moduledoc """
+  This module represents the Native Extism runtime API and is for internal use.
+  Do not use or rely on this this module.
+  """
+  use Rustler,
+    otp_app: :extism,
+    crate: :extism_nif
+
+  def context_new(), do: error()
+  def context_reset(_ctx), do: error()
+  def context_free(_ctx), do: error()
+  def plugin_new_with_manifest(_ctx, _manifest, _wasi), do: error()
+  def plugin_call(_ctx, _plugin_id, _name, _input), do: error()
+  def plugin_update_manifest(_ctx, _plugin_id, _manifest, _wasi), do: error()
+  def plugin_has_function(_ctx, _plugin_id, _function_name), do: error()
+  def plugin_free(_ctx, _plugin_id), do: error()
+  def set_log_file(_filename, _level), do: error()
+
+  defp error, do: :erlang.nif_error(:nif_not_loaded)
+end