feat: add support for manifest

.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]
+        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
+          LD_LIBRARY_PATH=/usr/local/lib go test
+          cd go
+          LD_LIBRARY_PATH=/usr/local/lib go run main.go | grep "Hello from Go!"

.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,93 @@
+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
+  LIBEXTISM_CRATE: libextism
+
+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 --release -p ${{ env.RUNTIME_CRATE }}
+      - name: Test all features
+        run: cargo test --all-features --release -p ${{ env.RUNTIME_CRATE }}
+      - name: Test no features
+        run: cargo test --no-default-features --release -p ${{ env.RUNTIME_CRATE }}
+

.github/workflows/ci-zig.yml

@@ -0,0 +1,37 @@
+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]
+        zig_version: ["master"] # eventually use multiple versions once stable
+        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
+        with: 
+          version: ${{ matrix.zig_version }}
+
+      - 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,16 @@
+on:
+  workflow_dispatch:
+
+name: Release Haskell 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,19 @@ jobs:
           override: true
           target: ${{ matrix.target }}
 
-      - name: Release Rust convert-macros 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-macros/${version}/download; then
-            cargo publish --manifest-path convert-macros/Cargo.toml --allow-dirty
-          else
-            echo "already published ${version}"
-          fi
-
-      - 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
+          # order of crate publication matter: manifest, runtime, rust
+          cargo publish --manifest-path manifest/Cargo.toml
+          # allow for crates.io to update so dependant crates can locate extism-manifest
+          sleep 10 
 
       - 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
+      
+  

.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
@@ -43,9 +41,4 @@ 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.26.0

Cargo.toml

@@ -1,18 +1,7 @@
 [workspace]
-resolver = "2"
-members = ["extism-maturin", "manifest", "runtime", "libextism", "convert", "convert-macros"]
+members = [
+  "manifest",
+  "runtime",
+  "libextism",
+]
 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" }

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,25 @@ 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)
+	cargo build --release $(FEATURE_FLAGS) --manifest-path libextism/Cargo.toml
 
 .PHONY: kernel
 kernel:
 	cd kernel && bash build.sh
 
 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,57 @@
-<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 and APIs may change until we hit v1.0.
 
-</div>
+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.
 
-# Overview
+[![Discord](https://img.shields.io/discord/1011124058408112148?color=%23404eed&label=Community%20Chat&logo=Discord&logoColor=%23404eed)](https://discord.gg/cx3usBCWnc)
 
-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.
+# [Extism](https://extism.org)
 
-> **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.
+The universal plug-in system. Run WebAssembly extensions inside your app. Use idiomatic Host SDKs for [Go](https://extism.org/docs/integrate-into-your-codebase/go-host-sdk), 
+[Ruby](https://extism.org/docs/integrate-into-your-codebase/ruby-host-sdk), [Python](https://extism.org/docs/integrate-into-your-codebase/python-host-sdk), 
+[Node](https://extism.org/docs/integrate-into-your-codebase/node-host-sdk), [Rust](https://extism.org/docs/integrate-into-your-codebase/rust-host-sdk), 
+[C](https://extism.org/docs/integrate-into-your-codebase/c-host-sdk), [C++](https://extism.org/docs/integrate-into-your-codebase/cpp-host-sdk), 
+[OCaml](https://extism.org/docs/integrate-into-your-codebase/ocaml-host-sdk), 
+[Haskell](https://extism.org/docs/integrate-into-your-codebase/haskell-host-sdk), 
+[PHP](https://extism.org/docs/integrate-into-your-codebase/php-host-sdk), 
+[Elixir/Erlang](https://extism.org/docs/integrate-into-your-codebase/elixir-or-erlang-host-sdk), 
+[.NET](https://extism.org/docs/integrate-into-your-codebase/dotnet-host-sdk),
+[Java](https://extism.org/docs/integrate-into-your-codebase/java-host-sdk),
+[Zig](https://extism.org/docs/integrate-into-your-codebase/zig-host-sdk) &amp; more (others coming soon). 
 
-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:
+Plug-in development kits (PDK) for plug-in authors supported in [Rust](https://github.com/extism/rust-pdk), [AssemblyScript](https://github.com/extism/assemblyscript-pdk), [Go](https://github.com/extism/go-pdk), [C/C++](https://github.com/extism/c-pdk), [Haskell](https://github.com/extism/haskell-pdk), and [Zig](https://github.com/extism/zig-pdk).
 
-- plug-in systems
-- FaaS platforms
-- code generators
-- web applications
-- & much more...
+<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>
 
-# Supported Targets
 
-We currently provide releases for the following 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:**
 
-- 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
+### 1. Import
 
-For Android we suggest taking a look at the [Chicory SDK](https://github.com/extism/chicory-sdk) for a pure Java
-Extism runtime.
+Import an Extism Host SDK into your code as a library dependency.
 
-# Run WebAssembly In Your App
+### 2. Integrate 
 
-Pick a SDK to import into your program, and refer to the documentation to get
-started:
+Identify the place(s) in your code where some arbitrary logic should run (the plug-in!), returning your code some results.
 
-| 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                                                                     |
+### 3. Execute
 
-# Compile WebAssembly to run in Extism Hosts
+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.
 
-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 +60,8 @@ 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,248 @@
+<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 helloWorld = function(index){
+              console.log("Hello, " + this.allocator.getString(index));
+              return index;
+            };
+            let plugin = await this.extismContext.newPlugin({ "wasm": [ { "path": url } ] }, {"hello_world": helloWorld});
+            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 helloWorld = function(index){
+            console.log("Hello, " + this.allocator.getString(index));
+            return index;
+          };
+          let plugin = await this.extismContext.newPlugin({ "wasm": [ { "path": this.state.url } ] }, {
+              "hello_world": helloWorld
+          });
+          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: 'jsdom',
+};

browser/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@extism/runtime-browser",
+  "version": "0.3.0",
+  "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",
+    "esbuild-jest": "^0.5.0",
+    "jest": "^29.2.2",
+    "jest-environment-jsdom": "^29.3.1",
+    "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.7"
+  }
+}

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, functions: Record<string, any> = {}, 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, functions, config);
+  }
+}

browser/src/index.test.ts

@@ -0,0 +1,24 @@
+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 });
+    expect(true).toEqual(true);
+  });
+});

browser/src/index.ts

@@ -0,0 +1,4 @@
+import ExtismContext from './context';
+import { ExtismFunction, ExtismPlugin } from './plugin';
+
+export { ExtismContext, ExtismFunction, ExtismPlugin };

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,203 @@
+import Allocator from './allocator';
+import { PluginConfig } from './manifest';
+import { WASI, Fd } from '@bjorn3/browser_wasi_shim';
+
+export type ExtismFunction = any;
+
+export class ExtismPlugin {
+  moduleData: ArrayBuffer;
+  allocator: Allocator;
+  config?: PluginConfig;
+  vars: Record<string, Uint8Array>;
+  input: Uint8Array;
+  output: Uint8Array;
+  module?: WebAssembly.WebAssemblyInstantiatedSource;
+  functions: Record<string, ExtismFunction>;
+
+  constructor(moduleData: ArrayBuffer, functions: Record<string, ExtismFunction> = {}, config?: PluginConfig) {
+    this.moduleData = moduleData;
+    this.allocator = new Allocator(1024 * 1024);
+    this.config = config;
+    this.vars = {};
+    this.input = new Uint8Array();
+    this.output = new Uint8Array();
+    this.functions = functions;
+  }
+
+  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: Fd[] = [
+      // new XtermStdio(term), // stdin
+      // new XtermStdio(term), // stdout
+      // new XtermStdio(term), // 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);
+    // normally we would call wasi.start here but it doesn't respect when there is
+    // no _start function
+    //@ts-ignore
+    wasi.inst = this.module.instance;
+    if (this.module.instance.exports._start) {
+      //@ts-ignore
+      this.module.instance.exports._start();
+    }
+    return this.module;
+  }
+
+  makeEnv(): any {
+    const plugin = this;
+    var env: any = {
+      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);
+      },
+    };
+
+    for (const [name, func] of Object.entries(this.functions)) {
+      env[name] = function () {
+        return func.apply(plugin, arguments);
+      };
+    }
+
+    return env;
+  }
+}

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,15 +53,12 @@ int main(int argc, char *argv[]) {
     exit(1);
   }
 
-  extism_log_custom("extism=trace,cranelift=trace");
-
   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);
