feat: add default cache config (#615)

Co-authored-by: zach <zach@dylibso.com>

.github/workflows/release-elixir.yaml

@@ -10,13 +10,6 @@ jobs:
     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:

.github/workflows/release-rust.yaml

@@ -19,16 +19,22 @@ jobs:
           override: true
           target: ${{ matrix.target }}
 
-      - name: Release Rust Host SDK
+      - name: Release Rust Manifest Crate
+        if: always()
         env:
           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_API_TOKEN }}
         run: |
           # 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 5 
 
+      - name: Release Rust Host SDK
+        if: always()
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_API_TOKEN }}
+        run: |
+
           cargo publish --manifest-path runtime/Cargo.toml --no-verify
           cargo publish --manifest-path rust/Cargo.toml
       

Cargo.toml

@@ -5,3 +5,4 @@ members = [
   "rust",
   "libextism",
 ]
+exclude = ["kernel"]

Makefile

@@ -21,6 +21,10 @@ endif
 build:
 	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
 

browser/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@extism/runtime-browser",
-  "version": "0.2.7",
+  "version": "0.3.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@extism/runtime-browser",
-      "version": "0.2.7",
+      "version": "0.3.0",
       "license": "BSD-3-Clause",
       "dependencies": {
         "@bjorn3/browser_wasi_shim": "^0.2.7"
@@ -7618,9 +7618,9 @@
       }
     },
     "node_modules/tough-cookie": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.2.tgz",
-      "integrity": "sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ==",
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.3.tgz",
+      "integrity": "sha512-aX/y5pVRkfRnfmuX+OdbSdXvPe6ieKX/G2s7e98f4poJHnqH3281gDPm/metm6E/WRamfx7WC4HUqkWHfQHprw==",
       "dev": true,
       "dependencies": {
         "psl": "^1.1.33",
@@ -8108,9 +8108,9 @@
       }
     },
     "node_modules/word-wrap": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
-      "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.4.tgz",
+      "integrity": "sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==",
       "dev": true,
       "engines": {
         "node": ">=0.10.0"
@@ -13986,9 +13986,9 @@
       }
     },
     "tough-cookie": {
-      "version": "4.1.2",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.2.tgz",
-      "integrity": "sha512-G9fqXWoYFZgTc2z8Q5zaHy/vJMjm+WV0AkAeHxVCQiEB1b+dGvWzFW6QV07cY5jQ5gRkeid2qIkzkxUnmoQZUQ==",
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-4.1.3.tgz",
+      "integrity": "sha512-aX/y5pVRkfRnfmuX+OdbSdXvPe6ieKX/G2s7e98f4poJHnqH3281gDPm/metm6E/WRamfx7WC4HUqkWHfQHprw==",
       "dev": true,
       "requires": {
         "psl": "^1.1.33",
@@ -14334,9 +14334,9 @@
       }
     },
     "word-wrap": {
-      "version": "1.2.3",
-      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.3.tgz",
-      "integrity": "sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==",
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.4.tgz",
+      "integrity": "sha512-2V81OA4ugVo5pRo46hAoD2ivUJx8jXmWXfUkY4KFNw0hEptvN0QfH3K4nHiwzGeKl5rFKedV48QVoqYavy4YpA==",
       "dev": true
     },
     "wrap-ansi": {

dotnet/nuget/Extism.runtime.win.csproj

@@ -1,24 +1,24 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-    <PropertyGroup>
-        <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
-        <NoBuild>true</NoBuild>
-        <IncludeBuildOutput>false</IncludeBuildOutput>
-    </PropertyGroup>
+  <PropertyGroup>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+    <NoBuild>true</NoBuild>
+    <IncludeBuildOutput>false</IncludeBuildOutput>
+  </PropertyGroup>
 
-    <PropertyGroup>
-        <PackageId>Extism.runtime.win-x64</PackageId>
-        <Version>0.6.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>
+  <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>
+  <ItemGroup>
+    <Content Include="runtimes/win-x64.dll"
+      CopyToOutputDirectory="Always"
+      Pack="true"
+      PackagePath="runtimes\win-x64\native\extism.dll" />
+  </ItemGroup>
 </Project>

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

@@ -1,28 +1,28 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-	<PropertyGroup>
-		<TargetFramework>netstandard2.1</TargetFramework>
-		<ImplicitUsings>enable</ImplicitUsings>
-		<Nullable>enable</Nullable>
-		<AllowUnsafeBlocks>True</AllowUnsafeBlocks>
-		<LangVersion>10</LangVersion>
-	</PropertyGroup>
+  <PropertyGroup>
+    <TargetFramework>netstandard2.1</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+    <LangVersion>10</LangVersion>
+  </PropertyGroup>
 
-	<PropertyGroup>
-		<PackageId>Extism.Sdk</PackageId>
-		<Version>0.5.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>
+  <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>
+    <None Include="README.md" Pack="true" PackagePath="\" />
+  </ItemGroup>
 
-	<ItemGroup>
-		<PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
-	</ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+  </ItemGroup>
 </Project>

dotnet/src/Extism.Sdk/HostFunction.cs

@@ -65,7 +65,7 @@ namespace Extism.Sdk
                 NativeHandle = LibExtism.extism_function_new(functionName, inputs, inputTypes.Length, outputs, outputTypes.Length, CallbackImpl, userData, IntPtr.Zero);
             }
 
-            if (!string.IsNullOrEmpty(functionName))
+            if (!string.IsNullOrEmpty(@namespace))
             {
                 LibExtism.extism_function_set_namespace(NativeHandle, @namespace);
             }

dune-project

@@ -26,7 +26,7 @@
   (ctypes-foreign (>= 0.18.0))
   (bigstringaf (>= 0.9.0))
   (ppx_yojson_conv (>= v0.15.0))
-  extism-manifest
+  (extism-manifest (= :version))
   (ppx_inline_test (>= v0.15.0))
   (cmdliner (>= 1.1.1))
  )

elixir/mix.exs