+  ExtismValType inputs[] = {I64};
+  ExtismValType outputs[] = {I64};
+  ExtismFunction *f = extism_function_new("hello_world", inputs, 1, outputs, 1,
+                                          hello_world, "Hello, again!", NULL);
 
   char *errmsg = NULL;
   ExtismPlugin *plugin = extism_plugin_new(
@@ -86,7 +77,5 @@ int main(int argc, char *argv[]) {
   write(STDOUT_FILENO, output, out_len);
   write(STDOUT_FILENO, "\n", 1);
   extism_plugin_free(plugin);
-  extism_function_free(f);
-  extism_log_drain(log_handler);
   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.14.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,16 @@
+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,44 @@
+#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");
+  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(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,458 @@
+#pragma once
+
+#include <cstring>
+#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;
+typedef uint64_t MemoryHandle;
+
+class CurrentPlugin {
+  ExtismCurrentPlugin *pointer;
+
+public:
+  CurrentPlugin(ExtismCurrentPlugin *p) : pointer(p) {}
+
+  uint8_t *memory() { return extism_current_plugin_memory(this->pointer); }
+  uint8_t *memory(MemoryHandle offs) { return this->memory() + offs; }
+
+  ExtismSize memoryLength(MemoryHandle offs) {
+    return extism_current_plugin_memory_length(this->pointer, offs);
+  }
+
+  MemoryHandle alloc(ExtismSize size) {
+    return extism_current_plugin_memory_alloc(this->pointer, size);
+  }
+
+  void free(MemoryHandle handle) {
+    extism_current_plugin_memory_free(this->pointer, handle);
+  }
+
+  void returnString(Val &output, const std::string &s) {
+    this->returnBytes(output, (const uint8_t *)s.c_str(), s.size());
+  }
+
+  void returnBytes(Val &output, const uint8_t *bytes, size_t len) {
+    auto offs = this->alloc(len);
+    memcpy(this->memory() + offs, bytes, len);
+    output.v.i64 = offs;
+  }
+
+  uint8_t *inputBytes(Val &inp, size_t *length = nullptr) {
+    if (inp.t != ValType::I64) {
+      return nullptr;
+    }
+    if (length != nullptr) {
+      *length = this->memoryLength(inp.v.i64);
+    }
+    return this->memory() + inp.v.i64;
+  }
+
+  std::string inputString(Val &inp) {
+    size_t length = 0;
+    char *buf = (char *)this->inputBytes(inp, &length);
+    return std::string(buf, length);
+  }
+};
+
+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);
+  }
+
+  void setNamespace(std::string s) {
+    extism_function_set_namespace(this->func.get(), s.c_str());
+  }
+
+  Function(const Function &f) { this->func = f.func; }
+
+  ExtismFunction *get() { return this->func.get(); }
+};
+
+class CancelHandle {
+  const ExtismCancelHandle *handle;
+
+public:
+  CancelHandle(const ExtismCancelHandle *x) : handle(x){};
+  bool cancel() { return extism_plugin_cancel(this->handle); }
+};
+
+class Plugin {
+  std::vector<Function> functions;
+
+public:
+  ExtismPlugin *plugin;
+  // Create a new plugin
+  Plugin(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());
+    }
+
+    char *errmsg = nullptr;
+    this->plugin = extism_plugin_new(wasm, length, ptrs.data(), ptrs.size(),
+                                     with_wasi, &errmsg);
+    if (this->plugin == nullptr) {
+      std::string s(errmsg);
+      extism_plugin_new_error_free(errmsg);
+      throw Error(s);
+    }
+  }
+
+  Plugin(const std::string &str, bool with_wasi = false,
+         std::vector<Function> functions = {})
+      : Plugin((const uint8_t *)str.c_str(), str.size(), with_wasi, functions) {
+  }
+
+  Plugin(const std::vector<uint8_t> &data, bool with_wasi = false,
+         std::vector<Function> functions = {})
+      : Plugin(data.data(), data.size(), with_wasi, functions) {}
+
+  CancelHandle cancelHandle() {
+    return CancelHandle(extism_plugin_cancel_handle(this->plugin));
+  }
+
+#ifndef EXTISM_NO_JSON
+  // Create a new plugin from Manifest
+  Plugin(const Manifest &manifest, bool with_wasi = false,
+         std::vector<Function> functions = {})
+      : Plugin(manifest.json().c_str(), with_wasi, functions) {}
+
+  ~Plugin() {
+    extism_plugin_free(this->plugin);
+    this->plugin = nullptr;
+  }
+
+  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->plugin, (const uint8_t *)json, length);
+    if (!b) {
+      const char *err = extism_plugin_error(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->plugin, func.c_str(), input, input_length);
+    if (rc != 0) {
+      const char *error = extism_plugin_error(this->plugin);
+      if (error == nullptr) {
+        throw Error("extism_call failed");
+      }
+
+      throw Error(error);
+    }
+
+    ExtismSize length = extism_plugin_output_length(this->plugin);
+    const uint8_t *ptr = extism_plugin_output_data(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 functionExists(const std::string &func) const {
+    return extism_plugin_function_exists(this->plugin, func.c_str());
+  }
+};
+
+// Set global log file for plugins
+inline bool setLogFile(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,117 @@
+#include "../extism.hpp"
+
+#include <fstream>
+#include <thread>
+
+#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>());
+}
+
+const std::string code = "../../wasm/code.wasm";
+
+namespace {
+using namespace extism;
+
+TEST(Plugin, Manifest) {
+  Manifest manifest = Manifest::path(code);
+  manifest.set_config("a", "1");
+
+  Plugin plugin(manifest);
+
+  Buffer buf = plugin.call("count_vowels", "this is a test");
+  ASSERT_EQ((std::string)buf, "{\"count\": 4}");
+}
+
+TEST(Plugin, BadManifest) {
+  Manifest manifest;
+  ASSERT_THROW(Plugin plugin(manifest), Error);
+}
+
+TEST(Plugin, Bytes) {
+  auto wasm = read(code.c_str());
+  ASSERT_NO_THROW(Plugin plugin(wasm));
+  Plugin plugin(wasm);
+
+  Buffer buf = plugin.call("count_vowels", "this is another test");
+  ASSERT_EQ(buf.string(), "{\"count\": 6}");
+}
+
+TEST(Plugin, UpdateConfig) {
+  auto wasm = read(code.c_str());
+  Plugin plugin(wasm);
+
+  Config config;
+  config["abc"] = "123";
+  ASSERT_NO_THROW(plugin.config(config));
+}
+
+TEST(Plugin, FunctionExists) {
+  auto wasm = read(code.c_str());
+  Plugin plugin(wasm);
+
+  ASSERT_FALSE(plugin.functionExists("bad_function"));
+  ASSERT_TRUE(plugin.functionExists("count_vowels"));
+}
+
+TEST(Plugin, HostFunction) {
+  auto wasm = read("../../wasm/code-functions.wasm");
+  auto t = std::vector<ValType>{ValType::I64};
+  Function hello_world =
+      Function("hello_world", t, t,
+               [](CurrentPlugin plugin, const std::vector<Val> &params,
+                  std::vector<Val> &results, void *user_data) {
+                 auto offs = plugin.alloc(4);
+                 memcpy(plugin.memory() + offs, "test", 4);
+                 results[0].v.i64 = (int64_t)offs;
+               });
+  auto functions = std::vector<Function>{
+      hello_world,
+  };
+  Plugin plugin(wasm, true, functions);
+  auto buf = plugin.call("count_vowels", "aaa");
+  ASSERT_EQ(buf.length, 4);
+  ASSERT_EQ((std::string)buf, "test");
+}
+
+void callThread(Plugin *plugin) {
+  auto buf = plugin->call("count_vowels", "aaa").string();
+  ASSERT_EQ(buf.size(), 10);
+  ASSERT_EQ(buf, "testing123");
+}
+
+TEST(Plugin, MultipleThreads) {
+  auto wasm = read("../../wasm/code-functions.wasm");
+  auto t = std::vector<ValType>{ValType::I64};
+  Function hello_world =
+      Function("hello_world", t, t,
+               [](CurrentPlugin plugin, const std::vector<Val> &params,
+                  std::vector<Val> &results, void *user_data) {
+                 auto offs = plugin.alloc(10);
+                 memcpy(plugin.memory() + offs, "testing123", 10);
+                 results[0].v.i64 = (int64_t)offs;
+               });
+  auto functions = std::vector<Function>{
+      hello_world,
+  };
+  Plugin plugin(wasm, true, functions);
+
+  std::vector<std::thread> threads;
+  for (int i = 0; i < 3; i++) {
+    threads.push_back(std::thread(callThread, &plugin));
+  }
+
+  for (auto &th : threads) {
+    th.join();
+  }
+}
+
+}; // 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.7.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,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<OutputType>Exe</OutputType>
+		<TargetFramework>net7.0</TargetFramework>
+		<ImplicitUsings>enable</ImplicitUsings>
+		<Nullable>enable</Nullable>
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<None Include="..\..\..\wasm\code.wasm" Link="code.wasm">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</None>
+		<None Include="..\..\..\wasm\code-functions.wasm" Link="code-functions.wasm">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</None>
+	</ItemGroup>
+
+	<ItemGroup>
+		<!-- <PackageReference Include="Extism.runtime.win-x64" Version="0.7.0" /> -->
+	</ItemGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\src\Extism.Sdk\Extism.Sdk.csproj" />
+	</ItemGroup>
+
+
+</Project>

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

@@ -0,0 +1,49 @@
+using Extism.Sdk;
+using Extism.Sdk.Native;
+
+using System.Runtime.InteropServices;
+using System.Text;
+
+Console.WriteLine($"Version: {Plugin.ExtismVersion()}");
+
+var userData = Marshal.StringToHGlobalAnsi("Hello again!");
+
+using var helloWorld = new HostFunction(
+    "hello_world",
+    "env",
+    new[] { ExtismValType.I64 },
+    new[] { ExtismValType.I64 },
+    userData,
+    HelloWorld);
+
+void HelloWorld(CurrentPlugin plugin, Span<ExtismVal> inputs, Span<ExtismVal> outputs, nint data)
+{
+    Console.WriteLine("Hello from .NET!");
+
+    var text = Marshal.PtrToStringAnsi(data);
+    Console.WriteLine(text);
+
+    var input = plugin.ReadString(new nint(inputs[0].v.i64));
+    Console.WriteLine($"Input: {input}");
+
+    outputs[0].v.i64 = plugin.WriteString(input);
+}
+
+var manifest = new Manifest(new PathWasmSource("./code-functions.wasm"))
+{
+    Config = new Dictionary<string, string>
+    {
+        { "my-key", "some cool value" }
+    },
+};
+
+using var plugin = new Plugin(manifest, new[] { helloWorld }, withWasi: true);
+
+Console.WriteLine("Plugin creatd!!!");
+
+var output = Encoding.UTF8.GetString(
+    plugin.CallFunction("count_vowels", Encoding.UTF8.GetBytes("Hello World!"))
+);
+
+Console.WriteLine($"Output: {output}");
+

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/CurrentPlugin.cs

@@ -0,0 +1,138 @@
+using Extism.Sdk.Native;
+
+using System.Text;
+
+namespace Extism.Sdk
+{
+    /// <summary>
+    /// Represents the current plugin. Can only be used within <see cref="HostFunction"/>s.
+    /// </summary>
+    public class CurrentPlugin
+    {
+        internal CurrentPlugin(nint nativeHandle)
+        {
+            NativeHandle = nativeHandle;
+        }
+
+        internal nint NativeHandle { get; }
+
+        /// <summary>
+        /// Returns a pointer to the memory of the currently running plugin.
+        /// NOTE: this should only be called from host functions.
+        /// </summary>
+        /// <returns></returns>
+        public nint GetMemory()
+        {
+            return LibExtism.extism_current_plugin_memory(NativeHandle);
+        }
+
+        /// <summary>
+        /// Reads a string from a memory block using UTF8.
+        /// </summary>
+        /// <param name="pointer"></param>
+        /// <returns></returns>
+        public string ReadString(nint pointer)
+        {
+            return ReadString(pointer, Encoding.UTF8);
+        }
+
+        /// <summary>
+        /// Reads a string form a memory block.
+        /// </summary>
+        /// <param name="pointer"></param>
+        /// <param name="encoding"></param>
+        /// <returns></returns>
+        public string ReadString(nint pointer, Encoding encoding)
+        {
+            var buffer = ReadBytes(pointer);
+
+            return encoding.GetString(buffer);
+        }
+
+        /// <summary>
+        /// Returns a span of bytes for a given block.
+        /// </summary>
+        /// <param name="pointer"></param>
+        /// <returns></returns>
+        public unsafe Span<byte> ReadBytes(nint pointer)
+        {
+            var mem = GetMemory();
+            var length = (int)BlockLength(pointer);
+            var ptr = (byte*)mem + pointer;
+
+            return new Span<byte>(ptr, length);
+        }
+
+        /// <summary>
+        /// Writes a string into the current plugin memory using UTF-8 encoding and returns the pointer of the block.
+        /// </summary>
+        /// <param name="value"></param>
+        public nint WriteString(string value)
+            => WriteString(value, Encoding.UTF8);
+
+        /// <summary>
+        /// Writes a string into the current plugin memory and returns the pointer of the block.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="encoding"></param>
+        public nint WriteString(string value, Encoding encoding)
+        {
+            var bytes = encoding.GetBytes(value);
+            var pointer = AllocateBlock(bytes.Length);
+            WriteBytes(pointer, bytes);
+
+            return pointer;
+        }
+
+        /// <summary>
+        /// Writes a byte array into a block of memory.
+        /// </summary>
+        /// <param name="pointer"></param>
+        /// <param name="bytes"></param>
+        public unsafe void WriteBytes(nint pointer, Span<byte> bytes)
+        {
+            var length = BlockLength(pointer);
+            if (length < bytes.Length)
+            {
+                throw new InvalidOperationException("Destination block length is less than source block length.");
+            }
+
+            var mem = GetMemory();
+            var ptr = (void*)(mem + pointer);
+            var destination = new Span<byte>(ptr, bytes.Length);
+
+            bytes.CopyTo(destination);
+        }
+
+        /// <summary>
+        /// Frees a block of memory belonging to the current plugin.
+        /// </summary>
+        /// <param name="pointer"></param>
+        public void FreeBlock(nint pointer)
+        {
+            LibExtism.extism_current_plugin_memory_free(NativeHandle, pointer);
+        }
+
+        /// <summary>
+        /// Allocate a memory block in the currently running plugin.
+        /// 
+        /// </summary>
+        /// <param name="length"></param>
+        /// <returns></returns>
+        public nint AllocateBlock(long length)
+        {
+            return LibExtism.extism_current_plugin_memory_alloc(NativeHandle, length);
+        }
+
+        /// <summary>
+        /// Get the length of an allocated block.
+        /// NOTE: this should only be called from host functions.
+        /// </summary>
+        /// <param name="pointer"></param>
+        /// <returns></returns>
+        public long BlockLength(nint pointer)
+        {
+            return LibExtism.extism_current_plugin_memory_length(NativeHandle, pointer);
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <LangVersion>11</LangVersion>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <PackageId>Extism.Sdk</PackageId>
+    <Version>0.7.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" />
+    <PackageReference Include="System.Text.Json" Version="7.0.3" />
+  </ItemGroup>
+</Project>

dotnet/src/Extism.Sdk/ExtismException.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/HostFunction.cs

@@ -0,0 +1,146 @@
+using Extism.Sdk.Native;
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Extism.Sdk
+{
+    /// <summary>
+    /// A host function signature.
+    /// </summary>
+    /// <param name="plugin">Plugin Index</param>
+    /// <param name="inputs">Input parameters</param>
+    /// <param name="outputs">Output parameters, the host function can change this.</param>
+    /// <param name="userData">A data passed in during Host Function creation.</param>
+    public delegate void ExtismFunction(CurrentPlugin plugin, Span<ExtismVal> inputs, Span<ExtismVal> outputs, IntPtr userData);
+
+    /// <summary>
+    /// A function provided by the host that plugins can call.
+    /// </summary>
+    public class HostFunction : IDisposable
+    {
+        private const int DisposedMarker = 1;
+        private int _disposed;
+
+        /// <summary>
+        /// Registers a Host Function.
+        /// </summary>
+        /// <param name="functionName">The literal name of the function, how it would be called from a <see cref="Plugin"/>.</param>
+        /// <param name="inputTypes">The types of the input arguments/parameters the <see cref="Plugin"/> caller will provide.</param>
+        /// <param name="outputTypes">The types of the output returned from the host function to the <see cref="Plugin"/>.</param>
+        /// <param name="userData">An opaque pointer to an object from the host, accessible to the <see cref="Plugin"/>.
+        /// NOTE: it is the shared responsibility of the host and <see cref="Plugin"/> to cast/dereference this value properly.</param>
+        /// <param name="hostFunction"></param>
+        public HostFunction(
+            string functionName,
+            Span<ExtismValType> inputTypes,
+            Span<ExtismValType> outputTypes,
+            IntPtr userData,
+            ExtismFunction hostFunction) :
+            this(functionName, "", inputTypes, outputTypes, userData, hostFunction)
+        {
+
+        }
+
+        /// <summary>
+        /// Registers a Host Function.
+        /// </summary>
+        /// <param name="functionName">The literal name of the function, how it would be called from a <see cref="Plugin"/>.</param>
+        /// <param name="namespace">Function namespace.</param>
+        /// <param name="inputTypes">The types of the input arguments/parameters the <see cref="Plugin"/> caller will provide.</param>
+        /// <param name="outputTypes">The types of the output returned from the host function to the <see cref="Plugin"/>.</param>
+        /// <param name="userData">An opaque pointer to an object from the host, accessible to the <see cref="Plugin"/>.
+        /// NOTE: it is the shared responsibility of the host and <see cref="Plugin"/> to cast/dereference this value properly.</param>
+        /// <param name="hostFunction"></param>
+        unsafe public HostFunction(
+            string functionName,
+            string @namespace,
+            Span<ExtismValType> inputTypes,
+            Span<ExtismValType> outputTypes,
+            IntPtr userData,
+            ExtismFunction hostFunction)
+        {
+            fixed (ExtismValType* inputs = inputTypes)
+            fixed (ExtismValType* outputs = outputTypes)
+            {
+                NativeHandle = LibExtism.extism_function_new(functionName, inputs, inputTypes.Length, outputs, outputTypes.Length, CallbackImpl, userData, IntPtr.Zero);
+            }
+
+            if (!string.IsNullOrEmpty(@namespace))
+            {
+                LibExtism.extism_function_set_namespace(NativeHandle, @namespace);
+            }
+
+            void CallbackImpl(
+                nint plugin,
+                ExtismVal* inputsPtr,
+                uint n_inputs,
+                ExtismVal* outputsPtr,
+                uint n_outputs,
+                IntPtr data)
+            {
+                var outputs = new Span<ExtismVal>(outputsPtr, (int)n_outputs);
+                var inputs = new Span<ExtismVal>(inputsPtr, (int)n_inputs);
+
+                hostFunction(new CurrentPlugin(plugin), inputs, outputs, data);
+            }
+        }
+
+        internal IntPtr NativeHandle { get; }
+
+        /// <summary>
+        /// Frees all resources held by this Host Function.
+        /// </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 Host Function 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(HostFunction));
+        }
+
+        /// <summary>
+        /// Frees all resources held by this Host Function.
+        /// </summary>
+        unsafe protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                // Free up any managed resources here
+            }
+
+            // Free up unmanaged resources
+            LibExtism.extism_function_free(NativeHandle);
+        }
+
+        /// <summary>
+        /// Destructs the current Host Function and frees all resources used by it.
+        /// </summary>
+        ~HostFunction()
+        {
+            Dispose(false);
+        }
+    }
+}

dotnet/src/Extism.Sdk/LibExtism.cs

@@ -0,0 +1,310 @@
+using System.Runtime.InteropServices;
+
+namespace Extism.Sdk.Native;
+
+/// <summary>
+/// A union type for host function argument/return values.
+/// </summary>
+[StructLayout(LayoutKind.Explicit)]
+public struct ExtismValUnion
+{
+    /// <summary>
+    /// Set this for 32 bit integers
+    /// </summary>
+    [FieldOffset(0)]
+    public int i32;
+
+    /// <summary>
+    /// Set this for 64 bit integers
+    /// </summary>
+    [FieldOffset(0)]
+    public long i64;
+
+    /// <summary>
+    /// Set this for 32 bit floats
+    /// </summary>
+    [FieldOffset(0)]
+    public float f32;
+
+    /// <summary>
+    /// Set this for 64 bit floats
+    /// </summary>
+    [FieldOffset(0)]
+    public double f64;
+}
+
+/// <summary>
+/// Represents Wasm data types that Extism can understand
+/// </summary>
+public enum ExtismValType : byte
+{
+    /// <summary>
+    /// Signed 32 bit integer. Equivalent of <see cref="int"/> or <see cref="uint"/>
+    /// </summary>
+    I32,
+
+    /// <summary>
+    /// Signed 64 bit integer. Equivalent of <see cref="long"/> or <see cref="ulong"/>
+    /// </summary>
+    I64,
+
+    /// <summary>
+    /// Floating point 32 bit integer. Equivalent of <see cref="float"/>
+    /// </summary>
+    F32,
+
+    /// <summary>
+    /// Floating point 64 bit integer. Equivalent of <see cref="double"/>
+    /// </summary>
+    F64,
+
+    /// <summary>
+    /// A 128 bit number.
+    /// </summary>
+    V128,
+
+    /// <summary>
+    /// A reference to opaque data in the Wasm instance.
+    /// </summary>
+    FuncRef,
+
+    /// <summary>
+    /// A reference to opaque data in the Wasm instance.
+    /// </summary>
+    ExternRef
+}
+
+/// <summary>
+/// `ExtismVal` holds the type and value of a function argument/return
+/// </summary>
+[StructLayout(LayoutKind.Sequential)]
+public struct ExtismVal
+{
+    /// <summary>
+    /// The type for the argument
+    /// </summary>
+    public ExtismValType t;
+
+    /// <summary>
+    /// The value for the argument
+    /// </summary>
+    public ExtismValUnion v;
+}
+
+/// <summary>
+/// Functions exposed by the native Extism library.
+/// </summary>
+internal static class LibExtism
+{
+    /// <summary>
+    /// An Extism Plugin
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct ExtismPlugin { }
+
+    /// <summary>
+    /// Host function signature
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <param name="inputs"></param>
+    /// <param name="n_inputs"></param>
+    /// <param name="outputs"></param>
+    /// <param name="n_outputs"></param>
+    /// <param name="data"></param>
+    unsafe internal delegate void InternalExtismFunction(nint plugin, ExtismVal* inputs, uint n_inputs, ExtismVal* outputs, uint n_outputs, IntPtr data);
+
+    /// <summary>
+    /// Returns a pointer to the memory of the currently running plugin.
+    /// NOTE: this should only be called from host functions.
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <returns></returns>
+    [DllImport("extism", EntryPoint = "extism_current_plugin_memory")]
+    internal static extern IntPtr extism_current_plugin_memory(nint plugin);
+
+    /// <summary>
+    /// Allocate a memory block in the currently running plugin
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <param name="n"></param>
+    /// <returns></returns>
+    [DllImport("extism", EntryPoint = "extism_current_plugin_memory_alloc")]
+    internal static extern IntPtr extism_current_plugin_memory_alloc(nint plugin, long n);
+
+    /// <summary>
+    /// Get the length of an allocated block.
+    /// NOTE: this should only be called from host functions.
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <param name="n"></param>
+    /// <returns></returns>
+    [DllImport("extism", EntryPoint = "extism_current_plugin_memory_length")]
+    internal static extern long extism_current_plugin_memory_length(nint plugin, long n);
+
+    /// <summary>
+    /// Get the length of an allocated block.
+    /// NOTE: this should only be called from host functions.
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <param name="ptr"></param>
+    [DllImport("extism", EntryPoint = "extism_current_plugin_memory_free")]
+    internal static extern void extism_current_plugin_memory_free(nint plugin, IntPtr ptr);
+
+    /// <summary>
+    /// Create a new host function.
+    /// </summary>
+    /// <param name="name">function name, this should be valid UTF-8</param>
+    /// <param name="inputs">argument types</param>
+    /// <param name="nInputs">number of argument types</param>
+    /// <param name="outputs">return types</param>
+    /// <param name="nOutputs">number of return types</param>
+    /// <param name="func">the function to call</param>
+    /// <param name="userData">a pointer that will be passed to the function when it's called this value should live as long as the function exists</param>
+    /// <param name="freeUserData">a callback to release the `user_data` value when the resulting `ExtismFunction` is freed.</param>
+    /// <returns></returns>
+    [DllImport("extism", EntryPoint = "extism_function_new")]
+    unsafe internal static extern IntPtr extism_function_new(string name, ExtismValType* inputs, long nInputs, ExtismValType* outputs, long nOutputs, InternalExtismFunction func, IntPtr userData, IntPtr freeUserData);
+
+    /// <summary>
+    /// Set the namespace of an <see cref="ExtismFunction"/>
+    /// </summary>
+    /// <param name="ptr"></param>
+    /// <param name="namespace"></param>
+    [DllImport("extism", EntryPoint = "extism_function_set_namespace")]
+    internal static extern void extism_function_set_namespace(IntPtr ptr, string @namespace);
+
+    /// <summary>
+    /// Free an <see cref="ExtismFunction"/>
+    /// </summary>
+    /// <param name="ptr"></param>
+    [DllImport("extism", EntryPoint = "extism_function_free")]
+    internal static extern void extism_function_free(IntPtr ptr);
+
+    /// <summary>
+    /// Load a WASM plugin.
+    /// </summary>
+    /// <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>
+    /// <param name="errmsg"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe internal static extern ExtismPlugin* extism_plugin_new(byte* wasm, ulong wasmSize, IntPtr* functions, ulong nFunctions, [MarshalAs(UnmanagedType.I1)] bool withWasi, out char** errmsg);
+
+    /// <summary>
+    /// Frees a plugin error message.
+    /// </summary>
+    /// <param name="errorMessage"></param>
+    [DllImport("extism")]
+    unsafe internal static extern void extism_plugin_new_error_free(IntPtr errorMessage);
+
+    /// <summary>
+    /// Remove a plugin from the registry and free associated memory.
+    /// </summary>
+    /// <param name="plugin">Pointer to the plugin you want to free.</param>
+    [DllImport("extism")]
+    unsafe internal static extern void extism_plugin_free(ExtismPlugin* plugin);
+
+    /// <summary>
+    /// Update plugin config values, this will merge with the existing values.
+    /// </summary>
+    /// <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 internal static extern bool extism_plugin_config(ExtismPlugin* plugin, byte* json, int jsonLength);
+
+    /// <summary>
+    /// Returns true if funcName exists.
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <param name="funcName"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe internal static extern bool extism_plugin_function_exists(ExtismPlugin* plugin, string funcName);
+
+    /// <summary>
+    /// Call a function.
+    /// </summary>
+    /// <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 internal static extern int extism_plugin_call(ExtismPlugin* plugin, string funcName, byte* data, int dataLen);
+
+    /// <summary>
+    /// Get the error associated with a Plugin
+    /// </summary>
+    /// <param name="plugin">A plugin pointer</param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe internal static extern IntPtr extism_plugin_error(ExtismPlugin* plugin);
+
+    /// <summary>
+    /// Get the length of a plugin's output data.
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe internal static extern long extism_plugin_output_length(ExtismPlugin* plugin);
+
+    /// <summary>
+    /// Get the plugin's output data.
+    /// </summary>
+    /// <param name="plugin"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    unsafe internal static extern IntPtr extism_plugin_output_data(ExtismPlugin* plugin);
+
+    /// <summary>
+    /// Set log file and level.
+    /// </summary>
+    /// <param name="filename"></param>
+    /// <param name="logLevel"></param>
+    /// <returns></returns>
+    [DllImport("extism")]
+    internal static extern bool extism_log_file(string filename, string logLevel);
+
+    /// <summary>
+    /// Get Extism Runtime version.
+    /// </summary>
+    /// <returns></returns>
+    [DllImport("extism")]
+    internal static extern IntPtr extism_version();
+
+    /// <summary>
+    /// Extism Log Levels
+    /// </summary>
+    internal static class LogLevels
+    {
+        /// <summary>
+        /// Designates very serious errors.
+        /// </summary>
+        internal const string Error = "Error";
+
+        /// <summary>
+        /// Designates hazardous situations.
+        /// </summary>
+        internal const string Warn = "Warn";
+
+        /// <summary>
+        /// Designates useful information.
+        /// </summary>
+        internal const string Info = "Info";
+
+        /// <summary>
+        /// Designates lower priority information.
+        /// </summary>
+        internal const string Debug = "Debug";
+
+        /// <summary>
+        /// Designates very low priority, often extremely verbose, information.
+        /// </summary>
+        internal const string Trace = "Trace";
+    }
+}

dotnet/src/Extism.Sdk/LogLevel.cs

@@ -0,0 +1,32 @@
+namespace Extism.Sdk.Native;
+
+/// <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/Manifest.cs

@@ -0,0 +1,221 @@
+using System.Security.Cryptography;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+using System.Text;
+using System.Xml.Linq;
+
+namespace Extism.Sdk
+{
+    /// <summary>
+    /// The manifest is a description of your plugin and some of the runtime constraints to apply to it.
+    /// You can think of it as a blueprint to build your plugin.
+    /// </summary>
+    public class Manifest
+    {
+        /// <summary>
+        /// Create an empty manifest.
+        /// </summary>
+        public Manifest()
+        {
+            AllowedPaths = new Dictionary<string, string>
+            {
+                { "/usr/plugins/1/data", "/data" }, // src, dest
+                { "d:/plugins/1/data", "/data" } // src, dest
+            };
+        }
+
+        /// <summary>
+        /// Create a manifest from one or more Wasm sources.
+        /// </summary>
+        /// <param name="sources"></param>
+        public Manifest(params WasmSource[] sources)
+        {
+            Sources.AddRange(sources);
+        }
+
+        /// <summary>
+        /// List of Wasm sources. See <see cref="PathWasmSource"/> and <see cref="ByteArrayWasmSource"/>.
+        /// </summary>
+        [JsonPropertyName("wasm")]
+        public List<WasmSource> Sources { get; set; } = new();
+
+        /// <summary>
+        /// Configures memory for the Wasm runtime.
+        /// Memory is described in units of pages (64KB) and represent contiguous chunks of addressable memory.
+        /// </summary>
+        [JsonPropertyName("memory")]
+        public MemoryOptions? MemoryOptions { get; set; }
+
+        /// <summary>
+        /// List of host names the plugins can access. Example:
+        /// <code>
+        /// AllowedHosts = new List&lt;string&gt; {
+        ///     "www.example.com",
+        ///     "api.*.com",
+        ///     "example.*",
+        /// }
+        /// </code>
+        /// </summary>
+        [JsonPropertyName("allowed_hosts")]
+        public List<string> AllowedHosts { get; set; } = new();
+
+        /// <summary>
+        /// List of directories that can be accessed by the plugins. Examples:
+        /// <code>
+        /// AllowedPaths = new Dictionary&lt;string, string&gt;
+        /// {
+        ///     { "/usr/plugins/1/data", "/data" }, // src, dest
+        ///     { "d:/plugins/1/data", "/data" }    // src, dest
+        /// };
+        /// </code>
+        /// </summary>
+        [JsonPropertyName("allowed_paths")]
+        public Dictionary<string, string> AllowedPaths { get; set; } = new();
+
+        /// <summary>
+        /// Configurations available to the plugins. Examples:
+        /// <code>
+        /// Config = new Dictionary&lt;string, string&gt;
+        /// {
+        ///     { "userId", "55" }, // key, value
+        ///     { "mySecret", "super-secret-key" } // key, value
+        /// };
+        /// </code>
+        /// </summary>
+        [JsonPropertyName("config")]
+        public Dictionary<string, string> Config { get; set; } = new();
+    }
+
+    /// <summary>
+    /// Configures memory for the Wasm runtime.
+    /// Memory is described in units of pages (64KB) and represent contiguous chunks of addressable memory.
+    /// </summary>
+    public class MemoryOptions
+    {
+        /// <summary>
+        /// Max number of pages. Each page is 64KB.
+        /// </summary>
+        [JsonPropertyName("max")]
+        public int MaxPages { get; set; }
+    }
+
+    /// <summary>
+    /// A named Wasm source.
+    /// </summary>
+    public abstract class WasmSource
+    {
+        /// <summary>
+        /// Logical name of the Wasm source
+        /// </summary>
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        /// <summary>
+        /// Hash of the WASM source
+        /// </summary>
+        [JsonPropertyName("hash")]
+        public string? Hash { get; set; }
+    }
+
+    /// <summary>
+    /// Wasm Source represented by a file referenced by a path.
+    /// </summary>
+    public class PathWasmSource : WasmSource
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="path">path to wasm plugin.</param>
+        /// <param name="name"></param>
+        /// <param name="hash"></param>
+        public PathWasmSource(string path, string? name = null, string? hash = null)
+        {
+            Path = System.IO.Path.GetFullPath(path);
+            Name = name ?? System.IO.Path.GetFileNameWithoutExtension(path);
+            Hash = hash;
+
+            if (Hash is null)
+            {
+                using var file = File.OpenRead(Path);
+                Hash = Helpers.ComputeSha256Hash(file);
+            }
+        }
+
+        /// <summary>
+        /// Path to wasm plugin.
+        /// </summary>
+        [JsonPropertyName("path")]
+        public string Path { get; }
+    }
+
+    /// <summary>
+    /// Wasm Source represented by raw bytes.
+    /// </summary>
+    public class ByteArrayWasmSource : WasmSource
+    {
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="data">the byte array representing the Wasm code</param>
+        /// <param name="name"></param>
+        /// <param name="hash"></param>
+        public ByteArrayWasmSource(byte[] data, string? name, string? hash = null)
+        {
+            Data = data;
+            Name = name;
+            Hash = hash;
+
+            if (Hash is null)
+            {
+                using var memory = new MemoryStream(data);
+                Hash = Helpers.ComputeSha256Hash(memory);
+            }
+        }
+
+        /// <summary>
+        /// The byte array representing the Wasm code
+        /// </summary>
+        [JsonPropertyName("data")]
+        [JsonConverter(typeof(Base64EncodedStringConverter))]
+        public byte[] Data { get; }
+    }
+
+    static class Helpers
+    {
+        public static string ComputeSha256Hash(Stream stream)
+        {
+            using (SHA256 sha256 = SHA256.Create())
+            {
+                byte[] hashBytes = sha256.ComputeHash(stream);
+                return BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
+            }
+        }
+    }
+
+    class Base64EncodedStringConverter : JsonConverter<string>
+    {
+        public override string Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+            Encoding.UTF8.GetString(reader.GetBytesFromBase64());
+
+        public override void Write(Utf8JsonWriter writer, string value, JsonSerializerOptions options) =>
+            writer.WriteBase64StringValue(Encoding.UTF8.GetBytes(value));
+    }
+
+    class WasmSourceConverter : JsonConverter<WasmSource>
+    {
+        public override WasmSource Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override void Write(Utf8JsonWriter writer, WasmSource value, JsonSerializerOptions options)
+        {
+            if (value is PathWasmSource path)
+                JsonSerializer.Serialize(writer, path, typeof(PathWasmSource), options);
+            else if (value is ByteArrayWasmSource bytes)
+                JsonSerializer.Serialize(writer, bytes, typeof(ByteArrayWasmSource), options);
+            else
+                throw new ArgumentOutOfRangeException(nameof(value), "Unknown Wasm Source");
+        }
+    }
+}

dotnet/src/Extism.Sdk/Plugin.cs

@@ -0,0 +1,254 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.Json;
+
+namespace Extism.Sdk.Native;
+
+/// <summary>
+/// Represents a WASM Extism plugin.
+/// </summary>
+public unsafe class Plugin : IDisposable
+{
+    private const int DisposedMarker = 1;
+
+    private readonly HostFunction[] _functions;
+    private int _disposed;
+
+    /// <summary>
+    /// Native pointer to the Extism Plugin.
+    /// </summary>
+    internal LibExtism.ExtismPlugin* NativeHandle { get; }
+
+    /// <summary>
+    /// Create a plugin from a Manifest.
+    /// </summary>
+    /// <param name="manifest"></param>
+    /// <param name="functions"></param>
+    /// <param name="withWasi"></param>
+    public Plugin(Manifest manifest, HostFunction[] functions, bool withWasi)
+    {
+        _functions = functions;
+
+        var options = new JsonSerializerOptions
+        {
+            DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,
+            PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        };
+
+        options.Converters.Add(new WasmSourceConverter());
+        var json = JsonSerializer.Serialize(manifest, options);
+
+        var bytes = Encoding.UTF8.GetBytes(json);
+
+        var functionHandles = functions.Select(f => f.NativeHandle).ToArray();
+        fixed (byte* wasmPtr = bytes)
+        fixed (IntPtr* functionsPtr = functionHandles)
+        {
+            NativeHandle = Initialize(wasmPtr, bytes.Length, functions, withWasi, functionsPtr);
+        }
+    }
+
+    /// <summary>
+    /// Create and load a plugin from a byte array.
+    /// </summary>
+    /// <param name="wasm">A WASM module (wat or wasm) or a JSON encoded manifest.</param>
+    /// <param name="functions">List of host functions expected by the plugin.</param>
+    /// <param name="withWasi">Enable/Disable WASI.</param>
+    public Plugin(ReadOnlySpan<byte> wasm, HostFunction[] functions, bool withWasi)
+    {
+        _functions = functions;
+
+        var functionHandles = functions.Select(f => f.NativeHandle).ToArray();
+        fixed (byte* wasmPtr = wasm)
+        fixed (IntPtr* functionsPtr = functionHandles)
+        {
+            NativeHandle = Initialize(wasmPtr, wasm.Length, functions, withWasi, functionsPtr);
+        }
+    }
+
+    private unsafe LibExtism.ExtismPlugin* Initialize(byte* wasmPtr, int wasmLength, HostFunction[] functions, bool withWasi, IntPtr* functionsPtr)
+    {
+        char** errorMsgPtr;
+
+        var handle = LibExtism.extism_plugin_new(wasmPtr, (ulong)wasmLength, functionsPtr, (ulong)functions.Length, withWasi, out errorMsgPtr);
+        if (handle == null)
+        {
+            var msg = "Unable to create plugin";
+
+            if (errorMsgPtr is not null)
+            {
+                msg = Marshal.PtrToStringAnsi(new IntPtr(errorMsgPtr));
+            }
+
+            throw new ExtismException(msg);
+        }
+
+        return handle;
+    }
+
+    /// <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(NativeHandle, jsonPtr, json.Length);
+        }
+    }
+
+    /// <summary>
+    /// Checks if a specific function exists in the current plugin.
+    /// </summary>
+    unsafe public bool FunctionExists(string name)
+    {
+        CheckNotDisposed();
+
+        return LibExtism.extism_plugin_function_exists(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(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>
+    unsafe internal int OutputLength()
+    {
+        CheckNotDisposed();
+
+        return (int)LibExtism.extism_plugin_output_length(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(NativeHandle).ToPointer();
+            return new Span<byte>(ptr, length);
+        }
+    }
+
+    /// <summary>
+    /// Get the error associated with the current plugin.
+    /// </summary>
+    /// <returns></returns>
+    unsafe internal string? GetError()
+    {
+        CheckNotDisposed();
+
+        var result = LibExtism.extism_plugin_error(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>
+    unsafe protected virtual void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            // Free up any managed resources here
+        }
+
+        // Free up unmanaged resources
+        LibExtism.extism_plugin_free(NativeHandle);
+    }
+
+    /// <summary>
+    /// Destructs the current Plugin and frees all resources used by it.
+    /// </summary>
+    ~Plugin()
+    {
+        Dispose(false);
+    }
+
+    /// <summary>
+    /// Get Extism Runtime version.
+    /// </summary>
+    /// <returns></returns>
+    public static string ExtismVersion()
+    {
+        var version = LibExtism.extism_version();
+        return Marshal.PtrToStringAnsi(version);
+
+    }
+}

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,58 @@
+using Extism.Sdk.Native;
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+
+using Xunit;
+
+namespace Extism.Sdk.Tests;
+
+public class BasicTests
+{
+    [Fact]
+    public void CountHelloWorldVowels()
+    {
+        var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!;
+        var wasm = File.ReadAllBytes(Path.Combine(binDirectory, "code.wasm"));
+        using var plugin = new Plugin(wasm, Array.Empty<HostFunction>(), withWasi: true);
+
+        var response = plugin.CallFunction("count_vowels", Encoding.UTF8.GetBytes("Hello World"));
+        Assert.Equal("{\"count\": 3}", Encoding.UTF8.GetString(response));
+    }
+
+    [Fact]
+    public void CountVowelsHostFunctions()
+    {
+        var userData = Marshal.StringToHGlobalAnsi("Hello again!");
+
+        using var helloWorld = new HostFunction(
+            "hello_world",
+            "env",
+            new[] { ExtismValType.I64 },
+            new[] { ExtismValType.I64 },
+            userData,
+            HelloWorld);
+
+        var binDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!;
+        var wasm = File.ReadAllBytes(Path.Combine(binDirectory, "code-functions.wasm"));
+        using var plugin = new Plugin(wasm, new[] { helloWorld }, withWasi: true);
+
+        var response = plugin.CallFunction("count_vowels", Encoding.UTF8.GetBytes("Hello World"));
+        Assert.Equal("{\"count\": 3}", Encoding.UTF8.GetString(response));
+
+        void HelloWorld(CurrentPlugin plugin, Span<ExtismVal> inputs, Span<ExtismVal> outputs, nint data)
+        {
+            Console.WriteLine("Hello from .NET!");
+
+            var text = Marshal.PtrToStringAnsi(data);
+            Console.WriteLine(text);
+
+            var input = plugin.ReadString(new nint(inputs[0].v.i64));
+            Console.WriteLine($"Input: {input}");
+
+            var output = new string(input); // clone the string
+            outputs[0].v.i64 = plugin.WriteString(output);
+        }
+    }
+}

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

@@ -0,0 +1,42 @@
+<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>
+		<None Include="..\..\..\wasm\code-functions.wasm" Link="code-functions.wasm">
+			<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+		</None>
+	</ItemGroup>
+
+
+	<ItemGroup>
+		<ProjectReference Include="..\..\src\Extism.Sdk\Extism.Sdk.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<PackageReference Include="Extism.runtime.win-x64" Version="0.7.0" />
+	</ItemGroup>
+
+</Project>

dune

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

dune-project

@@ -0,0 +1,49 @@
+(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
+  (ctypes (>= 0.18.0))
+  (ctypes-foreign (>= 0.18.0))
+  (bigstringaf (>= 0.9.0))
+  (ppx_yojson_conv (>= v0.15.0))
+  (extism-manifest (= :version))
+  (ppx_inline_test (>= v0.15.0))
+  (cmdliner (>= 1.1.1))
+  (uuidm (>= 0.9.0))
+ )
+ (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
+  (ppx_yojson_conv (>= v0.15.0))
+  (ppx_inline_test (>= v0.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 -v
+
+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,54 @@
+# 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
+# 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.Plugin.new(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}}
+```
+
+### Modules
+
+The primary modules you should learn is:
+
+* [Extism.Plugin](Extism.Plugin.html)
+
+#### 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.Plugin.new(manifest, false)
+{:ok, output} = Extism.Plugin.call(plugin, "count_vowels", "this is a test")
+```