@@ -4,7 +4,7 @@ defmodule Extism.MixProject do
   def project do
     [
       app: :extism,
-      version: "0.3.2",
+      version: "0.5.1",
       elixir: "~> 1.12",
       start_permanent: Mix.env() == :prod,
       deps: deps(),
@@ -23,7 +23,7 @@ defmodule Extism.MixProject do
 
   defp deps do
     [
-      {:rustler, "~> 0.28.0"},
+      {:rustler, "~> 0.29.1"},
       {:json, "~> 1.4"},
       {:ex_doc, "~> 0.21", only: :dev, runtime: false}
     ]

elixir/mix.lock

@@ -1,12 +1,12 @@
 %{
-  "earmark_parser": {:hex, :earmark_parser, "1.4.31", "a93921cdc6b9b869f519213d5bc79d9e218ba768d7270d46fdcf1c01bacff9e2", [:mix], [], "hexpm", "317d367ee0335ef037a87e46c91a2269fef6306413f731e8ec11fc45a7efd059"},
-  "ex_doc": {:hex, :ex_doc, "0.29.4", "6257ecbb20c7396b1fe5accd55b7b0d23f44b6aa18017b415cb4c2b91d997729", [:mix], [{:earmark_parser, "~> 1.4.31", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "2c6699a737ae46cb61e4ed012af931b57b699643b24dabe2400a8168414bc4f5"},
+  "earmark_parser": {:hex, :earmark_parser, "1.4.33", "3c3fd9673bb5dcc9edc28dd90f50c87ce506d1f71b70e3de69aa8154bc695d44", [:mix], [], "hexpm", "2d526833729b59b9fdb85785078697c72ac5e5066350663e5be6a1182da61b8f"},
+  "ex_doc": {:hex, :ex_doc, "0.30.5", "aa6da96a5c23389d7dc7c381eba862710e108cee9cfdc629b7ec021313900e9e", [:mix], [{:earmark_parser, "~> 1.4.31", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "88a1e115dcb91cefeef7e22df4a6ebbe4634fbf98b38adcbc25c9607d6d9d8e6"},
   "jason": {:hex, :jason, "1.4.0", "e855647bc964a44e2f67df589ccf49105ae039d4179db7f6271dfd3843dc27e6", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "79a3791085b2a0f743ca04cec0f7be26443738779d09302e01318f97bdb82121"},
   "json": {:hex, :json, "1.4.1", "8648f04a9439765ad449bc56a3ff7d8b11dd44ff08ffcdefc4329f7c93843dfa", [:mix], [], "hexpm", "9abf218dbe4ea4fcb875e087d5f904ef263d012ee5ed21d46e9dbca63f053d16"},
   "makeup": {:hex, :makeup, "1.1.0", "6b67c8bc2882a6b6a445859952a602afc1a41c2e08379ca057c0f525366fc3ca", [:mix], [{:nimble_parsec, "~> 1.2.2 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "0a45ed501f4a8897f580eabf99a2e5234ea3e75a4373c8a52824f6e873be57a6"},
-  "makeup_elixir": {:hex, :makeup_elixir, "0.16.0", "f8c570a0d33f8039513fbccaf7108c5d750f47d8defd44088371191b76492b0b", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "28b2cbdc13960a46ae9a8858c4bebdec3c9a6d7b4b9e7f4ed1502f8159f338e7"},
-  "makeup_erlang": {:hex, :makeup_erlang, "0.1.1", "3fcb7f09eb9d98dc4d208f49cc955a34218fc41ff6b84df7c75b3e6e533cc65f", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "174d0809e98a4ef0b3309256cbf97101c6ec01c4ab0b23e926a9e17df2077cbb"},
-  "nimble_parsec": {:hex, :nimble_parsec, "1.2.3", "244836e6e3f1200c7f30cb56733fd808744eca61fd182f731eac4af635cc6d0b", [:mix], [], "hexpm", "c8d789e39b9131acf7b99291e93dae60ab48ef14a7ee9d58c6964f59efb570b0"},
-  "rustler": {:hex, :rustler, "0.28.0", "b8e2c43013e12dd06f61dcf87033d2e2c8245feddb121b82179c923be31ad319", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "99f811f58c993f0343851adb0af589a99cfd3dc20f2efb8ef08d1a8447980b98"},
+  "makeup_elixir": {:hex, :makeup_elixir, "0.16.1", "cc9e3ca312f1cfeccc572b37a09980287e243648108384b97ff2b76e505c3555", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "e127a341ad1b209bd80f7bd1620a15693a9908ed780c3b763bccf7d200c767c6"},
+  "makeup_erlang": {:hex, :makeup_erlang, "0.1.2", "ad87296a092a46e03b7e9b0be7631ddcf64c790fa68a9ef5323b6cbb36affc72", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f3f5a1ca93ce6e092d92b6d9c049bcda58a3b617a8d888f8e7231c85630e8108"},
+  "nimble_parsec": {:hex, :nimble_parsec, "1.3.1", "2c54013ecf170e249e9291ed0a62e5832f70a476c61da16f6aac6dca0189f2af", [:mix], [], "hexpm", "2682e3c0b2eb58d90c6375fc0cc30bc7be06f365bf72608804fb9cffa5e1b167"},
+  "rustler": {:hex, :rustler, "0.29.1", "880f20ae3027bd7945def6cea767f5257bc926f33ff50c0d5d5a5315883c084d", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "109497d701861bfcd26eb8f5801fe327a8eef304f56a5b63ef61151ff44ac9b6"},
   "toml": {:hex, :toml, "0.7.0", "fbcd773caa937d0c7a02c301a1feea25612720ac3fa1ccb8bfd9d30d822911de", [:mix], [], "hexpm", "0690246a2478c1defd100b0c9b89b4ea280a22be9a7b313a8a058a2408a2fa70"},
 }

elixir/native/extism_nif/Cargo.toml

@@ -13,6 +13,6 @@ crate-type = ["cdylib"]
 [workspace]
 
 [dependencies]
-rustler = "0.28.0"
-extism = "0.3.0"
+rustler = "0.29.1"
+extism = "0.5.2"
 log = "0.4"

extism.go

@@ -173,8 +173,9 @@ func (ctx *Context) Free() {
 
 // Plugin is used to call WASM functions
 type Plugin struct {
-	ctx *Context
-	id  int32
+	ctx       *Context
+	id        int32
+	functions []Function
 }
 
 type WasmData struct {
@@ -272,7 +273,7 @@ func register(ctx *Context, data []byte, functions []Function, wasi bool) (Plugi
 		)
 	}
 
-	return Plugin{id: int32(plugin), ctx: ctx}, nil
+	return Plugin{id: int32(plugin), ctx: ctx, functions: functions}, nil
 }
 
 func update(ctx *Context, plugin int32, data []byte, functions []Function, wasi bool) error {
@@ -361,7 +362,7 @@ func (p *Plugin) Update(module io.Reader, functions []Function, wasi bool) error
 	if err != nil {
 		return err
 	}
-
+	p.functions = functions
 	return update(p.ctx, p.id, wasm, functions, wasi)
 }
 
@@ -372,6 +373,7 @@ func (p *Plugin) UpdateManifest(manifest Manifest, functions []Function, wasi bo
 		return err
 	}
 
+	p.functions = functions
 	return update(p.ctx, p.id, data, functions, wasi)
 }
 

extism.opam

@@ -16,7 +16,7 @@ depends: [
   "ctypes-foreign" {>= "0.18.0"}
   "bigstringaf" {>= "0.9.0"}
   "ppx_yojson_conv" {>= "v0.15.0"}
-  "extism-manifest"
+  "extism-manifest" {= version}
   "ppx_inline_test" {>= "v0.15.0"}
   "cmdliner" {>= "1.1.1"}
   "odoc" {with-doc}

haskell/Example.hs

@@ -1,15 +1,24 @@
 module Main where
 
 import Extism
+import Extism.CurrentPlugin
 import Extism.Manifest(manifest, wasmFile)
 
 unwrap (Right x) = x
 unwrap (Left (ExtismError msg)) = do
   error msg
 
+hello plugin params msg = do
+  putStrLn "Hello from Haskell!"
+  putStrLn msg
+  offs <- allocBytes plugin (toByteString "{\"count\": 999}")
+  return [toI64 offs]
+
 main = do
-  let m = manifest [wasmFile "../wasm/code.wasm"]
-  plugin <- unwrap <$> Extism.createPluginFromManifest m False
-  res <- unwrap <$> Extism.call plugin "count_vowels" (Extism.toByteString "this is a test")
-  putStrLn (Extism.fromByteString res)
-  Extism.free plugin
+  setLogFile "stdout" Error
+  let m = manifest [wasmFile "../wasm/code-functions.wasm"]
+  f <- hostFunction "hello_world" [I64] [I64] hello "Hello, again"
+  plugin <- unwrap <$> createPluginFromManifest m [f] True
+  res <- unwrap <$> call plugin "count_vowels" (toByteString "this is a test")
+  putStrLn (fromByteString res)
+  free plugin

haskell/extism.cabal

@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               extism
-version:            0.2.0
+version:            0.5.0
 license:            BSD-3-Clause
 maintainer:         oss@extism.org
 author:             Extism authors
@@ -8,10 +8,10 @@ bug-reports:        https://github.com/extism/extism
 synopsis:           Extism bindings
 description:        Bindings to Extism, the universal plugin system
 category:           Plugins, WebAssembly
-extra-source-files: CHANGELOG.md
+extra-doc-files: CHANGELOG.md
 
 library
-    exposed-modules:    Extism
+    exposed-modules:    Extism Extism.CurrentPlugin
     reexported-modules: Extism.Manifest
     hs-source-dirs:     src
     other-modules:      Extism.Bindings
@@ -19,10 +19,10 @@ library
     extra-libraries:    extism
     extra-lib-dirs:     /usr/local/lib
     build-depends:
-        base              >= 4.16.1 && < 4.19.0,
-        bytestring        >= 0.11.3 && < 0.12,
-        json              >= 0.10 && < 0.11,
-        extism-manifest   >= 0.0.0 && < 0.3.0
+        base              >= 4.16.1 && < 5,
+        bytestring        >= 0.11.3 && <= 0.12,
+        json              >= 0.10 && <= 0.11,
+        extism-manifest   >= 0.0.0 && < 0.4.0
 
 test-suite extism-example
     type:             exitcode-stdio-1.0

haskell/manifest/Extism/JSON.hs

@@ -16,8 +16,8 @@ isNull JSNull = True
 isNull _ = False
 filterNulls obj = [(a, b) | (a, b) <- obj, not (isNull b)]
 object x = makeObj $ filterNulls x
-objectWithNulls x = makeObj x
-nonNull x = NotNull x
+objectWithNulls = makeObj
+nonNull = NotNull
 null' = Null
 (.=) a b = (a, showJSON b)
 toNullable (Just x) = NotNull x
@@ -40,7 +40,7 @@ find :: JSON a => String -> JSValue -> Nullable a
 find k obj = obj .? k
 
 update :: JSON a => String -> a -> JSValue -> JSValue
-update k v (JSObject obj) = object $ (fromJSObject obj) ++ [k .= v]
+update k v (JSObject obj) = object $ fromJSObject obj ++ [k .= v]
 
 instance JSON a => JSON (Nullable a) where
   showJSON (NotNull x) = showJSON x

haskell/manifest/extism-manifest.cabal

@@ -1,6 +1,6 @@
 cabal-version:      3.0
 name:               extism-manifest
-version:            0.2.0
+version:            0.3.0
 license:            BSD-3-Clause
 maintainer:         oss@extism.org
 author:             Extism authors
@@ -8,14 +8,14 @@ bug-reports:        https://github.com/extism/extism
 synopsis:           Extism manifest bindings
 description:        Bindings to Extism WebAssembly manifest
 category:           Plugins, WebAssembly
-extra-source-files: CHANGELOG.md
+extra-doc-files: CHANGELOG.md
 
 library
     exposed-modules:    Extism.Manifest Extism.JSON
     hs-source-dirs:     .
     default-language:   Haskell2010
     build-depends:
-        base              >= 4.16.1 && < 4.19.0,
-        bytestring        >= 0.11.3 && < 0.12,
-        json              >= 0.10 && < 0.11,
+        base              >= 4.16.1 && < 5,
+        bytestring        >= 0.11.3 && <= 0.12,
+        json              >= 0.10 && <= 0.11,
         base64-bytestring >= 1.2.1 && < 1.3,

haskell/src/Extism.hs

@@ -1,10 +1,21 @@
-module Extism (module Extism, module Extism.Manifest) where
+module Extism (
+  module Extism,
+  module Extism.Manifest,
+  ValType(..),
+  Val(..)
+) where
+
 import Data.Int
 import Data.Word
 import Control.Monad (void)
 import Foreign.ForeignPtr
 import Foreign.C.String
 import Foreign.Ptr
+import Foreign.Marshal.Array
+import Foreign.Storable
+import Foreign.StablePtr
+import Foreign.Concurrent
+import Foreign.Marshal.Utils (copyBytes, moveBytes)
 import Data.ByteString as B
 import Data.ByteString.Internal (c2w, w2c)
 import Data.ByteString.Unsafe (unsafeUseAsCString)
@@ -16,10 +27,17 @@ import Extism.Bindings
 -- | Context for managing plugins
 newtype Context = Context (ForeignPtr ExtismContext)
 
--- | Plugins can be used to call WASM function
-data Plugin = Plugin Context Int32
+-- | Host function
+data Function = Function (ForeignPtr ExtismFunction) (StablePtr ())
 
-data CancelHandle = CancelHandle (Ptr ExtismCancelHandle)
+-- | Plugins can be used to call WASM function
+data Plugin = Plugin Context Int32 [Function]
+
+-- | Cancellation handle for Plugins
+newtype CancelHandle = CancelHandle (Ptr ExtismCancelHandle)
+
+-- | Access the plugin that is currently executing from inside a host function
+type CurrentPlugin = Ptr ExtismCurrentPlugin
 
 -- | Log level
 data LogLevel = Error | Warn | Info | Debug | Trace deriving (Show)
@@ -53,80 +71,94 @@ reset (Context ctx) =
 newContext :: IO Context
 newContext = do
   ptr <- extism_context_new
-  fptr <- newForeignPtr extism_context_free ptr
+  fptr <- Foreign.ForeignPtr.newForeignPtr extism_context_free ptr
   return (Context fptr)
- 
+
 -- | Execute a function with a new 'Context' that is destroyed when it returns
 withContext :: (Context -> IO a) -> IO a
 withContext f = do
   ctx <- newContext
   f ctx
 
+-- | Execute a function with the provided 'Plugin' as a parameter, then frees the 'Plugin'
+-- | before returning the result.
+withPlugin :: (Plugin -> IO a) -> Plugin -> IO a
+withPlugin f plugin = do
+  res <- f plugin
+  free plugin
+  return res
+
 -- | Create a 'Plugin' from a WASM module, `useWasi` determines if WASI should
 -- | be linked
-plugin :: Context -> B.ByteString -> Bool -> IO (Result Plugin)
-plugin c wasm useWasi =
+plugin :: Context -> B.ByteString -> [Function] -> Bool -> IO (Result Plugin)
+plugin c wasm functions useWasi =
+  let nfunctions = fromIntegral (Prelude.length functions) in
   let length = fromIntegral (B.length wasm) in
   let wasi = fromInteger (if useWasi then 1 else 0) in
   let Context ctx = c in
   do
+    funcs <- Prelude.mapM (\(Function ptr _) -> withForeignPtr ptr (\x -> do return x)) functions
     withForeignPtr ctx (\ctx -> do
       p <- unsafeUseAsCString wasm (\s ->
-        extism_plugin_new ctx (castPtr s) length nullPtr 0 wasi )
+        withArray funcs (\funcs ->
+          extism_plugin_new ctx (castPtr s) length funcs nfunctions wasi ))
       if p < 0 then do
         err <- extism_error ctx (-1)
         e <- peekCString err
         return $ Left (ExtismError e)
       else
-        return $ Right (Plugin c p))
-      
+        return $ Right (Plugin c p functions))
+
 -- | Create a 'Plugin' with its own 'Context'
-createPlugin :: B.ByteString -> Bool -> IO (Result Plugin)
-createPlugin c useWasi = do
+createPlugin :: B.ByteString -> [Function] -> Bool -> IO (Result Plugin)
+createPlugin c functions useWasi = do
   ctx <- newContext
-  plugin ctx c useWasi
+  plugin ctx c functions useWasi
 
 -- | Create a 'Plugin' from a 'Manifest'
-pluginFromManifest :: Context -> Manifest -> Bool -> IO (Result Plugin)
-pluginFromManifest ctx manifest useWasi =
+pluginFromManifest :: Context -> Manifest -> [Function] -> Bool -> IO (Result Plugin)
+pluginFromManifest ctx manifest functions useWasi =
   let wasm = toByteString $ toString manifest in
-  plugin ctx wasm useWasi
+  plugin ctx wasm functions useWasi
 
 -- | Create a 'Plugin' with its own 'Context' from a 'Manifest'
-createPluginFromManifest :: Manifest -> Bool -> IO (Result Plugin)
-createPluginFromManifest manifest useWasi = do
+createPluginFromManifest :: Manifest -> [Function] -> Bool -> IO (Result Plugin)
+createPluginFromManifest manifest functions useWasi = do
   ctx <- newContext
-  pluginFromManifest ctx manifest useWasi
+  pluginFromManifest ctx manifest functions useWasi
 
 -- | Update a 'Plugin' with a new WASM module
-update :: Plugin -> B.ByteString -> Bool -> IO (Result ())
-update (Plugin (Context ctx) id) wasm useWasi =
+update :: Plugin -> B.ByteString -> [Function] -> Bool -> IO (Result Plugin)
+update (Plugin (Context ctx) id _) wasm functions useWasi =
+  let nfunctions = fromIntegral (Prelude.length functions) in
   let length = fromIntegral (B.length wasm) in
   let wasi = fromInteger (if useWasi then 1 else 0) in
   do
-    withForeignPtr ctx (\ctx -> do
+    funcs <- Prelude.mapM (\(Function ptr _ ) -> withForeignPtr ptr (\x -> do return x)) functions
+    withForeignPtr ctx (\ctx' -> do
       b <- unsafeUseAsCString wasm (\s ->
-        extism_plugin_update ctx id (castPtr s) length nullPtr 0 wasi)
+        withArray funcs (\funcs ->
+          extism_plugin_update ctx' id (castPtr s) length funcs nfunctions wasi))
       if b <= 0 then do
-        err <- extism_error ctx (-1)
+        err <- extism_error ctx' (-1)
         e <- peekCString err
         return $ Left (ExtismError e)
       else
-        return (Right ()))
+        return (Right (Plugin (Context ctx) id functions)))
 
 -- | Update a 'Plugin' with a new 'Manifest'
-updateManifest :: Plugin -> Manifest -> Bool -> IO (Result ())
-updateManifest plugin manifest useWasi =
+updateManifest :: Plugin -> Manifest -> [Function] -> Bool -> IO (Result Plugin)
+updateManifest plugin manifest functions useWasi =
   let wasm = toByteString $ toString manifest in
-  update plugin wasm useWasi
+  update plugin wasm functions useWasi
 
 -- | Check if a 'Plugin' is valid
 isValid :: Plugin -> Bool
-isValid (Plugin _ p) = p >= 0
+isValid (Plugin _ p _) = p >= 0
 
 -- | Set configuration values for a plugin
 setConfig :: Plugin -> [(String, Maybe String)] -> IO Bool
-setConfig (Plugin (Context ctx) plugin) x =
+setConfig (Plugin (Context ctx) plugin _) x =
   if plugin < 0
     then return False
   else
@@ -155,14 +187,14 @@ setLogFile filename level =
 
 -- | Check if a function exists in the given plugin
 functionExists :: Plugin -> String -> IO Bool
-functionExists (Plugin (Context ctx) plugin) name = do
+functionExists (Plugin (Context ctx) plugin _) name = do
   withForeignPtr ctx (\ctx -> do
     b <- withCString name (extism_plugin_function_exists ctx plugin)
     if b == 1 then return True else return False)
 
 --- | Call a function provided by the given plugin
 call :: Plugin -> String -> B.ByteString -> IO (Result B.ByteString)
-call (Plugin (Context ctx) plugin) name input =
+call (Plugin (Context ctx) plugin _) name input =
   let length = fromIntegral (B.length input) in
   do
     withForeignPtr ctx (\ctx -> do
@@ -184,15 +216,73 @@ call (Plugin (Context ctx) plugin) name input =
 -- | Free a 'Plugin', this will automatically be called for every plugin
 -- | associated with a 'Context' when that 'Context' is freed
 free :: Plugin -> IO ()
-free (Plugin (Context ctx) plugin) =
+free (Plugin (Context ctx) plugin _) =
   withForeignPtr ctx (`extism_plugin_free` plugin)
 
+-- | Create a new 'CancelHandle' that can be used to cancel a running plugin
+-- | from another thread.
 cancelHandle :: Plugin -> IO CancelHandle
-cancelHandle (Plugin (Context ctx) plugin) = do
-  handle <- withForeignPtr ctx (\ctx -> extism_plugin_cancel_handle ctx plugin)
+cancelHandle (Plugin (Context ctx) plugin _) = do
+  handle <- withForeignPtr ctx (`extism_plugin_cancel_handle` plugin)
   return (CancelHandle handle)
 
+-- | Cancel a running plugin using a 'CancelHandle'
 cancel :: CancelHandle -> IO Bool
-cancel (CancelHandle handle) = 
+cancel (CancelHandle handle) =
   extism_plugin_cancel handle
 
+
+-- | Create a new 'Function' that can be called from a 'Plugin'
+hostFunction :: String -> [ValType] -> [ValType] -> (CurrentPlugin -> [Val] -> a -> IO [Val]) -> a -> IO Function
+hostFunction name params results f v =
+  let nparams = fromIntegral $ Prelude.length params in
+  let nresults = fromIntegral $ Prelude.length results in
+  do
+    cb <- callbackWrap (callback f :: CCallback)
+    free <- freePtrWrap freePtr
+    userData <- newStablePtr (v, free, cb)
+    let userDataPtr = castStablePtrToPtr userData
+    x <- withCString name (\name ->  do
+      withArray params (\params ->
+        withArray results (\results -> do
+          extism_function_new name params nparams results nresults cb userDataPtr free)))
+    let freeFn = extism_function_free x
+    fptr <- Foreign.Concurrent.newForeignPtr x freeFn
+    return $ Function fptr (castPtrToStablePtr userDataPtr)
+
+
+-- | Create a new I32 'Val'
+toI32 :: Integral a => a -> Val
+toI32 x = ValI32 (fromIntegral x)
+
+-- | Create a new I64 'Val'
+toI64 :: Integral a => a -> Val
+toI64 x = ValI64 (fromIntegral x)
+
+-- | Create a new F32 'Val'
+toF32 :: Float -> Val
+toF32 = ValF32
+
+-- | Create a new F64 'Val'
+toF64 :: Double -> Val
+toF64 = ValF64
+
+-- | Get I32 'Val'
+fromI32 :: Integral a => Val -> Maybe a
+fromI32 (ValI32 x) = Just (fromIntegral x)
+fromI32 _ = Nothing
+
+-- | Get I64 'Val'
+fromI64 :: Integral a => Val -> Maybe a
+fromI64 (ValI64 x) = Just (fromIntegral x)
+fromI64 _ = Nothing
+
+-- | Get F32 'Val'
+fromF32 :: Val -> Maybe Float
+fromF32 (ValF32 x) = Just x
+fromF32 _ = Nothing
+
+-- | Get F64 'Val'
+fromF64 :: Val -> Maybe Double
+fromF64 (ValF64 x) = Just x
+fromF64 _ = Nothing

haskell/src/Extism/Bindings.hs

@@ -7,10 +7,77 @@ import Foreign.Ptr
 import Foreign.C.String
 import Data.Int
 import Data.Word
+import Foreign.Storable
+import Foreign.Marshal.Array
+import Foreign.StablePtr
+
+type FreeCallback = Ptr () -> IO ()
 
 newtype ExtismContext = ExtismContext () deriving Show
 newtype ExtismFunction = ExtismFunction () deriving Show
 newtype ExtismCancelHandle = ExtismCancelHandle () deriving Show
+newtype ExtismCurrentPlugin = ExtismCurrentPlugin () deriving Show
+data ValType = I32 | I64 | F32 | F64 | V128 | FuncRef | ExternRef deriving (Show, Eq)
+data Val = ValI32 Int32 | ValI64 Int64 | ValF32 Float | ValF64 Double deriving (Show, Eq)
+
+typeOfVal (ValI32 _) = I32
+typeOfVal (ValI64 _) = I64
+typeOfVal (ValF32 _) = F32
+typeOfVal (ValF64 _) = F64
+
+type CCallback = Ptr ExtismCurrentPlugin -> Ptr Val -> Word64 -> Ptr Val -> Word64 -> Ptr () -> IO ()
+
+_32Bit = sizeOf (undefined :: Int) == 4
+
+instance Storable Val where
+  sizeOf _ =
+    if _32Bit then 12 else 16
+  alignment _ = 1
+  peek ptr = do
+    let offs = if _32Bit then 4 else 8
+    t <- valTypeOfInt <$> peekByteOff ptr 0
+    case t of
+      I32 -> ValI32 <$> peekByteOff ptr offs
+      I64 -> ValI64 <$> peekByteOff ptr offs
+      F32 -> ValF32 <$> peekByteOff ptr offs
+      F64 -> ValF64 <$> peekByteOff ptr offs
+  poke ptr x = do
+    let offs = if _32Bit then 4 else 8
+    pokeByteOff ptr 0 (typeOfVal x)
+    case x of
+      ValI32 x -> pokeByteOff ptr offs x
+      ValI64 x -> pokeByteOff ptr offs x
+      ValF32 x -> pokeByteOff ptr offs x
+      ValF64 x -> pokeByteOff ptr offs x
+
+
+intOfValType :: ValType -> CInt
+intOfValType I32 = 0
+intOfValType I64 = 1
+intOfValType F32 = 2
+intOfValType F64 = 3
+intOfValType V128 = 4
+intOfValType FuncRef = 5
+intOfValType ExternRef = 6
+
+valTypeOfInt :: CInt -> ValType
+valTypeOfInt 0 = I32
+valTypeOfInt 1 = I64
+valTypeOfInt 2 = F32
+valTypeOfInt 3 = F64
+valTypeOfInt 4 = V128
+valTypeOfInt 5 = FuncRef
+valTypeOfInt 6 = ExternRef
+valTypeOfInt _ = error "Invalid ValType"
+
+instance Storable ValType where
+  sizeOf _ = 4
+  alignment _ = 1
+  peek ptr = do
+    x <- peekByteOff ptr 0
+    return $ valTypeOfInt (x :: CInt)
+  poke ptr x = do
+    pokeByteOff ptr 0 (intOfValType x)
 
 foreign import ccall safe "extism.h extism_context_new" extism_context_new :: IO (Ptr ExtismContext)
 foreign import ccall safe "extism.h &extism_context_free" extism_context_free :: FunPtr (Ptr ExtismContext -> IO ())
@@ -28,3 +95,28 @@ foreign import ccall safe "extism.h extism_context_reset" extism_context_reset :
 foreign import ccall safe "extism.h extism_version" extism_version :: IO CString
 foreign import ccall safe "extism.h extism_plugin_cancel_handle" extism_plugin_cancel_handle :: Ptr ExtismContext -> Int32 -> IO (Ptr ExtismCancelHandle)
 foreign import ccall safe "extism.h extism_plugin_cancel" extism_plugin_cancel :: Ptr ExtismCancelHandle -> IO Bool
+
+foreign import ccall safe "extism.h extism_function_new" extism_function_new :: CString -> Ptr ValType -> Word64 -> Ptr ValType -> Word64 -> FunPtr CCallback -> Ptr () -> FunPtr FreeCallback -> IO (Ptr ExtismFunction)
+foreign import ccall safe "extism.h extism_function_free" extism_function_free :: Ptr ExtismFunction -> IO ()
+foreign import ccall safe "extism.h extism_current_plugin_memory" extism_current_plugin_memory :: Ptr ExtismCurrentPlugin -> IO (Ptr Word8)
+foreign import ccall safe "extism.h extism_current_plugin_memory_alloc" extism_current_plugin_memory_alloc :: Ptr ExtismCurrentPlugin -> Word64 -> IO Word64
+foreign import ccall safe "extism.h extism_current_plugin_memory_length" extism_current_plugin_memory_length :: Ptr ExtismCurrentPlugin -> Word64 -> IO Word64
+foreign import ccall safe "extism.h extism_current_plugin_memory_free" extism_current_plugin_memory_free :: Ptr ExtismCurrentPlugin -> Word64 -> IO ()
+
+freePtr ptr = do
+  let s = castPtrToStablePtr ptr
+  (a, b, c) <- deRefStablePtr s
+  freeHaskellFunPtr b
+  freeHaskellFunPtr c
+  freeStablePtr s
+
+foreign import ccall "wrapper" freePtrWrap :: FreeCallback -> IO (FunPtr FreeCallback)
+
+foreign import ccall "wrapper" callbackWrap :: CCallback -> IO (FunPtr CCallback)
+
+callback :: (Ptr ExtismCurrentPlugin -> [Val] -> a -> IO [Val]) -> (Ptr ExtismCurrentPlugin -> Ptr Val -> Word64 -> Ptr Val -> Word64 -> Ptr () -> IO ())
+callback f plugin params nparams results nresults ptr = do
+    p <- peekArray (fromIntegral nparams) params
+    (userData, _, _)  <- deRefStablePtr (castPtrToStablePtr ptr)
+    res <- f plugin p userData
+    pokeArray results res

haskell/src/Extism/CurrentPlugin.hs

@@ -0,0 +1,48 @@
+module Extism.CurrentPlugin where
+
+import Extism
+import Extism.Bindings
+import Data.Word
+import Data.ByteString as B
+import Foreign.Ptr
+import Foreign.Marshal.Array
+
+-- | Allocate a new handle of the given size
+memoryAlloc :: CurrentPlugin -> Word64 -> IO Word64
+memoryAlloc = extism_current_plugin_memory_alloc
+
+-- | Get the length of a handle, returns 0 if the handle is invalid
+memoryLength :: CurrentPlugin -> Word64 -> IO Word64
+memoryLength = extism_current_plugin_memory_length
+
+-- | Free allocated memory
+memoryFree :: CurrentPlugin -> Word64 -> IO ()
+memoryFree = extism_current_plugin_memory_free
+
+-- | Access a pointer to the entire memory region
+memory :: CurrentPlugin -> IO (Ptr Word8)
+memory = extism_current_plugin_memory
+
+-- | Access a pointer the a specific offset in memory
+memoryOffset :: CurrentPlugin -> Word64 -> IO (Ptr Word8)
+memoryOffset plugin offs = do
+  x <- extism_current_plugin_memory plugin
+  return $ plusPtr x (fromIntegral offs)
+
+-- | Access the data associated with a handle as a 'ByteString'
+memoryBytes :: CurrentPlugin -> Word64 ->  IO B.ByteString
+memoryBytes plugin offs = do
+  ptr <- memoryOffset plugin offs
+  len <- memoryLength plugin offs
+  arr <- peekArray (fromIntegral len) ptr
+  return $ B.pack arr
+
+-- | Allocate memory and copy an existing 'ByteString' into it
+allocBytes :: CurrentPlugin -> B.ByteString -> IO Word64
+allocBytes plugin s = do
+  let length = B.length s
+  offs <- memoryAlloc plugin (fromIntegral length)
+  ptr <- memoryOffset plugin offs
+  pokeArray ptr (B.unpack s)
+  return offs
+

haskell/test/Test.hs

@@ -1,6 +1,7 @@
 import Test.HUnit
 import Extism
 import Extism.Manifest
+import Extism.CurrentPlugin
 
 
 unwrap (Right x) = return x
@@ -8,12 +9,13 @@ unwrap (Left (ExtismError msg)) =
   assertFailure msg
 
 defaultManifest = manifest [wasmFile "../../wasm/code.wasm"]
+hostFunctionManifest = manifest [wasmFile "../../wasm/code-functions.wasm"]
 
 initPlugin :: Maybe Context -> IO Plugin
 initPlugin Nothing =
-  Extism.createPluginFromManifest defaultManifest False >>= unwrap
+  Extism.createPluginFromManifest defaultManifest [] False >>= unwrap
 initPlugin (Just ctx) =
-  Extism.pluginFromManifest ctx defaultManifest False >>= unwrap
+  Extism.pluginFromManifest ctx defaultManifest [] False >>= unwrap
 
 pluginFunctionExists = do
   p <- initPlugin Nothing
@@ -30,6 +32,17 @@ pluginCall = do
   p <- initPlugin Nothing
   checkCallResult p
 
+
+hello plugin params () = do
+  putStrLn "Hello from Haskell!"
+  offs <- allocBytes plugin (toByteString "{\"count\": 999}")
+  return [toI64 offs]
+
+pluginCallHostFunction = do
+  p <- Extism.createPluginFromManifest hostFunctionManifest [] False >>= unwrap
+  res <- call p "count_vowels" (toByteString "this is a test") >>= unwrap
+  assertEqual "count vowels output" "{\"count\": 999}" (fromByteString res)
+
 pluginMultiple = do
   withContext(\ctx -> do
     p <- initPlugin (Just ctx)
@@ -42,7 +55,7 @@ pluginMultiple = do
 pluginUpdate = do
   withContext (\ctx -> do
     p <- initPlugin (Just ctx)
-    updateManifest p defaultManifest True >>= unwrap
+    updateManifest p defaultManifest [] True >>= unwrap
     checkCallResult p)
 
 pluginConfig = do
@@ -62,6 +75,7 @@ main = do
     [
       t "Plugin.FunctionExists" pluginFunctionExists
       , t "Plugin.Call" pluginCall
+      , t "Plugin.CallHostFunction" pluginCallHostFunction
       , t "Plugin.Multiple" pluginMultiple
       , t "Plugin.Update" pluginUpdate
       , t "Plugin.Config" pluginConfig

java/pom.xml

@@ -1,193 +1,194 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>org.extism.sdk</groupId>
-    <artifactId>extism</artifactId>
-    <packaging>jar</packaging>
-    <version>0.3.0</version>
-    <name>extism</name>
-    <url>https://github.com/extism/extism</url>
-    <description>Java-SDK for Extism to use webassembly from Java</description>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>org.extism.sdk</groupId>
+  <artifactId>extism</artifactId>
+  <packaging>jar</packaging>
+  <version>0.5.0</version>
+  <name>extism</name>
+  <url>https://github.com/extism/extism</url>
+  <description>Java-SDK for Extism to use webassembly from Java</description>
 
-    <licenses>
-        <license>
-            <name>BSD 3-Clause</name>
-            <url>https://opensource.org/licenses/BSD-3-Clause</url>
-        </license>
-    </licenses>
+  <licenses>
+    <license>
+      <name>BSD 3-Clause</name>
+      <url>https://opensource.org/licenses/BSD-3-Clause</url>
+    </license>
+  </licenses>
 
-    <organization>
-        <name>Dylibso, Inc.</name>
-        <url>https://dylib.so</url>
-    </organization>
+  <organization>
+    <name>Dylibso, Inc.</name>
+    <url>https://dylib.so</url>
+  </organization>
 
-    <developers>
-        <developer>
-            <name>The Extism Authors</name>
-            <email>oss@extism.org</email>
-            <roles>
-                <role>Maintainer</role>
-            </roles>
-            <organization>Dylibso, Inc.</organization>
-            <organizationUrl>https://dylib.so</organizationUrl>
-        </developer>
-    </developers>
+  <developers>
+    <developer>
+      <name>The Extism Authors</name>
+      <email>oss@extism.org</email>
+      <roles>
+        <role>Maintainer</role>
+      </roles>
+      <organization>Dylibso, Inc.</organization>
+      <organizationUrl>https://dylib.so</organizationUrl>
+    </developer>
+  </developers>
 
-    <scm>
-        <connection>scm:git:git://github.com/extism/extism.git</connection>
-        <developerConnection>scm:git:ssh://git@github.com/extism/extism.git</developerConnection>
-        <url>https://github.com/extism/extism/tree/main/java</url>
-        <tag>main</tag>
-    </scm>
+  <scm>
+    <connection>scm:git:git://github.com/extism/extism.git</connection>
+    <developerConnection>scm:git:ssh://git@github.com/extism/extism.git</developerConnection>
+    <url>https://github.com/extism/extism/tree/main/java</url>
+    <tag>main</tag>
+  </scm>
 
-    <issueManagement>
-        <system>Github</system>
-        <url>https://github.com/extism/extism/issues</url>
-    </issueManagement>
+  <issueManagement>
+    <system>Github</system>
+    <url>https://github.com/extism/extism/issues</url>
+  </issueManagement>
 
-    <properties>
-        <java.version>11</java.version>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  <properties>
+    <java.version>11</java.version>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 
-        <!-- dependencies -->
-        <jna.version>5.12.1</jna.version>
-        <gson.version>2.10</gson.version>
+    <!-- dependencies -->
+    <jna.version>5.12.1</jna.version>
+    <gson.version>2.10</gson.version>
 
-        <!-- testing -->
-        <junit-jupiter-engine.version>5.9.1</junit-jupiter-engine.version>
-        <assertj-core.version>3.23.1</assertj-core.version>
+    <!-- testing -->
+    <junit-jupiter-engine.version>5.9.1</junit-jupiter-engine.version>
+    <assertj-core.version>3.23.1</assertj-core.version>
 
-        <!-- maven plugins -->
-        <maven-compiler-plugin.version>3.10.1</maven-compiler-plugin.version>
-        <maven-surefire-plugin.version>2.22.2</maven-surefire-plugin.version>
+    <!-- maven plugins -->
+    <maven-compiler-plugin.version>3.10.1</maven-compiler-plugin.version>
+    <maven-surefire-plugin.version>2.22.2</maven-surefire-plugin.version>
 
-        <!-- jreleaser -->
-        <jreleaser.git.root.search>true</jreleaser.git.root.search>
-    </properties>
+    <!-- jreleaser -->
+    <jreleaser.git.root.search>true</jreleaser.git.root.search>
+  </properties>
 
-    <profiles>
-      <profile>
-        <id>release</id>
-        <build>
-          <plugins>
-            <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-javadoc-plugin</artifactId>
-              <version>3.4.1</version>
-              <configuration>
-               <additionalJOption>-Xdoclint:none</additionalJOption>
-              </configuration>
-              <executions>
-                <execution>
-                  <id>attach-javadoc</id>
-                  <goals>
-                    <goal>jar</goal>
-                  </goals>
-                </execution>
-              </executions>
-            </plugin>
-            <plugin>
-              <groupId>org.apache.maven.plugins</groupId>
-              <artifactId>maven-source-plugin</artifactId>
-              <version>3.2.1</version>
-              <executions>
-                <execution>
-                  <id>attach-source</id>
-                  <goals>
-                    <goal>jar</goal>
-                  </goals>
-                </execution>
-              </executions>
-            </plugin>
-            <plugin>
-              <groupId>org.jreleaser</groupId>
-              <artifactId>jreleaser-maven-plugin</artifactId>
-              <version>1.3.1</version>
-              <configuration>
-                <jreleaser>
-                  <release>
-                    <github>
-                      <skipRelease>true</skipRelease>
-                    </github>
-                  </release>
-                  <signing>
-                    <active>ALWAYS</active>
-                    <armored>true</armored>
-                  </signing>
-                  <deploy>
-                    <maven>
-                      <nexus2>
-                        <maven-central>
-                          <active>ALWAYS</active>
-                          <url>https://s01.oss.sonatype.org/service/local</url>
-                          <!--
+  <profiles>
+    <profile>
+      <id>release</id>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-javadoc-plugin</artifactId>
+            <version>3.4.1</version>
+            <configuration>
+              <additionalJOption>-Xdoclint:none</additionalJOption>
+            </configuration>
+            <executions>
+              <execution>
+                <id>attach-javadoc</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-source-plugin</artifactId>
+            <version>3.2.1</version>
+            <executions>
+              <execution>
+                <id>attach-source</id>
+                <goals>
+                  <goal>jar</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+          <plugin>
+            <groupId>org.jreleaser</groupId>
+            <artifactId>jreleaser-maven-plugin</artifactId>
+            <version>1.3.1</version>
+            <configuration>
+              <jreleaser>
+                <release>
+                  <github>
+                    <skipRelease>true</skipRelease>
+                  </github>
+                </release>
+                <signing>
+                  <active>ALWAYS</active>
+                  <armored>true</armored>
+                </signing>
+                <deploy>
+                  <maven>
+                    <nexus2>
+                      <maven-central>
+                        <active>ALWAYS</active>
+                        <url>https://s01.oss.sonatype.org/service/local</url>
+                        <!--
                           <closeRepository>false</closeRepository>
                           <releaseRepository>false</releaseRepository>
                           -->
-                          <stagingRepositories>target/staging-deploy</stagingRepositories>
-                        </maven-central>
-                      </nexus2>
-                    </maven>
-                  </deploy>
-                </jreleaser>
-              </configuration>
-            </plugin>
-          </plugins>
-        </build>
-      </profile>
-    </profiles>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>${maven-compiler-plugin.version}</version>
-                <configuration>
-                    <release>${java.version}</release>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-surefire-plugin</artifactId>
-                <version>${maven-surefire-plugin.version}</version>
-                <configuration>
-                    <systemPropertyVariables>
-                        <jna.library.path>../target/release</jna.library.path>
-                    </systemPropertyVariables>
-                </configuration>
-            </plugin>
+                        <stagingRepositories>target/staging-deploy</stagingRepositories>
+                      </maven-central>
+                    </nexus2>
+                  </maven>
+                </deploy>
+              </jreleaser>
+            </configuration>
+          </plugin>
         </plugins>
-    </build>
-    <dependencies>
-        <dependency>
-            <groupId>net.java.dev.jna</groupId>
-            <artifactId>jna</artifactId>
-            <version>${jna.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.google.code.gson</groupId>
-            <artifactId>gson</artifactId>
-            <version>${gson.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <version>${junit-jupiter-engine.version}</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <version>${assertj-core.version}</version>
-            <scope>test</scope>
-        </dependency>
+      </build>
+    </profile>
+  </profiles>
 
-        <dependency>
-            <groupId>uk.org.webcompere</groupId>
-            <artifactId>model-assert</artifactId>
-            <version>1.0.0</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>${maven-compiler-plugin.version}</version>
+        <configuration>
+          <release>${java.version}</release>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>${maven-surefire-plugin.version}</version>
+        <configuration>
+          <systemPropertyVariables>
+            <jna.library.path>../target/release</jna.library.path>
+          </systemPropertyVariables>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>net.java.dev.jna</groupId>
+      <artifactId>jna</artifactId>
+      <version>${jna.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.google.code.gson</groupId>
+      <artifactId>gson</artifactId>
+      <version>${gson.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-engine</artifactId>
+      <version>${junit-jupiter-engine.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <version>${assertj-core.version}</version>
+      <scope>test</scope>
+    </dependency>
+
+    <dependency>
+      <groupId>uk.org.webcompere</groupId>
+      <artifactId>model-assert</artifactId>
+      <version>1.0.0</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
 </project>

java/src/test/java/org/extism/sdk/PluginTests.java

@@ -20,10 +20,10 @@ public class PluginTests {
 
     @Test
     public void shouldInvokeFunctionWithMemoryOptions() {
-        //FIXME check whether memory options are effective
         var manifest = new Manifest(List.of(CODE.pathWasmSource()), new MemoryOptions(0));
-        var output = Extism.invokeFunction(manifest, "count_vowels", "Hello World");
-        assertThat(output).isEqualTo("{\"count\": 3}");
+        assertThrows(ExtismException.class, () -> {
+            Extism.invokeFunction(manifest, "count_vowels", "Hello World");
+        });
     }
 
     @Test

kernel/.cargo/config

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-unknown-unknown"

kernel/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "extism-runtime-kernel"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+
+[workspace]
+members = [
+  "."
+]

kernel/README.md

@@ -0,0 +1,20 @@
+# Extism kernel
+
+The Extism kernel implements core parts of the Extism runtime in Rust compiled to WebAssembly. This code is a conceptual
+re-write of [memory.rs][] with the goal of making core parts of the Extism implementation more portable across WebAssembly
+runtimes.
+
+See [lib.rs][] for more details about the implementation itself.
+
+## Building
+
+Because this crate is built using the `wasm32-unknown-unknown` target, it is a separate build process from the `extism-runtime` crate. 
+
+To build `extism-runtime.wasm`, strip it and copy it to the proper location in the `extism-runtime` tree you can run:
+
+```shell
+$ sh build.sh
+```
+
+[memory.rs]: https://github.com/extism/extism/blob/f4aa139eced4a74eb4a103f78222ba503e146109/runtime/src/memory.rs
+[lib.rs]: ./src/lib.rs

kernel/build.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+cargo build --release --target wasm32-unknown-unknown --package extism-runtime-kernel --bin extism-runtime
+cp target/wasm32-unknown-unknown/release/extism-runtime.wasm .
+wasm-strip extism-runtime.wasm
+mv extism-runtime.wasm ../runtime/src/extism-runtime.wasm
+

kernel/src/bin/extism-runtime.rs

@@ -0,0 +1,10 @@
+#![no_main]
+#![no_std]
+
+pub use extism_runtime_kernel::*;
+
+#[cfg(target_arch = "wasm32")]
+#[panic_handler]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
+    core::arch::wasm32::unreachable()
+}

kernel/src/lib.rs

@@ -0,0 +1,525 @@
+//! # Extism kernel
+//!
+//! - Isolated memory from both host and plugin
+//! - An allocator for managing that memory
+//! - Input/output handling
+//! - Error message handling
+//! - Backward compatible `extism_*` functions
+//!
+//! ## Allocator
+//!
+//! The Extism allocator is a bump allocator that tracks the `length` of the total number of bytes
+//! available to the allocator and `position` to track how much of the data has been used. Things like memory
+//! have not really been optimized at all. When a new allocation that is larger than the remaning size is made,
+//! the allocator attempts to call `memory.grow` if that fails a `0` offset is returned, which should be interpreted
+//! as a failed allocation.
+//!
+//! ## Input/Output
+//!
+//! Input and output are just allocated blocks of memory that are marked as either input or output using
+//! the `extism_input_set` or `extism_output_set` functions. The MemoryRoot field `input_offset` contains
+//! the offset in memory to the input data and `input_length` contains the size of the input data. `output_offset`
+//! and `output_length` are used for the output data.
+//!
+//! ## Error handling
+//!
+//! The `error` field is used to track the current error message. If it is set to `0` then there is no error.
+//! The length of the error message can be retreived using `extism_length`.
+//!
+//! ## Memory offsets
+//! An offset of `0` is similar to a `NULL` pointer in C - it implies an allocation failure or memory error
+//! of some kind
+//!
+//! ## Extism functions
+//!
+//! These functions are backward compatible with the pre-kernel runtime, but a few new functions are added to
+//! give runtimes more access to the internals necesarry to load data in and out of a plugin.
+#![no_std]
+#![allow(clippy::missing_safety_doc)]
+
+use core::sync::atomic::*;
+
+pub type Pointer = u64;
+pub type Length = u64;
+
+/// WebAssembly page size
+const PAGE_SIZE: usize = 65536;
+
+/// Provides information about the usage status of a `MemoryBlock`
+#[repr(u8)]
+#[derive(PartialEq)]
+pub enum MemoryStatus {
+    /// Unused memory that is available b
+    Unused = 0,
+    /// In-use memory
+    Active = 1,
+    /// Free memory that is available for re-use
+    Free = 2,
+}
+
+/// A single `MemoryRoot` exists at the start of the memory to track information about the total
+/// size of the allocated memory and the position of the bump allocator.
+///
+/// The overall layout of the Extism-manged memory is organized like this:
+
+/// |------|-------+---------|-------+--------------|
+/// | Root | Block +  Data   | Block +     Data     | ...
+/// |------|-------+---------|-------+--------------|
+///
+/// Where `Root` and `Block` are fixed to the size of the `MemoryRoot` and `MemoryBlock` structs. But
+/// the size of `Data` is dependent on the allocation size.
+///
+/// This means that the offset of a `Block` is the size of `Root` plus the size of all existing `Blocks`
+/// including their data.
+#[repr(C)]
+pub struct MemoryRoot {
+    /// Set to true after initialization
+    pub initialized: AtomicBool,
+    /// Position of the bump allocator, relative to `blocks` field
+    pub position: AtomicU64,
+    /// The total size of all data allocated using this allocator
+    pub length: AtomicU64,
+    /// Offset of error block
+    pub error: AtomicU64,
+    /// Input position in memory
+    pub input_offset: Pointer,
+    /// Input length
+    pub input_length: Length,
+    /// Output position in memory
+    pub output_offset: Pointer,
+    /// Output length
+    pub output_length: Length,
+    /// A pointer to the start of the first block
+    pub blocks: [MemoryBlock; 0],
+}
+
+/// A `MemoryBlock` contains some metadata about a single allocation
+#[repr(C)]
+pub struct MemoryBlock {
+    /// The usage status of the block, `Unused` or `Free` blocks can be re-used.
+    pub status: AtomicU8,
+    /// The total size of the allocation
+    pub size: usize,
+    /// The number of bytes currently being used. If this block is a fresh allocation then `size` and `used` will
+    /// always be the same. If a block is re-used then these numbers may differ.
+    pub used: usize,
+    /// A pointer to the block data
+    pub data: [u8; 0],
+}
+
+/// Returns the number of pages needed for the given number of bytes
+pub fn num_pages(nbytes: u64) -> usize {
+    let npages = nbytes / PAGE_SIZE as u64;
+    let remainder = nbytes % PAGE_SIZE as u64;
+    if remainder != 0 {
+        (npages + 1) as usize
+    } else {
+        npages as usize
+    }
+}
+
+// Get the `MemoryRoot`, this is always stored at offset 1 in memory
+#[inline]
+unsafe fn memory_root() -> &'static mut MemoryRoot {
+    &mut *(1 as *mut MemoryRoot)
+}
+
+impl MemoryRoot {
+    /// Initialize or load the `MemoryRoot` from the correct position in memory
+    pub unsafe fn new() -> &'static mut MemoryRoot {
+        let root = memory_root();
+
+        // If this fails then `INITIALIZED` is already `true` and we can just return the
+        // already initialized `MemoryRoot`
+        if root
+            .initialized
+            .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+            .is_err()
+        {
+            return root;
+        }
+
+        // Ensure that at least one page is allocated to store the `MemoryRoot` data
+        if core::arch::wasm32::memory_size(0) == 0 {
+            if core::arch::wasm32::memory_grow(0, 1) == usize::MAX {
+                core::arch::wasm32::unreachable()
+            }
+        }
+
+        root.input_offset = 0;
+        root.input_length = 0;
+        root.output_offset = 0;
+        root.output_length = 0;
+        root.error.store(0, Ordering::Release);
+
+        // Initialize the `MemoryRoot` length, position and data
+        root.length.store(
+            PAGE_SIZE as u64 - core::mem::size_of::<MemoryRoot>() as u64,
+            Ordering::Release,
+        );
+        root.position.store(0, Ordering::Release);
+
+        // Ensure the first block is marked as `Unused`
+        #[allow(clippy::size_of_in_element_count)]
+        core::ptr::write_bytes(
+            root.blocks.as_mut_ptr() as *mut _,
+            MemoryStatus::Unused as u8,
+            core::mem::size_of::<MemoryBlock>(),
+        );
+        root
+    }
+
+    /// Resets the position of the allocator and zeroes out all allocations
+    pub unsafe fn reset(&mut self) {
+        core::ptr::write_bytes(
+            self.blocks.as_mut_ptr() as *mut u8,
+            0,
+            self.length.load(Ordering::Acquire) as usize,
+        );
+        self.position.store(0, Ordering::Release);
+        self.error.store(0, Ordering::Release);
+        self.input_offset = 0;
+        self.input_length = 0;
+        self.output_offset = 0;
+        self.output_length = 0;
+    }
+
+    #[inline(always)]
+    #[allow(unused)]
+    fn pointer_in_bounds(&self, p: Pointer) -> bool {
+        let start_ptr = self.blocks.as_ptr() as Pointer;
+        p >= start_ptr && p < start_ptr + self.length.load(Ordering::Acquire) as Pointer
+    }
+
+    #[inline(always)]
+    #[allow(unused)]
+    fn pointer_in_bounds_fast(p: Pointer) -> bool {
+        // Similar to `pointer_in_bounds` but less accurate on the upper bound. This uses the total memory size,
+        // instead of checking `MemoryRoot::length`
+        let end = core::arch::wasm32::memory_size(0) << 16;
+        p >= core::mem::size_of::<Self>() as Pointer && p <= end as Pointer
+    }
+
+    // Find a block that is free to use, this can be a new block or an existing freed block. The `self_position` argument
+    // is used to avoid loading the allocators position more than once when performing an allocation.
+    unsafe fn find_free_block(
+        &mut self,
+        length: Length,
+        self_position: u64,
+    ) -> Option<&'static mut MemoryBlock> {
+        // Get the first block
+        let mut block = self.blocks.as_mut_ptr();
+
+        // Only loop while the block pointer is less then the current position
+        while (block as u64) < self.blocks.as_ptr() as u64 + self_position {
+            let b = &mut *block;
+
+            // Get the block status, this lets us know if we are able to re-use it
+            let status = b.status.load(Ordering::Acquire);
+
+            // An unused block is safe to use
+            if status == MemoryStatus::Unused as u8 {
+                return Some(b);
+            }
+
+            // Re-use freed blocks when they're large enough
+            if status == MemoryStatus::Free as u8 && b.size >= length as usize {
+                // Split block if there is too much excess
+                if b.size - length as usize >= 128 {
+                    b.size -= length as usize;
+                    b.used = 0;
+
+                    let block1 = b.data.as_mut_ptr().add(b.size) as *mut MemoryBlock;
+                    let b1 = &mut *block1;
+                    b1.size = length as usize;
+                    b1.used = 0;
+                    b1.status.store(MemoryStatus::Free as u8, Ordering::Release);
+                    return Some(b1);
+                }
+
+                // Otherwise return the whole block
+                return Some(b);
+            }
+
+            // Get the next block
+            block = b.next_ptr();
+        }
+
+        None
+    }
+
+    /// Create a new `MemoryBlock`, when `Some(block)` is returned, `block` will contain at least enough room for `length` bytes
+    /// but may be as large as `length` + `BLOCK_SPLIT_SIZE` bytes. When `None` is returned the allocation has failed.
+    pub unsafe fn alloc(&mut self, length: Length) -> Option<&'static mut MemoryBlock> {
+        let self_position = self.position.load(Ordering::Acquire);
+        let self_length = self.length.load(Ordering::Acquire);
+        let b = self.find_free_block(length, self_position);
+
+        // If there's a free block then re-use it
+        if let Some(b) = b {
+            b.used = length as usize;
+            b.status
+                .store(MemoryStatus::Active as u8, Ordering::Release);
+            return Some(b);
+        }
+
+        // Get the current index for a new block
+        let curr = self.blocks.as_ptr() as u64 + self_position;
+
+        // Get the number of bytes available
+        let mem_left = self_length - self_position - core::mem::size_of::<MemoryRoot>() as u64;
+
+        // When the allocation is larger than the number of bytes available
+        // we will need to try to grow the memory
+        if length >= mem_left {
+            // Calculate the number of pages needed to cover the remaining bytes
+            let npages = num_pages(length - mem_left);
+            let x = core::arch::wasm32::memory_grow(0, npages);
+            if x == usize::MAX {
+                return None;
+            }
+            self.length
+                .fetch_add(npages as u64 * PAGE_SIZE as u64, Ordering::SeqCst);
+        }
+
+        // Bump the position by the size of the actual data + the size of the MemoryBlock structure
+        self.position.fetch_add(
+            length + core::mem::size_of::<MemoryBlock>() as u64,
+            Ordering::SeqCst,
+        );
+
+        // Initialize a new block at the current position
+        let ptr = curr as *mut MemoryBlock;
+        let block = &mut *ptr;
+        block
+            .status
+            .store(MemoryStatus::Active as u8, Ordering::Release);
+        block.size = length as usize;
+        block.used = length as usize;
+        Some(block)
+    }
+
+    /// Finds the block at an offset in memory
+    pub unsafe fn find_block(&mut self, offs: Pointer) -> Option<&mut MemoryBlock> {
+        if !Self::pointer_in_bounds_fast(offs) {
+            return None;
+        }
+        let ptr = offs - core::mem::size_of::<MemoryBlock>() as u64;
+        let ptr = ptr as *mut MemoryBlock;
+        Some(&mut *ptr)
+    }
+}
+
+impl MemoryBlock {
+    /// Get a pointer to the next block
+    ///
+    /// NOTE: This does no checking to ensure the resulting pointer is valid, the offset
+    /// is calculated based on metadata provided by the current block
+    #[inline]
+    pub unsafe fn next_ptr(&mut self) -> *mut MemoryBlock {
+        self.data.as_mut_ptr().add(self.size) as *mut MemoryBlock
+    }
+
+    /// Mark a block as free
+    pub fn free(&mut self) {
+        self.status
+            .store(MemoryStatus::Free as u8, Ordering::Release);
+    }
+}
+
+// Extism functions
+
+/// Allocate a block of memory and return the offset
+#[no_mangle]
+pub unsafe fn extism_alloc(n: Length) -> Pointer {
+    if n == 0 {
+        return 0;
+    }
+    let region = MemoryRoot::new();
+    let block = region.alloc(n);
+    match block {
+        Some(block) => block.data.as_mut_ptr() as Pointer,
+        None => 0,
+    }
+}
+
+/// Free allocated memory
+#[no_mangle]
+pub unsafe fn extism_free(p: Pointer) {
+    if p == 0 {
+        return;
+    }
+    let root = MemoryRoot::new();
+    let block = root.find_block(p);
+    if let Some(block) = block {
+        block.free();
+
+        // If the input pointer is freed for some reason, make sure the input length to 0
+        // since the original data is gone
+        if p == root.input_offset {
+            root.input_length = 0;
+        }
+    }
+}
+
+/// Get the length of an allocated memory block
+#[no_mangle]
+pub unsafe fn extism_length(p: Pointer) -> Length {
+    if p == 0 {
+        return 0;
+    }
+    if let Some(block) = MemoryRoot::new().find_block(p) {
+        block.used as Length
+    } else {
+        0
+    }
+}
+
+/// Load a byte from Extism-managed memory
+#[no_mangle]
+pub unsafe fn extism_load_u8(p: Pointer) -> u8 {
+    #[cfg(feature = "bounds-checking")]
+    if !MemoryRoot::pointer_in_bounds_fast(p) {
+        return 0;
+    }
+    *(p as *mut u8)
+}
+
+/// Load a u64 from Extism-managed memory
+#[no_mangle]
+pub unsafe fn extism_load_u64(p: Pointer) -> u64 {
+    #[cfg(feature = "bounds-checking")]
+    if !MemoryRoot::pointer_in_bounds_fast(p + core::mem::size_of::<u64>() as u64 - 1) {
+        return 0;
+    }
+    *(p as *mut u64)
+}
+
+/// Load a byte from the input data
+#[no_mangle]
+pub unsafe fn extism_input_load_u8(p: Pointer) -> u8 {
+    let root = MemoryRoot::new();
+    #[cfg(feature = "bounds-checking")]
+    if p >= root.input_length {
+        return 0;
+    }
+    *((root.input_offset + p) as *mut u8)
+}
+
+/// Load a u64 from the input data
+#[no_mangle]
+pub unsafe fn extism_input_load_u64(p: Pointer) -> u64 {
+    let root = MemoryRoot::new();
+    #[cfg(feature = "bounds-checking")]
+    if p + core::mem::size_of::<u64>() as Pointer > root.input_length {
+        return 0;
+    }
+    *((root.input_offset + p) as *mut u64)
+}
+
+/// Write a byte in Extism-managed memory
+#[no_mangle]
+pub unsafe fn extism_store_u8(p: Pointer, x: u8) {
+    #[cfg(feature = "bounds-checking")]
+    if !MemoryRoot::pointer_in_bounds_fast(p) {
+        return;
+    }
+    *(p as *mut u8) = x;
+}
+
+/// Write a u64 in Extism-managed memory
+#[no_mangle]
+pub unsafe fn extism_store_u64(p: Pointer, x: u64) {
+    #[cfg(feature = "bounds-checking")]
+    if !MemoryRoot::pointer_in_bounds_fast(p + core::mem::size_of::<u64>() as u64 - 1) {
+        return;
+    }
+    *(p as *mut u64) = x;
+}
+
+/// Set the range of the input data in memory
+#[no_mangle]
+pub unsafe fn extism_input_set(p: Pointer, len: Length) {
+    let root = MemoryRoot::new();
+    #[cfg(feature = "bounds-checking")]
+    {
+        if !root.pointer_in_bounds(p) || !root.pointer_in_bounds(p + len - 1) {
+            return;
+        }
+    }
+    root.input_offset = p;
+    root.input_length = len;
+}
+
+/// Set the range of the output data in memory
+#[no_mangle]
+pub unsafe fn extism_output_set(p: Pointer, len: Length) {
+    let root = MemoryRoot::new();
+    #[cfg(feature = "bounds-checking")]
+    {
+        if !root.pointer_in_bounds(p) || !root.pointer_in_bounds(p + len - 1) {
+            return;
+        }
+    }
+    root.output_offset = p;
+    root.output_length = len;
+}
+
+/// Get the input length
+#[no_mangle]
+pub fn extism_input_length() -> Length {
+    unsafe { MemoryRoot::new().input_length }
+}
+
+/// Get the input offset in Exitsm-managed memory
+#[no_mangle]
+pub fn extism_input_offset() -> Length {
+    unsafe { MemoryRoot::new().input_offset }
+}
+
+/// Get the output length
+#[no_mangle]
+pub unsafe fn extism_output_length() -> Length {
+    unsafe { MemoryRoot::new().output_length }
+}
+
+/// Get the output offset in Extism-managed memory
+#[no_mangle]
+pub unsafe fn extism_output_offset() -> Length {
+    MemoryRoot::new().output_offset
+}
+
+/// Reset the allocator
+#[no_mangle]
+pub unsafe fn extism_reset() {
+    MemoryRoot::new().reset()
+}
+
+/// Set the error message offset
+#[no_mangle]
+pub unsafe fn extism_error_set(ptr: Pointer) {
+    let root = MemoryRoot::new();
+
+    // Allow ERROR to be set to 0
+    if ptr == 0 {
+        root.error.store(ptr, Ordering::SeqCst);
+        return;
+    }
+
+    if !root.pointer_in_bounds(ptr) {
+        return;
+    }
+    root.error.store(ptr, Ordering::SeqCst);
+}
+
+/// Get the error message offset, if it's `0` then no error has been set
+#[no_mangle]
+pub unsafe fn extism_error_get() -> Pointer {
+    MemoryRoot::new().error.load(Ordering::SeqCst)
+}
+
+/// Get the position of the allocator, this can be used as an indication of how many bytes are currently in-use
+#[no_mangle]
+pub unsafe fn extism_memory_bytes() -> Length {
+    MemoryRoot::new().position.load(Ordering::Acquire)
+}

libextism/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "libextism"
-version = "0.3.0"
+version = "0.5.4"
 edition = "2021"
 authors = ["The Extism Authors", "oss@extism.org"]
 license = "BSD-3-Clause"

manifest/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "extism-manifest"
-version = "0.3.0"
+version = "0.5.0"
 edition = "2021"
 authors = ["The Extism Authors", "oss@extism.org"]
 license = "BSD-3-Clause"

manifest/src/lib.rs

@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
 #[deprecated]
 pub type ManifestMemory = MemoryOptions;
 
-#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
 #[serde(deny_unknown_fields)]
 pub struct MemoryOptions {
@@ -12,7 +12,7 @@ pub struct MemoryOptions {
     pub max_pages: Option<u32>,
 }
 
-#[derive(serde::Serialize, serde::Deserialize)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
 #[serde(deny_unknown_fields)]
 pub struct HttpRequest {
@@ -43,7 +43,7 @@ impl HttpRequest {
     }
 }
 
-#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
 #[serde(deny_unknown_fields)]
 pub struct WasmMetadata {
@@ -81,7 +81,7 @@ impl From<Vec<u8>> for Wasm {
 #[deprecated]
 pub type ManifestWasm = Wasm;
 
-#[derive(serde::Serialize, serde::Deserialize)]
+#[derive(Clone, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
 #[serde(untagged)]
 #[serde(deny_unknown_fields)]
@@ -153,7 +153,7 @@ fn base64_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::
     schema.into()
 }
 
-#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
 #[cfg_attr(feature = "json_schema", derive(schemars::JsonSchema))]
 #[serde(deny_unknown_fields)]
 pub struct Manifest {

node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@extism/extism",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Extism Host SDK for Node",
   "keywords": [
     "extism",
@@ -41,7 +41,7 @@
     "@types/jest": "^29.2.0",
     "@types/node": "^20.1.0",
     "jest": "^29.2.2",
-    "prettier": "2.8.8",
+    "prettier": "3.0.2",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
     "typedoc": "^0.24.1",

ocaml/Makefile

@@ -1,5 +1,5 @@
-VERSION?=0.2.0
-TAG?=0.3.0
+VERSION?=0.4.0
+TAG?=0.5.0
 
 build:
 	dune build

ocaml/lib/plugin.ml

@@ -77,7 +77,9 @@ let update plugin ?config ?(wasi = false) ?(functions = []) wasm =
     | Some msg -> Error (`Msg msg)
   else if not (set_config plugin config) then
     Error (`Msg "call to set_config failed")
-  else Ok ()
+  else
+    let () = plugin.functions <- functions in
+    Ok ()
 
 let update_manifest plugin ?wasi manifest =
   let data = Manifest.to_json manifest in

ocaml/manifest/extism_manifest.ml

@@ -1,3 +1,5 @@
+open Ppx_yojson_conv_lib.Yojson_conv
+
 type base64 = string
 
 let yojson_of_base64 x = `String (Base64.encode_exn x)

php/example/index.php

@@ -2,9 +2,8 @@
 
 require_once __DIR__ . '/vendor/autoload.php';
 
-$ctx = new \Extism\Context();
 $wasm = file_get_contents("../../wasm/code.wasm");
-$plugin = new \Extism\Plugin($ctx, $wasm);
+$plugin = new \Extism\Plugin($wasm);
 
 $output = $plugin->call("count_vowels", "this is an example");
 $json = json_decode(pack('C*', ...$output));

python/example.py

@@ -5,7 +5,9 @@ import hashlib
 import pathlib
 
 sys.path.append(".")
-from extism import Function, host_fn, ValType, Plugin
+from extism import Function, host_fn, ValType, Plugin, set_log_file
+
+set_log_file("stderr", "trace")
 
 
 @host_fn
@@ -26,14 +28,14 @@ def main(args):
     if len(args) > 1:
         data = args[1].encode()
     else:
-        data = b"some data from python!"
+        data = b"a" * 1024
 
     wasm_file_path = (
         pathlib.Path(__file__).parent.parent / "wasm" / "code-functions.wasm"
     )
     wasm = wasm_file_path.read_bytes()
     hash = hashlib.sha256(wasm).hexdigest()
-    manifest = {"wasm": [{"data": wasm, "hash": hash}], "memory": {"max": 5}}
+    manifest = {"wasm": [{"data": wasm, "hash": hash}]}
 
     functions = [
         Function(
@@ -46,11 +48,13 @@ def main(args):
     ]
     plugin = Plugin(manifest, wasi=True, functions=functions)
     # Call `count_vowels`
-    wasm_vowel_count = json.loads(plugin.call("count_vowels", data))
+    wasm_vowel_count = plugin.call("count_vowels", data)
+    print(wasm_vowel_count)
+    j = json.loads(wasm_vowel_count)
 
-    print("Number of vowels:", wasm_vowel_count["count"])
+    print("Number of vowels:", j["count"])
 
-    assert wasm_vowel_count["count"] == count_vowels(data)
+    assert j["count"] == count_vowels(data)
 
 
 if __name__ == "__main__":

python/extism/extism.py

@@ -263,6 +263,7 @@ class Plugin:
             context = Context()
 
         wasm = _wasm(plugin)
+        self.functions = functions
 
         # Register plugin
         if functions is not None:
@@ -310,6 +311,7 @@ class Plugin:
         """
         wasm = _wasm(manifest)
         if functions is not None:
+            self.functions = functions
             functions = [f.pointer for f in functions]
             ptr = _ffi.new("ExtismFunction*[]", functions)
             ok = _lib.extism_plugin_update(

python/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "extism"
-version = "0.3.0"
+version = "0.5.0"
 description = "Extism Host SDK for python"
 authors = ["The Extism Authors <oss@extism.org>"]
 license = "BSD-3-Clause"

python/tests/test_extism.py

@@ -115,14 +115,13 @@ class TestExtism(unittest.TestCase):
     def _manifest(self, functions=False):
         wasm = self._count_vowels_wasm(functions)
         hash = hashlib.sha256(wasm).hexdigest()
-        return {"wasm": [{"data": wasm, "hash": hash}], "memory": {"max_pages": 5}}
+        return {"wasm": [{"data": wasm, "hash": hash}]}
 
     def _loop_manifest(self):
         wasm = self._infinite_loop_wasm()
         hash = hashlib.sha256(wasm).hexdigest()
         return {
             "wasm": [{"data": wasm, "hash": hash}],
-            "memory": {"max_pages": 5},
             "timeout_ms": 1000,
         }
 

ruby/Gemfile

@@ -11,5 +11,5 @@ gem "ffi", "~> 1.15.5"
 group :development do
   gem "yard", "~> 0.9.28"
   gem "rufo", "~> 0.13.0"
-  gem "minitest", "~> 5.18.0"
+  gem "minitest", "~> 5.19.0"
 end

ruby/lib/extism/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Extism
-  VERSION = "0.3.0"
+  VERSION = '0.5.0'
 end

runtime/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "extism-runtime"
-version = "0.4.0"
+version = "0.5.5"
 edition = "2021"
 authors = ["The Extism Authors", "oss@extism.org"]
 license = "BSD-3-Clause"
@@ -9,9 +9,9 @@ repository = "https://github.com/extism/extism"
 description = "Extism runtime component"
 
 [dependencies]
-wasmtime = "8.0.0"
-wasmtime-wasi = "8.0.0"
-wasmtime-wasi-nn = {version = "8.0.0", optional=true}
+wasmtime = ">= 10.0.0, < 12.0.0"
+wasmtime-wasi = ">= 10.0.0, < 12.0.0"
+wasmtime-wasi-nn = {version = ">= 10.0.0, < 12.0.0", optional=true}
 anyhow = "1"
 serde = {version = "1", features = ["derive"]}
 serde_json = "1"
@@ -22,8 +22,7 @@ log4rs = "1.1"
 url = "2"
 glob = "0.3"
 ureq = {version = "2.5", optional=true}
-extism-manifest = { version = "0.3.0", path = "../manifest" }
-pretty-hex = { version = "0.3" }
+extism-manifest = { version = "0.5.0", path = "../manifest" }
 uuid = { version = "1", features = ["v4"] }
 libc = "0.2"
 

runtime/build.rs

@@ -1,4 +1,6 @@
 fn main() {
+    println!("cargo:rerun-if-changed=src/extism-runtime.wasm");
+
     let fn_macro = "
 #define EXTISM_FUNCTION(N) extern void N(ExtismCurrentPlugin*, const ExtismVal*, ExtismSize, ExtismVal*, ExtismSize, void*)
 #define EXTISM_GO_FUNCTION(N) extern void N(void*, ExtismVal*, ExtismSize, ExtismVal*, ExtismSize, uintptr_t)

runtime/extism.h

@@ -81,7 +81,12 @@ typedef struct {
 /**
  * Host function signature
  */
-typedef void (*ExtismFunctionType)(ExtismCurrentPlugin *plugin, const ExtismVal *inputs, ExtismSize n_inputs, ExtismVal *outputs, ExtismSize n_outputs, void *data);
+typedef void (*ExtismFunctionType)(ExtismCurrentPlugin *plugin,
+                                   const ExtismVal *inputs,
+                                   ExtismSize n_inputs,
+                                   ExtismVal *outputs,
+                                   ExtismSize n_outputs,
+                                   void *data);
 
 typedef int32_t ExtismPlugin;
 
@@ -245,7 +250,7 @@ const char *extism_error(ExtismContext *ctx, ExtismPlugin plugin);
 ExtismSize extism_plugin_output_length(ExtismContext *ctx, ExtismPlugin plugin);
 
 /**
- * Get the length of a plugin's output data
+ * Get a pointer to the output data
  */
 const uint8_t *extism_plugin_output_data(ExtismContext *ctx, ExtismPlugin plugin);
 

runtime/src/internal.rs

@@ -2,58 +2,6 @@ use std::collections::BTreeMap;
 
 use crate::*;
 
-/// Internal stores data that is available to the caller in PDK functions
-pub struct Internal {
-    /// Call input length
-    pub input_length: usize,
-
-    /// Pointer to call input
-    pub input: *const u8,
-
-    /// Memory offset that points to the output
-    pub output_offset: usize,
-
-    /// Length of output in memory
-    pub output_length: usize,
-
-    /// WASI context
-    pub wasi: Option<Wasi>,
-
-    /// Keep track of the status from the last HTTP request
-    pub http_status: u16,
-
-    /// Store plugin-specific error messages
-    pub last_error: std::cell::RefCell<Option<std::ffi::CString>>,
-
-    /// Plugin variables
-    pub vars: BTreeMap<String, Vec<u8>>,
-
-    /// A pointer to the plugin memory, this should mostly be used from the PDK
-    pub memory: *mut PluginMemory,
-}
-
-/// InternalExt provides a unified way of acessing `memory`, `store` and `internal` values
-pub trait InternalExt {
-    fn memory(&self) -> &PluginMemory;
-    fn memory_mut(&mut self) -> &mut PluginMemory;
-
-    fn store(&self) -> &Store<Internal> {
-        self.memory().store()
-    }
-
-    fn store_mut(&mut self) -> &mut Store<Internal> {
-        self.memory_mut().store_mut()
-    }
-
-    fn internal(&self) -> &Internal {
-        self.store().data()
-    }
-
-    fn internal_mut(&mut self) -> &mut Internal {
-        self.store_mut().data_mut()
-    }
-}
-
 /// WASI context
 pub struct Wasi {
     /// wasi
@@ -62,12 +10,222 @@ pub struct Wasi {
     /// wasi-nn
     #[cfg(feature = "nn")]
     pub nn: wasmtime_wasi_nn::WasiNnCtx,
-    #[cfg(not(feature = "nn"))]
-    pub nn: (),
+}
+
+/// Internal stores data that is available to the caller in PDK functions
+pub struct Internal {
+    /// Store
+    pub store: *mut Store<Internal>,
+
+    /// Linker
+    pub linker: *mut wasmtime::Linker<Internal>,
+
+    /// WASI context
+    pub wasi: Option<Wasi>,
+
+    /// Keep track of the status from the last HTTP request
+    pub http_status: u16,
+
+    /// Plugin variables
+    pub vars: BTreeMap<String, Vec<u8>>,
+
+    pub manifest: Manifest,
+
+    pub available_pages: Option<u32>,
+
+    pub(crate) memory_limiter: Option<MemoryLimiter>,
+}
+
+/// InternalExt provides a unified way of acessing `memory`, `store` and `internal` values
+pub trait InternalExt {
+    fn store(&self) -> &Store<Internal>;
+
+    fn store_mut(&mut self) -> &mut Store<Internal>;
+
+    fn linker(&self) -> &Linker<Internal>;
+
+    fn linker_mut(&mut self) -> &mut Linker<Internal>;
+
+    fn linker_and_store(&mut self) -> (&mut Linker<Internal>, &mut Store<Internal>);
+
+    fn internal(&self) -> &Internal {
+        self.store().data()
+    }
+
+    fn internal_mut(&mut self) -> &mut Internal {
+        self.store_mut().data_mut()
+    }
+
+    fn memory_ptr(&mut self) -> *mut u8 {
+        let (linker, mut store) = self.linker_and_store();
+        if let Some(mem) = linker.get(&mut store, "env", "memory") {
+            if let Some(mem) = mem.into_memory() {
+                return mem.data_ptr(&mut store);
+            }
+        }
+
+        std::ptr::null_mut()
+    }
+
+    fn memory(&mut self) -> &mut [u8] {
+        let (linker, mut store) = self.linker_and_store();
+        let mem = linker
+            .get(&mut store, "env", "memory")
+            .unwrap()
+            .into_memory()
+            .unwrap();
+        let ptr = mem.data_ptr(&store);
+        if ptr.is_null() {
+            return &mut [];
+        }
+        let size = mem.data_size(&store);
+        unsafe { std::slice::from_raw_parts_mut(ptr, size) }
+    }
+
+    fn memory_read(&mut self, offs: u64, len: Size) -> &[u8] {
+        trace!("memory_read: {}, {}", offs, len);
+        let offs = offs as usize;
+        let len = len as usize;
+        let mem = self.memory();
+        &mem[offs..offs + len]
+    }
+
+    fn memory_read_str(&mut self, offs: u64) -> Result<&str, std::str::Utf8Error> {
+        let len = self.memory_length(offs);
+        std::str::from_utf8(self.memory_read(offs, len))
+    }
+
+    fn memory_write(&mut self, offs: u64, bytes: impl AsRef<[u8]>) {
+        trace!("memory_write: {}", offs);
+        let b = bytes.as_ref();
+        let offs = offs as usize;
+        let len = b.len();
+        self.memory()[offs..offs + len].copy_from_slice(bytes.as_ref());
+    }
+
+    fn memory_alloc(&mut self, n: Size) -> Result<u64, Error> {
+        if n == 0 {
+            return Ok(0);
+        }
+        let (linker, mut store) = self.linker_and_store();
+        let output = &mut [Val::I64(0)];
+        linker
+            .get(&mut store, "env", "extism_alloc")
+            .unwrap()
+            .into_func()
+            .unwrap()
+            .call(&mut store, &[Val::I64(n as i64)], output)?;
+        let offs = output[0].unwrap_i64() as u64;
+        if offs == 0 && n > 0 {
+            anyhow::bail!("out of memory")
+        }
+        trace!("memory_alloc: {}, {}", offs, n);
+        Ok(offs)
+    }
+
+    fn memory_alloc_bytes(&mut self, bytes: impl AsRef<[u8]>) -> Result<u64, Error> {
+        let b = bytes.as_ref();
+        let offs = self.memory_alloc(b.len() as Size)?;
+        self.memory_write(offs, b);
+        Ok(offs)
+    }
+
+    fn memory_free(&mut self, offs: u64) {
+        let (linker, mut store) = self.linker_and_store();
+        linker
+            .get(&mut store, "env", "extism_free")
+            .unwrap()
+            .into_func()
+            .unwrap()
+            .call(&mut store, &[Val::I64(offs as i64)], &mut [])
+            .unwrap();
+    }
+
+    fn memory_length(&mut self, offs: u64) -> u64 {
+        let (linker, mut store) = self.linker_and_store();
+        let output = &mut [Val::I64(0)];
+        linker
+            .get(&mut store, "env", "extism_length")
+            .unwrap()
+            .into_func()
+            .unwrap()
+            .call(&mut store, &[Val::I64(offs as i64)], output)
+            .unwrap();
+        let len = output[0].unwrap_i64() as u64;
+        trace!("memory_length: {}, {}", offs, len);
+        len
+    }
+
+    // A convenience method to set the plugin error and return a value
+    fn error<E>(&mut self, e: impl std::fmt::Debug, x: E) -> E {
+        let s = format!("{e:?}");
+        debug!("Set error: {:?}", s);
+        if let Ok(offs) = self.memory_alloc_bytes(&s) {
+            let (linker, mut store) = self.linker_and_store();
+            if let Some(f) = linker.get(&mut store, "env", "extism_error_set") {
+                f.into_func()
+                    .unwrap()
+                    .call(&mut store, &[Val::I64(offs as i64)], &mut [])
+                    .unwrap();
+            }
+        }
+        x
+    }
+
+    fn clear_error(&mut self) {
+        let (linker, mut store) = self.linker_and_store();
+        if let Some(f) = linker.get(&mut store, "env", "extism_error_set") {
+            f.into_func()
+                .unwrap()
+                .call(&mut store, &[Val::I64(0)], &mut [])
+                .unwrap();
+        }
+    }
+
+    fn has_error(&mut self) -> bool {
+        let (linker, mut store) = self.linker_and_store();
+        let output = &mut [Val::I64(0)];
+        linker
+            .get(&mut store, "env", "extism_error_get")
+            .unwrap()
+            .into_func()
+            .unwrap()
+            .call(&mut store, &[], output)
+            .unwrap();
+        output[0].unwrap_i64() != 0
+    }
+
+    fn get_error(&mut self) -> Option<&str> {
+        let (linker, mut store) = self.linker_and_store();
+        let output = &mut [Val::I64(0)];
+        linker
+            .get(&mut store, "env", "extism_error_get")
+            .unwrap()
+            .into_func()
+            .unwrap()
+            .call(&mut store, &[], output)
+            .unwrap();
+        let offs = output[0].unwrap_i64() as u64;
+        if offs == 0 {
+            return None;
+        }
+
+        let length = self.memory_length(offs);
+        let data = self.memory_read(offs, length);
+        let s = std::str::from_utf8(data);
+        match s {
+            Ok(s) => Some(s),
+            Err(_) => None,
+        }
+    }
 }
 
 impl Internal {
-    pub(crate) fn new(manifest: &Manifest, wasi: bool) -> Result<Self, Error> {
+    pub(crate) fn new(
+        manifest: Manifest,
+        wasi: bool,
+        available_pages: Option<u32>,
+    ) -> Result<Self, Error> {
         let wasi = if wasi {
             let auth = wasmtime_wasi::ambient_authority();
             let mut ctx = wasmtime_wasi::WasiCtxBuilder::new();
@@ -85,48 +243,106 @@ impl Internal {
             #[cfg(feature = "nn")]
             let nn = wasmtime_wasi_nn::WasiNnCtx::new()?;
 
-            #[cfg(not(feature = "nn"))]
-            #[allow(clippy::let_unit_value)]
-            let nn = ();
-
             Some(Wasi {
                 ctx: ctx.build(),
+                #[cfg(feature = "nn")]
                 nn,
             })
         } else {
             None
         };
 
+        let memory_limiter = if let Some(pgs) = available_pages {
+            let n = pgs as usize * 65536;
+            Some(MemoryLimiter {
+                max_bytes: n,
+                bytes_left: n,
+            })
+        } else {
+            None
+        };
+
         Ok(Internal {
-            input_length: 0,
-            output_offset: 0,
-            output_length: 0,
-            input: std::ptr::null(),
             wasi,
-            memory: std::ptr::null_mut(),
+            manifest,
             http_status: 0,
-            last_error: std::cell::RefCell::new(None),
             vars: BTreeMap::new(),
+            linker: std::ptr::null_mut(),
+            store: std::ptr::null_mut(),
+            available_pages,
+            memory_limiter,
         })
     }
 
-    pub fn set_error(&self, e: impl std::fmt::Debug) {
-        debug!("Set error: {:?}", e);
-        *self.last_error.borrow_mut() = Some(error_string(e));
+    pub fn linker(&self) -> &wasmtime::Linker<Internal> {
+        unsafe { &*self.linker }
     }
 
-    /// Unset `last_error` field
-    pub fn clear_error(&self) {
-        *self.last_error.borrow_mut() = None;
+    pub fn linker_mut(&mut self) -> &mut wasmtime::Linker<Internal> {
+        unsafe { &mut *self.linker }
     }
 }
 
 impl InternalExt for Internal {
-    fn memory(&self) -> &PluginMemory {
-        unsafe { &*self.memory }
+    fn store(&self) -> &Store<Internal> {
+        unsafe { &*self.store }
     }
 
-    fn memory_mut(&mut self) -> &mut PluginMemory {
-        unsafe { &mut *self.memory }
+    fn store_mut(&mut self) -> &mut Store<Internal> {
+        unsafe { &mut *self.store }
+    }
+
+    fn linker(&self) -> &Linker<Internal> {
+        unsafe { &*self.linker }
+    }
+
+    fn linker_mut(&mut self) -> &mut Linker<Internal> {
+        unsafe { &mut *self.linker }
+    }
+
+    fn linker_and_store(&mut self) -> (&mut Linker<Internal>, &mut Store<Internal>) {
+        unsafe { (&mut *self.linker, &mut *self.store) }
+    }
+}
+
+pub(crate) struct MemoryLimiter {
+    bytes_left: usize,
+    max_bytes: usize,
+}
+
+impl MemoryLimiter {
+    pub(crate) fn reset(&mut self) {
+        self.bytes_left = self.max_bytes;
+    }
+}
+
+impl wasmtime::ResourceLimiter for MemoryLimiter {
+    fn memory_growing(
+        &mut self,
+        current: usize,
+        desired: usize,
+        maximum: Option<usize>,
+    ) -> Result<bool> {
+        if let Some(max) = maximum {
+            if desired > max {
+                return Ok(false);
+            }
+        }
+
+        let d = desired - current;
+        if d > self.bytes_left {
+            return Ok(false);
+        }
+
+        self.bytes_left -= d;
+        Ok(true)
+    }
+
+    fn table_growing(&mut self, _current: u32, desired: u32, maximum: Option<u32>) -> Result<bool> {
+        if let Some(max) = maximum {
+            return Ok(desired <= max);
+        }
+
+        Ok(true)
     }
 }

runtime/src/lib.rs

@@ -5,7 +5,6 @@ mod context;
 mod function;
 mod internal;
 pub mod manifest;
-mod memory;
 pub(crate) mod pdk;
 mod plugin;
 mod plugin_ref;
@@ -16,7 +15,6 @@ pub use context::Context;
 pub use function::{Function, UserData, Val, ValType};
 pub use internal::{Internal, InternalExt, Wasi};
 pub use manifest::Manifest;
-pub use memory::{MemoryBlock, PluginMemory, ToMemoryBlock};
 pub use plugin::Plugin;
 pub use plugin_ref::PluginRef;
 pub(crate) use timer::{Timer, TimerAction};

runtime/src/manifest.rs

@@ -7,7 +7,7 @@ use sha2::Digest;
 use crate::*;
 
 /// Manifest wraps the manifest exported by `extism_manifest`
-#[derive(Default, serde::Serialize, serde::Deserialize)]
+#[derive(Default, Clone, serde::Serialize, serde::Deserialize)]
 #[serde(transparent)]
 pub struct Manifest(extism_manifest::Manifest);
 
@@ -60,6 +60,8 @@ fn check_hash(hash: &Option<String>, data: &[u8]) -> Result<(), Error> {
     }
 }
 
+const WASM: &[u8] = include_bytes!("extism-runtime.wasm");
+
 /// Convert from manifest to a wasmtime Module
 fn to_module(engine: &Engine, wasm: &extism_manifest::Wasm) -> Result<(String, Module), Error> {
     match wasm {
@@ -167,6 +169,7 @@ const WASM_MAGIC: [u8; 4] = [0x00, 0x61, 0x73, 0x6d];
 impl Manifest {
     /// Create a new Manifest, returns the manifest and a map of modules
     pub fn new(engine: &Engine, data: &[u8]) -> Result<(Self, BTreeMap<String, Module>), Error> {
+        let extism_module = Module::new(engine, WASM)?;
         let has_magic = data.len() >= 4 && data[0..4] == WASM_MAGIC;
         let is_wast = data.starts_with(b"(module") || data.starts_with(b";;");
         if !has_magic && !is_wast {
@@ -178,12 +181,14 @@ impl Manifest {
             }
 
             let t = serde_json::from_slice::<Self>(data)?;
-            let m = t.modules(engine)?;
+            let mut m = t.modules(engine)?;
+            m.insert("env".to_string(), extism_module);
             return Ok((t, m));
         }
 
         let m = Module::new(engine, data)?;
         let mut modules = BTreeMap::new();
+        modules.insert("env".to_string(), extism_module);
         modules.insert("main".to_string(), m);
         Ok((Manifest::default(), modules))
     }

runtime/src/memory.rs

@@ -1,378 +0,0 @@
-use std::collections::BTreeMap;
-
-use crate::*;
-
-use pretty_hex::PrettyHex;
-
-/// Handles memory for plugins
-pub struct PluginMemory {
-    /// wasmtime Store
-    pub store: Option<Store<Internal>>,
-
-    /// WASM memory
-    pub memory: Memory,
-
-    /// Tracks allocated blocks
-    pub live_blocks: BTreeMap<usize, usize>,
-
-    /// Tracks free blocks
-    pub free: Vec<MemoryBlock>,
-
-    /// Tracks current offset in memory
-    pub position: usize,
-
-    /// Extism manifest
-    pub manifest: Manifest,
-}
-
-/// `ToMemoryBlock` is used to convert from Rust values to blocks of WASM memory
-pub trait ToMemoryBlock {
-    fn to_memory_block(&self, mem: &PluginMemory) -> Result<MemoryBlock, Error>;
-}
-
-impl ToMemoryBlock for MemoryBlock {
-    fn to_memory_block(&self, _mem: &PluginMemory) -> Result<MemoryBlock, Error> {
-        Ok(*self)
-    }
-}
-
-impl ToMemoryBlock for (usize, usize) {
-    fn to_memory_block(&self, _mem: &PluginMemory) -> Result<MemoryBlock, Error> {
-        Ok(MemoryBlock {
-            offset: self.0,
-            length: self.1,
-        })
-    }
-}
-
-impl ToMemoryBlock for usize {
-    fn to_memory_block(&self, mem: &PluginMemory) -> Result<MemoryBlock, Error> {
-        match mem.at_offset(*self) {
-            Some(x) => Ok(x),
-            None => Err(Error::msg(format!("Invalid memory offset: {}", self))),
-        }
-    }
-}
-
-const PAGE_SIZE: u32 = 65536;
-
-// BLOCK_SIZE_THRESHOLD exists to ensure that free blocks are never split up any
-// smaller than this value
-const BLOCK_SIZE_THRESHOLD: usize = 32;
-
-impl PluginMemory {
-    /// Create memory for a plugin
-    pub fn new(store: Store<Internal>, memory: Memory, manifest: Manifest) -> Self {
-        PluginMemory {
-            free: Vec::new(),
-            live_blocks: BTreeMap::new(),
-            store: Some(store),
-            memory,
-            position: 1,
-            manifest,
-        }
-    }
-
-    pub fn store(&self) -> &Store<Internal> {
-        self.store.as_ref().unwrap()
-    }
-
-    pub fn store_mut(&mut self) -> &mut Store<Internal> {
-        self.store.as_mut().unwrap()
-    }
-
-    /// Moves module to a new store
-    pub fn reinstantiate(&mut self) -> Result<(), Error> {
-        if let Some(store) = self.store.take() {
-            let engine = store.engine().clone();
-            let internal = store.into_data();
-            let mut store = Store::new(&engine, internal);
-            store.epoch_deadline_callback(|_internal| Err(Error::msg("timeout")));
-            self.memory = Memory::new(
-                &mut store,
-                MemoryType::new(4, self.manifest.as_ref().memory.max_pages),
-            )?;
-            self.store = Some(store);
-        }
-
-        self.reset();
-
-        Ok(())
-    }
-
-    /// Write byte to memory
-    pub(crate) fn store_u8(&mut self, offs: usize, data: u8) -> Result<(), MemoryAccessError> {
-        trace!("store_u8: offset={offs} data={data:#04x}");
-        if offs >= self.size() {
-            // This should raise MemoryAccessError
-            let buf = &mut [0];
-            self.memory.read(&self.store.as_ref().unwrap(), offs, buf)?;
-            return Ok(());
-        }
-        self.memory.data_mut(&mut self.store.as_mut().unwrap())[offs] = data;
-        Ok(())
-    }
-
-    /// Read byte from memory
-    pub(crate) fn load_u8(&self, offs: usize) -> Result<u8, MemoryAccessError> {
-        trace!("load_u8: offset={offs}");
-        if offs >= self.size() {
-            // This should raise MemoryAccessError
-            let buf = &mut [0];
-            self.memory.read(&self.store.as_ref().unwrap(), offs, buf)?;
-            return Ok(0);
-        }
-        Ok(self.memory.data(&self.store.as_ref().unwrap())[offs])
-    }
-
-    /// Write u64 to memory
-    pub(crate) fn store_u64(&mut self, offs: usize, data: u64) -> Result<(), Error> {
-        trace!("store_u64: offset={offs} data={data:#18x}");
-        let handle = MemoryBlock {
-            offset: offs,
-            length: 8,
-        };
-        self.write(handle, data.to_ne_bytes())?;
-        Ok(())
-    }
-
-    /// Read u64 from memory
-    pub(crate) fn load_u64(&self, offs: usize) -> Result<u64, Error> {
-        trace!("load_u64: offset={offs}");
-        let mut buf = [0; 8];
-        let handle = MemoryBlock {
-            offset: offs,
-            length: 8,
-        };
-        self.read(handle, &mut buf)?;
-        Ok(u64::from_ne_bytes(buf))
-    }
-
-    /// Write slice to memory
-    pub fn write(&mut self, pos: impl ToMemoryBlock, data: impl AsRef<[u8]>) -> Result<(), Error> {
-        let pos = pos.to_memory_block(self)?;
-        assert!(data.as_ref().len() <= pos.length);
-        self.memory
-            .write(&mut self.store.as_mut().unwrap(), pos.offset, data.as_ref())?;
-        Ok(())
-    }
-
-    /// Read slice from memory
-    pub fn read(&self, pos: impl ToMemoryBlock, mut data: impl AsMut<[u8]>) -> Result<(), Error> {
-        let pos = pos.to_memory_block(self)?;
-        assert!(data.as_mut().len() <= pos.length);
-        self.memory
-            .read(&self.store.as_ref().unwrap(), pos.offset, data.as_mut())?;
-        Ok(())
-    }
-
-    /// Size of memory in bytes
-    pub fn size(&self) -> usize {
-        self.memory.data_size(&self.store.as_ref().unwrap())
-    }
-
-    /// Size of memory in pages
-    pub fn pages(&self) -> u32 {
-        self.memory.size(&self.store.as_ref().unwrap()) as u32
-    }
-
-    /// Reserve `n` bytes of memory
-    pub fn alloc(&mut self, n: usize) -> Result<MemoryBlock, Error> {
-        debug!("Allocating {n} bytes");
-
-        for (i, block) in self.free.iter_mut().enumerate() {
-            if block.length == n {
-                let block = self.free.swap_remove(i);
-                self.live_blocks.insert(block.offset, block.length);
-                debug!("Found block with exact size at offset {}", block.offset);
-                return Ok(block);
-            } else if block.length.saturating_sub(n) >= BLOCK_SIZE_THRESHOLD {
-                let handle = MemoryBlock {
-                    offset: block.offset,
-                    length: n,
-                };
-                debug!(
-                    "Using block with size {} at offset {}",
-                    block.length, block.offset
-                );
-
-                block.offset += n;
-                block.length -= n;
-                self.live_blocks.insert(handle.offset, handle.length);
-                return Ok(handle);
-            }
-        }
-
-        let new_offset = self.position.saturating_add(n);
-
-        // If there aren't enough bytes, try to grow the memory size
-        if new_offset >= self.size() {
-            debug!("Need more memory");
-
-            let bytes_needed = (new_offset as f64 - self.size() as f64) / PAGE_SIZE as f64;
-            let mut pages_needed = bytes_needed.ceil() as u64;
-            if pages_needed == 0 {
-                pages_needed = 1
-            }
-
-            debug!("Requesting {pages_needed} more pages");
-            // This will fail if we've already allocated the maximum amount of memory allowed
-            self.memory
-                .grow(&mut self.store.as_mut().unwrap(), pages_needed)?;
-        }
-
-        let mem = MemoryBlock {
-            offset: self.position,
-            length: n,
-        };
-
-        debug!(
-            "Allocated new block: {} bytes at offset {}",
-            mem.length, mem.offset
-        );
-
-        self.live_blocks.insert(mem.offset, mem.length);
-        self.position += n;
-        Ok(mem)
-    }
-
-    /// Allocate and copy `data` into the wasm memory
-    pub fn alloc_bytes(&mut self, data: impl AsRef<[u8]>) -> Result<MemoryBlock, Error> {
-        let handle = self.alloc(data.as_ref().len())?;
-        self.write(handle, data)?;
-        Ok(handle)
-    }
-
-    /// Free the block allocated at `offset`
-    pub fn free(&mut self, offset: usize) {
-        debug!("Freeing block at {offset}");
-        if let Some(length) = self.live_blocks.remove(&offset) {
-            self.free.push(MemoryBlock { offset, length });
-        } else {
-            return;
-        }
-
-        let free_size: usize = self.free.iter().map(|x| x.length).sum();
-
-        // Perform compaction if there is at least 1kb of free memory available
-        if free_size >= 1024 {
-            let mut last: Option<MemoryBlock> = None;
-            let mut free = Vec::new();
-            for block in self.free.iter() {
-                match last {
-                    None => {
-                        free.push(*block);
-                    }
-                    Some(last) => {
-                        if last.offset + last.length == block.offset {
-                            free.push(MemoryBlock {
-                                offset: last.offset,
-                                length: last.length + block.length,
-                            });
-                        }
-                    }
-                }
-                last = Some(*block);
-            }
-            self.free = free;
-        }
-    }
-
-    /// Log entire memory as hexdump using the `trace` log level
-    pub fn dump(&self) {
-        let data = self.memory.data(self.store.as_ref().unwrap());
-
-        trace!("{:?}", data[..self.position].hex_dump());
-    }
-
-    /// Reset memory - clears free-list and live blocks and resets position
-    pub fn reset(&mut self) {
-        self.free.clear();
-        self.live_blocks.clear();
-        self.position = 1;
-    }
-
-    /// Get memory as a slice of bytes
-    pub fn data(&self) -> &[u8] {
-        self.memory.data(self.store.as_ref().unwrap())
-    }
-
-    /// Get memory as a mutable slice of bytes
-    pub fn data_mut(&mut self) -> &mut [u8] {
-        self.memory.data_mut(self.store.as_mut().unwrap())
-    }
-
-    /// Get bytes occupied by the provided memory handle
-    pub fn get(&self, handle: impl ToMemoryBlock) -> Result<&[u8], Error> {
-        let handle = handle.to_memory_block(self)?;
-        Ok(&self.memory.data(self.store.as_ref().unwrap())
-            [handle.offset..handle.offset + handle.length])
-    }
-
-    /// Get mutable bytes occupied by the provided memory handle
-    pub fn get_mut(&mut self, handle: impl ToMemoryBlock) -> Result<&mut [u8], Error> {
-        let handle = handle.to_memory_block(self)?;
-        Ok(&mut self.memory.data_mut(self.store.as_mut().unwrap())
-            [handle.offset..handle.offset + handle.length])
-    }
-
-    /// Get str occupied by the provided memory handle
-    pub fn get_str(&self, handle: impl ToMemoryBlock) -> Result<&str, Error> {
-        let handle = handle.to_memory_block(self)?;
-        Ok(std::str::from_utf8(
-            &self.memory.data(self.store.as_ref().unwrap())
-                [handle.offset..handle.offset + handle.length],
-        )?)
-    }
-
-    /// Get mutable str occupied by the provided memory handle
-    pub fn get_mut_str(&mut self, handle: impl ToMemoryBlock) -> Result<&mut str, Error> {
-        let handle = handle.to_memory_block(self)?;
-        Ok(std::str::from_utf8_mut(
-            &mut self.memory.data_mut(self.store.as_mut().unwrap())
-                [handle.offset..handle.offset + handle.length],
-        )?)
-    }
-
-    /// Pointer to the provided memory handle
-    pub fn ptr(&self, handle: impl ToMemoryBlock) -> Result<*mut u8, Error> {
-        let handle = handle.to_memory_block(self)?;
-        Ok(unsafe {
-            self.memory
-                .data_ptr(&self.store.as_ref().unwrap())
-                .add(handle.offset)
-        })
-    }
-
-    /// Get the length of the block starting at `offs`
-    pub fn block_length(&self, offs: usize) -> Option<usize> {
-        self.live_blocks.get(&offs).cloned()
-    }
-
-    /// Get the block at the specified offset
-    pub fn at_offset(&self, offset: usize) -> Option<MemoryBlock> {
-        let block_length = self.block_length(offset);
-        block_length.map(|length| MemoryBlock { offset, length })
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct MemoryBlock {
-    pub offset: usize,
-    pub length: usize,
-}
-
-impl From<(usize, usize)> for MemoryBlock {
-    fn from(x: (usize, usize)) -> Self {
-        MemoryBlock {
-            offset: x.0,
-            length: x.1,
-        }
-    }
-}
-
-impl MemoryBlock {
-    pub fn new(offset: usize, length: usize) -> Self {
-        MemoryBlock { offset, length }
-    }
-}

runtime/src/pdk.rs

@@ -18,177 +18,6 @@ macro_rules! args {
     };
 }
 
-/// Get the input length
-/// Params: none
-/// Returns: i64 (length)
-pub(crate) fn input_length(
-    caller: Caller<Internal>,
-    _input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &Internal = caller.data();
-    output[0] = Val::I64(data.input_length as i64);
-    Ok(())
-}
-
-/// Load a byte from input
-/// Params: i64 (offset)
-/// Returns: i32 (byte)
-pub(crate) fn input_load_u8(
-    caller: Caller<Internal>,
-    input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &Internal = caller.data();
-    if data.input.is_null() {
-        return Ok(());
-    }
-    output[0] = unsafe { Val::I32(*data.input.add(input[0].unwrap_i64() as usize) as i32) };
-    Ok(())
-}
-
-/// Load an unsigned 64 bit integer from input
-/// Params: i64 (offset)
-/// Returns: i64 (int)
-pub(crate) fn input_load_u64(
-    caller: Caller<Internal>,
-    input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &Internal = caller.data();
-    if data.input.is_null() {
-        return Ok(());
-    }
-    let offs = args!(input, 0, i64) as usize;
-    let slice = unsafe { std::slice::from_raw_parts(data.input.add(offs), 8) };
-    let byte = u64::from_ne_bytes(slice.try_into().unwrap());
-    output[0] = Val::I64(byte as i64);
-    Ok(())
-}
-
-/// Store a byte in memory
-/// Params: i64 (offset), i32 (byte)
-/// Returns: none
-pub(crate) fn store_u8(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    _output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let (offset, byte) = args!(input, (0, i64), (1, i32));
-    data.memory_mut().store_u8(offset as usize, byte as u8)?;
-    Ok(())
-}
-
-/// Load a byte from memory
-/// Params: i64 (offset)
-/// Returns: i32 (byte)
-pub(crate) fn load_u8(
-    caller: Caller<Internal>,
-    input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &Internal = caller.data();
-    let offset = args!(input, 0, i64) as usize;
-    let byte = data.memory().load_u8(offset)?;
-    output[0] = Val::I32(byte as i32);
-    Ok(())
-}
-
-/// Store an unsigned 64 bit integer in memory
-/// Params: i64 (offset), i64 (int)
-/// Returns: none
-pub(crate) fn store_u64(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    _output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let (offset, b) = args!(input, (0, i64), (1, i64));
-    data.memory_mut().store_u64(offset as usize, b as u64)?;
-    Ok(())
-}
-
-/// Load an unsigned 64 bit integer from memory
-/// Params: i64 (offset)
-/// Returns: i64 (int)
-pub(crate) fn load_u64(
-    caller: Caller<Internal>,
-    input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &Internal = caller.data();
-    let offset = args!(input, 0, i64) as usize;
-    let byte = data.memory().load_u64(offset)?;
-    output[0] = Val::I64(byte as i64);
-    Ok(())
-}
-
-/// Set output offset and length
-/// Params: i64 (offset), i64 (length)
-/// Returns: none
-pub(crate) fn output_set(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    _output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let (offset, length) = args!(input, (0, i64), (1, i64));
-    data.output_offset = offset as usize;
-    data.output_length = length as usize;
-    Ok(())
-}
-
-/// Allocate bytes
-/// Params: i64 (length)
-/// Returns: i64 (offset)
-pub(crate) fn alloc(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let offs = data.memory_mut().alloc(input[0].unwrap_i64() as _)?;
-    output[0] = Val::I64(offs.offset as i64);
-
-    Ok(())
-}
-
-/// Free memory
-/// Params: i64 (offset)
-/// Returns: none
-pub(crate) fn free(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    _output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let offset = args!(input, 0, i64) as usize;
-    data.memory_mut().free(offset);
-    Ok(())
-}
-
-/// Set the error message, this can be checked by the host program
-/// Params: i64 (offset)
-/// Returns: none
-pub(crate) fn error_set(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    _output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let offset = args!(input, 0, i64) as usize;
-
-    if offset == 0 {
-        *data.last_error.borrow_mut() = None;
-        return Ok(());
-    }
-
-    let s = data.memory().get_str(offset)?;
-    data.set_error(s);
-    Ok(())
-}
-
 /// Get a configuration value
 /// Params: i64 (offset)
 /// Returns: i64 (offset)
@@ -199,21 +28,24 @@ pub(crate) fn config_get(
 ) -> Result<(), Error> {
     let data: &mut Internal = caller.data_mut();
 
-    let offset = args!(input, 0, i64) as usize;
-    let key = data.memory().get_str(offset)?;
-    let val = data.memory().manifest.as_ref().config.get(key);
+    let offset = args!(input, 0, i64) as u64;
+    let key = data.memory_read_str(offset)?;
+    let key = unsafe {
+        std::str::from_utf8_unchecked(std::slice::from_raw_parts(key.as_ptr(), key.len()))
+    };
+    let val = data.internal().manifest.as_ref().config.get(key);
     let ptr = val.map(|x| (x.len(), x.as_ptr()));
     let mem = match ptr {
         Some((len, ptr)) => {
             let bytes = unsafe { std::slice::from_raw_parts(ptr, len) };
-            data.memory_mut().alloc_bytes(bytes)?
+            data.memory_alloc_bytes(bytes)?
         }
         None => {
             output[0] = Val::I64(0);
             return Ok(());
         }
     };
-    output[0] = Val::I64(mem.offset as i64);
+    output[0] = Val::I64(mem as i64);
     Ok(())
 }
 
@@ -227,23 +59,24 @@ pub(crate) fn var_get(
 ) -> Result<(), Error> {
     let data: &mut Internal = caller.data_mut();
 
-    let offset = args!(input, 0, i64) as usize;
-    let key = data.memory().get_str(offset)?;
-    let val = data.vars.get(key);
+    let offset = args!(input, 0, i64) as u64;
+    let key = data.memory_read_str(offset)?;
+    let key = unsafe {
+        std::str::from_utf8_unchecked(std::slice::from_raw_parts(key.as_ptr(), key.len()))
+    };
+    let val = data.internal().vars.get(key);
     let ptr = val.map(|x| (x.len(), x.as_ptr()));
-
     let mem = match ptr {
         Some((len, ptr)) => {
             let bytes = unsafe { std::slice::from_raw_parts(ptr, len) };
-            data.memory_mut().alloc_bytes(bytes)?
+            data.memory_alloc_bytes(bytes)?
         }
         None => {
             output[0] = Val::I64(0);
             return Ok(());
         }
     };
-
-    output[0] = Val::I64(mem.offset as i64);
+    output[0] = Val::I64(mem as i64);
     Ok(())
 }
 
@@ -262,16 +95,16 @@ pub(crate) fn var_set(
         size += v.len();
     }
 
-    let voffset = args!(input, 1, i64) as usize;
+    let voffset = args!(input, 1, i64) as u64;
 
     // If the store is larger than 100MB then stop adding things
     if size > 1024 * 1024 * 100 && voffset != 0 {
         return Err(Error::msg("Variable store is full"));
     }
 
-    let key_offs = args!(input, 0, i64) as usize;
+    let key_offs = args!(input, 0, i64) as u64;
     let key = {
-        let key = data.memory().get_str(key_offs)?;
+        let key = data.memory_read_str(key_offs)?;
         let key_len = key.len();
         let key_ptr = key.as_ptr();
         unsafe { std::str::from_utf8_unchecked(std::slice::from_raw_parts(key_ptr, key_len)) }
@@ -283,10 +116,11 @@ pub(crate) fn var_set(
         return Ok(());
     }
 
-    let value = data.memory().get(voffset)?;
+    let vlen = data.memory_length(voffset);
+    let value = data.memory_read(voffset, vlen).to_vec();
 
     // Insert the value from memory into the `vars` map
-    data.vars.insert(key.to_string(), value.to_vec());
+    data.vars.insert(key.to_string(), value);
 
     Ok(())
 }
@@ -312,18 +146,19 @@ pub(crate) fn http_request(
     {
         use std::io::Read;
         let data: &mut Internal = caller.data_mut();
-        let http_req_offset = args!(input, 0, i64) as usize;
+        let http_req_offset = args!(input, 0, i64) as u64;
 
+        let http_req_len = data.memory_length(http_req_offset);
         let req: extism_manifest::HttpRequest =
-            serde_json::from_slice(data.memory().get(http_req_offset)?)?;
+            serde_json::from_slice(data.memory_read(http_req_offset, http_req_len))?;
 
-        let body_offset = args!(input, 1, i64) as usize;
+        let body_offset = args!(input, 1, i64) as u64;
 
         let url = match url::Url::parse(&req.url) {
             Ok(u) => u,
             Err(e) => return Err(Error::msg(format!("Invalid URL: {e:?}"))),
         };
-        let allowed_hosts = &data.memory().manifest.as_ref().allowed_hosts;
+        let allowed_hosts = &data.internal().manifest.as_ref().allowed_hosts;
         let host_str = url.host_str().unwrap_or_default();
         let host_matches = if let Some(allowed_hosts) = allowed_hosts {
             allowed_hosts.iter().any(|url| {
@@ -352,7 +187,8 @@ pub(crate) fn http_request(
         }
 
         let res = if body_offset > 0 {
-            let buf = data.memory().get(body_offset)?;
+            let len = data.memory_length(body_offset);
+            let buf = data.memory_read(body_offset, len);
             r.send_bytes(buf)
         } else {
             r.call()
@@ -364,6 +200,7 @@ pub(crate) fn http_request(
                 Some(res.into_reader())
             }
             Err(e) => {
+                log::error!("Unable to make HTTP request: {:?}", e);
                 if let Some(res) = e.into_response() {
                     data.http_status = res.status();
                     Some(res.into_reader())
@@ -379,9 +216,8 @@ pub(crate) fn http_request(
                 .take(1024 * 1024 * 50) // TODO: make this limit configurable
                 .read_to_end(&mut buf)?;
 
-            let mem = data.memory_mut().alloc_bytes(buf)?;
-
-            output[0] = Val::I64(mem.offset as i64);
+            let mem = data.memory_alloc_bytes(buf)?;
+            output[0] = Val::I64(mem as i64);
         } else {
             output[0] = Val::I64(0);
         }
@@ -403,39 +239,17 @@ pub(crate) fn http_status_code(
     Ok(())
 }
 
-/// Get the length of an allocated block given the offset
-/// Params: i64 (offset)
-/// Returns: i64 (length or 0)
-pub(crate) fn length(
-    mut caller: Caller<Internal>,
-    input: &[Val],
-    output: &mut [Val],
-) -> Result<(), Error> {
-    let data: &mut Internal = caller.data_mut();
-    let offset = args!(input, 0, i64) as usize;
-    if offset == 0 {
-        output[0] = Val::I64(0);
-        return Ok(());
-    }
-    let length = match data.memory().block_length(offset) {
-        Some(x) => x,
-        None => return Err(Error::msg("Unable to find length for offset")),
-    };
-    output[0] = Val::I64(length as i64);
-    Ok(())
-}
-
 pub fn log(
     level: log::Level,
-    caller: Caller<Internal>,
+    mut caller: Caller<Internal>,
     input: &[Val],
     _output: &mut [Val],
 ) -> Result<(), Error> {
-    let data: &Internal = caller.data();
-    let offset = args!(input, 0, i64) as usize;
-    let buf = data.memory().get(offset)?;
+    let data: &mut Internal = caller.data_mut();
+    let offset = args!(input, 0, i64) as u64;
+    let buf = data.memory_read_str(offset);
 
-    match std::str::from_utf8(buf) {
+    match buf {
         Ok(buf) => log::log!(level, "{}", buf),
         Err(_) => log::log!(level, "{:?}", buf),
     }

runtime/src/plugin.rs

@@ -9,17 +9,16 @@ pub struct Plugin {
 
     /// Used to define functions and create new instances
     pub linker: Linker<Internal>,
+    pub store: Store<Internal>,
 
     /// Instance provides the ability to call functions in a module
-    pub instance: Instance,
+    pub instance: Option<Instance>,
+    pub instance_pre: InstancePre<Internal>,
 
     /// Keep track of the number of times we're instantiated, this exists
     /// to avoid issues with memory piling up since `Instance`s are only
     /// actually cleaned up along with a `Store`
-    pub instantiations: usize,
-
-    /// Handles interactions with WASM memory
-    pub memory: std::cell::UnsafeCell<PluginMemory>,
+    instantiations: usize,
 
     /// The ID used to identify this plugin with the `Timer`
     pub timer_id: uuid::Uuid,
@@ -27,18 +26,30 @@ pub struct Plugin {
     /// A handle used to cancel execution of a plugin
     pub(crate) cancel_handle: sdk::ExtismCancelHandle,
 
-    /// Runtime determines any initialization and cleanup functions needed
+    /// Runtime determines any initialization functions needed
     /// to run a module
     pub(crate) runtime: Option<Runtime>,
 }
 
 impl InternalExt for Plugin {
-    fn memory(&self) -> &PluginMemory {
-        unsafe { &*self.memory.get() }
+    fn store(&self) -> &Store<Internal> {
+        &self.store
     }
 
-    fn memory_mut(&mut self) -> &mut PluginMemory {
-        self.memory.get_mut()
+    fn store_mut(&mut self) -> &mut Store<Internal> {
+        &mut self.store
+    }
+
+    fn linker(&self) -> &Linker<Internal> {
+        &self.linker
+    }
+
+    fn linker_mut(&mut self) -> &mut Linker<Internal> {
+        &mut self.linker
+    }
+
+    fn linker_and_store(&mut self) -> (&mut Linker<Internal>, &mut Store<Internal>) {
+        (&mut self.linker, &mut self.store)
     }
 }
 
@@ -55,6 +66,59 @@ fn profiling_strategy() -> ProfilingStrategy {
     }
 }
 
+fn calculate_available_memory(
+    available_pages: &mut Option<u32>,
+    modules: &BTreeMap<String, Module>,
+) -> anyhow::Result<()> {
+    let available_pages = match available_pages {
+        Some(p) => p,
+        None => return Ok(()),
+    };
+
+    let max_pages = *available_pages;
+    let mut fail_memory_check = false;
+    let mut total_memory_needed = 0;
+    for (name, module) in modules.iter() {
+        if name == "env" {
+            continue;
+        }
+        let mut memories = 0;
+        for export in module.exports() {
+            if let Some(memory) = export.ty().memory() {
+                memories += 1;
+                let memory_max = memory.maximum();
+                match memory_max {
+                    None => anyhow::bail!("Unbounded memory in module {name}, when `memory.max_pages` is set in the manifest all modules \
+                                           must have a maximum bound set on an exported memory"),
+                    Some(m) => {
+                        total_memory_needed += m;
+                        if !fail_memory_check {
+                            continue;
+                        }
+
+                        *available_pages = available_pages.saturating_sub(m as u32);
+                        if *available_pages == 0 {
+                            fail_memory_check = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        if memories == 0 {
+            anyhow::bail!("No memory exported from module {name}, when `memory.max_pages` is set in the manifest all modules must \
+                           have a maximum bound set on an exported memory");
+        }
+    }
+
+    if fail_memory_check {
+        anyhow::bail!("Not enough memory configured to run the provided plugin, `memory.max_pages` is set to {max_pages} in the manifest \
+                       but {total_memory_needed} pages are needed by the plugin");
+    }
+
+    Ok(())
+}
+
 impl Plugin {
     /// Create a new plugin from the given WASM code
     pub fn new<'a>(
@@ -68,20 +132,28 @@ impl Plugin {
             Config::new()
                 .epoch_interruption(true)
                 .debug_info(std::env::var("EXTISM_DEBUG").is_ok())
-                .profiler(profiling_strategy()),
+                .profiler(profiling_strategy())
+                .cache_config_load_default()?,
         )?;
         let mut imports = imports.into_iter();
         let (manifest, modules) = Manifest::new(&engine, wasm.as_ref())?;
-        let mut store = Store::new(&engine, Internal::new(&manifest, with_wasi)?);
-        store.epoch_deadline_callback(|_internal| Err(Error::msg("timeout")));
 
-        // Create memory
-        let memory = Memory::new(
-            &mut store,
-            MemoryType::new(4, manifest.as_ref().memory.max_pages),
-        )?;
-        let mut memory = PluginMemory::new(store, memory, manifest);
+        // Calculate how much memory is available based on the value of `max_pages` and the exported
+        // memory of the modules. An error will be returned if a module doesn't have an exported memory
+        // or there is no maximum set for a module's exported memory.
+        let mut available_pages = manifest.as_ref().memory.max_pages;
+        calculate_available_memory(&mut available_pages, &modules)?;
+        log::trace!("Available pages: {available_pages:?}");
 
+        let mut store = Store::new(
+            &engine,
+            Internal::new(manifest, with_wasi, available_pages)?,
+        );
+        store.epoch_deadline_callback(|_internal| Ok(wasmtime::UpdateDeadline::Continue(1)));
+
+        if available_pages.is_some() {
+            store.limiter(|internal| internal.memory_limiter.as_mut().unwrap());
+        }
         let mut linker = Linker::new(&engine);
         linker.allow_shadowing(true);
 
@@ -119,7 +191,10 @@ impl Plugin {
         }
 
         // Add builtins
-        for (_name, module) in modules.iter() {
+        for (name, module) in modules.iter() {
+            if name != main_name {
+                linker.module(&mut store, name, module)?;
+            }
             for import in module.imports() {
                 let module_name = import.module();
                 let name = import.name();
@@ -127,249 +202,242 @@ impl Plugin {
 
                 if module_name == EXPORT_MODULE_NAME {
                     define_funcs!(name,  {
-                        alloc(I64) -> I64;
-                        free(I64);
-                        load_u8(I64) -> I32;
-                        load_u64(I64) -> I64;
-                        store_u8(I64, I32);
-                        store_u64(I64, I64);
-                        input_length() -> I64;
-                        input_load_u8(I64) -> I32;
-                        input_load_u64(I64) -> I64;
-                        output_set(I64, I64);
-                        error_set(I64);
                         config_get(I64) -> I64;
                         var_get(I64) -> I64;
                         var_set(I64, I64);
                         http_request(I64, I64) -> I64;
                         http_status_code() -> I32;
-                        length(I64) -> I64;
                         log_warn(I64);
                         log_info(I64);
                         log_debug(I64);
                         log_error(I64);
                     });
-
-                    for f in &mut imports {
-                        let name = f.name().to_string();
-                        let ns = f.namespace().unwrap_or(EXPORT_MODULE_NAME);
-                        linker.func_new(ns, &name, f.ty().clone(), unsafe {
-                            &*std::sync::Arc::as_ptr(&f.f)
-                        })?;
-                    }
                 }
             }
         }
 
-        // Add modules to linker
-        for (name, module) in modules.iter() {
-            if name != main_name {
-                linker.module(&mut memory.store_mut(), name, module)?;
-            }
+        for f in &mut imports {
+            let name = f.name().to_string();
+            let ns = f.namespace().unwrap_or(EXPORT_MODULE_NAME);
+            linker.func_new(ns, &name, f.ty().clone(), unsafe {
+                &*std::sync::Arc::as_ptr(&f.f)
+            })?;
         }
 
-        let instance = linker.instantiate(&mut memory.store_mut(), main)?;
+        let instance_pre = linker.instantiate_pre(&main)?;
         let timer_id = uuid::Uuid::new_v4();
         let mut plugin = Plugin {
             modules,
             linker,
-            memory: std::cell::UnsafeCell::new(memory),
-            instance,
-            instantiations: 1,
+            instance: None,
+            instance_pre,
+            store,
             runtime: None,
             timer_id,
             cancel_handle: sdk::ExtismCancelHandle {
                 id: timer_id,
                 epoch_timer_tx: None,
             },
+            instantiations: 0,
         };
 
-        // Make sure `Internal::memory` is initialized
-        plugin.internal_mut().memory = plugin.memory.get();
-
-        // Then detect runtime before returning the new plugin
-        plugin.detect_runtime();
+        plugin.internal_mut().store = &mut plugin.store;
+        plugin.internal_mut().linker = &mut plugin.linker;
         Ok(plugin)
     }
 
+    pub(crate) fn reset_store(&mut self) -> Result<(), Error> {
+        self.instance = None;
+        if self.instantiations > 5 {
+            let (main_name, main) = self
+                .modules
+                .get("main")
+                .map(|x| ("main", x))
+                .unwrap_or_else(|| {
+                    let entry = self.modules.iter().last().unwrap();
+                    (entry.0.as_str(), entry.1)
+                });
+
+            let engine = self.store.engine().clone();
+            let internal = self.internal();
+            self.store = Store::new(
+                &engine,
+                Internal::new(
+                    internal.manifest.clone(),
+                    internal.wasi.is_some(),
+                    internal.available_pages,
+                )?,
+            );
+            self.store
+                .epoch_deadline_callback(|_internal| Ok(UpdateDeadline::Continue(1)));
+
+            if self.internal().available_pages.is_some() {
+                self.store
+                    .limiter(|internal| internal.memory_limiter.as_mut().unwrap());
+            }
+
+            for (name, module) in self.modules.iter() {
+                if name != main_name {
+                    self.linker.module(&mut self.store, name, module)?;
+                }
+            }
+            self.instantiations = 0;
+            self.instance_pre = self.linker.instantiate_pre(&main)?;
+
+            let store = &mut self.store as *mut _;
+            let linker = &mut self.linker as *mut _;
+            let internal = self.internal_mut();
+            internal.store = store;
+            internal.linker = linker;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn instantiate(&mut self) -> Result<(), Error> {
+        self.instance = Some(self.instance_pre.instantiate(&mut self.store)?);
+        self.instantiations += 1;
+        if let Some(limiter) = &mut self.internal_mut().memory_limiter {
+            limiter.reset();
+        }
+        self.detect_runtime();
+        self.initialize_runtime()?;
+        Ok(())
+    }
+
     /// Get a function by name
     pub fn get_func(&mut self, function: impl AsRef<str>) -> Option<Func> {
-        self.instance
-            .get_func(&mut self.memory.get_mut().store_mut(), function.as_ref())
-    }
+        if let None = &self.instance {
+            if let Err(e) = self.instantiate() {
+                error!("Unable to instantiate: {e}");
+                return None;
+            }
+        }
 
-    // A convenience method to set the plugin error and return a value
-    pub fn error<E>(&self, e: impl std::fmt::Debug, x: E) -> E {
-        self.store().data().set_error(e);
-        x
+        if let Some(instance) = &mut self.instance {
+            instance.get_func(&mut self.store, function.as_ref())
+        } else {
+            None
+        }
     }
 
     /// Store input in memory and initialize `Internal` pointer
-    pub fn set_input(&mut self, input: *const u8, mut len: usize) {
+    pub(crate) fn set_input(&mut self, input: *const u8, mut len: usize) -> Result<(), Error> {
         if input.is_null() {
             len = 0;
         }
-        let ptr = self.memory.get();
-        let internal = self.internal_mut();
-        internal.input = input;
-        internal.input_length = len;
-        internal.memory = ptr
-    }
 
-    /// Dump memory using trace! logging
-    pub fn dump_memory(&self) {
-        self.memory().dump();
-    }
-
-    /// Create a new instance from the same modules
-    pub fn reinstantiate(&mut self) -> Result<(), Error> {
-        let (main_name, main) = self
-            .modules
-            .get("main")
-            .map(|x| ("main", x))
-            .unwrap_or_else(|| {
-                let entry = self.modules.iter().last().unwrap();
-                (entry.0.as_str(), entry.1)
-            });
-
-        // Avoid running into resource limits, after 5 instantiations reset the store. This will
-        // release any old `Instance` objects
-        if self.instantiations > 5 {
-            self.memory.get_mut().reinstantiate()?;
-
-            // Get the `main` module, or the last one if `main` doesn't exist
-            for (name, module) in self.modules.iter() {
-                if name != main_name {
-                    self.linker
-                        .module(&mut self.memory.get_mut().store_mut(), name, module)?;
-                }
-            }
-            self.instantiations = 0;
+        {
+            let store = &mut self.store as *mut _;
+            let linker = &mut self.linker as *mut _;
+            let internal = self.internal_mut();
+            internal.store = store;
+            internal.linker = linker;
+        }
+
+        if len > 0 {
+            let bytes = unsafe { std::slice::from_raw_parts(input, len) };
+            trace!("Input size: {}", bytes.len());
+
+            if let Some(f) = self.linker.get(&mut self.store, "env", "extism_reset") {
+                f.into_func().unwrap().call(&mut self.store, &[], &mut [])?;
+            } else {
+                error!("Call to extism_reset failed");
+            }
+
+            let offs = self.memory_alloc_bytes(bytes)?;
+
+            if let Some(f) = self.linker.get(&mut self.store, "env", "extism_input_set") {
+                f.into_func().unwrap().call(
+                    &mut self.store,
+                    &[Val::I64(offs as i64), Val::I64(len as i64)],
+                    &mut [],
+                )?;
+            }
         }
 
-        let instance = self
-            .linker
-            .instantiate(&mut self.memory.get_mut().store_mut(), &main)?;
-        self.instance = instance;
-        self.detect_runtime();
-        self.instantiations += 1;
         Ok(())
     }
 
     /// Determine if wasi is enabled
     pub fn has_wasi(&self) -> bool {
-        self.memory().store().data().wasi.is_some()
+        self.internal().wasi.is_some()
     }
 
     fn detect_runtime(&mut self) {
         // Check for Haskell runtime initialization functions
-        // Initialize Haskell runtime if `hs_init` and `hs_exit` are present,
+        // Initialize Haskell runtime if `hs_init` is present,
         // by calling the `hs_init` export
         if let Some(init) = self.get_func("hs_init") {
-            if let Some(cleanup) = self.get_func("hs_exit") {
-                if init
-                    .typed::<(i32, i32), ()>(&self.memory().store())
-                    .is_err()
-                {
+            let reactor_init = if let Some(init) = self.get_func("_initialize") {
+                if init.typed::<(), ()>(&self.store()).is_err() {
                     trace!(
-                        "hs_init function found with type {:?}",
-                        init.ty(&self.memory().store())
+                        "_initialize function found with type {:?}",
+                        init.ty(self.store())
                     );
+                    None
+                } else {
+                    trace!("WASI reactor module detected");
+                    Some(init)
                 }
-                self.runtime = Some(Runtime::Haskell { init, cleanup });
-            }
+            } else {
+                None
+            };
+            self.runtime = Some(Runtime::Haskell { init, reactor_init });
             return;
         }
 
-        // Check for `__wasm__call_ctors` and `__wasm_call_dtors`, this is used by WASI to
+        // Check for `__wasm_call_ctors` or `_initialize`, this is used by WASI to
         // initialize certain interfaces.
-        if self.has_wasi() {
-            if let Some(init) = self.get_func("__wasm_call_ctors") {
-                if init.typed::<(), ()>(&self.memory().store()).is_err() {
-                    trace!(
-                        "__wasm_call_ctors function found with type {:?}",
-                        init.ty(&self.memory().store())
-                    );
-                    return;
-                }
-                trace!("WASI runtime detected");
-                if let Some(cleanup) = self.get_func("__wasm_call_dtors") {
-                    if cleanup.typed::<(), ()>(&self.memory().store()).is_err() {
-                        trace!(
-                            "__wasm_call_dtors function found with type {:?}",
-                            cleanup.ty(&self.memory().store())
-                        );
-                        return;
-                    }
-                    self.runtime = Some(Runtime::Wasi {
-                        init,
-                        cleanup: Some(cleanup),
-                    });
-                    return;
-                }
-
-                self.runtime = Some(Runtime::Wasi {
-                    init,
-                    cleanup: None,
-                });
+        let init = if let Some(init) = self.get_func("__wasm_call_ctors") {
+            if init.typed::<(), ()>(&self.store()).is_err() {
+                trace!(
+                    "__wasm_call_ctors function found with type {:?}",
+                    init.ty(self.store())
+                );
+                return;
             }
+            trace!("WASI runtime detected");
+            init
+        } else if let Some(init) = self.get_func("_initialize") {
+            if init.typed::<(), ()>(&self.store()).is_err() {
+                trace!(
+                    "_initialize function found with type {:?}",
+                    init.ty(self.store())
+                );
+                return;
+            }
+            trace!("Reactor module detected");
+            init
+        } else {
             return;
-        }
+        };
+
+        self.runtime = Some(Runtime::Wasi { init });
 
         trace!("No runtime detected");
     }
 
     pub(crate) fn initialize_runtime(&mut self) -> Result<(), Error> {
+        let mut store = &mut self.store;
         if let Some(runtime) = &self.runtime {
             trace!("Plugin::initialize_runtime");
             match runtime {
-                Runtime::Haskell { init, cleanup: _ } => {
-                    let mut results =
-                        vec![Val::null(); init.ty(&self.memory().store()).results().len()];
+                Runtime::Haskell { init, reactor_init } => {
+                    if let Some(reactor_init) = reactor_init {
+                        reactor_init.call(&mut store, &[], &mut [])?;
+                    }
+                    let mut results = vec![Val::null(); init.ty(&store).results().len()];
                     init.call(
-                        &mut self.memory.get_mut().store_mut(),
+                        &mut store,
                         &[Val::I32(0), Val::I32(0)],
                         results.as_mut_slice(),
                     )?;
                     debug!("Initialized Haskell language runtime");
                 }
-                Runtime::Wasi { init, cleanup: _ } => {
-                    debug!("Calling __wasm_call_ctors");
-                    init.call(&mut self.memory.get_mut().store_mut(), &[], &mut [])?;
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    #[inline(always)]
-    pub(crate) fn cleanup_runtime(&mut self) -> Result<(), Error> {
-        if let Some(runtime) = self.runtime.clone() {
-            trace!("Plugin::cleanup_runtime");
-            match runtime {
-                Runtime::Wasi {
-                    init: _,
-                    cleanup: Some(cleanup),
-                } => {
-                    debug!("Calling __wasm_call_dtors");
-                    cleanup.call(&mut self.memory_mut().store_mut(), &[], &mut [])?;
-                }
-                Runtime::Wasi {
-                    init: _,
-                    cleanup: None,
-                } => (),
-                // Cleanup Haskell runtime if `hs_exit` and `hs_exit` are present,
-                // by calling the `hs_exit` export
-                Runtime::Haskell { init: _, cleanup } => {
-                    let mut results =
-                        vec![Val::null(); cleanup.ty(&self.memory().store()).results().len()];
-                    cleanup.call(
-                        &mut self.memory_mut().store_mut(),
-                        &[],
-                        results.as_mut_slice(),
-                    )?;
-                    debug!("Cleaned up Haskell language runtime");
+                Runtime::Wasi { init } => {
+                    init.call(&mut store, &[], &mut [])?;
+                    debug!("Initialied WASI runtime");
                 }
             }
         }
@@ -384,14 +452,16 @@ impl Plugin {
         tx: &std::sync::mpsc::SyncSender<TimerAction>,
     ) -> Result<(), Error> {
         let duration = self
-            .memory()
+            .internal()
             .manifest
             .as_ref()
             .timeout_ms
             .map(std::time::Duration::from_millis);
         self.cancel_handle.epoch_timer_tx = Some(tx.clone());
-        self.memory_mut().store_mut().set_epoch_deadline(1);
-        let engine: Engine = self.memory().store().engine().clone();
+        self.store_mut().set_epoch_deadline(1);
+        self.store
+            .epoch_deadline_callback(|_internal| Err(Error::msg("timeout")));
+        let engine: Engine = self.store().engine().clone();
         tx.send(TimerAction::Start {
             id: self.timer_id,
             duration,
@@ -405,6 +475,8 @@ impl Plugin {
         if let Some(tx) = &self.cancel_handle.epoch_timer_tx {
             tx.send(TimerAction::Stop { id: self.timer_id })?;
         }
+        self.store
+            .epoch_deadline_callback(|_internal| Ok(wasmtime::UpdateDeadline::Continue(1)));
         Ok(())
     }
 }
@@ -412,6 +484,11 @@ impl Plugin {
 // Enumerates the supported PDK language runtimes
 #[derive(Clone)]
 pub(crate) enum Runtime {
-    Haskell { init: Func, cleanup: Func },
-    Wasi { init: Func, cleanup: Option<Func> },
+    Haskell {
+        init: Func,
+        reactor_init: Option<Func>,
+    },
+    Wasi {
+        init: Func,
+    },
 }

runtime/src/plugin_ref.rs

@@ -3,6 +3,7 @@ use crate::*;
 // PluginRef is used to access a plugin from a context-scoped plugin registry
 pub struct PluginRef<'a> {
     pub id: PluginIndex,
+    running: bool,
     pub(crate) epoch_timer_tx: std::sync::mpsc::SyncSender<TimerAction>,
     plugin: *mut Plugin,
     _t: std::marker::PhantomData<&'a ()>,
@@ -10,23 +11,25 @@ pub struct PluginRef<'a> {
 
 impl<'a> PluginRef<'a> {
     /// Initialize the plugin for a new call
-    ///
-    /// - Resets memory offsets
-    /// - Updates `input` pointer
-    pub fn init(mut self, data: *const u8, data_len: usize) -> Self {
-        trace!("PluginRef::init: {}", self.id,);
-        let plugin = self.as_mut();
-        plugin.memory_mut().reset();
-        if plugin.has_wasi() || plugin.runtime.is_some() {
-            if let Err(e) = plugin.reinstantiate() {
-                error!("Failed to reinstantiate: {e:?}");
-                plugin
-                    .internal()
-                    .set_error(format!("Failed to reinstantiate: {e:?}"));
-                return self;
+    pub(crate) fn start_call(mut self, is_start: bool) -> Self {
+        trace!("PluginRef::start_call: {}", self.id,);
+
+        let plugin = unsafe { &mut *self.plugin };
+        if is_start {
+            if let Err(e) = plugin.reset_store() {
+                error!("Call to Plugin::reset_store failed: {e:?}");
             }
         }
-        plugin.set_input(data, data_len);
+
+        if plugin.instance.is_none() {
+            trace!("Plugin::instance is none, instantiating");
+            if let Err(e) = plugin.instantiate() {
+                error!("Plugin::instantiate failed: {e:?}");
+                plugin.error(e, ());
+            }
+        }
+
+        self.running = true;
         self
     }
 
@@ -45,13 +48,13 @@ impl<'a> PluginRef<'a> {
             return ctx.error(format!("Plugin does not exist: {plugin_id}"), None);
         };
 
+        let plugin = unsafe { &mut *plugin };
+
         if clear_error {
             trace!("Clearing context error");
             ctx.error = None;
             trace!("Clearing plugin error: {plugin_id}");
-            unsafe {
-                (&*plugin).internal().clear_error();
-            }
+            plugin.clear_error();
         }
 
         Some(PluginRef {
@@ -59,6 +62,7 @@ impl<'a> PluginRef<'a> {
             plugin,
             epoch_timer_tx,
             _t: std::marker::PhantomData,
+            running: false,
         })
     }
 }
@@ -78,6 +82,14 @@ impl<'a> AsMut<Plugin> for PluginRef<'a> {
 impl<'a> Drop for PluginRef<'a> {
     fn drop(&mut self) {
         trace!("Dropping PluginRef {}", self.id);
-        // Cleanup?
+        if self.running {
+            let plugin = self.as_mut();
+
+            // Stop timer
+            if let Err(e) = plugin.stop_timer() {
+                let id = plugin.timer_id;
+                error!("Failed to stop timeout manager for {id}: {e:?}");
+            }
+        }
     }
 }

runtime/src/sdk.rs

@@ -99,7 +99,7 @@ pub unsafe extern "C" fn extism_current_plugin_memory(plugin: *mut Internal) ->
     }
 
     let plugin = &mut *plugin;
-    plugin.memory_mut().data_mut().as_mut_ptr()
+    plugin.memory_ptr()
 }
 
 /// Allocate a memory block in the currently running plugin
@@ -111,16 +111,7 @@ pub unsafe extern "C" fn extism_current_plugin_memory_alloc(plugin: *mut Interna
     }
 
     let plugin = &mut *plugin;
-
-    let mem = match plugin.memory_mut().alloc(n as usize) {
-        Ok(x) => x,
-        Err(e) => {
-            plugin.set_error(e);
-            return 0;
-        }
-    };
-
-    mem.offset as u64
+    plugin.memory_alloc(n as u64).unwrap_or_default()
 }
 
 /// Get the length of an allocated block
@@ -135,11 +126,7 @@ pub unsafe extern "C" fn extism_current_plugin_memory_length(
     }
 
     let plugin = &mut *plugin;
-
-    match plugin.memory().block_length(n as usize) {
-        Some(x) => x as Size,
-        None => 0,
-    }
+    plugin.memory_length(n)
 }
 
 /// Free an allocated memory block
@@ -151,7 +138,7 @@ pub unsafe extern "C" fn extism_current_plugin_memory_free(plugin: *mut Internal
     }
 
     let plugin = &mut *plugin;
-    plugin.memory_mut().free(ptr as usize);
+    plugin.memory_free(ptr);
 }
 
 /// Create a new host function
@@ -436,21 +423,21 @@ pub unsafe extern "C" fn extism_plugin_config(
             }
         };
 
-    let wasi = &mut plugin.memory.get_mut().store_mut().data_mut().wasi;
+    let wasi = &mut plugin.internal_mut().wasi;
     if let Some(Wasi { ctx, .. }) = wasi {
         for (k, v) in json.iter() {
             match v {
                 Some(v) => {
-                    let _ = ctx.push_env(&k, &v);
+                    let _ = ctx.push_env(k, v);
                 }
                 None => {
-                    let _ = ctx.push_env(&k, "");
+                    let _ = ctx.push_env(k, "");
                 }
             }
         }
     }
 
-    let config = &mut plugin.memory.get_mut().manifest.as_mut().config;
+    let config = &mut plugin.internal_mut().manifest.as_mut().config;
     for (k, v) in json.into_iter() {
         match v {
             Some(v) => {
@@ -508,41 +495,28 @@ pub unsafe extern "C" fn extism_plugin_call(
 ) -> i32 {
     let ctx = &mut *ctx;
 
+    // Get function name
+    let name = std::ffi::CStr::from_ptr(func_name);
+    let name = match name.to_str() {
+        Ok(name) => name,
+        Err(e) => return ctx.error(e, -1),
+    };
+    let is_start = name == "_start";
+
     // Get a `PluginRef` and call `init` to set up the plugin input and memory, this is only
     // needed before a new call
     let mut plugin_ref = match PluginRef::new(ctx, plugin_id, true) {
         None => return -1,
-        Some(p) => p.init(data, data_len as usize),
+        Some(p) => p.start_call(is_start),
     };
     let tx = plugin_ref.epoch_timer_tx.clone();
     let plugin = plugin_ref.as_mut();
 
-    if plugin.internal().last_error.borrow().is_some() {
-        return -1;
-    }
-
-    // Find function
-    let name = std::ffi::CStr::from_ptr(func_name);
-    let name = match name.to_str() {
-        Ok(name) => name,
-        Err(e) => return plugin.error(e, -1),
-    };
-    let is_start = name == "_start";
-
     let func = match plugin.get_func(name) {
         Some(x) => x,
         None => return plugin.error(format!("Function not found: {name}"), -1),
     };
 
-    // Start timer
-    if let Err(e) = plugin.start_timer(&tx) {
-        let id = plugin.timer_id;
-        return plugin.error(
-            format!("Unable to start timeout manager for {id}: {e:?}"),
-            -1,
-        );
-    }
-
     // Check the number of results, reject functions with more than 1 result
     let n_results = func.ty(plugin.store()).results().len();
     if n_results > 1 {
@@ -552,40 +526,29 @@ pub unsafe extern "C" fn extism_plugin_call(
         );
     }
 
-    // Initialize runtime
-    if !is_start {
-        if let Err(e) = plugin.initialize_runtime() {
-            return plugin.error(format!("Failed to initialize runtime: {e:?}"), -1);
-        }
+    if let Err(e) = plugin.set_input(data, data_len as usize) {
+        return plugin.error(e, -1);
+    }
+
+    if plugin.has_error() {
+        return -1;
+    }
+
+    // Start timer, this will be stopped when PluginRef goes out of scope
+    if let Err(e) = plugin.start_timer(&tx) {
+        return plugin.error(e, -1);
     }
 
     debug!("Calling function: {name} in plugin {plugin_id}");
 
     // Call the function
     let mut results = vec![wasmtime::Val::null(); n_results];
-    let res = func.call(&mut plugin.store_mut(), &[], results.as_mut_slice());
-
-    plugin.dump_memory();
-
-    // Cleanup runtime
-    if !is_start {
-        if let Err(e) = plugin.cleanup_runtime() {
-            return plugin.error(format!("Failed to cleanup runtime: {e:?}"), -1);
-        }
-    }
-
-    // Stop timer
-    if let Err(e) = plugin.stop_timer() {
-        let id = plugin.timer_id;
-        return plugin.error(
-            format!("Failed to stop timeout manager for {id}: {e:?}"),
-            -1,
-        );
-    }
+    let res = func.call(plugin.store_mut(), &[], results.as_mut_slice());
 
     match res {
         Ok(()) => (),
         Err(e) => {
+            plugin.store.set_epoch_deadline(1);
             if let Some(exit) = e.downcast_ref::<wasmtime_wasi::I32Exit>() {
                 trace!("WASI return code: {}", exit.0);
                 if exit.0 != 0 {
@@ -635,20 +598,27 @@ pub unsafe extern "C" fn extism_error(ctx: *mut Context, plugin: PluginIndex) ->
         return get_context_error(ctx);
     }
 
-    let plugin_ref = match PluginRef::new(ctx, plugin, false) {
+    let mut plugin_ref = match PluginRef::new(ctx, plugin, false) {
         None => return std::ptr::null(),
         Some(p) => p,
     };
-    let plugin = plugin_ref.as_ref();
-
-    let err = plugin.internal().last_error.borrow();
-    match err.as_ref() {
-        Some(e) => e.as_ptr() as *const _,
-        None => {
-            trace!("Error is NULL");
-            std::ptr::null()
-        }
+    let plugin = plugin_ref.as_mut();
+    let output = &mut [Val::I64(0)];
+    if let Some(f) = plugin
+        .linker
+        .get(&mut plugin.store, "env", "extism_error_get")
+    {
+        f.into_func()
+            .unwrap()
+            .call(&mut plugin.store, &[], output)
+            .unwrap();
     }
+    if output[0].unwrap_i64() == 0 {
+        trace!("Error is NULL");
+        return std::ptr::null();
+    }
+
+    plugin.memory_ptr().add(output[0].unwrap_i64() as usize) as *const _
 }
 
 /// Get the length of a plugin's output data
@@ -660,18 +630,25 @@ pub unsafe extern "C" fn extism_plugin_output_length(
     trace!("Call to extism_plugin_output_length for plugin {plugin}");
 
     let ctx = &mut *ctx;
-    let plugin_ref = match PluginRef::new(ctx, plugin, true) {
+    let mut plugin_ref = match PluginRef::new(ctx, plugin, true) {
         None => return 0,
         Some(p) => p,
     };
-    let plugin = plugin_ref.as_ref();
-
-    let len = plugin.internal().output_length as Size;
+    let plugin = plugin_ref.as_mut();
+    let out = &mut [Val::I64(0)];
+    let _ = plugin
+        .linker
+        .get(&mut plugin.store, "env", "extism_output_length")
+        .unwrap()
+        .into_func()
+        .unwrap()
+        .call(&mut plugin.store_mut(), &[], out);
+    let len = out[0].unwrap_i64() as Size;
     trace!("Output length: {len}");
     len
 }
 
-/// Get the length of a plugin's output data
+/// Get a pointer to the output data
 #[no_mangle]
 pub unsafe extern "C" fn extism_plugin_output_data(
     ctx: *mut Context,
@@ -680,20 +657,26 @@ pub unsafe extern "C" fn extism_plugin_output_data(
     trace!("Call to extism_plugin_output_data for plugin {plugin}");
 
     let ctx = &mut *ctx;
-    let plugin_ref = match PluginRef::new(ctx, plugin, true) {
+    let mut plugin_ref = match PluginRef::new(ctx, plugin, true) {
         None => return std::ptr::null(),
         Some(p) => p,
     };
-    let plugin = plugin_ref.as_ref();
-    let internal = plugin.internal();
+    let plugin = plugin_ref.as_mut();
+    let ptr = plugin.memory_ptr();
+    let out = &mut [Val::I64(0)];
+    let mut store = &mut *(plugin.store_mut() as *mut Store<_>);
     plugin
-        .memory()
-        .ptr(MemoryBlock::new(
-            internal.output_offset,
-            internal.output_length,
-        ))
-        .map(|x| x as *const _)
-        .unwrap_or(std::ptr::null())
+        .linker
+        .get(&mut store, "env", "extism_output_offset")
+        .unwrap()
+        .into_func()
+        .unwrap()
+        .call(&mut store, &[], out)
+        .unwrap();
+
+    let offs = out[0].unwrap_i64() as usize;
+    trace!("Output offset: {}", offs);
+    ptr.add(offs)
 }
 
 /// Set log file and level

rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "extism"
-version = "0.3.0"
+version = "0.5.5"
 edition = "2021"
 authors = ["The Extism Authors", "oss@extism.org"]
 license = "BSD-3-Clause"
@@ -9,8 +9,8 @@ repository = "https://github.com/extism/extism"
 description = "Extism Host SDK for Rust"
 
 [dependencies]
-extism-manifest = { version = "0.3.0", path = "../manifest" }
-extism-runtime = { version = "0.4.0", path = "../runtime"}
+extism-manifest = { version = "0.5.0", path = "../manifest" }
+extism-runtime = { version = "0.5.5", path = "../runtime"}
 serde_json = "1"
 log = "0.4"
 anyhow = "1"

rust/src/bindings.rs

@@ -1,45 +1,260 @@
-/* automatically generated by rust-bindgen 0.60.1 */
+/* automatically generated by rust-bindgen 0.65.1 */
 
-pub type __uint8_t = ::std::os::raw::c_uchar;
-pub type __int32_t = ::std::os::raw::c_int;
-pub type __uint64_t = ::std::os::raw::c_ulong;
+#[doc = " Signed 32 bit integer."]
+pub const ExtismValType_I32: ExtismValType = 0;
+#[doc = " Signed 64 bit integer."]
+pub const ExtismValType_I64: ExtismValType = 1;
+#[doc = " Floating point 32 bit integer."]
+pub const ExtismValType_F32: ExtismValType = 2;
+#[doc = " Floating point 64 bit integer."]
+pub const ExtismValType_F64: ExtismValType = 3;
+#[doc = " A 128 bit number."]
+pub const ExtismValType_V128: ExtismValType = 4;
+#[doc = " A reference to a Wasm function."]
+pub const ExtismValType_FuncRef: ExtismValType = 5;
+#[doc = " A reference to opaque data in the Wasm instance."]
+pub const ExtismValType_ExternRef: ExtismValType = 6;
+#[doc = " A list of all possible value types in WebAssembly."]
+pub type ExtismValType = ::std::os::raw::c_uint;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
 pub struct ExtismContext {
     _unused: [u8; 0],
 }
-pub type ExtismPlugin = i32;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ExtismCancelHandle {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ExtismFunction {
+    _unused: [u8; 0],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ExtismCurrentPlugin {
+    _unused: [u8; 0],
+}
 pub type ExtismSize = u64;
+#[doc = " A union type for host function argument/return values"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ExtismValUnion {
+    pub i32_: i32,
+    pub i64_: i64,
+    pub f32_: f32,
+    pub f64_: f64,
+}
+#[test]
+fn bindgen_test_layout_ExtismValUnion() {
+    const UNINIT: ::std::mem::MaybeUninit<ExtismValUnion> = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ExtismValUnion>(),
+        8usize,
+        concat!("Size of: ", stringify!(ExtismValUnion))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ExtismValUnion>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ExtismValUnion))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i32_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ExtismValUnion),
+            "::",
+            stringify!(i32_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).i64_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ExtismValUnion),
+            "::",
+            stringify!(i64_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f32_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ExtismValUnion),
+            "::",
+            stringify!(f32_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).f64_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ExtismValUnion),
+            "::",
+            stringify!(f64_)
+        )
+    );
+}
+#[doc = " `ExtismVal` holds the type and value of a function argument/return"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ExtismVal {
+    pub t: ExtismValType,
+    pub v: ExtismValUnion,
+}
+#[test]
+fn bindgen_test_layout_ExtismVal() {
+    const UNINIT: ::std::mem::MaybeUninit<ExtismVal> = ::std::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::std::mem::size_of::<ExtismVal>(),
+        16usize,
+        concat!("Size of: ", stringify!(ExtismVal))
+    );
+    assert_eq!(
+        ::std::mem::align_of::<ExtismVal>(),
+        8usize,
+        concat!("Alignment of ", stringify!(ExtismVal))
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).t) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ExtismVal),
+            "::",
+            stringify!(t)
+        )
+    );
+    assert_eq!(
+        unsafe { ::std::ptr::addr_of!((*ptr).v) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(ExtismVal),
+            "::",
+            stringify!(v)
+        )
+    );
+}
+#[doc = " Host function signature"]
+pub type ExtismFunctionType = ::std::option::Option<
+    unsafe extern "C" fn(
+        plugin: *mut ExtismCurrentPlugin,
+        inputs: *const ExtismVal,
+        n_inputs: ExtismSize,
+        outputs: *mut ExtismVal,
+        n_outputs: ExtismSize,
+        data: *mut ::std::os::raw::c_void,
+    ),
+>;
+pub type ExtismPlugin = i32;
 extern "C" {
+    #[doc = " Create a new context"]
     pub fn extism_context_new() -> *mut ExtismContext;
 }
 extern "C" {
+    #[doc = " Free a context"]
     pub fn extism_context_free(ctx: *mut ExtismContext);
 }
 extern "C" {
+    #[doc = " Returns a pointer to the memory of the currently running plugin\n NOTE: this should only be called from host functions."]
+    pub fn extism_current_plugin_memory(plugin: *mut ExtismCurrentPlugin) -> *mut u8;
+}
+extern "C" {
+    #[doc = " Allocate a memory block in the currently running plugin\n NOTE: this should only be called from host functions."]
+    pub fn extism_current_plugin_memory_alloc(
+        plugin: *mut ExtismCurrentPlugin,
+        n: ExtismSize,
+    ) -> u64;
+}
+extern "C" {
+    #[doc = " Get the length of an allocated block\n NOTE: this should only be called from host functions."]
+    pub fn extism_current_plugin_memory_length(
+        plugin: *mut ExtismCurrentPlugin,
+        n: ExtismSize,
+    ) -> ExtismSize;
+}
+extern "C" {
+    #[doc = " Free an allocated memory block\n NOTE: this should only be called from host functions."]
+    pub fn extism_current_plugin_memory_free(plugin: *mut ExtismCurrentPlugin, ptr: u64);
+}
+extern "C" {
+    #[doc = " Create a new host function\n\n Arguments\n - `name`: function name, this should be valid UTF-8\n - `inputs`: argument types\n - `n_inputs`: number of argument types\n - `outputs`: return types\n - `n_outputs`: number of return types\n - `func`: the function to call\n - `user_data`: a pointer that will be passed to the function when it's called\n    this value should live as long as the function exists\n - `free_user_data`: a callback to release the `user_data` value when the resulting\n   `ExtismFunction` is freed.\n\n Returns a new `ExtismFunction` or `null` if the `name` argument is invalid."]
+    pub fn extism_function_new(
+        name: *const ::std::os::raw::c_char,
+        inputs: *const ExtismValType,
+        n_inputs: ExtismSize,
+        outputs: *const ExtismValType,
+        n_outputs: ExtismSize,
+        func: ExtismFunctionType,
+        user_data: *mut ::std::os::raw::c_void,
+        free_user_data: ::std::option::Option<
+            unsafe extern "C" fn(__: *mut ::std::os::raw::c_void),
+        >,
+    ) -> *mut ExtismFunction;
+}
+extern "C" {
+    #[doc = " Set the namespace of an `ExtismFunction`"]
+    pub fn extism_function_set_namespace(
+        ptr: *mut ExtismFunction,
+        namespace_: *const ::std::os::raw::c_char,
+    );
+}
+extern "C" {
+    #[doc = " Free an `ExtismFunction`"]
+    pub fn extism_function_free(ptr: *mut ExtismFunction);
+}
+extern "C" {
+    #[doc = " Create a new plugin with additional host functions\n\n `wasm`: is a WASM module (wat or wasm) or a JSON encoded manifest\n `wasm_size`: the length of the `wasm` parameter\n `functions`: an array of `ExtismFunction*`\n `n_functions`: the number of functions provided\n `with_wasi`: enables/disables WASI"]
     pub fn extism_plugin_new(
         ctx: *mut ExtismContext,
         wasm: *const u8,
         wasm_size: ExtismSize,
+        functions: *mut *const ExtismFunction,
+        n_functions: ExtismSize,
         with_wasi: bool,
     ) -> ExtismPlugin;
 }
 extern "C" {
+    #[doc = " Update a plugin, keeping the existing ID\n\n Similar to `extism_plugin_new` but takes an `index` argument to specify\n which plugin to update\n\n Memory for this plugin will be reset upon update"]
     pub fn extism_plugin_update(
         ctx: *mut ExtismContext,
         index: ExtismPlugin,
         wasm: *const u8,
         wasm_size: ExtismSize,
+        functions: *mut *const ExtismFunction,
+        nfunctions: ExtismSize,
         with_wasi: bool,
     ) -> bool;
 }
 extern "C" {
+    #[doc = " Remove a plugin from the registry and free associated memory"]
     pub fn extism_plugin_free(ctx: *mut ExtismContext, plugin: ExtismPlugin);
 }
 extern "C" {
+    #[doc = " Get plugin ID for cancellation"]
+    pub fn extism_plugin_cancel_handle(
+        ctx: *mut ExtismContext,
+        plugin: ExtismPlugin,
+    ) -> *const ExtismCancelHandle;
+}
+extern "C" {
+    #[doc = " Cancel a running plugin"]
+    pub fn extism_plugin_cancel(handle: *const ExtismCancelHandle) -> bool;
+}
+extern "C" {
+    #[doc = " Remove all plugins from the registry"]
     pub fn extism_context_reset(ctx: *mut ExtismContext);
 }
 extern "C" {
+    #[doc = " Update plugin config values, this will merge with the existing values"]
     pub fn extism_plugin_config(
         ctx: *mut ExtismContext,
         plugin: ExtismPlugin,
@@ -48,6 +263,7 @@ extern "C" {
     ) -> bool;
 }
 extern "C" {
+    #[doc = " Returns true if `func_name` exists"]
     pub fn extism_plugin_function_exists(
         ctx: *mut ExtismContext,
         plugin: ExtismPlugin,
@@ -55,6 +271,7 @@ extern "C" {
     ) -> bool;
 }
 extern "C" {
+    #[doc = " Call a function\n\n `func_name`: is the function to call\n `data`: is the input data\n `data_len`: is the length of `data`"]
     pub fn extism_plugin_call(
         ctx: *mut ExtismContext,
         plugin_id: ExtismPlugin,
@@ -64,26 +281,29 @@ extern "C" {
     ) -> i32;
 }
 extern "C" {
+    #[doc = " Get the error associated with a `Context` or `Plugin`, if `plugin` is `-1` then the context\n error will be returned"]
     pub fn extism_error(
         ctx: *mut ExtismContext,
         plugin: ExtismPlugin,
     ) -> *const ::std::os::raw::c_char;
 }
 extern "C" {
+    #[doc = " Get the length of a plugin's output data"]
     pub fn extism_plugin_output_length(ctx: *mut ExtismContext, plugin: ExtismPlugin)
         -> ExtismSize;
 }
 extern "C" {
+    #[doc = " Get a pointer to the output data"]
     pub fn extism_plugin_output_data(ctx: *mut ExtismContext, plugin: ExtismPlugin) -> *const u8;
 }
 extern "C" {
+    #[doc = " Set log file and level"]
     pub fn extism_log_file(
         filename: *const ::std::os::raw::c_char,
         log_level: *const ::std::os::raw::c_char,
     ) -> bool;
 }
-
 extern "C" {
-    pub fn extism_version(
-    ) -> *const ::std::os::raw::c_char;
+    #[doc = " Get the Extism version string"]
+    pub fn extism_version() -> *const ::std::os::raw::c_char;
 }

rust/src/lib.rs

@@ -1,6 +1,6 @@
 pub use extism_manifest::{self as manifest, Manifest};
 pub use extism_runtime::{
-    sdk as bindings, Function, Internal as CurrentPlugin, MemoryBlock, UserData, Val, ValType,
+    sdk as bindings, Function, Internal as CurrentPlugin, InternalExt, UserData, Val, ValType,
 };
 
 mod context;
@@ -44,14 +44,20 @@ mod tests {
 
     const WASM: &[u8] = include_bytes!("../../wasm/code-functions.wasm");
     const WASM_LOOP: &[u8] = include_bytes!("../../wasm/loop.wasm");
+    const WASM_GLOBALS: &[u8] = include_bytes!("../../wasm/globals.wasm");
+    const REFLECT_WASM: &[u8] = include_bytes!("../../wasm/reflect.wasm");
 
     fn hello_world(
-        _plugin: &mut CurrentPlugin,
+        plugin: &mut CurrentPlugin,
         inputs: &[Val],
         outputs: &mut [Val],
         _user_data: UserData,
     ) -> Result<(), Error> {
-        outputs[0] = inputs[0].clone();
+        let input_offs = inputs[0].unwrap_i64() as u64;
+        let length = plugin.memory_length(input_offs);
+        let input = plugin.memory_read(input_offs, length).to_vec();
+        let output = plugin.memory_alloc_bytes(&input).unwrap();
+        outputs[0] = Val::I64(output as i64);
         Ok(())
     }
 
@@ -277,10 +283,63 @@ mod tests {
         });
 
         let start = std::time::Instant::now();
-        let _output = plugin.call("infinite_loop", "abc123");
+        let _output = plugin.call("infinite_loop", "");
         let end = std::time::Instant::now();
         let time = end - start;
         println!("Cancelled plugin ran for {:?}", time);
         // std::io::stdout().write_all(output).unwrap();
     }
+
+    #[test]
+    fn test_multiple_instantiations() {
+        let f = Function::new(
+            "hello_world",
+            [ValType::I64],
+            [ValType::I64],
+            None,
+            hello_world,
+        );
+
+        let context = Context::new();
+        let mut plugin = Plugin::new(&context, WASM, [f], true).unwrap();
+
+        // This is 10,001 because the wasmtime store limit is 10,000 - we want to test
+        // that our reinstantiation process is working and that limit is never hit.
+        for _ in 0..10001 {
+            let _output = plugin.call("count_vowels", "abc123").unwrap();
+        }
+    }
+
+    #[test]
+    fn test_globals() {
+        let context = Context::new();
+        let mut plugin = Plugin::new(&context, WASM_GLOBALS, [], true).unwrap();
+        for i in 0..1000 {
+            let output = plugin.call("globals", "").unwrap();
+            let count: serde_json::Value = serde_json::from_slice(&output).unwrap();
+            assert_eq!(count.get("count").unwrap().as_i64().unwrap(), i);
+        }
+    }
+
+    #[test]
+    fn test_fuzz_reflect_plugin() {
+        // assert!(set_log_file("stdout", Some(log::Level::Trace)));
+        let f = Function::new(
+            "host_reflect",
+            [ValType::I64],
+            [ValType::I64],
+            None,
+            hello_world,
+        );
+
+        let context = Context::new();
+        let mut plugin = Plugin::new(&context, REFLECT_WASM, [f], true).unwrap();
+
+        for i in 1..65540 {
+            let input = "a".repeat(i);
+            let output = plugin.call("reflect", input.clone());
+            let output = std::str::from_utf8(output.unwrap()).unwrap();
+            assert_eq!(output, input);
+        }
+    }
 }

rust/src/plugin.rs

@@ -232,8 +232,8 @@ impl<'a> Plugin<'a> {
     /// Call a function with the given input and call a callback with the output, this should be preferred when
     /// a single plugin may be acessed from multiple threads because the lock on the plugin is held during the
     /// callback, ensuring the output value is protected from modification.
-    pub fn call_map<T, F: FnOnce(&'a [u8]) -> Result<T, Error>>(
-        &mut self,
+    pub fn call_map<'b, T, F: FnOnce(&'b [u8]) -> Result<T, Error>>(
+        &'b mut self,
         name: impl AsRef<str>,
         input: impl AsRef<[u8]>,
         f: F,
@@ -268,11 +268,11 @@ impl<'a> Plugin<'a> {
     }
 
     /// Call a function with the given input
-    pub fn call(
-        &mut self,
+    pub fn call<'b>(
+        &'b mut self,
         name: impl AsRef<str>,
         input: impl AsRef<[u8]>,
-    ) -> Result<&'a [u8], Error> {
+    ) -> Result<&'b [u8], Error> {
         self.call_map(name, input, |x| Ok(x))
     }
 }

zig/build.zig

@@ -1,8 +1,15 @@
 const std = @import("std");
+const builtin = @import("builtin");
 
 pub fn build(b: *std.Build) void {
-    // Standard release options allow the person running `zig build` to select
-    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
+    comptime {
+        const current_zig = builtin.zig_version;
+        const min_zig = std.SemanticVersion.parse("0.12.0-dev.64+b835fd90c") catch unreachable; // std.json.ArrayHashMap
+        if (current_zig.order(min_zig) == .lt) {
+            @compileError(std.fmt.comptimePrint("Your Zig version v{} does not meet the minimum build requirement of v{}", .{ current_zig, min_zig }));
+        }
+    }
+
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
@@ -23,8 +30,8 @@ pub fn build(b: *std.Build) void {
 
     tests.addAnonymousModule("extism", .{ .source_file = .{ .path = "src/main.zig" } });
     tests.linkLibC();
-    tests.addIncludePath("/usr/local/include");
-    tests.addLibraryPath("/usr/local/lib");
+    tests.addIncludePath(.{ .path = "/usr/local/include" });
+    tests.addLibraryPath(.{ .path = "/usr/local/lib" });
     tests.linkSystemLibrary("extism");
     const tests_run_step = b.addRunArtifact(tests);
 
@@ -40,8 +47,8 @@ pub fn build(b: *std.Build) void {
 
     example.addAnonymousModule("extism", .{ .source_file = .{ .path = "src/main.zig" } });
     example.linkLibC();
-    example.addIncludePath("/usr/local/include");
-    example.addLibraryPath("/usr/local/lib");
+    example.addIncludePath(.{ .path = "/usr/local/include" });
+    example.addLibraryPath(.{ .path = "/usr/local/lib" });
     example.linkSystemLibrary("extism");
     const example_run_step = b.addRunArtifact(example);
 

zig/examples/basic.zig

@@ -9,7 +9,7 @@ const manifest = sdk.manifest;
 
 export fn hello_world(plugin_ptr: ?*sdk.c.ExtismCurrentPlugin, inputs: [*c]const sdk.c.ExtismVal, n_inputs: u64, outputs: [*c]sdk.c.ExtismVal, n_outputs: u64, user_data: ?*anyopaque) callconv(.C) void {
     std.debug.print("Hello from Zig!\n", .{});
-    const str_ud = @ptrCast([*:0]const u8, user_data orelse unreachable);
+    const str_ud = @as([*:0]const u8, @ptrCast(user_data orelse unreachable));
     std.debug.print("User data: {s}\n", .{str_ud});
     var input_slice = inputs[0..n_inputs];
     var output_slice = outputs[0..n_outputs];
@@ -33,16 +33,16 @@ pub fn main() !void {
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &hello_world,
-        @constCast(@ptrCast(*const anyopaque, "user data")),
+        @constCast(@as(*const anyopaque, @ptrCast("user data"))),
     );
     defer f.deinit();
     var my_plugin = try Plugin.initFromManifest(allocator, &context, man, &[_]Function{f}, true);
     // var my_plugin = try Plugin.init(allocator, &context, wasm, &[_]Function{f}, true);
     defer my_plugin.deinit();
 
-    var config = std.StringHashMap([]const u8).init(allocator);
-    defer config.deinit();
-    try config.put("thing", "this is a really important thing");
+    var config = std.json.ArrayHashMap([]const u8){};
+    defer config.deinit(allocator);
+    try config.map.put(allocator, "thing", "this is a really important thing");
     try my_plugin.setConfig(allocator, config);
 
     const input = "aeiouAEIOU____________________________________&smtms_y?" ** 1182;

zig/src/current_plugin.zig

@@ -13,7 +13,7 @@ pub fn getMemory(self: Self, offset: u64) []const u8 {
     const len = c.extism_current_plugin_memory_length(self.c_currplugin, offset);
     const c_data = c.extism_current_plugin_memory(self.c_currplugin);
     const data: [*:0]u8 = std.mem.span(c_data);
-    return (data + offset)[0..len];
+    return data[offset .. offset + len];
 }
 
 pub fn alloc(self: *Self, n: u64) u64 {
@@ -31,10 +31,10 @@ pub fn length(self: *Self, offset: u64) u64 {
 pub fn returnBytes(self: *Self, val: *const c.ExtismVal, data: []const u8) void {
     const mem = self.alloc(@as(u64, data.len));
     const ptr = self.getMemory(mem);
-    std.mem.copy(u8, ptr, data);
+    @memcpy(ptr, data);
     val.v.i64 = @as(i64, mem);
 }
 
 pub fn inputBytes(self: *Self, val: *const c.ExtismVal) []const u8 {
-    return self.getMemory(@intCast(u64, val.v.i64));
+    return self.getMemory(@intCast(val.v.i64));
 }

zig/src/manifest.zig

@@ -13,16 +13,27 @@ pub const WasmUrl = struct {
     hash: ?[]const u8 = null,
     name: ?[]const u8 = null,
     method: ?[]const u8 = null,
-    headers: ?std.StringHashMap([]const u8) = null,
+    headers: ?std.json.ArrayHashMap([]const u8) = null,
 };
 
-pub const Wasm = union(enum) { wasm_data: WasmData, wasm_file: WasmFile, wasm_url: WasmUrl };
+pub const Wasm = union(enum) {
+    wasm_data: WasmData,
+    wasm_file: WasmFile,
+    wasm_url: WasmUrl,
+    pub fn jsonStringify(self: @This(), jws: anytype) !void {
+        switch (self) {
+            inline else => |value| {
+                try jws.write(value);
+            },
+        }
+    }
+};
 
 pub const Manifest = struct {
     wasm: []const Wasm,
     memory: ?struct { max_pages: ?u32 } = null,
-    config: ?std.StringHashMap([]const u8) = null,
+    config: ?std.json.ArrayHashMap([]const u8) = null,
     allowed_hosts: ?[]const []const u8 = null,
-    allowed_paths: ?std.StringHashMap([]const u8) = null,
+    allowed_paths: ?std.json.ArrayHashMap([]const u8) = null,
     timeout: ?usize = null,
 };

zig/src/plugin.zig

@@ -4,7 +4,6 @@ const Manifest = @import("manifest.zig").Manifest;
 const Function = @import("function.zig");
 const CancelHandle = @import("cancel_handle.zig");
 const c = @import("ffi.zig");
-const utils = @import("utils.zig");
 
 const Self = @This();
 
@@ -52,7 +51,7 @@ pub fn init(allocator: std.mem.Allocator, ctx: *Context, data: []const u8, funct
 
 /// Create a new plugin from the given manifest
 pub fn initFromManifest(allocator: std.mem.Allocator, ctx: *Context, manifest: Manifest, functions: []const Function, wasi: bool) !Self {
-    const json = try utils.stringifyAlloc(allocator, manifest);
+    const json = try std.json.stringifyAlloc(allocator, manifest, .{ .emit_null_optional_fields = false });
     defer allocator.free(json);
     return init(allocator, ctx, json, functions, wasi);
 }
@@ -67,7 +66,7 @@ pub fn create(allocator: std.mem.Allocator, data: []const u8, functions: []const
 
 /// Create a new plugin from the given manifest in its own context
 pub fn createFromManifest(allocator: std.mem.Allocator, manifest: Manifest, functions: []const Function, wasi: bool) !Self {
-    const json = try utils.stringifyAlloc(allocator, manifest);
+    const json = try std.json.stringifyAlloc(allocator, manifest, .{ .emit_null_optional_fields = false });
     defer allocator.free(json);
     return create(allocator, json, functions, wasi);
 }
@@ -128,15 +127,15 @@ pub fn update(self: *Self, data: []const u8, wasi: bool) !void {
 
 /// Update a plugin with the given manifest
 pub fn updateWithManifest(self: *Self, allocator: std.mem.Allocator, manifest: Manifest, wasi: bool) !void {
-    const json = try utils.stringifyAlloc(allocator, manifest);
+    const json = try std.json.stringifyAlloc(allocator, manifest, .{ .emit_null_optional_fields = false });
     defer allocator.free(json);
     return self.update(json, wasi);
 }
 /// Set configuration values
-pub fn setConfig(self: *Self, allocator: std.mem.Allocator, config: std.StringHashMap([]const u8)) !void {
+pub fn setConfig(self: *Self, allocator: std.mem.Allocator, config: std.json.ArrayHashMap([]const u8)) !void {
     self.ctx.mutex.lock();
     defer self.ctx.mutex.unlock();
-    const config_json = try utils.stringifyAlloc(allocator, config);
+    const config_json = try std.json.stringifyAlloc(allocator, config, .{ .emit_null_optional_fields = false });
     defer allocator.free(config_json);
     _ = c.extism_plugin_config(self.ctx.ctx, self.id, config_json.ptr, @as(u64, config_json.len));
 }

zig/src/utils.zig

@@ -1,185 +0,0 @@
-const std = @import("std");
-const json = std.json;
-
-pub fn stringifyAlloc(allocator: std.mem.Allocator, value: anytype) ![]const u8 {
-    var list = std.ArrayList(u8).init(allocator);
-    errdefer list.deinit();
-    try stringify(value, .{ .emit_null_optional_fields = false }, list.writer());
-    return list.toOwnedSlice();
-}
-
-fn stringify(
-    value: anytype,
-    options: json.StringifyOptions,
-    out_stream: anytype,
-) @TypeOf(out_stream).Error!void {
-    const T = @TypeOf(value);
-    if (comptime std.mem.count(u8, @typeName(T), "hash_map.HashMap") > 0 and std.mem.count(u8, @typeName(T), "?") == 0) {
-        var it = value.iterator();
-        try out_stream.writeByte('{');
-        var i: usize = 0;
-        while (it.next()) |entry| {
-            i += 1;
-            const name = entry.key_ptr.*;
-            try json.encodeJsonString(name, options, out_stream);
-            if (i < value.count()) try out_stream.writeByte(':');
-            const val = entry.value_ptr.*;
-            try json.encodeJsonString(val, options, out_stream);
-        }
-        try out_stream.writeByte('}');
-        return;
-    }
-
-    switch (@typeInfo(T)) {
-        .Float, .ComptimeFloat => {
-            return std.fmt.formatFloatScientific(value, std.fmt.FormatOptions{}, out_stream);
-        },
-        .Int, .ComptimeInt => {
-            return std.fmt.formatIntValue(value, "", std.fmt.FormatOptions{}, out_stream);
-        },
-        .Bool => {
-            return out_stream.writeAll(if (value) "true" else "false");
-        },
-        .Null => {
-            return out_stream.writeAll("null");
-        },
-        .Optional => {
-            if (value) |payload| {
-                return try stringify(payload, options, out_stream);
-            } else {
-                return try stringify(null, options, out_stream);
-            }
-        },
-        .Enum => {
-            if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
-                return value.jsonStringify(options, out_stream);
-            }
-
-            @compileError("Unable to stringify enum '" ++ @typeName(T) ++ "'");
-        },
-        .Union => {
-            if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
-                return value.jsonStringify(options, out_stream);
-            }
-
-            const info = @typeInfo(T).Union;
-            if (info.tag_type) |UnionTagType| {
-                inline for (info.fields) |u_field| {
-                    if (value == @field(UnionTagType, u_field.name)) {
-                        return try stringify(@field(value, u_field.name), options, out_stream);
-                    }
-                }
-            } else {
-                @compileError("Unable to stringify untagged union '" ++ @typeName(T) ++ "'");
-            }
-        },
-        .Struct => |S| {
-            if (comptime std.meta.trait.hasFn("jsonStringify")(T)) {
-                return value.jsonStringify(options, out_stream);
-            }
-
-            try out_stream.writeByte('{');
-            var field_output = false;
-            var child_options = options;
-            if (child_options.whitespace) |*child_whitespace| {
-                child_whitespace.indent_level += 1;
-            }
-            inline for (S.fields) |Field| {
-                // don't include void fields
-                if (Field.type == void) continue;
-
-                var emit_field = true;
-
-                // don't include optional fields that are null when emit_null_optional_fields is set to false
-                if (@typeInfo(Field.type) == .Optional) {
-                    if (options.emit_null_optional_fields == false) {
-                        if (@field(value, Field.name) == null) {
-                            emit_field = false;
-                        }
-                    }
-                }
-
-                if (emit_field) {
-                    if (!field_output) {
-                        field_output = true;
-                    } else {
-                        try out_stream.writeByte(',');
-                    }
-                    if (child_options.whitespace) |child_whitespace| {
-                        try child_whitespace.outputIndent(out_stream);
-                    }
-                    try json.encodeJsonString(Field.name, options, out_stream);
-                    try out_stream.writeByte(':');
-                    if (child_options.whitespace) |child_whitespace| {
-                        if (child_whitespace.separator) {
-                            try out_stream.writeByte(' ');
-                        }
-                    }
-                    try stringify(@field(value, Field.name), child_options, out_stream);
-                }
-            }
-            if (field_output) {
-                if (options.whitespace) |whitespace| {
-                    try whitespace.outputIndent(out_stream);
-                }
-            }
-            try out_stream.writeByte('}');
-            return;
-        },
-        .ErrorSet => return stringify(@as([]const u8, @errorName(value)), options, out_stream),
-        .Pointer => |ptr_info| switch (ptr_info.size) {
-            .One => switch (@typeInfo(ptr_info.child)) {
-                .Array => {
-                    const Slice = []const std.meta.Elem(ptr_info.child);
-                    return stringify(@as(Slice, value), options, out_stream);
-                },
-                else => {
-                    // TODO: avoid loops?
-                    std.debug.print("a: {}", .{std.mem.indexOf(u8, @typeName(T), "HashMap") != null});
-                    // return stringify(value.*, options, out_stream);
-                },
-            },
-            // TODO: .Many when there is a sentinel (waiting for https://github.com/ziglang/zig/pull/3972)
-            .Slice => {
-                if (ptr_info.child == u8 and options.string == .String and std.unicode.utf8ValidateSlice(value)) {
-                    try json.encodeJsonString(value, options, out_stream);
-                    return;
-                }
-
-                try out_stream.writeByte('[');
-                var child_options = options;
-                if (child_options.whitespace) |*whitespace| {
-                    whitespace.indent_level += 1;
-                }
-                for (value, 0..) |x, i| {
-                    if (i != 0) {
-                        try out_stream.writeByte(',');
-                    }
-                    if (child_options.whitespace) |child_whitespace| {
-                        try child_whitespace.outputIndent(out_stream);
-                    }
-                    try stringify(x, child_options, out_stream);
-                }
-                if (value.len != 0) {
-                    if (options.whitespace) |whitespace| {
-                        try whitespace.outputIndent(out_stream);
-                    }
-                }
-                try out_stream.writeByte(']');
-                return;
-            },
-            else => {
-                @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'");
-            },
-        },
-        .Array => return stringify(&value, options, out_stream),
-        .Vector => |info| {
-            const array: [info.len]info.child = value;
-            return stringify(&array, options, out_stream);
-        },
-        else => {
-            @compileError("Unable to stringify type '" ++ @typeName(T) ++ "'");
-        },
-    }
-    unreachable;
-}

zig/test.zig

@@ -9,7 +9,7 @@ const manifest = sdk.manifest;
 
 export fn hello_world(plugin_ptr: ?*sdk.c.ExtismCurrentPlugin, inputs: [*c]const sdk.c.ExtismVal, n_inputs: u64, outputs: [*c]sdk.c.ExtismVal, n_outputs: u64, user_data: ?*anyopaque) callconv(.C) void {
     std.debug.print("Hello from Zig!\n", .{});
-    const str_ud = @ptrCast([*:0]const u8, user_data orelse unreachable);
+    const str_ud = @as([*:0]const u8, @ptrCast(user_data orelse unreachable));
     std.debug.print("User data: {s}\n", .{str_ud});
     var input_slice = inputs[0..n_inputs];
     var output_slice = outputs[0..n_outputs];
@@ -34,7 +34,7 @@ test "Single threaded tests" {
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &hello_world,
-        @constCast(@ptrCast(*const anyopaque, "user data")),
+        @constCast(@as(*const anyopaque, @ptrCast("user data"))),
     );
     defer f.deinit();
 
@@ -85,7 +85,7 @@ test "Multi threaded tests" {
                 &[_]sdk.c.ExtismValType{sdk.c.I64},
                 &[_]sdk.c.ExtismValType{sdk.c.I64},
                 &hello_world,
-                @constCast(@ptrCast(*const anyopaque, "user data")),
+                @constCast(@as(*const anyopaque, @ptrCast("user data"))),
             );
             defer f.deinit();
             var plugin = try Plugin.initFromManifest(testing.allocator, &ctx, man, &[_]Function{f}, true);
@@ -107,7 +107,7 @@ test "Multi threaded tests" {
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &hello_world,
-        @constCast(@ptrCast(*const anyopaque, "user data")),
+        @constCast(@as(*const anyopaque, @ptrCast("user data"))),
     );
     defer f.deinit();
 
@@ -129,7 +129,7 @@ test "Plugin Cancellation" {
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &[_]sdk.c.ExtismValType{sdk.c.I64},
         &hello_world,
-        @constCast(@ptrCast(*const anyopaque, "user data")),
+        @constCast(@as(*const anyopaque, @ptrCast("user data"))),
     );
     defer f.deinit();