Spec for Number as Ord

Bumps Microsoft.Build.NoTargets from 3.7.56 to 3.7.134

---
updated-dependencies:
- dependency-name: Microsoft.Build.NoTargets
  dependency-version: 3.7.134
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: per-dependency
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.cargo/config.toml

@@ -1,14 +1,2 @@
-[build]
-#target = "x86_64-unknown-linux-musl"
-
-# Flags to enable code-coverage for all builds.
-# These can be removed later.
-#rustflags = ["-Cinstrument-coverage"]
-incremental = true
-
-[env]
-# Name of coverage instrumentation log file.
-LLVM_PROFILE_FILE="target/cargo-test-%p-%m.profraw"
-
-[target.x86_64-unknown-linux-gnu]
-rustflags = ["-Cinstrument-coverage"]
+[alias]
+xtask = "run --package xtask --"

.devcontainer/devcontainer.json

@@ -4,11 +4,20 @@
 	"name": "Rust",
 	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
 	"image": "mcr.microsoft.com/devcontainers/rust:1-1-bullseye",
+	"customizations": {
+		"vscode": {
+			"extensions": [
+				"ms-dotnettools.csharp",
+				"ms-dotnettools.csdevkit"
+			]
+		}
+	},
 	"features": {
-		"ghcr.io/devcontainers/features/dotnet:2": {},
+		"ghcr.io/devcontainers/features/dotnet:2": {
+			"version": "8.0"
+		},
 		"ghcr.io/devcontainers/features/python:1": {}
 	}
-
 	// Use 'mounts' to make the cargo cache persistent in a Docker Volume.
 	// "mounts": [
 	// 	{

.github/actions/toolchains/rust/action.yml

@@ -0,0 +1,29 @@
+name: rust-toolchain
+description: Setup Rust toolchain with specified version and components
+inputs:
+  toolchain:
+    description: 'Rust toolchain version'
+    required: false
+    default: '1.92.0'
+  components:
+    description: 'Additional components to install'
+    required: false
+    default: 'clippy rustfmt'
+  targets:
+    description: 'Target architectures to install'
+    required: false
+    default: ''
+runs:
+  using: composite
+  steps:
+    - shell: bash
+      run: |
+        rustup override set ${{ inputs.toolchain }}
+        if [ -n "${{ inputs.components }}" ]; then
+          rustup component add ${{ inputs.components }}
+        fi
+        if [ -n "${{ inputs.targets }}" ]; then
+          rustup target add ${{ inputs.targets }}
+        fi
+        cargo --version
+        rustc --version

.github/dependabot.yml

@@ -1,3 +1,5 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
 # To get started with Dependabot version updates, you'll need to specify which
 # package ecosystems to update and where the package manifests are located.
 # Please see the documentation for all configuration options:
@@ -9,3 +11,137 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+    # Ignore vendored mimalloc crates; updates are managed manually.
+    ignore:
+      - dependency-name: "regorus-mimalloc"
+      - dependency-name: "regorus-mimalloc-sys"
+
+  - package-ecosystem: "cargo"
+    directory: "/bindings/ffi"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/bindings/java"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/bindings/python"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/bindings/ruby"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/bindings/ruby/ext/regorusrb"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/bindings/wasm"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/tests/ensure_no_std"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "cargo"
+    directory: "/xtask"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "gomod"
+    directory: "/bindings/go"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "maven"
+    directory: "/bindings/java"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "nuget"
+    directory: "/bindings/csharp"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "pip"
+    directory: "/bindings/python"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "bundler"
+    directory: "/bindings/ruby"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"
+
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      per-dependency:
+        patterns:
+          - "*"

.github/workflows/codeql.yml

@@ -0,0 +1,193 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: "CodeQL Security Analysis"
+
+on:
+  schedule:
+    # Run weekly on Wednesdays at 3:17 AM UTC
+    - cron: '17 3 * * 3'
+  workflow_dispatch:
+    # Allow manual triggering
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    runs-on: ubuntu-latest
+    timeout-minutes: 60
+    permissions:
+      # required for all workflows
+      security-events: write
+      # required to fetch internal or private CodeQL packs
+      packages: read
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # Rust analysis for main crate and Rust-based bindings
+          - language: rust
+            build-mode: none
+            working-directory: .
+          # C/C++ analysis for FFI bindings
+          - language: c-cpp
+            build-mode: manual
+            working-directory: bindings/ffi
+          # Python analysis for Python bindings
+          - language: python
+            build-mode: none
+            working-directory: bindings/python
+          # Java analysis for Java bindings
+          - language: java-kotlin
+            build-mode: manual
+            working-directory: bindings/java
+          # Go analysis for Go bindings
+          - language: go
+            build-mode: manual
+            working-directory: bindings/go
+          # C# analysis for C# bindings
+          - language: csharp
+            build-mode: manual
+            working-directory: bindings/csharp
+          # JavaScript analysis for WASM bindings
+          - language: javascript-typescript
+            build-mode: none
+            working-directory: bindings/wasm
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+    # Setup language-specific dependencies BEFORE CodeQL init for proper tracing setup
+    - name: Setup Rust
+      uses: ./.github/actions/toolchains/rust
+
+    - name: Cache cargo
+      uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+      with:
+        shared-key: ${{ runner.os }}-regorus
+
+    - name: Fetch workspace dependencies
+      run: cargo fetch --locked
+
+    - name: Fetch FFI crate dependencies
+      if: matrix.language == 'c-cpp' || matrix.language == 'go' || matrix.language == 'csharp'
+      run: cargo fetch --locked --manifest-path bindings/ffi/Cargo.toml
+
+    - name: Fetch Java crate dependencies
+      if: matrix.language == 'java-kotlin'
+      run: cargo fetch --locked --manifest-path bindings/java/Cargo.toml
+
+    - name: Setup Python
+      if: matrix.language == 'python'
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      with:
+        python-version: '3.10'
+
+    - name: Setup Java
+      if: matrix.language == 'java-kotlin'
+      uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+      with:
+        distribution: 'corretto'
+        java-version: '8'
+
+    - name: Setup Go
+      if: matrix.language == 'go'
+      uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
+      with:
+        go-version: '1.21'
+
+    - name: Setup .NET
+      if: matrix.language == 'csharp'
+      uses: actions/setup-dotnet@baa11fbfe1d6520db94683bd5c7a3818018e4309 # v5.1.0
+      with:
+        global-json-file: ./bindings/csharp/global.json
+
+    - name: Invoke dotnet directly
+      if: matrix.language == 'csharp'
+      run: dotnet --info
+
+    - name: Setup Node.js
+      if: matrix.language == 'javascript-typescript'
+      uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
+      with:
+        node-version: '18'
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+
+    # Install additional build dependencies
+    - name: Install system dependencies
+      if: matrix.language == 'rust' || matrix.language == 'c-cpp'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y build-essential cmake
+
+    - name: Install Python build dependencies
+      if: matrix.language == 'python'
+      working-directory: ${{ matrix.working-directory }}
+      run: |
+        python -m pip install --upgrade pip
+        pip install maturin[patchelf] pytest
+
+    - name: Setup Ruby
+      if: matrix.language == 'rust' && contains(matrix.working-directory, 'ruby')
+      uses: ruby/setup-ruby@09a7688d3b55cf0e976497ff046b70949eeaccfd # v1.288.0
+      with:
+        ruby-version: '3.4.2'
+        bundler-cache: true
+        working-directory: bindings/ruby
+
+    - name: Install WASM build dependencies
+      if: matrix.language == 'javascript-typescript'
+      run: |
+        cargo install wasm-pack
+
+    # Manual build steps for different languages
+    - name: Build C/C++ bindings via xtask
+      if: matrix.language == 'c-cpp'
+      run: |
+        cargo xtask test-c --release --frozen
+        cargo xtask test-cpp --release --frozen --skip-ffi
+        cargo xtask test-c-no-std --release --frozen --skip-ffi
+
+    - name: Build Java bindings via xtask
+      if: matrix.language == 'java-kotlin'
+      run: cargo xtask test-java --release --frozen
+
+    - name: Build Go bindings via xtask
+      if: matrix.language == 'go'
+      run: cargo xtask test-go --release --frozen
+
+    - name: Build C# bindings manually
+      if: matrix.language == 'csharp'
+      working-directory: ${{ matrix.working-directory }}
+      run: |
+        # Temporary workaround: CodeQL's tracer replaces dotnet with a missing shim when cargo xtask test-csharp runs,
+        # so invoke dotnet directly here until the upstream fix lands.
+        # Ideal command once fixed: cargo xtask test-csharp --release
+        # Build the FFI library that C# bindings access via P/Invoke
+        cd ../ffi
+        cargo build --release --locked
+        cd ../csharp
+        # Restore NuGet packages and build .NET assemblies in release mode
+        dotnet restore Regorus/Regorus.csproj
+        dotnet build Regorus/Regorus.csproj --no-restore /p:Configuration=Release /p:IgnoreMissingArtifacts=true
+
+    - name: Build WASM bindings via xtask
+      if: matrix.language == 'javascript-typescript'
+      run: cargo xtask build-wasm --release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v4.32.2
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/pr-extensions.yml

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: tests/release-extensions
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - name: Setup Rust toolchain
+      uses: ./.github/actions/toolchains/rust
+    - name: Cache cargo
+      uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+      with:
+        shared-key: ${{ runner.os }}-regorus
+    - name: Fetch dependencies
+      run: cargo fetch --locked
+    - name: Run rego extensions CI suite
+      run: >-
+        cargo xtask ci-release --frozen --features rego-extensions
+        --skip-all-features-build --skip-no-default-features-tests
+        --skip-azure-policy --skip-azure-rbac
+        --opa-features "opa-testutil,serde_json/arbitrary_precision,rego-extensions"

.github/workflows/pr.yml

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: tests/release
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - name: Setup Rust toolchain
+      uses: ./.github/actions/toolchains/rust
+    - name: Cache cargo
+      uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+      with:
+        shared-key: ${{ runner.os }}-regorus
+    - name: Fetch dependencies
+      run: cargo fetch --locked
+    - name: Run release CI suite
+      run: cargo xtask ci-release --frozen

.github/workflows/publish-java.yml

@@ -0,0 +1,94 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: publish-java
+
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build for ${{ matrix.target }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu-latest
+            extension: so
+            build_cmd: zigbuild
+            glibc: "2.17"
+          - target: aarch64-unknown-linux-gnu
+            os: ubuntu-latest
+            extension: so
+            build_cmd: zigbuild
+            glibc: "2.17"
+          - target: x86_64-apple-darwin
+            os: macos-latest
+            extension: dylib
+          - target: aarch64-apple-darwin
+            os: macos-latest
+            extension: dylib
+          - target: x86_64-pc-windows-msvc
+            os: windows-latest
+            extension: dll
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+        with:
+          java-version: 8
+          distribution: "corretto"
+      - uses: ./.github/actions/toolchains/rust
+        with:
+          targets: ${{ matrix.target }}
+      - if: ${{ matrix.build_cmd == 'zigbuild' }}
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.11"
+      - if: ${{ matrix.build_cmd == 'zigbuild' }}
+        run: pip install cargo-zigbuild
+      - run: cargo fetch --locked
+      - run: cargo fetch --locked --manifest-path bindings/java/Cargo.toml
+      - run: cargo ${{ matrix.build_cmd || 'build' }} --release --frozen --target ${{ matrix.target }}${{ matrix.glibc && format('.{0}', matrix.glibc) || '' }} --manifest-path ./bindings/java/Cargo.toml
+      - run: mkdir -p native/${{ matrix.target }}
+      - run: mv target/${{ matrix.target }}/release/*.${{ matrix.extension }} ./native/${{ matrix.target }}/
+      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: native-libraries-${{ matrix.target }}
+          path: native/
+
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+        with:
+          java-version: 8
+          distribution: "corretto"
+          server-id: ossrh
+          server-username: MAVEN_USERNAME
+          server-password: MAVEN_PASSWORD
+      - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          pattern: native-libraries-*
+          merge-multiple: true
+          path: ./bindings/java/native/
+      - run: mvn package
+        working-directory: ./bindings/java
+      - uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: built-jars
+          path: ./bindings/java/target/regorus-java-*.jar
+      - run: mvn deploy
+        working-directory: ./bindings/java
+        env:
+          MAVEN_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          MAVEN_PASSWORD: ${{ secrets.OSSRH_TOKEN }}

.github/workflows/publish-python.yml

@@ -1,3 +1,5 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
 # This file is autogenerated by maturin v1.4.0
 # To update, run
 #
@@ -18,21 +20,30 @@ jobs:
       matrix:
         target: [x86_64, x86, aarch64, armv7, s390x, ppc64le]
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: '3.10'
+      - uses: ./.github/actions/toolchains/rust
+
+      - name: Build Python extension
+        run: |
+          cargo fetch --locked
+          cargo clippy --all-targets --no-deps -- -Dwarnings
+          cargo build --release --target ${{ matrix.target }} --frozen
+        working-directory: bindings/python
+
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@b1bd829e37fef14c63f19162034228a2f3dc1021 # v1.43.0
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter --manifest-path bindings/python/Cargo.toml
+          args: --release --out dist --manifest-path bindings/python/Cargo.toml --offline --strip
           sccache: 'true'
           manylinux: auto
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
-          name: wheels
+          name: wheels-linux-${{ matrix.target }}
           path: dist
 
   windows:
@@ -41,21 +52,30 @@ jobs:
       matrix:
         target: [x64, x86]
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: '3.10'
           architecture: ${{ matrix.target }}
+      - uses: ./.github/actions/toolchains/rust
+
+      - name: Build Python extension
+        run: |
+          cargo fetch --locked
+          cargo clippy --all-targets --no-deps -- -Dwarnings
+          cargo build --release --target ${{ matrix.host.target }} --frozen
+        working-directory: bindings/python
+
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@b1bd829e37fef14c63f19162034228a2f3dc1021 # v1.43.0
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter --manifest-path bindings/python/Cargo.toml
+          args: --release --out dist --manifest-path bindings/python/Cargo.toml --frozen --strip
           sccache: 'true'
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
-          name: wheels
+          name: wheels-windows-${{ matrix.target }}
           path: dist
 
   macos:
@@ -64,35 +84,29 @@ jobs:
       matrix:
         target: [x86_64, aarch64, universal2-apple-darwin]
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
         with:
           python-version: '3.10'
+      - uses: ./.github/actions/toolchains/rust
+
+      - name: Build Python extension
+        run: |
+          cargo fetch --locked
+          cargo clippy --all-targets --no-deps -- -Dwarnings
+          cargo build --release --target ${{ matrix.host.target }} --frozen
+        working-directory: bindings/python
+
       - name: Build wheels
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@b1bd829e37fef14c63f19162034228a2f3dc1021 # v1.43.0
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist --find-interpreter --manifest-path bindings/python/Cargo.toml
+          args: --release --out dist --manifest-path bindings/python/Cargo.toml --offline --strip
           sccache: 'true'
       - name: Upload wheels
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
         with:
-          name: wheels
-          path: dist
-
-  sdist:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Build sdist
-        uses: PyO3/maturin-action@v1
-        with:
-          command: sdist
-          args: --out dist --manifest-path bindings/python/Cargo.toml
-      - name: Upload sdist
-        uses: actions/upload-artifact@v3
-        with:
-          name: wheels
+          name: wheels-macos-${{ matrix.host.target }}
           path: dist
 
   release:
@@ -100,13 +114,15 @@ jobs:
     runs-on: ubuntu-latest
     # Commented out for initial release.
     # if: "startsWith(github.ref, 'refs/tags/')"
-    needs: [linux, windows, macos, sdist]
+    needs: [linux, windows, macos]
     steps:
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
         with:
-          name: wheels
+          pattern: wheels-*
+          merge-multiple: true
+          path: wheels
       - name: Publish to PyPI
-        uses: PyO3/maturin-action@v1
+        uses: PyO3/maturin-action@b1bd829e37fef14c63f19162034228a2f3dc1021 # v1.43.0
         env:
           MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
         with:

.github/workflows/publish-wasm.yml

@@ -1,10 +1,13 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
 name: publish-wasm
 
 permissions:
   pull-requests: write
   contents: write
 
-on: workflow_dispatch
+on:
+  workflow_dispatch:
 
 jobs:
   publish-wasm:
@@ -12,11 +15,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           fetch-depth: 0
       # Setup .npmrc file to publish to npm
-      - uses: actions/setup-node@v4
+      - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
         with:
           node-version: '20.x'
           registry-url: 'https://registry.npmjs.org'

.github/workflows/release-plz.yml

@@ -1,24 +1,29 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
 name: Release-plz
 
 permissions:
   pull-requests: write
   contents: write
 
-on: workflow_dispatch
+on:
+  workflow_dispatch:
 
 jobs:
   release-plz:
     name: Release-plz
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           fetch-depth: 0
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@stable
+        uses: ./.github/actions/toolchains/rust
       - name: Run release-plz
-        uses: MarcoIeni/release-plz-action@v0.5
+        uses: MarcoIeni/release-plz-action@52440b50d383aa252927de395c8b2c1e0a9cf8e9 # v0.5.126
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/rust-clippy.yml

@@ -0,0 +1,58 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# rust-clippy is a tool that runs a bunch of lints to catch common
+# mistakes in your Rust code and help improve your Rust code.
+# More details at https://github.com/rust-lang/rust-clippy
+# and https://rust-lang.github.io/rust-clippy/
+
+name: rust-clippy analyze
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "main" ]
+  workflow_dispatch:
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  rust-clippy-analyze:
+    name: Run rust-clippy analyzing
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      security-events: write
+      actions: read # only required for a private repository by github/codeql-action/upload-sarif to get the Action run status
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+
+      - name: Install required cargo
+        run: cargo install clippy-sarif sarif-fmt
+
+      - name: Fetch
+        run: cargo fetch --locked
+
+      - name: Run rust-clippy
+        run: cargo xtask clippy --sarif rust-clippy-results.sarif
+        continue-on-error: true
+
+      - name: Upload analysis results to GitHub
+        uses: github/codeql-action/upload-sarif@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # v3.29.11
+        with:
+          sarif_file: rust-clippy-results.sarif
+          wait-for-processing: true

.github/workflows/rust.yml

@@ -1,47 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-    branches: [ "main" ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v3
-    - name: Add musl target
-      run: rustup target add x86_64-unknown-linux-musl
-    - name: Format Check
-      run: cargo fmt --check
-    - name: Build
-      run: cargo build --verbose
-    - name: Build Tests
-      run: cargo build --all-targets --verbose
-    - name: Clippy
-      run: cargo clippy --all-targets --no-deps -- -Dwarnings
-    - name: Run tests
-      run: cargo test -r --verbose
-    - name: Build (MUSL)
-      run: cargo build --verbose --all-targets --target x86_64-unknown-linux-musl
-    - name: Run tests (MUSL)
-      run: cargo test -r --verbose --target x86_64-unknown-linux-musl
-    - name: Run tests (ACI)
-      run: cargo test -r --test aci
-    - name: Run tests (OPA Conformance)
-      run: >-
-        cargo test -r --test opa --features opa-testutil  -- $(tr '\n' ' ' < tests/opa.passing)
-
-    # - name: Install wasm-pack
-    #   run: curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-
-    # - name: Run wasm binding tests
-    #   run: |
-    #     cd bindings/wasm
-    #     wasm-pack test --node -r

.github/workflows/test-c-cpp.yml

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/c-cpp
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch FFI crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/ffi/Cargo.toml
+
+      - name: Setup gcc, g++, cmake, ninja
+        run: sudo apt update && sudo apt install -y gcc g++ cmake ninja-build
+
+      - name: Test C binding via xtask
+        run: cargo xtask test-c --release --frozen
+
+      - name: Test C (no-std) binding via xtask
+        run: cargo xtask test-c-nostd --release --frozen --skip-ffi
+
+      - name: Test C++ binding via xtask
+        run: cargo xtask test-cpp --release --frozen --skip-ffi

.github/workflows/test-csharp.yml

@@ -0,0 +1,166 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/csharp
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+env:
+  VersionSuffix: ${{ github.event_name == 'workflow_dispatch' && 'manualtrigger' || null }}
+
+jobs:  
+  build-ffi:
+    name: 'Build Regorus FFI: (${{ matrix.runtime.target }})'
+    runs-on: ${{ matrix.runtime.os }}
+    strategy:
+      # let us get failures from other jobs even if one fails
+      fail-fast: false
+      matrix:
+        runtime:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            libpath: |
+              **/release/regorus_ffi.dll
+              **/release/regorus_ffi.pdb
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            libpath: |
+              **/release/libregorus_ffi.so
+          - os: macos-latest
+            target: aarch64-apple-darwin
+            libpath: |
+              **/release/libregorus_ffi.dylib
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/toolchains/rust
+        with:
+          targets: ${{ matrix.runtime.target }}
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch FFI crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/ffi/Cargo.toml --target ${{ matrix.runtime.target }}
+
+      - name: Build Regorus FFI via xtask
+        run: cargo xtask build-ffi --release --target ${{ matrix.runtime.target }}
+        
+      - name: Upload regorus ffi shared library
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: regorus-ffi-artifacts-${{ matrix.runtime.target }}
+          # Note: The full path of each artifact relative to . is preserved.
+          path: ${{ matrix.runtime.libpath }}
+          if-no-files-found: error
+          retention-days: 1
+
+  build-csharp:
+    name: 'Build Regorus nuget'
+    runs-on: ubuntu-latest
+    needs: build-ffi
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0  
+      - uses: ./.github/actions/toolchains/rust
+      - uses: actions/setup-dotnet@baa11fbfe1d6520db94683bd5c7a3818018e4309 # v5.1.0
+        with:
+          global-json-file: ./bindings/csharp/global.json
+
+      - run: echo '${{ steps.stepid.outputs.dotnet-version }}'
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Download regorus ffi shared libraries
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          pattern: regorus-ffi-artifacts-*
+          merge-multiple: true
+          path: ./bindings/csharp/Regorus/tmp
+
+      - name: Display regorus ffi artifacts
+        run: ls -R ./bindings/csharp/Regorus/tmp
+
+      - name: Build Regorus nuget via xtask
+        run: cargo xtask build-csharp --release --clean --artifacts-dir ./bindings/csharp/Regorus/tmp/bindings/ffi/target --enforce-artifacts --repository-commit ${{ github.sha }} --include-symbols
+
+      - name: Upload Regorus nuget
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: regorus-nuget
+          path: |
+            bindings/csharp/Regorus/bin/Release/Regorus*.nupkg
+            bindings/csharp/Regorus/bin/Release/Regorus*.snupkg
+          if-no-files-found: error
+          retention-days: 1
+
+  test-nuget:
+    name: 'Test Regorus Nuget: (${{ matrix.runtime.target }})'
+    needs: build-csharp
+    runs-on: ${{ matrix.runtime.os }}
+    strategy:
+      # let us get failures from other jobs even if one fails
+      fail-fast: false
+      matrix:
+        runtime:
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - os: macos-latest
+            target: aarch64-apple-darwin
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - uses: ./.github/actions/toolchains/rust
+
+      - uses: actions/setup-dotnet@baa11fbfe1d6520db94683bd5c7a3818018e4309 # v5.1.0
+        with:
+          global-json-file: ./bindings/csharp/global.json
+
+      - run: echo '${{ steps.stepid.outputs.dotnet-version }}'
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Download regorus nuget
+        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+        with:
+          name: regorus-nuget
+          path: ./bindings/csharp/Regorus/bin/Release
+
+      - name: Display regorus nuget
+        run: ls -R ./bindings/csharp/Regorus/bin/Release
+
+      - name: Run C# tests via xtask
+        run: cargo xtask test-csharp --release --clean --nuget-dir bindings/csharp/Regorus/bin/Release
+
+      

.github/workflows/test-ffi.yml

@@ -0,0 +1,34 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/ffi
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch FFI crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/ffi/Cargo.toml
+
+      - name: Test FFI
+        run: cargo xtask test-ffi --release --frozen

.github/workflows/test-go.yml

@@ -0,0 +1,38 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/go
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch FFI crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/ffi/Cargo.toml
+
+      - uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
+        with:
+          architecture: x64
+
+      - name: Test Go binding via xtask
+        run: cargo xtask test-go --release --frozen

.github/workflows/test-java.yml

@@ -0,0 +1,39 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/java
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+        with:
+          java-version: 8
+          distribution: "corretto"
+      - uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch Java crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/java/Cargo.toml
+
+      - name: Run Java smoke tests via xtask
+        run: cargo xtask test-java --release --frozen

.github/workflows/test-musl.yml

@@ -0,0 +1,38 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: musl
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - uses: ./.github/actions/toolchains/rust
+      with:
+        targets: x86_64-unknown-linux-musl
+    - name: Cache cargo
+      uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+      with:
+        shared-key: ${{ runner.os }}-regorus
+    - name: Fetch dependencies
+      run: cargo fetch --locked
+    - name: Fetch MUSL target dependencies
+      run: cargo fetch --locked --target x86_64-unknown-linux-musl
+    - name: Install musl-gcc
+      run: sudo apt update && sudo apt install -y musl-tools
+    - name: Run MUSL suite via xtask
+      run: cargo xtask test-musl --release --frozen --target x86_64-unknown-linux-musl

.github/workflows/test-no-std.yml

@@ -0,0 +1,37 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/no-std
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - uses: ./.github/actions/toolchains/rust
+      with:
+        targets: thumbv7m-none-eabi
+    - name: Cache cargo
+      uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+      with:
+        shared-key: ${{ runner.os }}-regorus
+    - name: Fetch dependencies
+      run: cargo fetch --locked
+    - name: Fetch ensure_no_std crate dependencies
+      run: cargo fetch --locked --manifest-path tests/ensure_no_std/Cargo.toml --target thumbv7m-none-eabi
+    - name: Test no-std
+      run: cargo xtask test-no-std --release --frozen
+

.github/workflows/test-python.yml

@@ -0,0 +1,91 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/python
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        host:
+          - name: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - name: windows-latest
+            target: x86_64-pc-windows-msvc
+    runs-on: ${{ matrix.host.name }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/toolchains/rust
+        with:
+          targets: ${{ matrix.host.target }}
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch Python crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/python/Cargo.toml --target ${{ matrix.host.target }}
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: "3.10"
+          architecture: x64
+
+      - name: Install maturin
+        run: python -m pip install maturin==1.5.1
+
+      - name: Build Python wheel via xtask
+        run: cargo xtask build-python --release --target ${{ matrix.host.target }} --target-dir bindings/python/dist --frozen
+
+      - name: Upload wheel artefacts
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: regorus-wheel-${{ matrix.host.name }}
+          path: bindings/python/dist/regorus-*.whl
+
+  test:
+    needs: build
+    strategy:
+      matrix:
+        host: [ubuntu-24.04, ubuntu-22.04, windows-latest]
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    runs-on: ${{ matrix.host }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+      - uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch Python crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/python/Cargo.toml
+
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version: ${{ matrix.python-version }}
+          architecture: x64
+
+      - name: Install maturin
+        run: python -m pip install maturin==1.5.1
+
+      - name: Run Python smoke tests via xtask
+        run: cargo xtask test-python --release --python python

.github/workflows/test-ruby.yml

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/ruby
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test:
+    if: false # temporarily disabled
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Setup Ruby and Rust
+        uses: oxidize-rb/actions/setup-ruby-and-rust@e5f9a49a7812a078584072f6e3f657ad247c8771 # v1.26
+        with:
+          bundler: 2.6.5
+          rubygems: 3.6.5
+          ruby-version: "3.4.2"
+          rustup-toolchain: "stable"
+          bundler-cache: true
+          cargo-cache: true
+          working-directory: "bindings/ruby"
+
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch Ruby crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/ruby/Cargo.toml
+
+      - name: Run ruby tests
+        run: cargo xtask test-ruby --release --frozen

.github/workflows/test-wasm.yml

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: bindings/wasm
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/toolchains/rust
+      - name: Cache cargo
+        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        with:
+          shared-key: ${{ runner.os }}-regorus
+      - name: Fetch dependencies
+        run: cargo fetch --locked
+
+      - name: Fetch WASM crate dependencies
+        run: cargo fetch --locked --manifest-path bindings/wasm/Cargo.toml
+
+      - name: Setup Node
+        uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0
+        with:
+          node-version: 22
+
+      - name: Install wasmlpack
+        run: cargo install wasm-pack
+
+      - name: Test wasm binding via xtask
+        run: cargo xtask test-wasm --release --frozen --node node

.github/workflows/tests-debug.yml

@@ -0,0 +1,33 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+name: tests/debug
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+  schedule:
+    # Run at 8:00 AM every day
+    - cron: "0 8 * * *"
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+    - name: Setup Rust toolchain
+      uses: ./.github/actions/toolchains/rust
+    - name: Cache cargo
+      uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+      with:
+        shared-key: ${{ runner.os }}-regorus
+    - name: Fetch dependencies
+      run: cargo fetch --locked
+    - name: Run debug CI suite
+      run: cargo xtask ci-debug --frozen

.gitignore

@@ -1,10 +1,8 @@
 # Generated by Cargo
 # will have compiled files and executables
 /target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
+**/wheels/
+**/__pycache__/
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
@@ -13,4 +11,43 @@ Cargo.lock
 .vscode/
 
 # worktrees
-worktrees/
+worktrees/
+
+# build folders
+**/build
+
+# Generated C# bindings
+**/*.g.cs
+
+# Generated C, C++ headers
+bindings/ffi/regorus.h
+bindings/ffi/regorus.ffi.hpp
+
+bindings/*/target
+
+# C# build folders
+**bin
+**obj
+bindings/csharp/.nuget/
+
+# Bundler binstubs regenerated during ruby setup
+bindings/ruby/bin/
+
+# Visual Studio folders
+**/*.vs
+
+# Visual Studio solution files
+*.sln
+
+# JetBrains IDEs files
+.idea/
+
+# Java build artifacts
+**/*.class
+**/*.jar
+bindings/java/.classpath
+bindings/java/.project
+bindings/java/.settings/
+
+# Emacs temporary files
+*~

CHANGELOG.md

@@ -6,6 +6,269 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.1](https://github.com/microsoft/regorus/compare/regorus-v0.9.0...regorus-v0.9.1) - 2026-02-06
+
+### Fixed
+- Release native C# handles reliably to avoid memory growth ([#571](https://github.com/microsoft/regorus/pull/571)).
+- Centralize C# handle gating with a short dispose wait and deferred release to avoid leaks while blocking new calls ([#571](https://github.com/microsoft/regorus/pull/571)).
+
+### Added
+- Manual C# memory growth tests for both `using` and finalizer paths ([#571](https://github.com/microsoft/regorus/pull/571)).
+- C# test runner options for filtered tests, console logging, and skipping sample apps ([#571](https://github.com/microsoft/regorus/pull/571)).
+
+## [0.5.0](https://github.com/microsoft/regorus/compare/regorus-v0.4.0...regorus-v0.5.0) - 2025-07-08
+
+### Added
+
+- [**breaking**] Indexes for nodes in the AST ([#414](https://github.com/anakrish/regorus/pull/414))
+- Updates for Policy Framework ([#405](https://github.com/anakrish/regorus/pull/405))
+- Regorus nuget package ([#383](https://github.com/anakrish/regorus/pull/383))
+
+### Fixed
+
+- emit import warning to stderr ([#430](https://github.com/anakrish/regorus/pull/430))
+- Clippy warnings ([#424](https://github.com/anakrish/regorus/pull/424))
+- Disallow else blocks for set rules ([#403](https://github.com/anakrish/regorus/pull/403))
+- [**breaking**] Remove cryptographic builtins ([#396](https://github.com/anakrish/regorus/pull/396))
+- [**breaking**] Fix glob.match behavior in presence of : ([#390](https://github.com/anakrish/regorus/pull/390))
+- C# EvalRule ([#387](https://github.com/anakrish/regorus/pull/387))
+
+### Other
+
+- Update release-plz action to v0.5.108 ([#431](https://github.com/anakrish/regorus/pull/431))
+- Early return for 'some in' statement ([#427](https://github.com/anakrish/regorus/pull/427))
+- Support manually generating C# bindings via Github action and add a README ([#423](https://github.com/anakrish/regorus/pull/423))
+- Make the bindings/cpp CMake project installable ([#416](https://github.com/anakrish/regorus/pull/416))
+- *(deps)* bump clap from 4.5.38 to 4.5.39 ([#415](https://github.com/anakrish/regorus/pull/415))
+- *(deps)* Update criterion and other deps ([#412](https://github.com/anakrish/regorus/pull/412))
+- Basic benchmarking setup with Criterion ([#408](https://github.com/anakrish/regorus/pull/408))
+- Default to Rego v1 in `regorus parse` ([#407](https://github.com/anakrish/regorus/pull/407))
+- *(deps)* bump clap from 4.5.37 to 4.5.38 ([#406](https://github.com/anakrish/regorus/pull/406))
+- Update dependencies ([#401](https://github.com/anakrish/regorus/pull/401))
+- Add C# test examples ([#397](https://github.com/anakrish/regorus/pull/397))
+- *(deps)* bump clap from 4.5.35 to 4.5.36 ([#395](https://github.com/anakrish/regorus/pull/395))
+- Python binding portability ([#388](https://github.com/anakrish/regorus/pull/388))
+- *(deps)* bump clap from 4.5.34 to 4.5.35 ([#389](https://github.com/anakrish/regorus/pull/389))
+- Use VersionPrefix and VersionSuffix ([#385](https://github.com/anakrish/regorus/pull/385))
+- Check-in Cargo.lock files and lockdown .net ([#384](https://github.com/anakrish/regorus/pull/384))
+
+## [0.4.0](https://github.com/microsoft/regorus/compare/regorus-v0.3.0...regorus-v0.4.0) - 2025-03-14
+
+### Fixed
+- [**breaking**] Update ruby json dependency ([#381](https://github.com/microsoft/regorus/pull/381))
+- [**breaking**] Remove ring dependency ([#380](https://github.com/microsoft/regorus/pull/380))
+- [**breaking**] Remove sha1 dependency ([#379](https://github.com/microsoft/regorus/pull/379))
+
+### Other
+- Specify optimization flags ([#378](https://github.com/microsoft/regorus/pull/378))
+
+## [0.3.0](https://github.com/microsoft/regorus/compare/regorus-v0.2.8...regorus-v0.3.0) - 2025-03-10
+
+### Added
+- [**breaking**] Update to OPA v1.2.0 ([#373](https://github.com/microsoft/regorus/pull/373))
+
+### Other
+- *(deps)* update pyo3 requirement from 0.23.5 to 0.24.0 ([#375](https://github.com/microsoft/regorus/pull/375))
+- Update ruby binding deps, ruby gem version 0.2.3 ([#374](https://github.com/microsoft/regorus/pull/374))
+- *(deps)* update pyo3 requirement from 0.22.0 to 0.23.5 ([#372](https://github.com/microsoft/regorus/pull/372))
+- *(deps)* update rand requirement from 0.8.5 to 0.9.0 ([#370](https://github.com/microsoft/regorus/pull/370))
+- *(deps)* update cbindgen requirement from 0.27.0 to 0.28.0 ([#361](https://github.com/microsoft/regorus/pull/361))
+- Fix typo in README.md ([#366](https://github.com/microsoft/regorus/pull/366))
+- Update dependencies ([#369](https://github.com/microsoft/regorus/pull/369))
+- Fix clippy warning for result? ([#362](https://github.com/microsoft/regorus/pull/362))
+- *(deps)* update itertools requirement from 0.13.0 to 0.14.0 ([#357](https://github.com/microsoft/regorus/pull/357))
+- *(deps)* update jsonschema requirement from 0.26.1 to 0.28.1 ([#356](https://github.com/microsoft/regorus/pull/356))
+- resolve anyhow compile errors ([#355](https://github.com/microsoft/regorus/pull/355))
+- *(deps)* update prettydiff requirement from 0.7.0 to 0.8.0 ([#348](https://github.com/microsoft/regorus/pull/348))
+
+## [0.2.8](https://github.com/microsoft/regorus/compare/regorus-v0.2.7...regorus-v0.2.8) - 2024-11-06
+
+### Other
+- *(deps)* update jsonschema requirement from 0.24.0 to 0.26.1 ([#343](https://github.com/microsoft/regorus/pull/343))
+- Update to OPA v0.70.0 ([#341](https://github.com/microsoft/regorus/pull/341))
+
+## [0.2.7](https://github.com/microsoft/regorus/compare/regorus-v0.2.6...regorus-v0.2.7) - 2024-10-22
+
+### Fixed
+- docs failing to build ([#334](https://github.com/microsoft/regorus/pull/334))
+
+### Other
+- *(deps)* update jsonschema requirement from 0.23.0 to 0.24.0 ([#332](https://github.com/microsoft/regorus/pull/332))
+- *(deps)* update jsonschema requirement from 0.22.3 to 0.23.0 ([#331](https://github.com/microsoft/regorus/pull/331))
+
+## [0.2.6](https://github.com/microsoft/regorus/compare/regorus-v0.2.5...regorus-v0.2.6) - 2024-10-09
+
+### Added
+- integer conversion functions for Value ([#328](https://github.com/microsoft/regorus/pull/328))
+
+### Other
+- update to OPA v0.69.0 ([#327](https://github.com/microsoft/regorus/pull/327))
+- *(deps)* update jsonschema requirement from 0.21.0 to 0.22.3 ([#326](https://github.com/microsoft/regorus/pull/326))
+- *(deps)* update jsonschema requirement from 0.20.0 to 0.21.0 ([#325](https://github.com/microsoft/regorus/pull/325))
+- update to jsonschema 0.20.0 ([#323](https://github.com/microsoft/regorus/pull/323))
+
+## [0.2.5](https://github.com/microsoft/regorus/compare/regorus-v0.2.4...regorus-v0.2.5) - 2024-09-18
+
+### Added
+- or keyword ([#315](https://github.com/microsoft/regorus/pull/315))
+
+### Fixed
+- Null terminate C# strings in Rust boundary ([#318](https://github.com/microsoft/regorus/pull/318))
+- Update readme with correct path to example policy ([#312](https://github.com/microsoft/regorus/pull/312))
+
+### Other
+- Update jsonschema requirement from 0.18.0 to 0.19.1 ([#317](https://github.com/microsoft/regorus/pull/317))
+- Update chrono-tz requirement from 0.8.5 to 0.10.0 ([#316](https://github.com/microsoft/regorus/pull/316))
+- Add tests for builtin strings::lower method ([#313](https://github.com/microsoft/regorus/pull/313))
+- Add tests for builtin strings::indexof method ([#311](https://github.com/microsoft/regorus/pull/311))
+
+## [0.2.4](https://github.com/microsoft/regorus/compare/regorus-v0.2.3...regorus-v0.2.4) - 2024-09-04
+
+### Added
+- OPA v0.68.0. Engine::set_rego_v1 ([#305](https://github.com/microsoft/regorus/pull/305))
+
+### Fixed
+- Handle parsing corner cases ([#309](https://github.com/microsoft/regorus/pull/309))
+- Propagate errors encountered in argument evaluation ([#308](https://github.com/microsoft/regorus/pull/308))
+- Issues [#302](https://github.com/microsoft/regorus/pull/302), [#303](https://github.com/microsoft/regorus/pull/303) ([#304](https://github.com/microsoft/regorus/pull/304))
+
+## [0.2.3](https://github.com/microsoft/regorus/compare/regorus-v0.2.2...regorus-v0.2.3) - 2024-08-16
+
+### Fixed
+- Match OPA behavior for split ([#295](https://github.com/microsoft/regorus/pull/295))
+- Merge data to init document ([#293](https://github.com/microsoft/regorus/pull/293))
+
+### Other
+- Update cbindgen requirement from 0.26.0 to 0.27.0 ([#296](https://github.com/microsoft/regorus/pull/296))
+- Bump rexml in /bindings/ruby in the bundler group across 1 directory ([#294](https://github.com/microsoft/regorus/pull/294))
+- Update csbindgen requirement from =1.9.0 to =1.9.3 ([#292](https://github.com/microsoft/regorus/pull/292))
+
+## [0.2.2](https://github.com/microsoft/regorus/compare/regorus-v0.2.1...regorus-v0.2.2) - 2024-07-28
+
+### Added
+- Update to opa v0.67.0 ([#286](https://github.com/microsoft/regorus/pull/286))
+
+### Fixed
+- Handle aliases in scheduler ([#285](https://github.com/microsoft/regorus/pull/285))
+
+### Other
+- Update readme ([#288](https://github.com/microsoft/regorus/pull/288))
+- Update binding versions ([#287](https://github.com/microsoft/regorus/pull/287))
+- build.rs create hooks dir if not exists ([#283](https://github.com/microsoft/regorus/pull/283))
+- add extension_list example ([#281](https://github.com/microsoft/regorus/pull/281))
+- Fix build break ([#278](https://github.com/microsoft/regorus/pull/278))
+- Update pyo3 requirement from 0.21.0 to 0.22.0 ([#275](https://github.com/microsoft/regorus/pull/275))
+- Update to OPA v0.66.0 ([#274](https://github.com/microsoft/regorus/pull/274))
+
+## [0.2.1](https://github.com/microsoft/regorus/compare/regorus-v0.2.0...regorus-v0.2.1) - 2024-06-19
+
+### Added
+- get_policies: Way to obtain policy files and content ([#267](https://github.com/microsoft/regorus/pull/267))
+
+### Other
+- Fix c,cpp,no-std binding examples ([#272](https://github.com/microsoft/regorus/pull/272))
+- Update binding versions for next release ([#270](https://github.com/microsoft/regorus/pull/270))
+- rename method from 'Clone' to 'clone' in 'Engine' class to match the java naming convention and definiont in the of java.lang.Object. ([#268](https://github.com/microsoft/regorus/pull/268))
+- Suppress clippy unused warning ([#269](https://github.com/microsoft/regorus/pull/269))
+- Provide ability to get JSON representation of policy AST ([#266](https://github.com/microsoft/regorus/pull/266))
+- Update OPA tests to v0.65.0 ([#264](https://github.com/microsoft/regorus/pull/264))
+- Allow lexer to be used for other policy languages ([#262](https://github.com/microsoft/regorus/pull/262))
+
+## [0.2.0](https://github.com/microsoft/regorus/compare/regorus-v0.1.5...regorus-v0.2.0) - 2024-05-30
+
+### Other
+- Add release-plz config to publish only regorus package ([#259](https://github.com/microsoft/regorus/pull/259))
+- Revert "chore: release v0.2.0 ([#257](https://github.com/microsoft/regorus/pull/257))" ([#258](https://github.com/microsoft/regorus/pull/258))
+- release v0.2.0 ([#257](https://github.com/microsoft/regorus/pull/257))
+- Fix release-plz hash ([#256](https://github.com/microsoft/regorus/pull/256))
+- non collections should evaluate to false ([#253](https://github.com/microsoft/regorus/pull/253))
+- Fix merge issue ([#252](https://github.com/microsoft/regorus/pull/252))
+- Update bindings to include newer APIs ([#250](https://github.com/microsoft/regorus/pull/250))
+- update ruby bindings version to 0.1.5, bump deps ([#251](https://github.com/microsoft/regorus/pull/251))
+- Use correct docsrs feature annotation ([#248](https://github.com/microsoft/regorus/pull/248))
+- Lockdown kata test prints as well as prints of various values ([#249](https://github.com/microsoft/regorus/pull/249))
+- Fix bindings and add CI tests ([#247](https://github.com/microsoft/regorus/pull/247))
+- Add test-ruby CI for github actions ([#244](https://github.com/microsoft/regorus/pull/244))
+- Update `README.md` for Java bindings to mention we don't publish to ([#246](https://github.com/microsoft/regorus/pull/246))
+- Update itertools requirement from 0.12.1 to 0.13.0 ([#245](https://github.com/microsoft/regorus/pull/245))
+- Update ruby bindings for add_policy and add_policy_from_file to return package name ([#240](https://github.com/microsoft/regorus/pull/240))
+- Provide a way to obtain package names of loaded policies ([#239](https://github.com/microsoft/regorus/pull/239))
+- `c_no_std` binding to show use in C freestanding environments. ([#238](https://github.com/microsoft/regorus/pull/238))
+- Bump rexml in /bindings/ruby in the bundler group across 1 directory ([#236](https://github.com/microsoft/regorus/pull/236))
+- Update prettydiff requirement from 0.6.4 to 0.7.0 ([#234](https://github.com/microsoft/regorus/pull/234))
+- Update jsonschema requirement from 0.17.1 to 0.18.0 ([#235](https://github.com/microsoft/regorus/pull/235))
+- no_std support ([#232](https://github.com/microsoft/regorus/pull/232))
+- add `std` feature ([#231](https://github.com/microsoft/regorus/pull/231))
+- Tests from MSFT fork of kata-containers ([#230](https://github.com/microsoft/regorus/pull/230))
+- Use alloc, core instead of std ([#225](https://github.com/microsoft/regorus/pull/225))
+
+## [0.1.5](https://github.com/microsoft/regorus/compare/regorus-v0.1.4...regorus-v0.1.5) - 2024-05-07
+
+### Added
+- Support policy files greater than 64KB in size ([#217](https://github.com/microsoft/regorus/pull/217))
+- Add tests for kata containers policies ([#221](https://github.com/microsoft/regorus/pull/221))
+- Support for OPA v0.64.0 ([#219](https://github.com/microsoft/regorus/pull/219))
+  - New builtin `json.marshal_with_options`
+### Changed
+- Improve example in readme ([#224](https://github.com/microsoft/regorus/pull/224))
+### Fixed
+- OPA Conformance: Do not interpret # within regular string ([#216](https://github.com/microsoft/regorus/pull/216))
+
+## [0.1.4](https://github.com/microsoft/regorus/compare/regorus-v0.1.3...regorus-v0.1.4) - 2024-04-22
+
+### Other
+- early return ([#189](https://github.com/microsoft/regorus/pull/189))
+- Fix anyhow dependency issues ([#208](https://github.com/microsoft/regorus/pull/208))
+- remove unused compact-rc dependency ([#207](https://github.com/microsoft/regorus/pull/207))
+
+## [0.1.3](https://github.com/microsoft/regorus/compare/regorus-v0.1.2...regorus-v0.1.3) - 2024-04-11
+
+### Other
+- Add a note in example to prefer eval_rule over eval_query ([#204](https://github.com/microsoft/regorus/pull/204))
+- Do not enable serde_json/arbitrary_precision by default ([#203](https://github.com/microsoft/regorus/pull/203))
+- Rewrite so that code compiles with chrono_tz 0.8.5 and 0.9.0 ([#201](https://github.com/microsoft/regorus/pull/201))
+- update ruby bindings ([#200](https://github.com/microsoft/regorus/pull/200))
+- Store Value instances in AST for strings, numbers and idents ([#197](https://github.com/microsoft/regorus/pull/197))
+- :Value> and From<serde_yaml::Value> ([#196](https://github.com/microsoft/regorus/pull/196))
+- Build dependency on git only if opa.runtime feature is enabled. ([#194](https://github.com/microsoft/regorus/pull/194))
+- Update to opa v0.63.0 ([#192](https://github.com/microsoft/regorus/pull/192))
+- Update pyo3 requirement from 0.20.2 to 0.21.0 ([#190](https://github.com/microsoft/regorus/pull/190))
+- Ruby bindings for existing FFI methods, plus eval_rule() ([#188](https://github.com/microsoft/regorus/pull/188))
+- Evaluate rules directly instead of queries ([#186](https://github.com/microsoft/regorus/pull/186))
+- Remove cruft. ([#184](https://github.com/microsoft/regorus/pull/184))
+
+## [0.1.2](https://github.com/microsoft/regorus/compare/regorus-v0.1.1...regorus-v0.1.2) - 2024-03-22
+
+### Other
+- Handle non simple refs in chained expressions ([#182](https://github.com/microsoft/regorus/pull/182))
+- Ability to gather print statements ([#179](https://github.com/microsoft/regorus/pull/179))
+- Top-down evaluation ([#177](https://github.com/microsoft/regorus/pull/177))
+- Make unary `-` operator OPA compatible. ([#175](https://github.com/microsoft/regorus/pull/175))
+- Don't use deprecated chrono `Duration` methods ([#173](https://github.com/microsoft/regorus/pull/173))
+- Propagate Undefined in object expressions ([#171](https://github.com/microsoft/regorus/pull/171))
+- Bump to OPA v0.62.0 ([#169](https://github.com/microsoft/regorus/pull/169))
+- Fix regression ([#164](https://github.com/microsoft/regorus/pull/164))
+- Separately keep track of whether rules have been evaluated or not ([#163](https://github.com/microsoft/regorus/pull/163))
+- Link Linux libraries against glibc 2.17 using `cargo-zigbuild` ([#158](https://github.com/microsoft/regorus/pull/158))
+
+## [0.1.1](https://github.com/microsoft/regorus/compare/regorus-v0.1.0...regorus-v0.1.1) - 2024-02-23
+
+### Other
+- Handle else block without body ([#155](https://github.com/microsoft/regorus/pull/155))
+- Ignore errors from builtin functions in non strict mode ([#154](https://github.com/microsoft/regorus/pull/154))
+- Java publishing ([#151](https://github.com/microsoft/regorus/pull/151))
+- Document coverage feature; Convenience query functions ([#152](https://github.com/microsoft/regorus/pull/152))
+- Policy Coverage ([#149](https://github.com/microsoft/regorus/pull/149))
+- Initial implementation of policy coverage ([#146](https://github.com/microsoft/regorus/pull/146))
+- Java bindings ([#147](https://github.com/microsoft/regorus/pull/147))
+- Preserve false in single-expression queries ([#145](https://github.com/microsoft/regorus/pull/145))
+- Create rust-clippy.yml ([#143](https://github.com/microsoft/regorus/pull/143))
+- `arc` feature to enable using Engine and other data structures from multiple threads ([#142](https://github.com/microsoft/regorus/pull/142))
+- genpolicy tweaks ([#141](https://github.com/microsoft/regorus/pull/141))
+- io.jwt.decode ([#140](https://github.com/microsoft/regorus/pull/140))
+- Use compact_rc ([#139](https://github.com/microsoft/regorus/pull/139))
+- Scripting tweaks ([#138](https://github.com/microsoft/regorus/pull/138))
+
 ## [0.1.0-alpha.3](https://github.com/microsoft/regorus/compare/regorus-v0.1.0-alpha.2...regorus-v0.1.0-alpha.3) - 2024-02-01
 
 ### Fixed
@@ -245,3 +508,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - LICENSE committed
 - CODE_OF_CONDUCT.md committed
 - Initial commit
+

Cargo.toml

@@ -1,109 +1,162 @@
 [workspace]
 
 members = [
-    "bindings/ffi",
-    "bindings/python",
-    "bindings/wasm"
+    "tests/ensure_no_std",
+  "xtask",
 ]
 
 [package]
 name = "regorus"
 description = "A fast, lightweight Rego (OPA policy language) interpreter"
-version = "0.1.0"
+version = "0.9.1"
 edition = "2021"
-license-file = "LICENSE"
+license = "MIT AND Apache-2.0 AND BSD-3-Clause"
 repository = "https://github.com/microsoft/regorus"
-keywords = ["interpreter", "opa", "policy-as-code", "rego"]
+keywords = ["interpreter", "no_std", "opa", "policy-as-code", "rego"]
+
+# Enable verification with Verus
+
+[package.metadata.verus]
+verify = true
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
-[features]
-default = ["full-opa"]
+[lib]
+doctest = false
 
+[features]
+default = ["full-opa", "arc", "rvm"]
+
+arc = []
+ast = []
+azure_policy = ["dep:jsonschema", "arc", "dashmap"]
+azure-rbac = []
 base64 = ["dep:data-encoding"]
 base64url = ["dep:data-encoding"]
-crypto = ["dep:constant_time_eq", "dep:hmac", "dep:hex", "dep:md-5", "dep:sha1", "dep:sha2"]
-deprecated = []
+coverage = []
 hex = ["dep:data-encoding"]
 http = []
-jwt = []
-glob = ["dep:wax"]
+glob = ["dep:globset"]
 graph = []
 jsonschema = ["dep:jsonschema"]
+mimalloc = ["dep:mimalloc"]
+net = ["dep:ipnet"]
+no_std = ["lazy_static/spin_no_std"]
 opa-runtime = []
 regex = ["dep:regex"]
+rvm = ["dep:bincode", "dep:indexmap"]
 semver = ["dep:semver"]
+allocator-memory-limits = ["std", "mimalloc", "mimalloc/allocator-memory-limits"]
+std = ["rand/std", "rand/std_rng", "serde_json/std", "msvc_spectre_libs" ]
+time = ["dep:chrono", "dep:chrono-tz"]
 uuid = ["dep:uuid"]
 urlquery = ["dep:url"]
-time = ["dep:chrono", "dep:chrono-tz"]
 yaml = ["serde_yaml"]
 full-opa = [
     "base64",
     "base64url",
-    "crypto",
-    "deprecated",
+    "coverage",
     "glob",
     "graph",
     "hex",
     "http",
-    "jwt",
     "jsonschema",
+    "allocator-memory-limits",
+    "mimalloc",
+    "net",
     "opa-runtime",
     "regex",
     "semver",
+    "std",
     "time",
     "uuid",
     "urlquery",
-    "yaml"
+    "yaml",
+
+    #"rego-extensions"
 ]
 
+# Features that can be used in no_std environments.
+# Note that: the spin_no_std feature in lazy_static must be specified.
+opa-no-std = [
+  "arc",
+  "base64",
+  "base64url",
+  "coverage",
+  "graph",
+  "hex",
+  "no_std",
+  "opa-runtime",
+  "regex",
+  "semver",
+  # Configure lazy_static to use spinlocks.
+  "lazy_static/spin_no_std"
+]
+
+# Rego language extensions
+rego-extensions = []
+
 # This feature enables some testing utils for OPA tests.
 opa-testutil = []
+rand = ["dep:rand"]
 
 [dependencies]
-anyhow = {version = "1.0.66", features = ["backtrace"] }
-serde = {version = "1.0.150", features = ["derive", "rc"] }
-serde_json = {version = "1.0.89", features = ["arbitrary_precision"] }
-serde_yaml = {version = "0.9.16", optional = true }
-log = "0.4.17"
-env_logger="0.11.1"
-lazy_static = "1.4.0"
-rand = "0.8.5"
-num = "0.4.1"
+anyhow = { version = "1.0.45", default-features = false }
+serde = {version = "1.0.150", default-features = false, features = ["derive", "rc", "alloc"] }
+serde_json = { version = "1.0.89", default-features = false, features = ["alloc"] }
+lazy_static =  { version = "1.4.0", default-features = false }
+thiserror = { version = "2.0", default-features = false }
 
-# Crypto
-constant_time_eq = {version = "0.3.0", optional = true}
-hmac = {version = "0.12.1", optional = true}
-sha2 = {version= "0.10.8", optional = true}
-hex = {version = "0.4.3", optional = true}
-sha1 = {version = "0.10.6", optional = true}
-md-5 = {version = "0.10.6", optional = true}
+data-encoding = { version = "2.8.0", optional = true, default-features=false, features = ["alloc"] }
+num-bigint = { version = "0.4", default-features = false }
+num-traits = { version = "0.2", default-features = false }
+spin = { version = "0.9.8", default-features = false, features = ["mutex", "spin_mutex"] }
 
-data-encoding = { version = "2.4.0", optional = true }
-scientific = { version = "0.5.2" }
+globset = { version = "0.4.16", features = ["simd-accel"], default-features = false, optional = true }
+regex = {version = "1.11.1", optional = true, default-features = false }
+semver = {version = "1.0.25", optional = true, default-features = false }
+url = { version = "2.5.4", optional = true }
+uuid = { version = "1.15.1", default-features = false, features = ["v4", "fast-rng"], optional = true }
+jsonschema = { version = "0.30.0", default-features = false, optional = true }
+chrono = { version = "0.4.40", optional = true }
+chrono-tz = { version = "0.10.1", optional = true }
+ipnet = { version = "2.11.0", optional = true, default-features = false }
 
-regex = {version = "1.10.2", optional = true}
-semver = {version = "1.0.20", optional = true}
-wax = { version = "0.6.0", features = [], default-features = false, optional = true }
-url = { version = "2.5.0", optional = true }
-uuid = { version = "1.6.1", features = ["v4", "fast-rng"], optional = true }
-jsonschema = { version = "0.17.1", default-features = false, optional = true }
-chrono = { version = "0.4.31", optional = true }
-chrono-tz = { version = "0.8.5", optional = true }
+serde_yaml = {version = "0.9.16", default-features = false, optional = true }
+# Specify thread_rng for in order to use random_range
+rand = { version = "0.9.0", default-features = false, features = ["thread_rng"], optional = true }
 
+# Causes the project to link with the Spectre-mitigated CRT and libs.
+msvc_spectre_libs = { version = "0.1", features = ["error"], optional = true }
+dashmap = { version = "6.1", default-features = false, optional = true }
+mimalloc = { package = "regorus-mimalloc", path = "mimalloc", version = "2.2.6", optional = true }
+
+# rvm related deps
+indexmap = { version = "2.12.1", default-features = false, features = ["serde"], optional = true }
+bincode = { version = "2.0.1", default-features = false, features = ["alloc", "serde"], optional = true }
+
+# Use Verus for verification
+vstd = { version = "0.0.0-2026-03-17-2326" }
 
 [dev-dependencies]
-clap = { version = "4.4.7", features = ["derive"] }
-colored-diff = "0.2.3"
+anyhow = "1.0.45"
+cfg-if = "1.0.0"
+clap = { version = "4.5.53", features = ["derive"] }
+prettydiff = { version = "0.9.0", default-features = false }
 serde_yaml = "0.9.16"
 test-generator = "0.3.1"
 walkdir = "2.3.2"
+criterion = { version = "0.8" }
+
+num_cpus = "1.16"
 
 [build-dependencies]
-anyhow = "1.0.66"
+anyhow = "1.0"
 
 [profile.release]
 debug = true
+lto = true
+codegen-units = 1
 
 [[test]]
 name="opa"
@@ -115,3 +168,46 @@ required-features = ["full-opa"]
 name="aci"
 harness=false
 test=false
+
+[[test]]
+name="kata"
+harness=false
+test=false
+
+[[bench]]
+name = "regorus_benchmark"
+harness = false
+
+[[bench]]
+name = "schema_validation_benchmark"
+harness = false
+required-features = ["azure_policy"]
+
+[[bench]]
+name = "engine_evaluation_benchmark"
+path = "benches/evaluation/engine_evaluation_benchmark.rs"
+harness = false
+
+[[bench]]
+name = "compiled_policy_evaluation_benchmark"
+path = "benches/evaluation/compiled_policy_evaluation_benchmark.rs"
+harness = false
+
+[[bench]]
+name = "aci_benchmark"
+harness = false
+
+[[example]]
+name="regorus"
+harness=false
+test=false
+doctest=false
+
+[package.metadata.docs.rs]
+# To build locally:
+# RUSTDOCFLAGS="--cfg docsrs" cargo +nightly doc --all-features --no-deps
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(verus_keep_ghost)'] }

LICENSE

@@ -19,3 +19,238 @@
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     SOFTWARE
+
+The file src/builtins/time/diff.rs contains code derived from Go's `time`
+package, which carries the following license:
+
+    Copyright (c) 2009 The Go Authors. All rights reserved.
+    
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+    
+       * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+    copyright notice, this list of conditions and the following disclaimer
+    in the documentation and/or other materials provided with the
+    distribution.
+       * Neither the name of Google Inc. nor the names of its
+    contributors may be used to endorse or promote products derived from
+    this software without specific prior written permission.
+    
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Some files are licensed Apache-2.0 (LICENSE-2.0.txt).
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -3,17 +3,18 @@
 **Regorus** is
 
   - *Rego*-*Rus(t)*  - A fast, light-weight [Rego](https://www.openpolicyagent.org/docs/latest/policy-language/)
-   interpreter written in Rust.
+    interpreter written in Rust.
   - *Rigorous* - A rigorous enforcer of well-defined Rego semantics.
 
 Regorus is also
   - *cross-platform* - Written in platform-agnostic Rust.
-  - *current* - We strive to keep Regorus up to date with latest OPA release. Regorus supports `import rego.v1`.
-  - *compliant* - Regorus is mostly compliant with the latest [OPA release v0.61.0](https://github.com/open-policy-agent/opa/releases/tag/v0.61.0). See [OPA Conformance](#opa-conformance) for details. Note that while we behaviorally produce the same results, we don't yet support all the builtins.
+  - *no_std compatible* - Regorus can be used in `no_std` environments too. Most of the builtins are supported.
+  - *current* - We strive to keep Regorus up to date with latest OPA release. Regorus defaults to `v1` of the Rego language.
+  - *compliant* - Regorus is mostly compliant with the latest [OPA release v1.2.0](https://github.com/open-policy-agent/opa/releases/tag/v1.2.0). See [OPA Conformance](#opa-conformance) for details. Note that while we behaviorally produce the same results, we don't yet support all the builtins.
   - *extensible* - Extend the Rego language by implementing custom stateful builtins in Rust.
     See [add_extension](https://github.com/microsoft/regorus/blob/fc68bf9c8bea36427dae9401a7d1f6ada771f7ab/src/engine.rs#L352).
     Support for extensibility using other languages coming soon.
-  - *polyglot* - In addition to Rust, Regorus can be used from *C*, *C++*, *C#*, *Golang*, *Javascript* and *Python*.
+  - *polyglot* - In addition to Rust, Regorus can be used from *C*, *C++*, *C#*, *Golang*, *Java*, *Javascript*, *Python*, and *Ruby*.
     This is made possible by the excellent FFI tools available in the Rust ecosystem. See [bindings](#bindings) for information on how to use Regorus from different languages.
 
     To try out a *Javascript(WASM)* compiled version of Regorus from your browser, visit [Regorus Playground](https://anakrish.github.io/regorus-playground/).
@@ -24,31 +25,59 @@ Regorus is available as a library that can be easily integrated into your Rust p
 Here is an example of evaluating a simple Rego policy:
 
 ```rust
-use anyhow::Result;
-use regorus::*;
-use serde_json;
+fn main() -> anyhow::Result<()> {
+    // Create an engine for evaluating Rego policies.
+    let mut engine = regorus::Engine::new();
 
-fn main() -> Result<()> {
-  // Create an engine for evaluating Rego policies.
-  let mut engine = Engine::new();
+    let policy = String::from(
+        r#"
+       package example
 
-  // Add policy to the engine.
-  engine.add_policy(
-    // Filename to be associated with the policy.
-    "hello.rego".to_string(),
+       allow if {
+          ## All actions are allowed for admins.
+          input.principal == "admin"
+       } else if {
+          ## Check if action is allowed for given user.
+          input.action in data.allowed_actions[input.principal]
+       }
+	"#,
+    );
 
-    // Rego policy that just sets a message.
-    r#"
-       package test
-       message = "Hello, World!"
-    "#.to_string()
-  )?;
+    // Add policy to the engine.
+    engine.add_policy(String::from("policy.rego"), policy)?;
 
-  // Evaluate the policy, fetch the message and print it.
-  let results = engine.eval_query("data.test.message".to_string(), false)?;
-  println!("{}", serde_json::to_string_pretty(&results)?);
+    // Add data to engine.
+    engine.add_data(regorus::Value::from_json_str(
+        r#"{
+     "allowed_actions": {
+        "user1" : ["read", "write"],
+        "user2" : ["read"]
+     }}"#,
+    )?)?;
 
-  Ok(())
+    // Set input and evaluate whether user1 can write.
+    engine.set_input(regorus::Value::from_json_str(
+        r#"{
+      "principal": "user1",
+      "action": "write"
+    }"#,
+    )?);
+
+    let r = engine.eval_rule(String::from("data.example.allow"))?;
+    assert_eq!(r, regorus::Value::from(true));
+
+    // Set input and evaluate whether user2 can write.
+    engine.set_input(regorus::Value::from_json_str(
+        r#"{
+      "principal": "user2",
+      "action": "write"
+    }"#,
+    )?);
+
+    let r = engine.eval_rule(String::from("data.example.allow"))?;
+    assert_eq!(r, regorus::Value::Undefined);
+
+    Ok(())
 }
 ```
 
@@ -56,20 +85,20 @@ Regorus is designed with [Confidential Computing](https://confidentialcomputing.
 it is important to be able to control exactly what is being run. Regorus allows enabling and disabling various components using cargo
 features. By default all features are enabled.
 
-The default build of regorus example program is 6.4M:
+The default build of regorus example program is 6.3M:
 ```bash
 $ cargo build -r --example regorus; strip target/release/examples/regorus; ls -lh target/release/examples/regorus
--rwxr-xr-x  1 anand  staff   6.4M Jan 19 11:23 target/release/examples/regorus*
+-rwxr-xr-x  1 anand  staff   6.3M May 11 22:03 target/release/examples/regorus*
 ```
 
 
-When all features except for `yaml` are disabled, the binary size drops down to 2.9M.
+When all default features are disabled, the binary size drops down to 1.9M.
 ```bash
-$ cargo build -r --example regorus --features "yaml" --no-default-features; strip target/release/examples/regorus; ls -lh target/release/examples/regorus
--rwxr-xr-x  1 anand  staff   2.9M Jan 19 11:26 target/release/examples/regorus*
+$ cargo build -r --example regorus --no-default-features; strip target/release/examples/regorus; ls -lh target/release/examples/regorus
+-rwxr-xr-x  1 anand  staff   1.9M May 11 22:04 target/release/examples/regorus*
 ```
 
-Regorus passes the [OPA v0.61.0 test-suite](https://www.openpolicyagent.org/docs/latest/ir/#test-suite) barring a few
+Regorus passes the [OPA v1.2.0 test-suite](https://www.openpolicyagent.org/docs/latest/ir/#test-suite) barring a few
 builtins. See [OPA Conformance](#opa-conformance) below.
 
 ## Bindings
@@ -78,16 +107,21 @@ Regorus can be used from a variety of languages:
 
 - *C*: C binding is generated using [cbindgen](https://github.com/mozilla/cbindgen).
   [corrosion-rs](https://github.com/corrosion-rs/corrosion) can be used to seamlessly use Regorous
-   in your CMake based projects. See [bindings/c](https://github.com/microsoft/regorus/tree/main/bindings/c).
+  in your CMake based projects. See [bindings/c](https://github.com/microsoft/regorus/tree/main/bindings/c).
+- *C freestanding*: [bindings/c_no_std](https://github.com/microsoft/regorus/tree/main/bindings/c_no_std) shows how to use Regorus from C environments without a libc.
 - *C++*: C++ binding is generated using [cbindgen](https://github.com/mozilla/cbindgen).
   [corrosion-rs](https://github.com/corrosion-rs/corrosion) can be used to seamlessly use Regorous
-   in your CMake based projects. See [bindings/cpp](https://github.com/microsoft/regorus/tree/main/bindings/cpp).
+  in your CMake based projects. See [bindings/cpp](https://github.com/microsoft/regorus/tree/main/bindings/cpp).
 - *C#*: C# binding is generated using [csbindgen](https://github.com/Cysharp/csbindgen). See [bindings/csharp](https://github.com/microsoft/regorus/tree/main/bindings/csharp) for an example of how to build and use Regorus in your C# projects.
 - *Golang*: The C bindings are exposed to Golang via [CGo](https://pkg.go.dev/cmd/cgo). See [bindings/go](https://github.com/microsoft/regorus/tree/main/bindings/go) for an example of how to build and use Regorus in your Go projects.
 - *Python*: Python bindings are generated using [pyo3](https://github.com/PyO3/pyo3). Wheels are created using [maturin](https://github.com/PyO3/maturin). See [bindings/python](https://github.com/microsoft/regorus/tree/main/bindings/python).
+- *Java*: Java bindings are developed using [jni-rs](https://github.com/jni-rs/jni-rs).
+  See [bindings/java](https://github.com/microsoft/regorus/tree/main/bindings/java).
 - *Javascript*: Regorus is compiled to WASM using [wasmpack](https://github.com/rustwasm/wasm-pack).
   See [bindings/wasm](https://github.com/microsoft/regorus/tree/main/bindings/wasm) for an example of using Regorus from nodejs.
   To try out a *Javascript(WASM)* compiled version of Regorus from your browser, visit [Regorus Playground](https://anakrish.github.io/regorus-playground/).
+- *Ruby*: Ruby bindings are developed using [magnus](https://github.com/matsadler/magnus).
+  See [bindings/ruby](https://github.com/microsoft/regorus/tree/main/bindings/ruby).
 
 To avoid operational overhead, we currently don't publish these bindings to various repositories.
 It is straight-forward to build these bindings yourself.
@@ -111,6 +145,7 @@ $ regorus
 Usage: regorus <COMMAND>
 
 Commands:
+  ast    Parse a Rego policy and dump AST
   eval   Evaluate a Rego Query
   lex    Tokenize a Rego policy
   parse  Parse a Rego policy
@@ -149,11 +184,11 @@ This produces the following output
 }
 ```
 
-Next, evaluate a sample [policy](examples/example.rego) and [input](examples/input.json)
+Next, evaluate a sample [policy](https://github.com/microsoft/regorus/blob/main/examples/server/allowed_server.rego) and [input](https://github.com/microsoft/regorus/blob/main/examples/server/input.json)
 (borrowed from [Rego tutorial](https://www.openpolicyagent.org/docs/latest/#2-try-opa-eval)):
 
 ```bash
-$ regorus eval -d examples/example.rego -i examples/input.json data.example
+$ regorus eval -d examples/server/allowed_server.rego -i examples/server/input.json data.example
 ```
 
 Finally, evaluate real-world [policies](tests/aci/) used in Azure Container Instances (ACI)
@@ -162,6 +197,23 @@ Finally, evaluate real-world [policies](tests/aci/) used in Azure Container Inst
 $ regorus eval -b tests/aci -d tests/aci/data.json -i tests/aci/input.json data.policy.mount_overlay=x
 ```
 
+## Policy coverage
+
+Regorus allows determining which lines of a policy have been executed using the `coverage` feature (enabled by default).
+
+We can try it out using the `regorus` example program by passing in the `--coverage` flag.
+
+```shell
+$ regorus eval -d examples/server/allowed_server.rego -i examples/server/input.json data.example --coverage
+```
+
+It produces the following coverage report which shows that all lines are executed except the line that sets `allow` to true.
+
+![coverage.png](https://github.com/microsoft/regorus/blob/main/docs/coverage.png?raw=true)
+
+See [Engine::get_coverage_report](https://docs.rs/regorus/latest/regorus/struct.Engine.html#method.get_coverage_report) for details.
+Policy coverage information is useful for debugging your policy as well as to write tests for your policy so that all
+lines of the policy are exercised by the tests.
 
 ## ACI Policies
 
@@ -222,28 +274,34 @@ Benchmark 1: opa eval -b tests/aci -d tests/aci/data.json -i tests/aci/input.jso
   Range (min … max):    43.8 ms …  46.7 ms    62 runs
 
 ```
+
+## Contributor Workflow
+
+Regorus uses a small companion CLI under the `xtask` package to keep CI and local development in sync.
+The commands mirror our GitHub Actions jobs, making it easy to dry-run CI steps before sending a pull request.
+
+- Run the full release pipeline with `cargo xtask ci-release` and the debug checks with `cargo xtask ci-debug`.
+- Exercise language bindings through focused helpers such as `cargo xtask test-java --release --frozen` or `cargo xtask test-go`.
+- Use `cargo xtask test-musl --release --frozen` for the cross-compilation matrix and `cargo xtask test-no-std` for embedded targets.
+- Formatting (`cargo xtask fmt`) and linting (`cargo xtask clippy --sarif`) wrap the usual Cargo tooling while matching CI defaults.
+
+The workflows in `.github/workflows` invoke the same commands, so keeping local runs green is usually enough to satisfy the checks enforced on `main`.
+
 ## OPA Conformance
 
-Regorus has been verified to be compliant with [OPA v0.61.0](https://github.com/open-policy-agent/opa/releases/tag/v0.61.0)
-using a [test driver](https://github.com/microsoft/regorus/blob/main/tests/opa.rs) that loads and runs the OPA testsuite using Regorus, and verifies that expected outputs
-are produced.
+Regorus has been verified to be compliant with [OPA v1.2.0](https://github.com/open-policy-agent/opa/releases/tag/v1.2.0)
+using a [test driver](https://github.com/microsoft/regorus/blob/main/tests/opa.rs) that loads and runs the OPA testsuite using Regorus, and verifies that expected outputs are produced.
 
 The test driver can be invoked by running:
 
 ```bash
-$ cargo test -r --test opa
+$ cargo test -r --test opa --features opa-testutil,serde_json/arbitrary_precision
 ```
 
 Currently, Regorus passes all the non-builtin specific tests.
 See [passing tests suites](https://github.com/microsoft/regorus/blob/main/tests/opa.passing).
 
-The following test suites don't pass fully due to mising builtins:
-- `cryptoparsersaprivatekeys`
-- `cryptox509parseandverifycertificates`
-- `cryptox509parsecertificaterequest`
-- `cryptox509parsecertificates`
-- `cryptox509parsekeypair`
-- `cryptox509parsersaprivatekey`
+The following test suites don't pass fully due to missing builtins:
 - `globsmatch`
 - `graphql`
 - `invalidkeyerror`
@@ -251,16 +309,15 @@ The following test suites don't pass fully due to mising builtins:
 - `jwtbuiltins`
 - `jwtdecodeverify`
 - `jwtencodesign`
+- `jwtencodesignheadererrors`
+- `jwtencodesignpayloaderrors`
 - `jwtencodesignraw`
 - `jwtverifyhs256`
 - `jwtverifyhs384`
 - `jwtverifyhs512`
 - `jwtverifyrsa`
-- `netcidrcontains`
 - `netcidrcontainsmatches`
-- `netcidrexpand`
 - `netcidrintersects`
-- `netcidrisvalid`
 - `netcidrmerge`
 - `netcidroverlap`
 - `netlookupipaddr`
@@ -272,6 +329,7 @@ The following test suites don't pass fully due to mising builtins:
 
 They are captured in the following [github issues](https://github.com/microsoft/regorus/issues?q=is%3Aopen+is%3Aissue+label%3Alib).
 
+Cryptographic builtins are not supported by design. Users that need cryptographic builtins are encouraged to use [extensions](https://docs.rs/regorus/latest/regorus/struct.Engine.html#method.add_extension).
 
 ### Grammar
 

benches/aci_benchmark.rs

@@ -0,0 +1,80 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+use regorus::{Engine, Value};
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use serde::{Deserialize, Serialize};
+use walkdir::WalkDir;
+
+use std::path::Path;
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+struct TestCase {
+    note: String,
+    data: Value,
+    input: Value,
+    modules: Vec<String>,
+    query: String,
+    want_result: Value,
+}
+
+#[derive(Serialize, Deserialize, PartialEq, Debug)]
+struct YamlTest {
+    cases: Vec<TestCase>,
+}
+
+fn aci_policy_eval(c: &mut Criterion) {
+    let dir = Path::new("tests/aci");
+    for entry in WalkDir::new(dir)
+        .sort_by_file_name()
+        .into_iter()
+        .filter_map(|e| e.ok())
+    {
+        let path = entry.path();
+        if !path.to_string_lossy().ends_with(".yaml") {
+            continue;
+        }
+
+        let yaml = std::fs::read(path).expect("failed to read yaml test");
+        let yaml = String::from_utf8_lossy(&yaml);
+        let test: YamlTest = serde_yaml::from_str(&yaml).expect("failed to deserialize yaml test");
+
+        for case in &test.cases {
+            let rule = case.query.replace("=x", "");
+            c.bench_with_input(
+                BenchmarkId::new("case ", format!("{} {}", &case.note, &rule)),
+                &case,
+                |b, case| {
+                    let mut engine = Engine::new();
+                    engine.set_rego_v0(true);
+
+                    engine
+                        .add_data(case.data.clone())
+                        .expect("failed to add data");
+                    engine.set_input(case.input.clone());
+
+                    for (idx, rego) in case.modules.iter().enumerate() {
+                        if rego.ends_with(".rego") {
+                            let path = dir.join(rego);
+                            let path = path.to_str().expect("not a valid path");
+                            engine
+                                .add_policy_from_file(path)
+                                .expect("failed to add policy");
+                        } else {
+                            engine
+                                .add_policy(format!("rego{idx}.rego"), rego.clone())
+                                .expect("failed to add policy");
+                        }
+                    }
+
+                    b.iter(|| {
+                        engine.eval_rule(rule.clone()).unwrap();
+                    })
+                },
+            );
+        }
+    }
+}
+
+criterion_group!(aci_benches, aci_policy_eval);
+criterion_main!(aci_benches);

benches/evaluation/README.md

@@ -0,0 +1,157 @@
+# Regorus Multi-Threaded Evaluation Benchmark
+
+A benchmark suite for measuring the multi-threaded performance of the Regorus policy evaluation engine.
+
+## Overview
+
+This benchmark evaluates the throughput and scalability of Regorus policy evaluation across different thread counts and configuration strategies. It measures performance variations between fresh and cloned engine instances, as well as fresh and cloned input data.
+
+## Features
+
+- **Multi-threaded evaluation** testing from 1 to `num_cpus * 2` threads
+- **Configurable engine strategies**: Fresh vs. cloned engine instances
+- **Configurable input strategies**: Fresh parsing vs. cloned input data
+- **Complex policy evaluation** using realistic RBAC and data sensitivity policies
+- **Criterion-based benchmarking** with statistical analysis
+- **Performance metrics** including throughput and timing
+
+## Benchmark Structure
+
+### Test Configurations
+
+The benchmark tests four different configuration combinations:
+
+1. **Cloned Engines + Cloned Inputs**: Pre-instantiated engines with pre-parsed input data
+2. **Cloned Engines + Fresh Inputs**: Pre-instantiated engines with fresh JSON parsing
+3. **Fresh Engines + Cloned Inputs**: New engine instances with pre-parsed input data
+4. **Fresh Engines + Fresh Inputs**: New engine instances with fresh JSON parsing
+
+### Thread Scaling
+
+Tests are performed with thread counts: 1, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32 (up to `num_cpus * 2`)
+
+Each thread performs 1000 policy evaluations to ensure statistically significant measurements.
+
+## Running the Benchmark
+
+### Prerequisites
+
+- Rust 1.70+
+- Cargo
+
+### Execution
+
+Run the complete benchmark suite:
+
+```bash
+cargo bench evaluation_benchmark
+```
+
+Run specific benchmarks:
+
+```bash
+# Run only cloned engines with cloned inputs
+cargo bench "cloned_engines , cloned_inputs"
+
+# Run only single-threaded tests
+cargo bench "1 threads"
+```
+
+### Output
+
+Results are generated in the `target/criterion/` directory and include:
+
+- Detailed timing statistics
+- Throughput measurements (Kelem/s)
+- Performance comparison with previous runs
+- HTML reports with graphs and analysis
+
+## Test Policies
+
+The benchmark uses complex Rego policies that simulate real-world scenarios:
+
+### RBAC Policy
+- Role-based access control with hierarchical permissions
+- User-role-resource mapping
+- Action-based authorization
+
+### Data Sensitivity Policy
+- Multi-level data classification (public, internal, confidential, secret)
+- Access level validation
+- Clearance-based filtering
+
+### Time-based Access Policy
+- Business hours validation
+- Temporal access control
+- Schedule-based permissions
+
+### Azure Resource Policies
+- **VM Deployment**: VM size restrictions, regional compliance, security configurations
+- **Storage Account Security**: Encryption requirements, network ACLs, HTTPS enforcement
+- **Key Vault Access**: Service principal validation, soft delete requirements, conditional access
+- **Network Security Groups**: Port restrictions, CIDR validation, priority-based rules
+
+### Policy Complexity Features
+- **Multi-condition validation**: Complex nested object property checks
+- **Network operations**: CIDR matching and IP range validation
+- **Time-based constraints**: Timestamp comparisons and business hour logic
+- **Security compliance**: Encryption, authentication, and access control patterns
+- **Azure Resource Manager**: Real-world cloud governance scenarios
+
+## Configuration
+
+### Benchmark Parameters
+
+- **Evaluations per thread**: 1000
+- **Measurement iterations**: 100 samples per configuration
+- **Warm-up time**: 3 seconds
+- **Measurement time**: 10 seconds (extended for high thread counts)
+
+### Customization
+
+The benchmark can be customized by modifying `evaluation_benchmark.rs`:
+
+```rust
+// Adjust evaluations per thread
+let evals_per_thread = 1000;
+
+// Modify thread count calculation
+let max_threads = num_cpus::get() * 2;
+
+// Configure test scenarios
+let scenarios = [
+    (true, true),   // cloned_engines, cloned_inputs
+    (true, false),  // cloned_engines, fresh_inputs
+    (false, true),  // fresh_engines, cloned_inputs
+    (false, false), // fresh_engines, fresh_inputs
+];
+```
+
+## Understanding Results
+
+### Metrics
+
+- **Total Evaluation Time**: Total execution time for all evaluations across all threads (ms)
+- **Throughput**: Evaluations per second measured in Kelem/s
+  - **Kelem/s**: Thousands of elements (policy evaluations) per second
+  - Example: 98.71 Kelem/s = 98,710 policy evaluations per second
+
+
+### Interpretation
+
+- **Lower time** = better performance
+- **Higher throughput** = better performance
+- **Consistent results** across runs indicate stable performance
+- **Outliers** may indicate system interference or measurement variance
+
+### Tips
+
+- Run on dedicated hardware for consistent results
+- Disable other applications during benchmarking
+- Use release builds for accurate performance measurements
+- Consider CPU affinity for highly controlled testing
+
+## Files
+
+- `evaluation_benchmark.rs`: Main benchmark implementation
+- Results are saved to `../../target/criterion/` directory

benches/evaluation/compiled_policy_evaluation_benchmark.md

@@ -0,0 +1,160 @@
+# Compiled Policy Evaluation Benchmark Results
+
+## Test Environment
+- **Platform**: Apple Silicon (M-Series)
+- **CPU**: 16 cores
+- **Architecture**: ARM64 (aarch64-apple-darwin)
+- **Rust Version**: 1.82.0
+- **Allocator**: mimalloc (default allocator)
+- **Benchmark Framework**: Criterion.rs
+- **Test Data**: 20,000 inputs per evaluation (1000 per thread)
+- **Policy**: Complex authorization policy with nested rules
+
+## Benchmark Overview
+
+The compiled policy evaluation benchmark tests Regorus compiled policy performance across multiple thread configurations (1-32 threads). It measures throughput (thousands of evaluations per second) for different combinations of compiled policy and input data reuse strategies.
+
+## Configuration Combinations
+
+1. **Compiled Shared Policies, Cloned Inputs**: Each thread uses shared compiled policies and clones of parsed input data - optimal for performance
+2. **Compiled Shared Policies, Fresh Inputs**: Each thread uses shared compiled policies but parses new inputs each time
+3. **Compiled Per Iteration, Cloned Inputs**: Each thread compiles the policy each iteration but reuses input data
+4. **Compiled Per Iteration, Fresh Inputs**: Each thread compiles new policies and parses new inputs for each iteration
+
+## Performance Results
+
+### Compiled Shared Policies, Cloned Inputs (Best Performance)
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                       2.35 |                  426 |
+|       2 |                       5.36 |                  373 |
+|       4 |                      11.70 |                  342 |
+|       6 |                      20.33 |                  295 |
+|       8 |                      43.26 |                  185 |
+|      10 |                      61.93 |                  162 |
+|      12 |                      79.30 |                  151 |
+|      14 |                      94.45 |                  148 |
+|      16 |                     113.39 |                  141 |
+|      18 |                     154.41 |                  117 |
+|      20 |                     184.37 |                  108 |
+|      22 |                     204.00 |                  108 |
+|      24 |                     220.45 |                  109 |
+|      26 |                     237.07 |                  110 |
+|      28 |                     252.58 |                  111 |
+|      30 |                     273.57 |                  110 |
+|      32 |                     292.69 |                  109 |
+
+### Compiled Shared Policies, Fresh Inputs
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                       3.34 |                  299 |
+|       2 |                       7.29 |                  274 |
+|       4 |                      15.19 |                  263 |
+|       6 |                      24.90 |                  241 |
+|       8 |                      49.22 |                  163 |
+|      10 |                      68.45 |                  146 |
+|      12 |                      86.55 |                  139 |
+|      14 |                     104.77 |                  134 |
+|      16 |                     136.07 |                  118 |
+|      18 |                     169.05 |                  106 |
+|      20 |                     198.25 |                  101 |
+|      22 |                     217.05 |                  101 |
+|      24 |                     234.75 |                  102 |
+|      26 |                     254.53 |                  102 |
+|      28 |                     276.06 |                  101 |
+|      30 |                     296.12 |                  101 |
+|      32 |                     318.81 |                  100 |
+
+### Compiled Per Iteration, Cloned Inputs
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                      18.11 |                   55 |
+|       2 |                      36.89 |                   54 |
+|       4 |                      75.46 |                   53 |
+|       6 |                     114.66 |                   52 |
+|       8 |                     152.80 |                   52 |
+|      10 |                     192.17 |                   52 |
+|      12 |                     232.32 |                   52 |
+|      14 |                     301.47 |                   46 |
+|      16 |                     380.36 |                   42 |
+|      18 |                     424.64 |                   42 |
+|      20 |                     484.76 |                   41 |
+|      22 |                     531.62 |                   41 |
+|      24 |                     582.88 |                   41 |
+|      26 |                     631.39 |                   41 |
+|      28 |                     671.99 |                   42 |
+|      30 |                     717.65 |                   42 |
+|      32 |                     766.05 |                   42 |
+
+### Compiled Per Iteration, Fresh Inputs
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                      19.07 |                   52 |
+|       2 |                      38.89 |                   51 |
+|       4 |                      79.52 |                   50 |
+|       6 |                     120.89 |                   50 |
+|       8 |                     161.08 |                   50 |
+|      10 |                     202.37 |                   49 |
+|      12 |                     244.04 |                   49 |
+|      14 |                     316.66 |                   44 |
+|      16 |                     398.02 |                   40 |
+|      18 |                     449.54 |                   40 |
+|      20 |                     500.57 |                   40 |
+|      22 |                     557.97 |                   39 |
+|      24 |                     605.71 |                   40 |
+|      26 |                     656.88 |                   40 |
+|      28 |                     710.03 |                   39 |
+|      30 |                     741.09 |                   40 |
+|      32 |                     801.26 |                   40 |
+
+## Analysis
+
+The compiled policy benchmark demonstrates the following performance characteristics with mimalloc as the default allocator:
+
+1. **Best Performance**: Compiled shared policies with cloned inputs provide the highest throughput
+2. **Compilation Impact**: 
+   - Pre-compiled policies: Significantly faster than per-iteration compilation
+   - Per-iteration compilation: Major overhead (~7-8x slower than pre-compiled)
+3. **Scaling Patterns with mimalloc**:
+   - Best throughput achieved at 1 thread for shared policy configurations
+   - mimalloc provides better thread scaling characteristics compared to the default allocator
+   - Higher thread counts show performance degradation due to contention, but less severe with mimalloc
+   - Per-iteration compilation shows poor scaling across all thread counts
+4. **Input Processing**: Fresh inputs add ~30% overhead across all configurations
+5. **Thread Performance with mimalloc**: 
+   - Peak performance at 1 thread for most configurations
+   - Reasonable performance maintained up to 12-16 threads for shared policies
+   - Compiled policies show better thread scaling than per-iteration compilation
+   - mimalloc helps reduce allocation-related contention in multi-threaded scenarios
+
+## Comparison with Engine Evaluation
+
+### Multi-Thread Performance Comparison
+
+| Configuration        | 1 Thread (Kelem/s) | 4 Threads (Kelem/s) | 8 Threads (Kelem/s) |
+|:---------------------|:-------------------|:--------------------|:--------------------|
+|                      | CP / EE            | CP / EE             | CP / EE             |
+| Shared/Cloned        | 426 / 423          | 342 / 406           | 185 / 341           |
+| Shared/Fresh         | 299 / 309          | 263 / 297           | 163 / 266           |
+| Per-iteration/Cloned | 55 / 56            | 53 / 54             | 52 / 53             |
+| Per-iteration/Fresh  | 52 / 53            | 50 / 51             | 50 / 51             |
+
+### Threading Efficiency Analysis
+
+| Configuration        | Low Contention (1-4t) | Medium Contention (6-12t) | High Contention (16+t) |
+|:---------------------|:----------------------|:--------------------------|:-----------------------|
+|                      | Avg CP / EE           | Avg CP / EE               | Avg CP / EE            |
+| Shared/Cloned        | 384 / 414             | 203 / 329                 | 123 / 250              |
+| Shared/Fresh         | 284 / 302             | 176 / 235                 | 108 / 201              |
+| Per-iteration/Cloned | 54 / 55               | 50 / 52                   | 42 / 42                |
+| Per-iteration/Fresh  | 51 / 52               | 47 / 50                   | 40 / 40                |
+
+The compiled policy evaluation shows performance characteristics that are generally comparable to engine evaluation, though with some notable differences. While single-threaded performance is very close between the systems, there are observable impacts from the compilation approach that become more apparent under different threading scenarios.
+
+**Key Observations:**
+- **Single-threaded performance**: Very close parity between systems, though results may vary between runs
+- **Threading behavior**: Engine evaluation demonstrates better scaling characteristics under higher thread contention (4+ threads)
+- **Multi-threaded impact**: Compiled policies show more pronounced performance degradation under thread contention in shared policy configurations
+- **Contention resistance**: Per-iteration compilation shows more consistent (though lower absolute) performance across thread counts
+- **Optimal usage**: Both systems achieve best results with minimal threading (1-4 threads), though engine evaluation maintains better performance at higher thread counts for shared configurations
+

benches/evaluation/compiled_policy_evaluation_benchmark.rs

@@ -0,0 +1,232 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use regorus::{compile_policy_with_entrypoint, CompiledPolicy, PolicyModule, Value};
+use std::collections::HashMap;
+use std::hint::black_box;
+use std::sync::{Arc, Barrier, Mutex};
+use std::thread;
+use std::time::Duration;
+
+mod policy_data;
+
+fn multi_threaded_compiled_eval(
+    num_threads: usize,
+    evals_per_thread: usize,
+    use_shared_policies: bool,
+    use_cloned_inputs: bool,
+) -> (std::time::Duration, HashMap<String, usize>, usize) {
+    // Complex policies with multiple valid inputs for each
+    let policies_with_inputs = policy_data::policies_with_inputs();
+
+    // Policy names for tracking
+    let policy_names = policy_data::policy_names()
+        .into_iter()
+        .map(|s| s.to_string())
+        .collect::<Vec<_>>();
+
+    // Pre-compile all policies and share them between threads (only if using shared policies)
+    let compiled_policies: Option<Arc<Vec<CompiledPolicy>>> = if use_shared_policies {
+        Some(Arc::new(
+            policies_with_inputs
+                .iter()
+                .map(|(policy, _)| {
+                    let module = PolicyModule {
+                        id: "policy.rego".into(),
+                        content: policy.as_str().into(),
+                    };
+                    compile_policy_with_entrypoint(
+                        Value::new_object(),
+                        &[module],
+                        "data.bench.allow".into(),
+                    )
+                    .unwrap()
+                })
+                .collect(),
+        ))
+    } else {
+        None
+    };
+
+    // Initialize policy evaluation counters
+    let policy_counters = Arc::new(Mutex::new(HashMap::new()));
+    for policy_name in &policy_names {
+        policy_counters
+            .lock()
+            .unwrap()
+            .insert(policy_name.to_string(), 0);
+    }
+    let total_evals = Arc::new(Mutex::new(0usize));
+
+    let barrier = Arc::new(Barrier::new(num_threads));
+    let mut handles = Vec::with_capacity(num_threads);
+
+    for thread_id in 0..num_threads {
+        let barrier = barrier.clone();
+        let policies_with_inputs = policies_with_inputs.clone();
+        let compiled_policies = compiled_policies.clone();
+        let policy_names = policy_names.clone();
+        let policy_counters = policy_counters.clone();
+        let total_evals = total_evals.clone();
+
+        handles.push(thread::spawn(move || {
+            let mut elapsed = std::time::Duration::ZERO;
+
+            // Pre-parse inputs if using cloned inputs
+            let parsed_inputs = if use_cloned_inputs {
+                Some(
+                    policies_with_inputs
+                        .iter()
+                        .map(|(_, inputs)| {
+                            inputs
+                                .iter()
+                                .map(|input_str| Value::from_json_str(input_str).unwrap())
+                                .collect::<Vec<_>>()
+                        })
+                        .collect::<Vec<_>>(),
+                )
+            } else {
+                None
+            };
+
+            barrier.wait();
+            for i in 0..evals_per_thread {
+                // Use different policy for each iteration - thread_id ensures different threads
+                // start with different policies for better load distribution
+                let policy_idx = (thread_id + i) % policies_with_inputs.len();
+                let (_, inputs) = &policies_with_inputs[policy_idx];
+
+                // Use different input for the same policy based on iteration - thread_id ensures
+                // different threads start with different inputs for better load distribution
+                let input_idx = (thread_id + i) % inputs.len();
+                let input = &inputs[input_idx];
+
+                let start = std::time::Instant::now();
+
+                let input_value = if use_cloned_inputs {
+                    parsed_inputs.as_ref().unwrap()[policy_idx][input_idx].clone()
+                } else {
+                    Value::from_json_str(input).unwrap()
+                };
+
+                let result = if let Some(ref compiled_policies_vec) = compiled_policies {
+                    // Use pre-compiled policy
+                    let compiled_policy = &compiled_policies_vec[policy_idx];
+                    compiled_policy.eval_with_input(input_value)
+                } else {
+                    // Compile policy in each iteration
+                    let (policy, _) = &policies_with_inputs[policy_idx];
+                    let module = PolicyModule {
+                        id: "policy.rego".into(),
+                        content: policy.as_str().into(),
+                    };
+                    let compiled_policy = compile_policy_with_entrypoint(
+                        Value::new_object(),
+                        &[module],
+                        "data.bench.allow".into(),
+                    )
+                    .unwrap();
+                    compiled_policy.eval_with_input(input_value)
+                };
+
+                elapsed += start.elapsed();
+
+                // Track total and successful evaluations
+                {
+                    let mut total = total_evals.lock().unwrap();
+                    *total += 1;
+                }
+                if result.is_ok() {
+                    if let Some(policy_name) = policy_names.get(policy_idx) {
+                        let mut counters = policy_counters.lock().unwrap();
+                        *counters.entry(policy_name.to_string()).or_insert(0) += 1;
+                    }
+                }
+            }
+            elapsed
+        }));
+    }
+
+    let mut total = std::time::Duration::ZERO;
+    for handle in handles {
+        total += handle.join().unwrap();
+    }
+
+    let final_counters = policy_counters.lock().unwrap().clone();
+    let total_evals = *total_evals.lock().unwrap();
+    (total, final_counters, total_evals)
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let max_threads = num_cpus::get() * 2;
+    println!(
+        "Running compiled policy benchmark with max_threads: {}",
+        max_threads
+    );
+
+    let evals_per_thread = 1000;
+
+    // Benchmark all combinations of compilation strategy and input strategy
+    for use_shared_policies in [true, false] {
+        for use_cloned_inputs in [true, false] {
+            let group_name = match (use_shared_policies, use_cloned_inputs) {
+                (true, true) => "compiled_shared_policies, cloned_inputs ",
+                (true, false) => "compiled_shared_policies, fresh_inputs  ",
+                (false, true) => "compiled_per_iteration , cloned_inputs ",
+                (false, false) => "compiled_per_iteration , fresh_inputs  ",
+            };
+
+            let mut group = c.benchmark_group(group_name);
+            group.measurement_time(Duration::from_secs(5));
+
+            // Test specific thread counts: powers of 2 + some intermediate values
+            let thread_counts: Vec<usize> = (1..=max_threads)
+                .filter(|&n| {
+                    n == 1 || // Always test single-threaded
+                    n % 2 == 0 || // Always test even threads
+                    n == max_threads // Maximum threads
+                })
+                .collect();
+
+            for threads in thread_counts {
+                let total_evals = threads * evals_per_thread;
+                group.throughput(Throughput::Elements(total_evals as u64));
+                group.bench_with_input(
+                    BenchmarkId::new("compiled_eval", format!(" {threads} threads")),
+                    &threads,
+                    |b, &threads| {
+                        b.iter_custom(|iters| {
+                            let evals_per_thread = evals_per_thread * (iters as usize);
+
+                            let (duration, policy_counters, total_evals_aggregated) = multi_threaded_compiled_eval(
+                                black_box(threads),
+                                black_box(evals_per_thread),
+                                black_box(use_shared_policies),
+                                black_box(use_cloned_inputs),
+                            );
+
+                            // Sanity check: Ensure the expected number of evaluations matches the actual number performed per iteration batch.
+                            // total_evals is the expected number for this batch, total_evals_aggregated is the sum over all iters.
+                            assert_eq!(total_evals, total_evals_aggregated/iters as usize);
+
+                            // On one iteration, print policy evaluation statistics
+                            if iters == 1 {
+                                // println!("\nCompiled Policy Evaluation Statistics:");
+                                for (policy_name, count) in &policy_counters {
+                                    // println!("  {}: {} evaluations", policy_name, count);
+                                    if *count == 0 {
+                                        println!("\x1b[31mERROR: Policy '{}' was never evaluated successfully!\x1b[0m", policy_name);
+                                    }
+                                }
+                            }
+
+                            duration
+                        });
+                    },
+                );
+            }
+            group.finish();
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

benches/evaluation/engine_evaluation_benchmark.md

@@ -0,0 +1,127 @@
+# Engine Evaluation Benchmark Results
+
+## Test Environment
+- **Platform**: Apple Silicon (M-Series)
+- **CPU**: 16 cores
+- **Architecture**: ARM64 (aarch64-apple-darwin)
+- **Rust Version**: 1.82.0
+- **Allocator**: mimalloc (default allocator)
+- **Benchmark Framework**: Criterion.rs
+- **Test Data**: 20,000 inputs per evaluation (1000 per thread)
+- **Policy**: Complex authorization policy with nested rules
+
+## Benchmark Overview
+
+The engine evaluation benchmark tests Regorus policy evaluation performance across multiple thread configurations (1-32 threads). It measures throughput (thousands of evaluations per second) for different combinations of engine and input data reuse strategies.
+
+## Configuration Combinations
+
+1. **Cloned Engines, Cloned Inputs**: Each thread uses its own engine and clones of parsed input data - optimal for performance
+2. **Cloned Engines, Fresh Inputs**: Each thread uses its own engine but parses new inputs each time
+3. **Fresh Engines, Cloned Inputs**: Each thread creates a new engine each iteration but reuses input data
+4. **Fresh Engines, Fresh Inputs**: Each thread creates new engines and parses new inputs for each iteration
+
+## Performance Results
+
+### Cloned Engines, Cloned Inputs (Best Performance)
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                       2.36 |                  423 |
+|       2 |                       4.85 |                  412 |
+|       4 |                       9.86 |                  406 |
+|       6 |                      15.02 |                  399 |
+|       8 |                      23.46 |                  341 |
+|      10 |                      33.34 |                  300 |
+|      12 |                      40.69 |                  295 |
+|      14 |                      48.26 |                  290 |
+|      16 |                      58.61 |                  273 |
+|      18 |                      77.35 |                  233 |
+|      20 |                      86.74 |                  231 |
+|      22 |                      94.17 |                  234 |
+|      24 |                     102.58 |                  234 |
+|      26 |                     110.17 |                  236 |
+|      28 |                     118.97 |                  235 |
+|      30 |                     126.54 |                  237 |
+|      32 |                     135.89 |                  235 |
+
+### Cloned Engines, Fresh Inputs
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                       3.24 |                  309 |
+|       2 |                       6.57 |                  304 |
+|       4 |                      13.47 |                  297 |
+|       6 |                      20.42 |                  294 |
+|       8 |                      30.01 |                  266 |
+|      10 |                      40.99 |                  244 |
+|      12 |                      49.99 |                  240 |
+|      14 |                      60.09 |                  233 |
+|      16 |                      73.95 |                  216 |
+|      18 |                      95.94 |                  188 |
+|      20 |                     105.24 |                  190 |
+|      22 |                     114.30 |                  192 |
+|      24 |                     124.67 |                  193 |
+|      26 |                     134.76 |                  193 |
+|      28 |                     145.16 |                  193 |
+|      30 |                     155.23 |                  193 |
+|      32 |                     165.42 |                  193 |
+
+### Fresh Engines, Cloned Inputs
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                      17.88 |                   56 |
+|       2 |                      36.32 |                   55 |
+|       4 |                      74.45 |                   54 |
+|       6 |                     112.95 |                   53 |
+|       8 |                     150.24 |                   53 |
+|      10 |                     189.61 |                   53 |
+|      12 |                     228.25 |                   53 |
+|      14 |                     297.37 |                   47 |
+|      16 |                     373.61 |                   43 |
+|      18 |                     426.46 |                   42 |
+|      20 |                     477.80 |                   42 |
+|      22 |                     523.00 |                   42 |
+|      24 |                     570.74 |                   42 |
+|      26 |                     619.92 |                   42 |
+|      28 |                     670.24 |                   42 |
+|      30 |                     717.47 |                   42 |
+|      32 |                     748.25 |                   43 |
+
+### Fresh Engines, Fresh Inputs
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                      18.69 |                   53 |
+|       2 |                      38.03 |                   53 |
+|       4 |                      77.82 |                   51 |
+|       6 |                     118.30 |                   51 |
+|       8 |                     157.65 |                   51 |
+|      10 |                     197.97 |                   51 |
+|      12 |                     239.05 |                   50 |
+|      14 |                     310.06 |                   45 |
+|      16 |                     391.36 |                   41 |
+|      18 |                     441.63 |                   41 |
+|      20 |                     495.88 |                   40 |
+|      22 |                     543.69 |                   40 |
+|      24 |                     591.51 |                   41 |
+|      26 |                     645.98 |                   40 |
+|      28 |                     697.37 |                   40 |
+|      30 |                     749.37 |                   40 |
+|      32 |                     784.63 |                   41 |
+
+## Analysis
+
+The benchmark results demonstrate the following performance characteristics with mimalloc as the default allocator:
+
+1. **Best Performance**: Cloned engines with cloned inputs consistently deliver the highest throughput
+2. **Configuration Performance Hierarchy**:
+   - Cloned engines, cloned inputs: Best performance (optimal configuration)
+   - Cloned engines, fresh inputs: ~27% reduction from optimal
+   - Fresh engines, cloned inputs: ~87% reduction from optimal
+   - Fresh engines, fresh inputs: ~87% reduction from optimal
+3. **Scaling Patterns with mimalloc**: 
+   - Performance degrades with increased thread count due to contention, but mimalloc provides better thread scaling characteristics
+   - Best throughput achieved at 1 thread for cloned engine configurations
+   - Fresh engine configurations show poor scaling across all thread counts
+   - The use of mimalloc as the default allocator has improved multi-threaded performance and reduced contention
+4. **Engine Creation Overhead**: Fresh engine creation is a significant performance bottleneck (~7-8x slower than cloned engines)
+5. **Input Processing**: Fresh input generation adds moderate overhead (~27% impact compared to cloned inputs)
+6. **Thread Contention**: Performance degradation occurs with higher thread counts across all configurations, though mimalloc helps mitigate some allocation-related contention

benches/evaluation/engine_evaluation_benchmark.rs

@@ -0,0 +1,228 @@
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use regorus::{Engine, Value};
+use std::collections::HashMap;
+use std::hint::black_box;
+use std::sync::{Arc, Barrier, Mutex};
+use std::thread;
+use std::time::Duration;
+
+mod policy_data;
+
+fn multi_threaded_eval(
+    num_threads: usize,
+    evals_per_thread: usize,
+    use_cloned_engines: bool,
+    use_cloned_inputs: bool,
+) -> (std::time::Duration, HashMap<String, usize>, usize) {
+    // Complex policies with multiple valid inputs for each
+    let policies_with_inputs = policy_data::policies_with_inputs();
+
+    // Policy names for tracking
+    let policy_names = policy_data::policy_names()
+        .into_iter()
+        .map(|s| s.to_string())
+        .collect::<Vec<_>>();
+
+    // Initialize policy evaluation counters
+    let policy_counters = Arc::new(Mutex::new(HashMap::new()));
+    for policy_name in &policy_names {
+        policy_counters
+            .lock()
+            .unwrap()
+            .insert(policy_name.to_string(), 0);
+    }
+
+    let barrier = Arc::new(Barrier::new(num_threads));
+    let mut handles = Vec::with_capacity(num_threads);
+
+    let total_evals = Arc::new(Mutex::new(0usize));
+    for thread_id in 0..num_threads {
+        let barrier = barrier.clone();
+        let policies_with_inputs = policies_with_inputs.clone();
+        let policy_names = policy_names.clone();
+        let policy_counters = policy_counters.clone();
+        let total_evals = total_evals.clone();
+
+        handles.push(thread::spawn(move || {
+            let mut elapsed = std::time::Duration::ZERO;
+
+            // Pre-create engines if using cloned engines
+            let engines = if use_cloned_engines {
+                Some(
+                    policies_with_inputs
+                        .iter()
+                        .map(|(policy, _)| {
+                            let mut engine = Engine::new();
+                            engine
+                                .add_policy("policy.rego".to_string(), policy.to_string())
+                                .unwrap();
+                            {
+                                // Warm up the engine to ensure it's fully prepared for evaluation.
+                                // This prevents each cloned engine from repeating preparation work.
+                                engine.set_input(Value::new_object());
+                                let _ = engine.eval_rule("data.bench.allow".to_string());
+                            }
+                            engine
+                        })
+                        .collect::<Vec<_>>(),
+                )
+            } else {
+                None
+            };
+
+            // Pre-parse inputs if using cloned inputs
+            let parsed_inputs = if use_cloned_inputs {
+                Some(
+                    policies_with_inputs
+                        .iter()
+                        .map(|(_, inputs)| {
+                            inputs
+                                .iter()
+                                .map(|input_str| regorus::Value::from_json_str(input_str).unwrap())
+                                .collect::<Vec<_>>()
+                        })
+                        .collect::<Vec<_>>(),
+                )
+            } else {
+                None
+            };
+
+            barrier.wait();
+            for i in 0..evals_per_thread {
+                // Use different policy for each iteration - thread_id ensures different threads
+                // start with different policies for better load distribution
+                let policy_idx = (thread_id + i) % policies_with_inputs.len();
+                let (policy, inputs) = &policies_with_inputs[policy_idx];
+
+                // Use different input for the same policy based on iteration - thread_id ensures
+                // different threads start with different inputs for better load distribution
+                let input_idx = (thread_id + i) % inputs.len();
+                let input = &inputs[input_idx];
+
+                let start = std::time::Instant::now();
+
+                let result = {
+                    let mut engine = if use_cloned_engines {
+                        engines.as_ref().unwrap()[policy_idx].clone()
+                    } else {
+                        let mut engine = Engine::new();
+                        engine
+                            .add_policy("policy.rego".to_string(), policy.to_string())
+                            .unwrap();
+                        engine
+                    };
+
+                    let input_value = if use_cloned_inputs {
+                        parsed_inputs.as_ref().unwrap()[policy_idx][input_idx].clone()
+                    } else {
+                        regorus::Value::from_json_str(input).unwrap()
+                    };
+
+                    engine.set_input(input_value);
+
+                    engine.eval_rule("data.bench.allow".to_string())
+
+                    // Engine cleanup/drop time is included in measurement to reflect
+                    // real-world total cost of policy evaluation lifecycle
+                };
+                elapsed += start.elapsed();
+
+                // Track total and successful evaluations
+                {
+                    let mut total = total_evals.lock().unwrap();
+                    *total += 1;
+                }
+                if result.is_ok() {
+                    if let Some(policy_name) = policy_names.get(policy_idx) {
+                        let mut counters = policy_counters.lock().unwrap();
+                        *counters.entry(policy_name.to_string()).or_insert(0) += 1;
+                    }
+                }
+            }
+            elapsed
+        }));
+    }
+
+    let mut total = std::time::Duration::ZERO;
+    for handle in handles {
+        total += handle.join().unwrap();
+    }
+
+    let final_counters = policy_counters.lock().unwrap().clone();
+    let total_evals = *total_evals.lock().unwrap();
+    (total, final_counters, total_evals)
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let max_threads = num_cpus::get() * 2;
+    println!("Running benchmark with max_threads: {}", max_threads);
+
+    let evals_per_thread = 1000;
+
+    // Benchmark all combinations of cloned engines and inputs
+    for use_cloned_engines in [true, false] {
+        for use_cloned_inputs in [true, false] {
+            let group_name = match (use_cloned_engines, use_cloned_inputs) {
+                (true, true) => "cloned_engines , cloned_inputs ",
+                (true, false) => "cloned_engines , fresh_inputs  ",
+                (false, true) => "fresh_engines  , cloned_inputs ",
+                (false, false) => "fresh_engines  , fresh_inputs  ",
+            };
+
+            let mut group = c.benchmark_group(group_name);
+            group.measurement_time(Duration::from_secs(5));
+
+            // Test specific thread counts: powers of 2 + some intermediate values
+            let thread_counts: Vec<usize> = (1..=max_threads)
+                .filter(|&n| {
+                    n == 1 || // Always test single-threaded
+                    n % 2 == 0 || // Always test even threads
+                    n == max_threads // Maximum threads
+                })
+                .collect();
+
+            for threads in thread_counts {
+                let total_evals = threads * evals_per_thread;
+                group.throughput(Throughput::Elements(total_evals as u64));
+                group.bench_with_input(
+                    BenchmarkId::new("eval", format!(" {threads} threads")),
+                    &threads,
+                    |b, &threads| {
+                        b.iter_custom(|iters| {
+                            let evals_per_thread = evals_per_thread * (iters as usize);
+
+                            let (duration, policy_counters, total_evals_aggregated) = multi_threaded_eval(
+                                black_box(threads),
+                                black_box(evals_per_thread),
+                                black_box(use_cloned_engines),
+                                black_box(use_cloned_inputs),
+                            );
+
+
+                            // Sanity check: Ensure the expected number of evaluations matches the actual number performed per iteration batch.
+                            // total_evals is the expected number for this batch, total_evals_aggregated is the sum over all iters.
+                            assert_eq!(total_evals, total_evals_aggregated/iters as usize);
+
+                            // On one iteration, print policy evaluation statistics
+                            if iters == 1 {
+                                // println!("\nPolicy Evaluation Statistics:");
+                                for (policy_name, count) in &policy_counters {
+                                    // println!("  {}: {} evaluations", policy_name, count);
+                                    if *count == 0 {
+                                        println!("\x1b[31mERROR: Policy '{}' was never evaluated successfully!\x1b[0m", policy_name);
+                                    }
+                                }
+                            }
+
+                            duration
+                        });
+                    },
+                );
+            }
+            group.finish();
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);

benches/evaluation/policy_data.rs

@@ -0,0 +1,117 @@
+// This module provides the full set of policies, inputs, and policy names for evaluation benchmarks.
+// Policies and inputs are now loaded from external files.
+
+use std::fs;
+use std::path::Path;
+
+pub fn policies_with_inputs() -> Vec<(String, Vec<String>)> {
+    let policy_with_input_files = [
+        (
+            "rbac_policy.rego",
+            vec!["rbac_input.json", "rbac_input2.json", "rbac_input3.json"],
+        ),
+        (
+            "api_access_policy.rego",
+            vec![
+                "api_access_input.json",
+                "api_access_input2.json",
+                "api_access_input3.json",
+            ],
+        ),
+        (
+            "data_sensitivity_policy.rego",
+            vec![
+                "data_sensitivity_input.json",
+                "data_sensitivity_input2.json",
+                "data_sensitivity_input3.json",
+            ],
+        ),
+        (
+            "time_based_policy.rego",
+            vec![
+                "time_based_input.json",
+                "time_based_input2.json",
+                "time_based_input3.json",
+            ],
+        ),
+        (
+            "data_processing_policy.rego",
+            vec![
+                "data_processing_input.json",
+                "data_processing_input2.json",
+                "data_processing_input3.json",
+            ],
+        ),
+        (
+            "azure_vm_policy.rego",
+            vec![
+                "azure_vm_input.json",
+                "azure_vm_input2.json",
+                "azure_vm_input3.json",
+            ],
+        ),
+        (
+            "azure_storage_policy.rego",
+            vec![
+                "azure_storage_input.json",
+                "azure_storage_input2.json",
+                "azure_storage_input3.json",
+            ],
+        ),
+        (
+            "azure_keyvault_policy.rego",
+            vec![
+                "azure_keyvault_input.json",
+                "azure_keyvault_input2.json",
+                "azure_keyvault_input3.json",
+            ],
+        ),
+        (
+            "azure_nsg_policy.rego",
+            vec![
+                "azure_nsg_input.json",
+                "azure_nsg_input2.json",
+                "azure_nsg_input3.json",
+            ],
+        ),
+    ];
+
+    let mut policies_and_inputs = Vec::new();
+    let base_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("benches")
+        .join("evaluation")
+        .join("test_data");
+
+    for (policy_file, input_files) in policy_with_input_files.iter() {
+        let policy_path = base_dir.join("policies").join(policy_file);
+
+        let policy_content = fs::read_to_string(&policy_path)
+            .unwrap_or_else(|e| panic!("Failed to read policy file {:?}: {}", policy_path, e));
+
+        let mut input_contents = Vec::new();
+        for input_file in input_files {
+            let input_path = base_dir.join("inputs").join(input_file);
+            let input_content = fs::read_to_string(&input_path)
+                .unwrap_or_else(|e| panic!("Failed to read input file {:?}: {}", input_path, e));
+            input_contents.push(input_content);
+        }
+
+        policies_and_inputs.push((policy_content, input_contents));
+    }
+
+    policies_and_inputs
+}
+
+pub fn policy_names() -> Vec<&'static str> {
+    vec![
+        "rbac_policy",
+        "api_access_policy",
+        "data_sensitivity_policy",
+        "time_based_policy",
+        "data_processing_policy",
+        "azure_vm_policy",
+        "azure_storage_policy",
+        "azure_keyvault_policy",
+        "azure_nsg_policy",
+    ]
+}

benches/evaluation/test_data/inputs/api_access_input.json

@@ -0,0 +1,15 @@
+{
+  "request": {
+    "method": "GET",
+    "path": "/api/v1/users/123"
+  },
+  "user": {
+    "id": "user123",
+    "scope": ["read:users", "write:users"],
+    "department": "engineering"
+  },
+  "resource": {
+    "owner": "user123",
+    "type": "user"
+  }
+}

benches/evaluation/test_data/inputs/api_access_input2.json

@@ -0,0 +1,15 @@
+{
+  "request": {
+    "method": "POST",
+    "path": "/api/v1/users"
+  },
+  "user": {
+    "id": "user456",
+    "scope": ["write:users", "admin:users"],
+    "department": "engineering"
+  },
+  "resource": {
+    "owner": "user456",
+    "type": "user"
+  }
+}

benches/evaluation/test_data/inputs/api_access_input3.json

@@ -0,0 +1,15 @@
+{
+  "request": {
+    "method": "DELETE",
+    "path": "/api/v1/users/789"
+  },
+  "user": {
+    "id": "admin123",
+    "scope": ["admin:users"],
+    "department": "security"
+  },
+  "resource": {
+    "owner": "user789",
+    "type": "user"
+  }
+}

benches/evaluation/test_data/inputs/azure_keyvault_input.json

@@ -0,0 +1,16 @@
+{
+  "vault": {
+    "name": "mykeyvault",
+    "location": "eastus",
+    "enableSoftDelete": true,
+    "softDeleteRetentionInDays": 90,
+    "enablePurgeProtection": true,
+    "networkAcls": {
+      "defaultAction": "Deny",
+      "bypass": "AzureServices"
+    },
+    "tags": {
+      "environment": "production"
+    }
+  }
+}

benches/evaluation/test_data/inputs/azure_keyvault_input2.json

@@ -0,0 +1,16 @@
+{
+  "vault": {
+    "name": "devkeyvault",
+    "location": "westus2",
+    "enableSoftDelete": true,
+    "softDeleteRetentionInDays": 30,
+    "enablePurgeProtection": false,
+    "networkAcls": {
+      "defaultAction": "Allow",
+      "bypass": "AzureServices"
+    },
+    "tags": {
+      "environment": "development"
+    }
+  }
+}

benches/evaluation/test_data/inputs/azure_keyvault_input3.json

@@ -0,0 +1,16 @@
+{
+  "vault": {
+    "name": "prodkeyvault",
+    "location": "eastus",
+    "enableSoftDelete": true,
+    "softDeleteRetentionInDays": 90,
+    "enablePurgeProtection": true,
+    "networkAcls": {
+      "defaultAction": "Deny",
+      "bypass": "AzureServices"
+    },
+    "tags": {
+      "environment": "production"
+    }
+  }
+}

benches/evaluation/test_data/inputs/azure_nsg_input.json

@@ -0,0 +1,13 @@
+{
+  "operation": "Microsoft.Network/networkSecurityGroups/securityRules/write",
+  "rule": {
+    "direction": "Inbound",
+    "access": "Allow",
+    "protocol": "TCP",
+    "sourceAddressPrefix": "10.0.0.0/24",
+    "sourcePortRange": "*",
+    "destinationAddressPrefix": "*",
+    "destinationPortRange": "80",
+    "priority": 1001
+  }
+}

benches/evaluation/test_data/inputs/azure_nsg_input2.json

@@ -0,0 +1,13 @@
+{
+  "operation": "Microsoft.Network/networkSecurityGroups/securityRules/write",
+  "rule": {
+    "direction": "Inbound",
+    "access": "Allow",
+    "protocol": "TCP",
+    "sourceAddressPrefix": "172.16.0.0/16",
+    "sourcePortRange": "*",
+    "destinationAddressPrefix": "*",
+    "destinationPortRange": "22",
+    "priority": 1200
+  }
+}

benches/evaluation/test_data/inputs/azure_nsg_input3.json

@@ -0,0 +1,13 @@
+{
+  "operation": "Microsoft.Network/networkSecurityGroups/securityRules/write",
+  "rule": {
+    "direction": "Inbound",
+    "access": "Allow",
+    "protocol": "TCP",
+    "sourceAddressPrefix": "203.0.113.0/24",
+    "sourcePortRange": "*",
+    "destinationAddressPrefix": "*",
+    "destinationPortRange": "443",
+    "priority": 300
+  }
+}

benches/evaluation/test_data/inputs/azure_storage_input.json

@@ -0,0 +1,15 @@
+{
+  "account": {
+    "name": "mystorageaccount",
+    "tier": "Standard",
+    "replication": "LRS",
+    "location": "eastus",
+    "tags": {
+      "environment": "production"
+    }
+  },
+  "container": {
+    "name": "data",
+    "publicAccess": "None"
+  }
+}

benches/evaluation/test_data/inputs/azure_storage_input2.json

@@ -0,0 +1,15 @@
+{
+  "account": {
+    "name": "devstorageaccount",
+    "tier": "Premium",
+    "replication": "LRS",
+    "location": "westus2",
+    "tags": {
+      "environment": "production"
+    }
+  },
+  "container": {
+    "name": "logs",
+    "publicAccess": "None"
+  }
+}

benches/evaluation/test_data/inputs/azure_storage_input3.json

@@ -0,0 +1,15 @@
+{
+  "account": {
+    "name": "prodstorageaccount",
+    "tier": "Standard",
+    "replication": "GRS",
+    "location": "eastus",
+    "tags": {
+      "environment": "production"
+    }
+  },
+  "container": {
+    "name": "backups",
+    "publicAccess": "None"
+  }
+}

benches/evaluation/test_data/inputs/azure_vm_input.json

@@ -0,0 +1,14 @@
+{
+  "vm": {
+    "size": "Standard_D2s_v3",
+    "os": "Linux",
+    "location": "eastus",
+    "tags": {
+      "environment": "production",
+      "department": "engineering"
+    }
+  },
+  "user": {
+    "department": "engineering"
+  }
+}

benches/evaluation/test_data/inputs/azure_vm_input2.json

@@ -0,0 +1,14 @@
+{
+  "vm": {
+    "size": "Standard_B1s",
+    "os": "Windows",
+    "location": "westus2",
+    "tags": {
+      "environment": "dev",
+      "department": "marketing"
+    }
+  },
+  "user": {
+    "department": "marketing"
+  }
+}

benches/evaluation/test_data/inputs/azure_vm_input3.json

@@ -0,0 +1,14 @@
+{
+  "vm": {
+    "size": "Standard_D4s_v3",
+    "os": "Linux",
+    "location": "eastus",
+    "tags": {
+      "environment": "production",
+      "department": "engineering"
+    }
+  },
+  "user": {
+    "department": "engineering"
+  }
+}

benches/evaluation/test_data/inputs/data_processing_input.json

@@ -0,0 +1,16 @@
+{
+  "operation": "collect",
+  "data": {
+    "type": "email",
+    "source": "user_input"
+  },
+  "consent": {
+    "given": true,
+    "purpose": "marketing",
+    "date": "2023-01-15"
+  },
+  "user": {
+    "age": 25,
+    "location": "US"
+  }
+}

benches/evaluation/test_data/inputs/data_processing_input2.json

@@ -0,0 +1,16 @@
+{
+  "operation": "process",
+  "data": {
+    "type": "survey_response",
+    "source": "user_input"
+  },
+  "consent": {
+    "given": true,
+    "purpose": "analytics",
+    "date": "2023-06-15"
+  },
+  "user": {
+    "age": 30,
+    "location": "US"
+  }
+}

benches/evaluation/test_data/inputs/data_processing_input3.json

@@ -0,0 +1,16 @@
+{
+  "operation": "delete",
+  "data": {
+    "type": "user_profile",
+    "source": "database"
+  },
+  "consent": {
+    "given": false,
+    "purpose": "none",
+    "date": "2022-01-01"
+  },
+  "user": {
+    "age": 16,
+    "location": "EU"
+  }
+}

benches/evaluation/test_data/inputs/data_sensitivity_input.json

@@ -0,0 +1,13 @@
+{
+  "data": {
+    "type": "user_profile",
+    "classification": "personal",
+    "contains_pii": true,
+    "region": "EU"
+  },
+  "user": {
+    "clearance": "confidential",
+    "location": "EU"
+  },
+  "operation": "read"
+}

benches/evaluation/test_data/inputs/data_sensitivity_input2.json

@@ -0,0 +1,13 @@
+{
+  "data": {
+    "type": "financial_report",
+    "classification": "confidential",
+    "contains_pii": false,
+    "region": "US"
+  },
+  "user": {
+    "clearance": "secret",
+    "location": "US"
+  },
+  "operation": "read"
+}

benches/evaluation/test_data/inputs/data_sensitivity_input3.json

@@ -0,0 +1,13 @@
+{
+  "data": {
+    "type": "public_announcement",
+    "classification": "public",
+    "contains_pii": false,
+    "region": "GLOBAL"
+  },
+  "user": {
+    "clearance": "public",
+    "location": "EU"
+  },
+  "operation": "read"
+}

benches/evaluation/test_data/inputs/rbac_input.json

@@ -0,0 +1,12 @@
+{
+  "user": {
+    "name": "alice",
+    "roles": ["viewer", "editor"]
+  },
+  "resource": {
+    "name": "document1",
+    "type": "document",
+    "owner": "alice"
+  },
+  "action": "read"
+}

benches/evaluation/test_data/inputs/rbac_input2.json

@@ -0,0 +1,12 @@
+{
+  "user": {
+    "name": "bob",
+    "roles": ["admin"]
+  },
+  "resource": {
+    "name": "document2",
+    "type": "document",
+    "owner": "bob"
+  },
+  "action": "write"
+}

benches/evaluation/test_data/inputs/rbac_input3.json

@@ -0,0 +1,12 @@
+{
+  "user": {
+    "name": "charlie",
+    "roles": ["viewer"]
+  },
+  "resource": {
+    "name": "document3",
+    "type": "document",
+    "owner": "alice"
+  },
+  "action": "read"
+}

benches/evaluation/test_data/inputs/time_based_input.json

@@ -0,0 +1,11 @@
+{
+  "time": "09:30:00",
+  "day": "monday",
+  "user": {
+    "role": "employee",
+    "shift": "day"
+  },
+  "request": {
+    "urgent": false
+  }
+}

benches/evaluation/test_data/inputs/time_based_input2.json

@@ -0,0 +1,11 @@
+{
+  "time": "14:30:00",
+  "day": "wednesday",
+  "user": {
+    "role": "employee",
+    "shift": "day"
+  },
+  "request": {
+    "urgent": false
+  }
+}

benches/evaluation/test_data/inputs/time_based_input3.json

@@ -0,0 +1,11 @@
+{
+  "time": "22:00:00",
+  "day": "friday",
+  "user": {
+    "role": "admin",
+    "shift": "night"
+  },
+  "request": {
+    "urgent": true
+  }
+}

benches/evaluation/test_data/policies/api_access_policy.rego

@@ -0,0 +1,13 @@
+package bench
+
+default allow := false
+
+valid_api_paths := ["/api/v1/", "/api/v2/", "/api/v3/"]
+
+allow if {
+    input.request.method == "GET"
+    some path in valid_api_paths
+    startswith(input.request.path, path)
+    input.user.authenticated == true
+    time.now_ns() - input.user.login_time < 86400000000000  # 24 hours in nanoseconds
+}

benches/evaluation/test_data/policies/azure_keyvault_policy.rego

@@ -0,0 +1,28 @@
+package bench
+
+default allow := false
+
+# Azure Key Vault access policy
+valid_operations := [
+    "Microsoft.KeyVault/vaults/keys/read",
+    "Microsoft.KeyVault/vaults/secrets/read",
+    "Microsoft.KeyVault/vaults/certificates/read"
+]
+
+vault_admins := ["admin@company.com", "security@company.com"]
+
+allow if {
+    input.operation in valid_operations
+    input.principal.type == "ServicePrincipal"
+    input.principal.appId != ""
+    input.resource.properties.enableSoftDelete == true
+    input.resource.properties.enablePurgeProtection == true
+    time.now_ns() - input.principal.createdTime < 31536000000000000  # Less than 1 year old
+}
+
+allow if {
+    input.operation in valid_operations
+    input.principal.type == "User"
+    input.principal.userPrincipalName in vault_admins
+    input.context.conditionalAccess.compliant == true
+}

benches/evaluation/test_data/policies/azure_nsg_policy.rego

@@ -0,0 +1,31 @@
+package bench
+
+default allow := false
+
+# Azure Network Security Group rules policy
+dangerous_ports := [22, 3389, 1433, 3306, 5432, 6379, 27017]
+internal_networks := ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16"]
+
+is_internal_source if {
+    some network in internal_networks
+    net.cidr_contains(network, input.rule.sourceAddressPrefix)
+}
+
+allow if {
+    input.operation == "Microsoft.Network/networkSecurityGroups/securityRules/write"
+    input.rule.direction == "Inbound"
+    input.rule.access == "Allow"
+    input.rule.destinationPortRange != "*"
+    not input.rule.destinationPortRange in dangerous_ports
+    input.rule.sourceAddressPrefix != "*"
+    input.rule.sourceAddressPrefix != "Internet"
+}
+
+allow if {
+    input.operation == "Microsoft.Network/networkSecurityGroups/securityRules/write"
+    input.rule.direction == "Inbound"
+    input.rule.access == "Allow"
+    input.rule.destinationPortRange in dangerous_ports
+    is_internal_source
+    input.rule.priority >= 1000
+}

benches/evaluation/test_data/policies/azure_storage_policy.rego

@@ -0,0 +1,17 @@
+package bench
+
+default allow := false
+
+# Azure Storage Account security policy
+required_encryption_algorithms := ["AES256", "RSA-OAEP"]
+
+allow if {
+    input.operation == "Microsoft.Storage/storageAccounts/write"
+    input.resource.properties.supportsHttpsTrafficOnly == true
+    input.resource.properties.minimumTlsVersion == "TLS1_2"
+    input.resource.properties.encryption.services.blob.enabled == true
+    input.resource.properties.encryption.keySource == "Microsoft.Storage"
+    input.resource.properties.allowBlobPublicAccess == false
+    input.resource.properties.networkAcls.defaultAction == "Deny"
+    count(input.resource.properties.networkAcls.ipRules) > 0
+}

benches/evaluation/test_data/policies/azure_vm_policy.rego

@@ -0,0 +1,20 @@
+package bench
+
+default allow := false
+
+# Azure VM deployment policy
+allowed_vm_sizes := [
+    "Standard_B1s", "Standard_B2s", "Standard_B4ms",
+    "Standard_D2s_v3", "Standard_D4s_v3", "Standard_F2s_v2"
+]
+
+allowed_regions := ["eastus", "westus2", "northeurope", "southeastasia"]
+
+allow if {
+    input.operation == "Microsoft.Compute/virtualMachines/write"
+    input.resource.properties.hardwareProfile.vmSize in allowed_vm_sizes
+    input.resource.location in allowed_regions
+    input.resource.properties.osProfile.adminPassword == null  # Require SSH keys
+    count(input.resource.tags) > 0  # Must have tags
+    input.resource.tags.environment in ["dev", "test", "prod"]
+}

benches/evaluation/test_data/policies/data_processing_policy.rego

@@ -0,0 +1,28 @@
+package bench
+
+default allow := false
+
+# Complex data filtering and aggregation
+sensitive_fields := ["ssn", "credit_card", "password"]
+
+contains_sensitive_data if {
+    some field in sensitive_fields
+    object.get(input.data, field, null) != null
+}
+
+user_clearance_level := object.get(input.user.attributes, "clearance", 0)
+
+required_clearance := 3 if contains_sensitive_data else := 1
+
+allow if {
+    user_clearance_level >= required_clearance
+    input.operation in ["read", "export"]
+    count(input.data) > 0
+    count(input.data) <= 1000  # Limit data size
+}
+
+allow if {
+    input.user.role == "data_processor"
+    input.operation == "transform"
+    not contains_sensitive_data
+}

benches/evaluation/test_data/policies/data_sensitivity_policy.rego

@@ -0,0 +1,25 @@
+package bench
+
+default allow := false
+
+rbac_roles := {
+    "admin": ["read", "write", "delete", "admin"],
+    "manager": ["read", "write"],
+    "user": ["read"]
+}
+
+user_permissions contains perm if {
+    some role in input.user.roles
+    perm := rbac_roles[role][_]
+}
+
+allow if {
+    input.action in user_permissions
+    input.resource.owner == input.user.id
+}
+
+allow if {
+    input.action in user_permissions
+    input.resource.public == true
+    input.action == "read"
+}

benches/evaluation/test_data/policies/rbac_policy.rego

@@ -0,0 +1,10 @@
+package bench
+
+default allow := false
+
+allow if {
+    input.user.role == "admin"
+    input.action in ["read", "write", "delete"]
+    input.resource.classification in ["public", "internal"]
+    count(input.user.permissions) > 0
+}

benches/evaluation/test_data/policies/time_based_policy.rego

@@ -0,0 +1,23 @@
+package bench
+
+default allow := false
+
+# Time-based access control with complex conditions
+business_hours if {
+    hour := time.clock([time.now_ns(), "America/New_York"])[0]
+    hour >= 9
+    hour < 17
+}
+
+allow if {
+    input.user.department in ["engineering", "product"]
+    input.action == "deploy"
+    business_hours
+    count([x | x := input.approvals[_]; x.status == "approved"]) >= 2
+}
+
+allow if {
+    input.user.emergency_access == true
+    input.action in ["read", "diagnose"]
+    input.justification != ""
+}

benches/regorus_benchmark.rs

@@ -0,0 +1,186 @@
+use std::hint::black_box;
+
+use regorus::{Engine, Value};
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use serde_json::json;
+
+fn engine_with_policy(policy: &str) -> Engine {
+    let mut engine = Engine::new();
+    engine
+        .add_policy("policy.rego".to_string(), policy.to_string())
+        .unwrap();
+    engine
+}
+
+fn eval_principal(engine: &mut Engine) {
+    engine.set_input(black_box(json!({"principal": "admin"}).into()));
+    let result = engine
+        .eval_rule(black_box("data.bench.allow".to_string()))
+        .unwrap();
+    assert_eq!(result, true.into());
+}
+
+fn allow_with_simple_equality(c: &mut Criterion) {
+    c.bench_function("simple equality check with constant", |b| {
+        let mut engine = engine_with_policy(
+            r#"
+            package bench
+            allow if input.principal == "admin"
+            "#,
+        );
+
+        b.iter(|| eval_principal(&mut engine))
+    });
+
+    c.bench_function("simple equality check with data", |b| {
+        let mut engine = engine_with_policy(
+            r#"
+            package bench
+            allow if input.principal == data.allowed_principal
+            "#,
+        );
+        engine
+            .add_data(json!({"allowed_principal": "admin"}).into())
+            .unwrap();
+
+        b.iter(|| eval_principal(&mut engine))
+    });
+}
+
+fn allow_with_simple_membership(c: &mut Criterion) {
+    let generate_principals = |n: usize| {
+        (0..n)
+            .map(|i| i.to_string())
+            .chain(std::iter::once("admin".to_string()))
+            .collect::<Vec<_>>()
+    };
+
+    let mut group = c.benchmark_group("allow with simple membership");
+    for size in [32, 64, 128, 512, 1024, 2048].iter() {
+        group.bench_with_input(BenchmarkId::new("with constant", size), size, |b, &size| {
+            let principals = generate_principals(size).join("\",\"");
+            let mut engine = engine_with_policy(&format!(
+                r#"
+                package bench
+
+                allowed_principals := {{
+                    "{principals}"
+                }}
+
+                allow if input.principal in allowed_principals
+                "#
+            ));
+
+            b.iter(|| eval_principal(&mut engine))
+        });
+
+        group.bench_with_input(BenchmarkId::new("with data", size), size, |b, &size| {
+            let principals = generate_principals(size);
+            let mut engine = engine_with_policy(
+                r#"
+                package bench
+                allow if input.principal in data.allowed_principals
+                "#,
+            );
+            engine
+                .add_data(json!({"allowed_principals": principals}).into())
+                .unwrap();
+
+            b.iter(|| eval_principal(&mut engine))
+        });
+    }
+    group.finish();
+}
+
+fn clone(c: &mut Criterion) {
+    // Use Arc<BtreeMap> as a reference. Clone will only increment
+    // the reference count.
+    let mut m = std::collections::BTreeMap::default();
+    m.insert(1, 2);
+    let m = std::sync::Arc::new(m);
+
+    c.bench_function("clone: Arc<BTreeMap>", |b| {
+        b.iter(|| {
+            let _ = m.clone();
+        })
+    });
+
+    let mut engine = Engine::new();
+    engine.set_rego_v0(true);
+    engine
+        .add_policy_from_file("tests/aci/framework.rego")
+        .unwrap();
+    engine.add_policy_from_file("tests/aci/api.rego").unwrap();
+    engine
+        .add_policy_from_file("tests/aci/policy.rego")
+        .unwrap();
+    engine
+        .add_data(Value::from_json_file("tests/aci/data.json").expect("failed to load data.json"))
+        .expect("failed to add data");
+    engine.set_input(
+        Value::from_json_file("tests/aci/input.json").expect("failed to load input.json"),
+    );
+
+    // An engine without preparation will not have processed fields populated.
+    c.bench_function("clone: engine with aci policies", |b| {
+        b.iter(|| {
+            let _ = engine.clone();
+        })
+    });
+
+    // Trigger engine preparation.
+    let _ = engine.eval_query("data.framework.mount_overlay".to_string(), false);
+
+    // Prepared engine will have many more fields populated. But the fields are
+    // immutable after preparation and will be shared between clones.
+    c.bench_function("clone: prepared engine with aci policies", |b| {
+        b.iter(|| {
+            let _ = engine.clone();
+        })
+    });
+}
+
+fn aci_policy_eval(c: &mut Criterion) {
+    let mut group = c.benchmark_group("ACI Policy Eval");
+    let rules = ["data.policy.mount_overlay", "data.policy.mount_device"];
+    for rule in rules {
+        group.bench_with_input(BenchmarkId::new("rule", rule), &rule, |b, rule| {
+            let mut engine = Engine::new();
+            engine.set_rego_v0(true);
+
+            engine
+                .add_policy_from_file("tests/aci/api.rego")
+                .expect("failed to add api.rego");
+            engine
+                .add_policy_from_file("tests/aci/framework.rego")
+                .expect("failed to add framework.rego");
+            engine
+                .add_policy_from_file("tests/aci/policy.rego")
+                .expect("failed to add policy.rego");
+            engine
+                .add_data(
+                    Value::from_json_file("tests/aci/data.json").expect("failed to load data.json"),
+                )
+                .expect("failed to add data");
+            let input =
+                Value::from_json_file("tests/aci/input.json").expect("failed to load input.json");
+            engine.set_input(input.clone());
+            engine.eval_rule(rule.to_string()).unwrap();
+            b.iter(|| {
+                engine.eval_rule(rule.to_string()).unwrap();
+            })
+        });
+    }
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    allow_with_simple_equality,
+    allow_with_simple_membership,
+    clone,
+    aci_policy_eval
+);
+
+criterion_main!(benches);

benches/schema_validation_benchmark.rs

@@ -0,0 +1,886 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use regorus::Value;
+use regorus::{Schema, SchemaValidator};
+use serde_json::json;
+
+// Observed: validate_string - 3.19 ns/iter
+fn bench_string_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "string",
+        "minLength": 3,
+        "maxLength": 10
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from("hello");
+
+    c.bench_function("validate_string", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_number - 146.5 ns/iter
+fn bench_number_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "number",
+        "minimum": 0.0,
+        "maximum": 100.0
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(42.5);
+
+    c.bench_function("validate_number", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_array - 95.0 ns/iter
+fn bench_array_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "array",
+        "items": { "type": "integer" },
+        "minItems": 2,
+        "maxItems": 5
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!([1, 2, 3]));
+
+    c.bench_function("validate_array", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_object - 126.9 ns/iter
+fn bench_object_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "name": { "type": "string" },
+            "age": { "type": "integer", "minimum": 0 }
+        },
+        "required": ["name", "age"]
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({"name": "Alice", "age": 30}));
+
+    c.bench_function("validate_object", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_complex_nested - 710.5 ns/iter
+fn bench_complex_nested_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "user": {
+                "type": "object",
+                "properties": {
+                    "id": { "type": "string" },
+                    "profile": {
+                        "type": "object",
+                        "properties": {
+                            "email": { "type": "string" },
+                            "roles": {
+                                "type": "array",
+                                "items": { "type": "string" }
+                            }
+                        },
+                        "required": ["email", "roles"]
+                    }
+                },
+                "required": ["id", "profile"]
+            },
+            "active": { "type": "boolean" }
+        },
+        "required": ["user", "active"]
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "user": {
+            "id": "u123",
+            "profile": {
+                "email": "alice@example.com",
+                "roles": ["admin", "user"]
+            }
+        },
+        "active": true
+    }));
+
+    c.bench_function("validate_complex_nested", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_string_pattern - 29.99 µs/iter
+fn bench_string_pattern_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "string",
+        "pattern": "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from("user@example.com");
+
+    c.bench_function("validate_string_pattern", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_enum - 7.26 ns/iter
+fn bench_enum_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "enum": ["pending", "approved", "rejected", "cancelled"]
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from("approved");
+
+    c.bench_function("validate_enum", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_boolean - 3.22 ns/iter
+fn bench_boolean_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "boolean"
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(true);
+
+    c.bench_function("validate_boolean", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_null - 3.22 ns/iter
+fn bench_null_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "null"
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::Null;
+
+    c.bench_function("validate_null", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_large_array - 17.30 µs/iter
+fn bench_large_array_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "array",
+        "items": { "type": "number" },
+        "minItems": 50,
+        "maxItems": 200
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let large_array: Vec<_> = (0..100).map(|i| json!(i as f64)).collect();
+    let value = Value::from(json!(large_array));
+
+    c.bench_function("validate_large_array", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_deeply_nested - 468.2 ns/iter
+fn bench_deeply_nested_object(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "level1": {
+                "type": "object",
+                "properties": {
+                    "level2": {
+                        "type": "object",
+                        "properties": {
+                            "level3": {
+                                "type": "object",
+                                "properties": {
+                                    "level4": {
+                                        "type": "object",
+                                        "properties": {
+                                            "level5": {
+                                                "type": "string"
+                                            }
+                                        },
+                                        "required": ["level5"]
+                                    }
+                                },
+                                "required": ["level4"]
+                            }
+                        },
+                        "required": ["level3"]
+                    }
+                },
+                "required": ["level2"]
+            }
+        },
+        "required": ["level1"]
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "level1": {
+            "level2": {
+                "level3": {
+                    "level4": {
+                        "level5": "deep value"
+                    }
+                }
+            }
+        }
+    }));
+
+    c.bench_function("validate_deeply_nested", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_mixed_type_array - 1.36 µs/iter
+fn bench_mixed_type_array(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "array",
+        "items": {
+            "anyOf": [
+                { "type": "string" },
+                { "type": "number" },
+                { "type": "boolean" }
+            ]
+        }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!(["hello", 42, true, "world", 99.5, false]));
+
+    c.bench_function("validate_mixed_type_array", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_additional_properties - 366.4 ns/iter
+fn bench_additional_properties(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "name": { "type": "string" },
+            "age": { "type": "integer" }
+        },
+        "additionalProperties": { "type": "string" },
+        "required": ["name"]
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "name": "Alice",
+        "age": 30,
+        "city": "New York",
+        "country": "USA",
+        "occupation": "Engineer"
+    }));
+
+    c.bench_function("validate_additional_properties", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_array_constraints - 146.2 ns/iter
+fn bench_array_constraints(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "array",
+        "items": { "type": "string" },
+        "minItems": 2,
+        "maxItems": 10
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!(["apple", "banana", "cherry", "date", "elderberry"]));
+
+    c.bench_function("validate_array_constraints", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_multi_level - 915.8 ns/iter
+fn bench_multi_level_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "user": {
+                "type": "object",
+                "properties": {
+                    "profile": {
+                        "type": "object",
+                        "properties": {
+                            "settings": {
+                                "type": "object",
+                                "properties": {
+                                    "theme": {
+                                        "enum": ["light", "dark", "auto"]
+                                    },
+                                    "notifications": {
+                                        "type": "boolean"
+                                    }
+                                },
+                                "required": ["theme"],
+                                "additionalProperties": { "type": "string" }
+                            }
+                        },
+                        "required": ["settings"],
+                        "additionalProperties": { "type": "any" }
+                    }
+                },
+                "required": ["profile"],
+                "additionalProperties": { "type": "any" }
+            }
+        },
+        "required": ["user"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "user": {
+            "profile": {
+                "settings": {
+                    "theme": "dark",
+                    "notifications": true,
+                    "language": "en"
+                },
+                "avatar": "default.png"
+            },
+            "lastLogin": "2024-01-01"
+        },
+        "metadata": "extra info"
+    }));
+
+    c.bench_function("validate_multi_level", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Azure Resource Validation Benchmarks
+
+// Observed: validate_azure_vm_resource - 34.74 µs/iter
+fn bench_azure_vm_resource_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "type": {
+                "const": "Microsoft.Compute/virtualMachines"
+            },
+            "apiVersion": {
+                "enum": ["2021-03-01", "2021-07-01", "2022-03-01"]
+            },
+            "name": {
+                "type": "string",
+                "pattern": "^[a-zA-Z0-9-._]{1,64}$"
+            },
+            "location": {
+                "type": "string",
+                "description": "Azure region where the VM will be deployed"
+            },
+            "properties": {
+                "type": "object",
+                "properties": {
+                    "hardwareProfile": {
+                        "type": "object",
+                        "properties": {
+                            "vmSize": {
+                                "enum": ["Standard_B1s", "Standard_B2s", "Standard_D2s_v3", "Standard_D4s_v3"]
+                            }
+                        },
+                        "required": ["vmSize"]
+                    },
+                    "osProfile": {
+                        "type": "object",
+                        "properties": {
+                            "computerName": {
+                                "type": "string"
+                            },
+                            "adminUsername": {
+                                "type": "string"
+                            }
+                        },
+                        "required": ["computerName", "adminUsername"]
+                    }
+                },
+                "required": ["hardwareProfile", "osProfile"]
+            }
+        },
+        "required": ["type", "apiVersion", "name", "location", "properties"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "type": "Microsoft.Compute/virtualMachines",
+        "apiVersion": "2021-03-01",
+        "name": "my-vm-01",
+        "location": "eastus",
+        "properties": {
+            "hardwareProfile": {
+                "vmSize": "Standard_B2s"
+            },
+            "osProfile": {
+                "computerName": "my-computer",
+                "adminUsername": "azureuser"
+            }
+        }
+    }));
+
+    c.bench_function("validate_azure_vm_resource", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_azure_storage_resource - 22.12 µs/iter
+fn bench_azure_storage_resource_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "type": {
+                "const": "Microsoft.Storage/storageAccounts"
+            },
+            "apiVersion": {
+                "enum": ["2021-04-01", "2021-06-01", "2022-05-01"]
+            },
+            "name": {
+                "type": "string",
+                "pattern": "^[a-z0-9]{3,24}$"
+            },
+            "location": {
+                "type": "string"
+            },
+            "sku": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "enum": ["Standard_LRS", "Standard_GRS", "Standard_RAGRS", "Premium_LRS"]
+                    }
+                },
+                "required": ["name"]
+            },
+            "kind": {
+                "enum": ["Storage", "StorageV2", "BlobStorage", "FileStorage", "BlockBlobStorage"]
+            },
+            "properties": {
+                "type": "object",
+                "properties": {
+                    "accessTier": {
+                        "enum": ["Hot", "Cool", "Archive"]
+                    },
+                    "encryption": {
+                        "type": "object",
+                        "properties": {
+                            "services": {
+                                "type": "object"
+                            }
+                        }
+                    }
+                },
+                "additionalProperties": { "type": "any" }
+            }
+        },
+        "required": ["type", "apiVersion", "name", "location", "sku", "kind"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "type": "Microsoft.Storage/storageAccounts",
+        "apiVersion": "2021-04-01",
+        "name": "mystorageaccount001",
+        "location": "westus2",
+        "sku": {
+            "name": "Standard_LRS"
+        },
+        "kind": "StorageV2",
+        "properties": {
+            "accessTier": "Hot",
+            "encryption": {
+                "services": {}
+            }
+        }
+    }));
+
+    c.bench_function("validate_azure_storage_resource", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_azure_arm_template - 1.99 µs/iter
+fn bench_azure_arm_template_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "$schema": {
+                "type": "string"
+            },
+            "contentVersion": {
+                "type": "string"
+            },
+            "parameters": {
+                "type": "object",
+                "additionalProperties": { "type": "any" }
+            },
+            "variables": {
+                "type": "object",
+                "additionalProperties": { "type": "any" }
+            },
+            "resources": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "type": {
+                            "type": "string"
+                        },
+                        "apiVersion": {
+                            "type": "string"
+                        },
+                        "name": {
+                            "type": "string"
+                        },
+                        "location": {
+                            "type": "string"
+                        },
+                        "properties": {
+                            "type": "object",
+                            "additionalProperties": { "type": "any" }
+                        },
+                        "tags": {
+                            "type": "object",
+                            "additionalProperties": { "type": "string" }
+                        }
+                    },
+                    "required": ["type", "apiVersion", "name"],
+                    "additionalProperties": { "type": "any" }
+                }
+            },
+            "outputs": {
+                "type": "object",
+                "additionalProperties": { "type": "any" }
+            }
+        },
+        "required": ["resources"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+        "contentVersion": "1.0.0.0",
+        "parameters": {
+            "vmName": {
+                "type": "string",
+                "defaultValue": "myVM"
+            }
+        },
+        "variables": {
+            "storageAccountName": "[concat('storage', uniqueString(resourceGroup().id))]"
+        },
+        "resources": [
+            {
+                "type": "Microsoft.Compute/virtualMachines",
+                "apiVersion": "2021-03-01",
+                "name": "[parameters('vmName')]",
+                "location": "[resourceGroup().location]",
+                "properties": {
+                    "hardwareProfile": {
+                        "vmSize": "Standard_B1s"
+                    }
+                },
+                "tags": {
+                    "environment": "dev",
+                    "project": "test"
+                }
+            }
+        ],
+        "outputs": {
+            "vmId": {
+                "type": "string",
+                "value": "[resourceId('Microsoft.Compute/virtualMachines', parameters('vmName'))]"
+            }
+        }
+    }));
+
+    c.bench_function("validate_azure_arm_template", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Azure Policy Effect Validation Benchmarks
+
+// Observed: validate_azure_policy_deny_effect - 188.6 ns/iter
+fn bench_azure_policy_deny_effect_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "effect": {
+                "const": "deny"
+            },
+            "description": {
+                "type": "string"
+            }
+        },
+        "required": ["effect"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "effect": "deny",
+        "description": "Deny resources that don't meet security requirements"
+    }));
+
+    c.bench_function("validate_azure_policy_deny_effect", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_azure_policy_audit_effect - 516.7 ns/iter
+fn bench_azure_policy_audit_effect_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "effect": {
+                "const": "audit"
+            },
+            "description": {
+                "type": "string"
+            },
+            "auditDetails": {
+                "type": "object",
+                "properties": {
+                    "category": {
+                        "enum": ["security", "compliance", "cost", "operational"]
+                    },
+                    "severity": {
+                        "enum": ["low", "medium", "high", "critical"]
+                    }
+                },
+                "additionalProperties": { "type": "any" }
+            }
+        },
+        "required": ["effect"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "effect": "audit",
+        "description": "Audit non-compliant resources",
+        "auditDetails": {
+            "category": "security",
+            "severity": "high"
+        }
+    }));
+
+    c.bench_function("validate_azure_policy_audit_effect", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_azure_policy_modify_effect - 1.17 µs/iter
+fn bench_azure_policy_modify_effect_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "effect": {
+                "const": "modify"
+            },
+            "description": {
+                "type": "string"
+            },
+            "modifyDetails": {
+                "type": "object",
+                "properties": {
+                    "roleDefinitionIds": {
+                        "type": "array",
+                        "items": { "type": "string" }
+                    },
+                    "operations": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "operation": {
+                                    "enum": ["add", "replace", "remove"]
+                                },
+                                "field": {
+                                    "type": "string"
+                                },
+                                "value": {
+                                "type": "any"
+                            }
+                            },
+                            "required": ["operation", "field"],
+                            "additionalProperties": { "type": "any" }
+                        }
+                    }
+                },
+                "required": ["roleDefinitionIds", "operations"],
+                "additionalProperties": { "type": "any" }
+            }
+        },
+        "required": ["effect", "modifyDetails"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "effect": "modify",
+        "description": "Modify resources to ensure compliance",
+        "modifyDetails": {
+            "roleDefinitionIds": [
+                "/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c"
+            ],
+            "operations": [
+                {
+                    "operation": "add",
+                    "field": "tags.environment",
+                    "value": "production"
+                }
+            ]
+        }
+    }));
+
+    c.bench_function("validate_azure_policy_modify_effect", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+// Observed: validate_azure_policy_complex_effect - 1.40 µs/iter
+fn bench_azure_policy_complex_effect_validation(c: &mut Criterion) {
+    let schema_json = json!({
+        "type": "object",
+        "properties": {
+            "effect": {
+                "enum": ["auditIfNotExists", "deployIfNotExists"]
+            },
+            "parameters": {
+                "type": "object",
+                "additionalProperties": { "type": "any" }
+            },
+            "existenceCondition": {
+                "type": "object",
+                "properties": {
+                    "field": { "type": "string" },
+                    "equals": { "type": "string" }
+                },
+                "required": ["field"],
+                "additionalProperties": { "type": "any" }
+            },
+            "deployment": {
+                "type": "object",
+                "properties": {
+                    "properties": {
+                        "type": "object",
+                        "properties": {
+                            "mode": {
+                                "enum": ["incremental", "complete"]
+                            },
+                            "template": {
+                                "type": "object",
+                                "additionalProperties": { "type": "any" }
+                            },
+                            "parameters": {
+                                "type": "object",
+                                "additionalProperties": { "type": "any" }
+                            }
+                        },
+                        "required": ["mode", "template"],
+                        "additionalProperties": { "type": "any" }
+                    }
+                },
+                "required": ["properties"],
+                "additionalProperties": { "type": "any" }
+            }
+        },
+        "required": ["effect"],
+        "additionalProperties": { "type": "any" }
+    });
+    let schema = Schema::from_serde_json_value(schema_json).unwrap();
+    let value = Value::from(json!({
+        "effect": "deployIfNotExists",
+        "parameters": {},
+        "existenceCondition": {
+            "field": "Microsoft.Security/complianceResults/resourceStatus",
+            "equals": "OffByPolicy"
+        },
+        "deployment": {
+            "properties": {
+                "mode": "incremental",
+                "template": {
+                    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
+                    "contentVersion": "1.0.0.0",
+                    "resources": []
+                },
+                "parameters": {}
+            }
+        }
+    }));
+
+    c.bench_function("validate_azure_policy_complex_effect", |b| {
+        b.iter(|| {
+            SchemaValidator::validate(&value, &schema).unwrap();
+        })
+    });
+}
+
+criterion_group!(
+    schema_validation_benches,
+    bench_string_validation,
+    bench_number_validation,
+    bench_array_validation,
+    bench_object_validation,
+    bench_complex_nested_validation,
+    bench_string_pattern_validation,
+    bench_enum_validation,
+    bench_boolean_validation,
+    bench_null_validation,
+    bench_large_array_validation,
+    bench_deeply_nested_object,
+    bench_mixed_type_array,
+    bench_additional_properties,
+    bench_array_constraints,
+    bench_multi_level_validation,
+    bench_azure_vm_resource_validation,
+    bench_azure_storage_resource_validation,
+    bench_azure_arm_template_validation,
+    bench_azure_policy_deny_effect_validation,
+    bench_azure_policy_audit_effect_validation,
+    bench_azure_policy_modify_effect_validation,
+    bench_azure_policy_complex_effect_validation
+);
+criterion_main!(schema_validation_benches);

bindings/c-nostd/CMakeLists.txt

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft
+# Licensed under the MIT License.
+
+cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
+include(FetchContent)
+
+FetchContent_Declare(
+    Corrosion
+    GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git
+    # Use a tag that has a fix for https://github.com/corrosion-rs/corrosion/issues/590
+    GIT_TAG 6be991bb34c348dfb8344be22f3606288ea5c7fd
+)
+FetchContent_MakeAvailable(Corrosion)
+
+project("regorus-test")
+
+corrosion_import_crate(
+  # Path to <regorus-source-folder>/bindings/ffi/Cargo.toml
+  MANIFEST_PATH "../ffi/Cargo.toml"
+  # Always build regorus in Release mode.
+  PROFILE "release"
+  # Only build the "regorus-ffi" crate.
+  CRATES "regorus-ffi"
+  
+  # Turn off std support in regorus-ffi.
+  NO_DEFAULT_FEATURES
+  NO_STD
+
+  # custom_allocator allows using a custom memory allocator.
+  # To use malloc/free remove custom_allocator below.
+  # Additionally, select specific features in regorus.
+  # See regorus/opa_no_std
+  FEATURES "custom_allocator,regorus/semver"
+
+  LOCKED
+  
+  # Link statically
+  CRATE_TYPES staticlib FLAGS --crate-type=staticlib
+  )
+
+add_executable(regorus_test main.c)
+# Add path to <regorus-source-folder>/bindings/ffi
+target_include_directories(regorus_test PRIVATE "../ffi")
+target_link_libraries(regorus_test regorus_ffi)

bindings/c-nostd/main.c

@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+#if defined(_WIN32)
+#include <malloc.h>
+#endif
+#include "regorus.h"
+
+// Regorus has been built for no_std and cannot access files.
+char *file_to_string(const char *file)
+{
+    char *buffer = 0;
+    long length;
+    FILE *f = fopen(file, "rb");
+
+    if (f)
+    {
+        fseek(f, 0, SEEK_END);
+        length = ftell(f);
+        fseek(f, 0, SEEK_SET);
+        buffer = malloc(length + 1);
+        buffer[length] = '\0';
+        if (buffer)
+        {
+            fread(buffer, 1, length, f);
+        }
+        fclose(f);
+    }
+
+    return buffer;
+}
+
+// If regorus is built with custom-allocator, then provide implementation.
+uint8_t *regorus_aligned_alloc(size_t alignment, size_t size)
+{
+    // Aligned allocations must respect platform quirks: Windows offers
+    // _aligned_malloc/_aligned_free, while macOS/Linux reject aligned_alloc
+    // calls when size is not a multiple of alignment, so we rely on
+    // posix_memalign for the no_std build.
+#if defined(_WIN32)
+    return (uint8_t *)_aligned_malloc(size, alignment);
+#else
+    void *ptr = NULL;
+    // posix_memalign requires alignment to be at least sizeof(void*)
+    // and a power of two; normalize here so small requests succeed.
+    if (alignment < sizeof(void *))
+    {
+        alignment = sizeof(void *);
+    }
+
+    if (posix_memalign(&ptr, alignment, size) != 0)
+    {
+        return NULL;
+    }
+    return (uint8_t *)ptr;
+#endif
+}
+
+void regorus_free(uint8_t *ptr)
+{
+#if defined(_WIN32)
+    _aligned_free(ptr);
+#else
+    free(ptr);
+#endif
+}
+
+int main()
+{
+    // Create engine.
+    RegorusEngine *engine = regorus_engine_new();
+    RegorusResult r;
+    char *buffer = NULL;
+
+    // Turn on rego v0 since policy uses v0.
+    r = regorus_engine_set_rego_v0(engine, true);
+    if (r.status != Ok)
+        goto error;
+
+    // Load policies.
+    r = regorus_engine_add_policy(engine, "framework.rego", (buffer = file_to_string("../../../tests/aci/framework.rego")));
+    free(buffer);
+    if (r.status != Ok)
+        goto error;
+    printf("Loaded package %s\n", r.output);
+    regorus_result_drop(r);
+
+    r = regorus_engine_add_policy(engine, "api.rego", (buffer = file_to_string("../../../tests/aci/api.rego")));
+    free(buffer);
+    if (r.status != Ok)
+        goto error;
+    printf("Loaded package %s\n", r.output);
+    regorus_result_drop(r);
+
+    r = regorus_engine_add_policy(engine, "policy.rego", (buffer = file_to_string("../../../tests/aci/policy.rego")));
+    free(buffer);
+    if (r.status != Ok)
+        goto error;
+    printf("Loaded package %s\n", r.output);
+    regorus_result_drop(r);
+
+    // Add data
+    r = regorus_engine_add_data_json(engine, (buffer = file_to_string("../../../tests/aci/data.json")));
+    free(buffer);
+    if (r.status != Ok)
+        goto error;
+    regorus_result_drop(r);
+
+    // Set input
+    r = regorus_engine_set_input_json(engine, (buffer = file_to_string("../../../tests/aci/input.json")));
+    free(buffer);
+    if (r.status != Ok)
+        goto error;
+    regorus_result_drop(r);
+
+    // Eval rule.
+    r = regorus_engine_eval_rule(engine, "data.framework.mount_overlay");
+    if (r.status != Ok)
+        goto error;
+
+    // Print output
+    printf("%s", r.output);
+    regorus_result_drop(r);
+
+    // Free the engine.
+    regorus_engine_drop(engine);
+
+    return 0;
+error:
+    printf("%s", r.error_message);
+
+    return 1;
+}

bindings/c/CMakeLists.txt

@@ -7,21 +7,39 @@ include(FetchContent)
 FetchContent_Declare(
     Corrosion
     GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git
-    GIT_TAG v0.4 # Optionally specify a commit hash, version tag or branch here
+    # Use a tag that has a fix for https://github.com/corrosion-rs/corrosion/issues/590
+    GIT_TAG 6be991bb34c348dfb8344be22f3606288ea5c7fd
 )
 FetchContent_MakeAvailable(Corrosion)
 
 project("regorus-test")
+enable_testing()
 
 corrosion_import_crate(
   # Path to <regorus-source-folder>/bindings/ffi/Cargo.toml
   MANIFEST_PATH "../ffi/Cargo.toml"
   # Always build regorus in Release mode.
   PROFILE "release"
-  # Only build the "regorusc" crate.
-  CRATES "regorus-ffi")
+  # Only build the "regorus-ffi" crate.
+  CRATES "regorus-ffi"
+
+  # Select specific features in regorus.
+  FEATURES "regorus/semver"
+
+  LOCKED
+  
+  # Link statically
+  CRATE_TYPES "cdylib"
+  )
 
 add_executable(regorus_test main.c)
 # Add path to <regorus-source-folder>/bindings/ffi
 target_include_directories(regorus_test PRIVATE "../ffi")
-target_link_libraries(regorus_test regorus-ffi)
+target_link_libraries(regorus_test regorus_ffi)
+
+add_executable(regorus_rvm_test rvm_tests.c)
+target_include_directories(regorus_rvm_test PRIVATE "../ffi")
+target_link_libraries(regorus_rvm_test regorus_ffi)
+
+add_test(NAME regorus_c_engine COMMAND regorus_test)
+add_test(NAME regorus_c_rvm COMMAND regorus_rvm_test)

bindings/c/main.c

@@ -6,50 +6,97 @@ int main() {
     RegorusEngine* engine = regorus_engine_new();
     RegorusResult r;
 
+    // Turn on rego v0 since policy uses v0.
+    r = regorus_engine_set_rego_v0(engine, true);
+    if (r.status != Ok)
+	goto error;
+
     // Load policies.
     r = regorus_engine_add_policy_from_file(engine, "../../../tests/aci/framework.rego");
-    if (r.status != RegorusStatusOk)
+    if (r.status != Ok)
 	goto error;
+    printf("Loaded package %s\n", r.output);
     regorus_result_drop(r);
 
     r = regorus_engine_add_policy_from_file(engine, "../../../tests/aci/api.rego");
-    if (r.status != RegorusStatusOk)
+    if (r.status != Ok)
 	goto error;
+    printf("Loaded package %s\n", r.output);
     regorus_result_drop(r);
     
     r = regorus_engine_add_policy_from_file(engine, "../../../tests/aci/policy.rego");
-    if (r.status != RegorusStatusOk)
+    if (r.status != Ok)
 	goto error;
+    printf("Loaded package %s\n", r.output);
     regorus_result_drop(r);
 
     // Add data
     r = regorus_engine_add_data_from_json_file(engine, "../../../tests/aci/data.json");
-    if (r.status != RegorusStatusOk)
+    if (r.status != Ok)
 	goto error;
     regorus_result_drop(r);
 
     // Set input
     r = regorus_engine_set_input_from_json_file(engine, "../../../tests/aci/input.json");
-    if (r.status != RegorusStatusOk)
+    if (r.status != Ok)
 	goto error;
     regorus_result_drop(r);
 
-    // Eval query
-    r = regorus_engine_eval_query(engine, "data.framework.mount_overlay=x");
-    if (r.status != RegorusStatusOk)
+    // Eval rule.
+    r = regorus_engine_eval_query(engine, "data.framework.mount_overlay");
+    if (r.status != Ok)
 	goto error;
 
     // Print output
-    printf("%s", r.output);
+    printf("%s\n", r.output);
     regorus_result_drop(r);
     
-    
     // Free the engine.
     regorus_engine_drop(engine);
 
+    // Create another engine.
+    engine = regorus_engine_new();
+
+    r = regorus_engine_add_policy(
+	engine,
+	"test.rego",
+	"package test\n"
+	"x = 1\n"
+	"message = `Hello`"
+	);
+
+    // Evaluate rule.
+    if (r.status != Ok)
+	goto error;
+
+    r = regorus_engine_set_enable_coverage(engine, true);
+    regorus_result_drop(r);
+    
+    r = regorus_engine_eval_query(engine, "data.test.message");
+    if (r.status != Ok)
+	goto error;
+
+    // Print output
+    printf("%s\n", r.output);
+    regorus_result_drop(r);
+	
+    // Print pretty coverage report.
+    r = regorus_engine_get_coverage_report_pretty(engine);
+    if (r.status != Ok)
+	goto error;
+
+    printf("%s\n", r.output);
+    regorus_result_drop(r);
+    
+    // Free the engine.
+    regorus_engine_drop(engine);
+    
     return 0;
+    
 error:
     printf("%s", r.error_message);
+    regorus_result_drop(r);
+    regorus_engine_drop(engine);
 	
     return 1;
 }

bindings/c/rvm_tests.c

@@ -0,0 +1,289 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <stdio.h>
+#include <string.h>
+#include "regorus.h"
+
+static int assert_ok(RegorusResult r, const char* message) {
+    if (r.status != Ok) {
+        fprintf(stderr, "%s: %s\n", message, r.error_message ? r.error_message : "(no error)");
+        return 0;
+    }
+    return 1;
+}
+
+int main() {
+    RegorusResult result = {0};
+    bool result_valid = false;
+    RegorusProgram* program = NULL;
+    RegorusBuffer* buffer = NULL;
+    RegorusProgram* program2 = NULL;
+    RegorusRvm* vm = NULL;
+    RegorusProgram* host_program = NULL;
+    RegorusRvm* host_vm = NULL;
+    bool is_partial = false;
+    int exit_code = 1;
+
+    const char* data_json =
+        "{"
+        "  \"roles\": {"
+        "    \"alice\": [\"admin\", \"reader\"]"
+        "  }"
+        "}";
+    const char* input_json =
+        "{"
+        "  \"user\": \"alice\","
+        "  \"actions\": [\"read\"]"
+        "}";
+    const char* module_text =
+        "package demo\n"
+        "default allow = false\n"
+        "allow if {\n"
+        "  input.user == \"alice\"\n"
+        "  some role in data.roles[input.user]\n"
+        "  role == \"admin\"\n"
+        "  count(input.actions) > 0\n"
+        "}\n";
+
+    const char* host_data_json = "{}";
+    const char* host_input_json = "{\"account\":{\"id\":\"acct-1\",\"active\":true}}";
+    const char* host_module_text =
+        "package demo\n"
+        "import rego.v1\n"
+        "default allow := false\n"
+        "allow if {\n"
+        "  input.account.active == true\n"
+        "  details := __builtin_host_await(input.account.id, \"account\")\n"
+        "  details.tier == \"gold\"\n"
+        "}\n";
+
+    RegorusPolicyModule module;
+    module.id = "demo.rego";
+    module.content = module_text;
+
+    const char* entry_points[] = {"data.demo.allow"};
+    printf("Rego policy:\n%s\n", module_text);
+    printf("Compiling program from modules...\n");
+    result = regorus_program_compile_from_modules(
+        data_json,
+        &module,
+        1,
+        entry_points,
+        1
+    );
+    result_valid = true;
+    if (!assert_ok(result, "compile program")) {
+        goto Cleanup;
+    }
+    program = (RegorusProgram*)result.pointer_value;
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Generating assembly listing...\n");
+    result = regorus_program_generate_listing(program);
+    result_valid = true;
+    if (!assert_ok(result, "generate listing")) {
+        goto Cleanup;
+    }
+    printf("Assembly listing:\n%s\n", result.output ? result.output : "(null)");
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Serializing program...\n");
+    result = regorus_program_serialize_binary(program);
+    result_valid = true;
+    if (!assert_ok(result, "serialize program")) {
+        goto Cleanup;
+    }
+    buffer = (RegorusBuffer*)result.pointer_value;
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Deserializing program (%zu bytes)...\n", buffer->len);
+    result = regorus_program_deserialize_binary(
+        buffer->data,
+        buffer->len,
+        &is_partial
+    );
+    result_valid = true;
+    if (!assert_ok(result, "deserialize program")) {
+        goto Cleanup;
+    }
+
+    if (is_partial) {
+        fprintf(stderr, "deserialized program marked partial\n");
+        goto Cleanup;
+    }
+
+    program2 = (RegorusProgram*)result.pointer_value;
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Creating VM...\n");
+    vm = regorus_rvm_new();
+    if (!vm) {
+        fprintf(stderr, "failed to allocate VM\n");
+        goto Cleanup;
+    }
+
+    printf("Loading program into VM...\n");
+    result = regorus_rvm_load_program(vm, program2);
+    result_valid = true;
+    if (!assert_ok(result, "load program")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Setting data...\n");
+    result = regorus_rvm_set_data(vm, data_json);
+    result_valid = true;
+    if (!assert_ok(result, "set data")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Setting input...\n");
+    result = regorus_rvm_set_input(vm, input_json);
+    result_valid = true;
+    if (!assert_ok(result, "set input")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    printf("Executing entry point...\n");
+    result = regorus_rvm_execute(vm);
+    result_valid = true;
+    if (!assert_ok(result, "execute")) {
+        goto Cleanup;
+    }
+
+        printf("Execution result (data.demo.allow): %s\n",
+            result.output ? result.output : "(null)");
+        printf("Decision: user=alice action=read -> allow=%s\n",
+            result.output ? result.output : "(null)");
+    if (!result.output || strcmp(result.output, "true") != 0) {
+        fprintf(stderr, "unexpected result: %s\n", result.output);
+        goto Cleanup;
+    }
+
+    printf("\n--- HostAwait example (suspendable execution) ---\n");
+    RegorusPolicyModule host_module;
+    host_module.id = "host_await.rego";
+    host_module.content = host_module_text;
+
+    const char* host_entry_points[] = {"data.demo.allow"};
+    result = regorus_program_compile_from_modules(
+        host_data_json,
+        &host_module,
+        1,
+        host_entry_points,
+        1
+    );
+    result_valid = true;
+    if (!assert_ok(result, "compile host await program")) {
+        goto Cleanup;
+    }
+    host_program = (RegorusProgram*)result.pointer_value;
+    regorus_result_drop(result);
+    result_valid = false;
+
+    host_vm = regorus_rvm_new();
+    if (!host_vm) {
+        fprintf(stderr, "failed to allocate host await VM\n");
+        goto Cleanup;
+    }
+
+    result = regorus_rvm_set_execution_mode(host_vm, 1);
+    result_valid = true;
+    if (!assert_ok(result, "set execution mode")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    result = regorus_rvm_load_program(host_vm, host_program);
+    result_valid = true;
+    if (!assert_ok(result, "load host await program")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    result = regorus_rvm_set_data(host_vm, host_data_json);
+    result_valid = true;
+    if (!assert_ok(result, "set host data")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    result = regorus_rvm_set_input(host_vm, host_input_json);
+    result_valid = true;
+    if (!assert_ok(result, "set host input")) {
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    result = regorus_rvm_execute(host_vm);
+    result_valid = true;
+    if (!assert_ok(result, "execute host await")) {
+        goto Cleanup;
+    }
+    printf("HostAwait initial result: %s\n", result.output ? result.output : "(null)");
+    regorus_result_drop(result);
+    result_valid = false;
+
+    result = regorus_rvm_get_execution_state(host_vm);
+    result_valid = true;
+    if (!assert_ok(result, "get execution state")) {
+        goto Cleanup;
+    }
+    printf("Execution state: %s\n", result.output ? result.output : "(null)");
+    regorus_result_drop(result);
+    result_valid = false;
+
+    result = regorus_rvm_resume(host_vm, "{\"tier\":\"gold\"}", true);
+    result_valid = true;
+    if (!assert_ok(result, "resume host await")) {
+        goto Cleanup;
+    }
+    printf("HostAwait resumed result: %s\n", result.output ? result.output : "(null)");
+
+    if (!result.output || strcmp(result.output, "true") != 0) {
+        fprintf(stderr, "unexpected host await result\n");
+        goto Cleanup;
+    }
+    regorus_result_drop(result);
+    result_valid = false;
+
+    exit_code = 0;
+
+Cleanup:
+    if (result_valid) {
+        regorus_result_drop(result);
+    }
+    if (host_vm) {
+        regorus_rvm_drop(host_vm);
+    }
+    if (host_program) {
+        regorus_program_drop(host_program);
+    }
+    if (vm) {
+        regorus_rvm_drop(vm);
+    }
+    if (program2) {
+        regorus_program_drop(program2);
+    }
+    if (buffer) {
+        regorus_buffer_drop(buffer);
+    }
+    if (program) {
+        regorus_program_drop(program);
+    }
+    return exit_code;
+}

bindings/cpp/CMakeLists.txt

@@ -7,22 +7,86 @@ include(FetchContent)
 FetchContent_Declare(
     Corrosion
     GIT_REPOSITORY https://github.com/corrosion-rs/corrosion.git
-    GIT_TAG v0.4 # Optionally specify a commit hash, version tag or branch here
+    # Use a tag that has a fix for https://github.com/corrosion-rs/corrosion/issues/590
+    GIT_TAG 6be991bb34c348dfb8344be22f3606288ea5c7fd
 )
 FetchContent_MakeAvailable(Corrosion)
 
 project("regorus-test")
 set(CMAKE_CXX_STANDARD 17)
+enable_testing()
+
+# installable ffi target
 
 corrosion_import_crate(
   # Path to <regorus-source-folder>/bindings/ffi/Cargo.toml
   MANIFEST_PATH "../ffi/Cargo.toml"
   # Always build regorus in Release mode.
   PROFILE "release"
-  # Only build the "regorusc" crate.
-  CRATES "regorus-ffi")
+  # Only build the "regorus-ffi" crate.
+  CRATES "regorus-ffi"
+
+  # Select specific features in regorus.
+  FEATURES "regorus/semver"
+
+  LOCKED
+  
+  # Link statically
+  CRATE_TYPES "cdylib")
+
+include(GNUInstallDirs)
+
+set(regorus_ffi_INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR}/regorus_ffi)
+set(regorus_ffi_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/regorus_ffi)
+set(regorus_ffi_LIBDIR ${CMAKE_INSTALL_LIBDIR})
+set(regorus_ffi_BINDIR ${CMAKE_INSTALL_BINDIR})
+
+add_library(regorus_ffi::regorus_ffi ALIAS regorus_ffi)
+corrosion_install(TARGETS regorus_ffi EXPORT regorus_ffi_targets LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+target_include_directories(regorus_ffi
+INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../ffi>
+    $<INSTALL_INTERFACE:${regorus_ffi_INCLUDEDIR}>
+)
+
+set(regorus_ffi_HEADER_FILES
+  regorus.hpp
+  ../ffi/regorus.ffi.hpp
+)
+
+install(FILES ${regorus_ffi_HEADER_FILES}
+  DESTINATION ${regorus_ffi_INCLUDEDIR}
+  COMPONENT Devel
+)
+
+install(EXPORT regorus_ffi_targets
+  FILE regorus_ffi_targets.cmake
+  NAMESPACE regorus_ffi::
+  DESTINATION ${regorus_ffi_CONFIGDIR}
+)
+
+include(CMakePackageConfigHelpers)
+
+configure_package_config_file(${CMAKE_CURRENT_LIST_DIR}/regorus_ffiConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/regorus_ffiConfig.cmake
+  INSTALL_DESTINATION ${regorus_ffi_CONFIGDIR}
+)
+
+install(FILES
+  ${CMAKE_CURRENT_BINARY_DIR}/regorus_ffiConfig.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}/corrosion/regorus_ffi_targetsCorrosion.cmake
+  DESTINATION ${regorus_ffi_CONFIGDIR}
+)
+
+# test binary
 
 add_executable(regorus_test main.cpp)
-# Add path to <regorus-source-folder>/bindings/ffi
-target_include_directories(regorus_test PRIVATE "../ffi")
-target_link_libraries(regorus_test regorus-ffi)
+target_link_libraries(regorus_test regorus_ffi::regorus_ffi)
+
+add_executable(regorus_rvm_test rvm_tests.cpp)
+target_link_libraries(regorus_rvm_test regorus_ffi::regorus_ffi)
+
+add_test(NAME regorus_cpp_engine COMMAND regorus_test)
+add_test(NAME regorus_cpp_rvm COMMAND regorus_rvm_test)

bindings/cpp/main.cpp

@@ -6,6 +6,9 @@ void example()
     // Create engine
     regorus::Engine engine;
 
+    engine.set_rego_v0(true);
+    engine.set_enable_coverage(true);
+    
     // Add policies.
     engine.add_policy("objects.rego",R"(package objects
 
@@ -67,12 +70,21 @@ f := e["dev"])");
     } else {
 	std::cerr<<result.error()<<std::endl;
     }
+
+    // Print coverage report
+    auto result1 = engine.get_coverage_report_pretty();
+    if (result1) {
+	std::cout<<result1.output()<<std::endl;
+    } else {
+	std::cerr<<result1.error()<<std::endl;
+    }
 }
 
 int main() {
 
     // Create engine.
     regorus::Engine engine;
+    engine.set_rego_v0(true);
 
 
     // Load policies.
@@ -89,6 +101,7 @@ int main() {
 	    std::cerr<<result.error()<<std::endl;
 	    return -1;
 	}
+	std::cout<<"Loaded package "<<result.output()<< std::endl;
     }
     {
 	auto result = engine.add_data_from_json_file("../../../tests/aci/data.json");
@@ -98,7 +111,7 @@ int main() {
 	}
     }
 
-    // Set input and eval query.
+    // Set input and eval rule.
     {
 	auto result = engine.set_input_from_json_file("../../../tests/aci/input.json");
 	if (!result) {
@@ -106,13 +119,13 @@ int main() {
 	    return -1;
 	}
     }
-    auto result = engine.eval_query("data.framework.mount_overlay = x");
+    auto result = engine.eval_rule("data.framework.mount_overlay");
     if (!result) {
 	std::cerr<<result.error()<<std::endl;
 	return -1;
     }
 
     std::cout<<result.output()<<std::endl;
-    
+
     example();
 }

bindings/cpp/regorus.hpp

@@ -1,6 +1,8 @@
 #ifndef REGORUS_WRAPPER_HPP
 #define REGORUS_WRAPPER_HPP
 
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <variant>
 
@@ -8,11 +10,14 @@
 
 namespace regorus {
 
-    class Result {
-    public:
+	class Buffer;
+	class Program;
 
-	operator bool() const { return result.status == RegorusStatus::RegorusStatusOk; }
-	bool operator !() const { return result.status != RegorusStatus::RegorusStatusOk; }
+	class Result {
+	public:
+
+	operator bool() const { return result.status == RegorusStatus::Ok; }
+	bool operator !() const { return result.status != RegorusStatus::Ok; }
 
 	const char* output() const {
 	    if (*this && result.output) {
@@ -30,18 +35,39 @@ namespace regorus {
 	    }
 	}
 
+	void* pointer() const {
+	    return result.pointer_value;
+	}
+
+	Program program() const;
+	Buffer buffer() const;
+
+	Result(RegorusResult r) : result(r) {}
+	Result(Result&& other) noexcept : result(other.result) {
+	    other.result.output = nullptr;
+	    other.result.error_message = nullptr;
+	    other.result.pointer_value = nullptr;
+	}
+	Result& operator=(Result&& other) noexcept {
+	    if (this != &other) {
+		regorus_result_drop(result);
+		result = other.result;
+		other.result.output = nullptr;
+		other.result.error_message = nullptr;
+		other.result.pointer_value = nullptr;
+	    }
+	    return *this;
+	}
+
 	~Result() {
 	    regorus_result_drop(result);
 	}
 	
     private:
-	friend class Engine;
 	RegorusResult result;
 
-	Result(RegorusResult r) : result(r) {}	
     private:
 	Result(const Result&) = delete;
-	Result(Result&&) = delete;
 	Result& operator=(const Result&) = delete;
 
     };
@@ -54,6 +80,9 @@ namespace regorus {
 	    return std::unique_ptr<Engine>(new Engine(regorus_engine_clone(engine)));
 	}
 
+	Result set_rego_v0(bool enable) {
+		return Result(regorus_engine_set_rego_v0(engine, enable));
+	}
 
 	Result add_policy(const char* path, const char* policy) {
 	    return Result(regorus_engine_add_policy(engine, path, policy));
@@ -83,9 +112,33 @@ namespace regorus {
 	    return Result(regorus_engine_eval_query(engine, query));
 	}
 	
+	Result eval_rule(const char* rule) {
+	    return Result(regorus_engine_eval_rule(engine, rule));
+	}
+	
+	Result set_enable_coverage(bool enable) {
+	    return Result(regorus_engine_set_enable_coverage(engine, enable));
+	}
+	
+	Result clear_coverage_data() {
+            return Result(regorus_engine_clear_coverage_data(engine));
+	}
+	
+	Result get_coverage_report() {
+            return Result(regorus_engine_get_coverage_report(engine));
+	}
+	
+	Result get_coverage_report_pretty() {
+            return Result(regorus_engine_get_coverage_report_pretty(engine));
+	}
+	
 	~Engine() {
 	    regorus_engine_drop(engine);
 	}
+
+	RegorusEngine* raw() const {
+	    return engine;
+	}
 	    
 	
     private:
@@ -96,6 +149,247 @@ namespace regorus {
 	Engine(Engine&&) = delete;
 	Engine& operator=(const Engine&) = delete;
     };
+
+    class CompiledPolicy {
+    public:
+	explicit CompiledPolicy(RegorusCompiledPolicy* p) : policy(p) {}
+
+	Result eval_with_input(const char* input_json) {
+	    return Result(regorus_compiled_policy_eval_with_input(policy, input_json));
+	}
+
+	Result get_policy_info() {
+	    return Result(regorus_compiled_policy_get_policy_info(policy));
+	}
+
+	RegorusCompiledPolicy* raw() const {
+	    return policy;
+	}
+
+	~CompiledPolicy() {
+	    if (policy) {
+		regorus_compiled_policy_drop(policy);
+	    }
+	}
+
+    private:
+	RegorusCompiledPolicy* policy;
+	CompiledPolicy(const CompiledPolicy&) = delete;
+	CompiledPolicy(CompiledPolicy&&) = delete;
+	CompiledPolicy& operator=(const CompiledPolicy&) = delete;
+    };
+
+    class Buffer {
+    public:
+	Buffer() : buffer(nullptr) {}
+	explicit Buffer(RegorusBuffer* b) : buffer(b) {}
+
+	const std::uint8_t* data() const {
+	    return buffer ? buffer->data : nullptr;
+	}
+
+	size_t size() const {
+	    return buffer ? buffer->len : 0;
+	}
+
+	RegorusBuffer* raw() const {
+	    return buffer;
+	}
+
+	~Buffer() {
+	    if (buffer) {
+		regorus_buffer_drop(buffer);
+	    }
+	}
+
+    private:
+	RegorusBuffer* buffer;
+	Buffer(const Buffer&) = delete;
+	Buffer(Buffer&&) = delete;
+	Buffer& operator=(const Buffer&) = delete;
+    };
+
+    class Program {
+    public:
+	Program() : program(regorus_program_new()) {}
+	explicit Program(RegorusProgram* p) : program(p) {}
+
+	static Result compile_from_policy(
+	    RegorusCompiledPolicy* compiled_policy,
+	    const char* const* entry_points,
+	    size_t entry_points_len
+	) {
+	    return Result(regorus_program_compile_from_policy(
+		compiled_policy,
+		entry_points,
+		entry_points_len
+	    ));
+	}
+
+	static Result compile_from_modules(
+	    const char* data_json,
+	    const RegorusPolicyModule* modules,
+	    size_t modules_len,
+	    const char* const* entry_points,
+	    size_t entry_points_len
+	) {
+	    return Result(regorus_program_compile_from_modules(
+		data_json,
+		modules,
+		modules_len,
+		entry_points,
+		entry_points_len
+	    ));
+	}
+
+	static Result compile_from_engine(
+	    RegorusEngine* engine,
+	    const char* const* entry_points,
+	    size_t entry_points_len
+	) {
+	    return Result(regorus_engine_compile_program_with_entrypoints(
+		engine,
+		entry_points,
+		entry_points_len
+	    ));
+	}
+
+	Result serialize_binary() const {
+	    return Result(regorus_program_serialize_binary(program));
+	}
+
+	static Result deserialize_binary(
+	    const std::uint8_t* data,
+	    size_t len,
+	    bool* is_partial
+	) {
+	    return Result(regorus_program_deserialize_binary(data, len, is_partial));
+	}
+
+	Result generate_listing() const {
+	    return Result(regorus_program_generate_listing(program));
+	}
+
+	Result generate_tabular_listing() const {
+	    return Result(regorus_program_generate_tabular_listing(program));
+	}
+
+	RegorusProgram* raw() const {
+	    return program;
+	}
+
+	~Program() {
+	    if (program) {
+		regorus_program_drop(program);
+	    }
+	}
+
+    private:
+	RegorusProgram* program;
+	Program(const Program&) = delete;
+	Program(Program&&) = delete;
+	Program& operator=(const Program&) = delete;
+    };
+
+	inline Program Result::program() const {
+	return Program(reinterpret_cast<RegorusProgram*>(result.pointer_value));
+	}
+
+	inline Buffer Result::buffer() const {
+	return Buffer(reinterpret_cast<RegorusBuffer*>(result.pointer_value));
+	}
+
+    class Rvm {
+    public:
+	Rvm() : vm(regorus_rvm_new()) {}
+	explicit Rvm(RegorusRvm* v) : vm(v) {}
+
+	static Result create_with_policy(RegorusCompiledPolicy* compiled_policy) {
+	    return Result(regorus_rvm_new_with_policy(compiled_policy));
+	}
+
+	Result load_program(const Program& program) {
+	    return Result(regorus_rvm_load_program(vm, program.raw()));
+	}
+
+	Result set_data(const char* data_json) {
+	    return Result(regorus_rvm_set_data(vm, data_json));
+	}
+
+	Result set_input(const char* input_json) {
+	    return Result(regorus_rvm_set_input(vm, input_json));
+	}
+
+	Result set_max_instructions(size_t max_instructions) {
+	    return Result(regorus_rvm_set_max_instructions(vm, max_instructions));
+	}
+
+	Result set_strict_builtin_errors(bool strict) {
+	    return Result(regorus_rvm_set_strict_builtin_errors(vm, strict));
+	}
+
+	Result set_execution_mode(std::uint8_t mode) {
+	    return Result(regorus_rvm_set_execution_mode(vm, mode));
+	}
+
+	Result set_step_mode(bool enabled) {
+	    return Result(regorus_rvm_set_step_mode(vm, enabled));
+	}
+
+	Result set_execution_timer_config(bool has_config, RegorusExecutionTimerConfig config) {
+	    return Result(regorus_rvm_set_execution_timer_config(vm, has_config, config));
+	}
+
+	Result execute() {
+	    return Result(regorus_rvm_execute(vm));
+	}
+
+	Result execute_entry_point_by_name(const char* entry_point) {
+	    return Result(regorus_rvm_execute_entry_point_by_name(vm, entry_point));
+	}
+
+	Result execute_entry_point_by_index(size_t index) {
+	    return Result(regorus_rvm_execute_entry_point_by_index(vm, index));
+	}
+
+	Result resume(const char* resume_value_json, bool has_value) {
+	    return Result(regorus_rvm_resume(vm, resume_value_json, has_value));
+	}
+
+	Result get_execution_state() {
+	    return Result(regorus_rvm_get_execution_state(vm));
+	}
+
+	RegorusRvm* raw() const {
+	    return vm;
+	}
+
+	~Rvm() {
+	    if (vm) {
+		regorus_rvm_drop(vm);
+	    }
+	}
+
+    private:
+	RegorusRvm* vm;
+	Rvm(const Rvm&) = delete;
+	Rvm(Rvm&&) = delete;
+	Rvm& operator=(const Rvm&) = delete;
+    };
+
+    inline Result compile_policy_with_entrypoint(
+	const char* data_json,
+	const RegorusPolicyModule* modules,
+	size_t modules_len,
+	const char* entry_point
+    ) {
+	return Result(regorus_compile_policy_with_entrypoint(
+	    data_json,
+	    modules,
+	    modules_len,
+	    entry_point
+	));
+    }
 }
 
 #endif // REGORUS_WRAPPER_HPP

bindings/cpp/regorus_ffiConfig.cmake.in

@@ -0,0 +1,3 @@
+@PACKAGE_INIT@
+include("${CMAKE_CURRENT_LIST_DIR}/regorus_ffi_targets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/regorus_ffi_targetsCorrosion.cmake")

bindings/cpp/rvm_tests.cpp

@@ -0,0 +1,261 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include <iostream>
+#include <string>
+#include "regorus.hpp"
+
+int main() {
+    const char* data_json =
+        "{"
+        "  \"roles\": {"
+        "    \"alice\": [\"admin\", \"reader\"]"
+        "  }"
+        "}";
+    const char* input_json =
+        "{"
+        "  \"user\": \"alice\","
+        "  \"actions\": [\"read\"]"
+        "}";
+    const char* module_text =
+        "package demo\n"
+        "default allow = false\n"
+        "allow if {\n"
+        "  input.user == \"alice\"\n"
+        "  some role in data.roles[input.user]\n"
+        "  role == \"admin\"\n"
+        "  count(input.actions) > 0\n"
+        "}\n";
+
+    const char* host_data_json = "{}";
+    const char* host_input_json = "{\"account\":{\"id\":\"acct-1\",\"active\":true}}";
+    const char* host_module_text =
+        "package demo\n"
+        "import rego.v1\n"
+        "default allow := false\n"
+        "allow if {\n"
+        "  input.account.active == true\n"
+        "  details := __builtin_host_await(input.account.id, \"account\")\n"
+        "  details.tier == \"gold\"\n"
+        "}\n";
+
+    RegorusPolicyModule module;
+    module.id = "demo.rego";
+    module.content = module_text;
+
+    const char* entry_points[] = {"data.demo.allow"};
+    std::cout << "Rego policy:\n" << module_text << std::endl;
+    std::cout << "Compiling program from modules..." << std::endl;
+    auto program_result = regorus::Program::compile_from_modules(
+        data_json,
+        &module,
+        1,
+        entry_points,
+        1
+    );
+    if (!program_result) {
+        std::cerr << "compile program (modules): " << program_result.error() << std::endl;
+        return 1;
+    }
+
+    regorus::Program program = program_result.program();
+
+    std::cout << "Generating assembly listing..." << std::endl;
+    auto listing_result = program.generate_listing();
+    if (!listing_result) {
+        std::cerr << "generate listing: " << listing_result.error() << std::endl;
+        return 1;
+    }
+    std::cout << "Assembly listing:\n" << listing_result.output() << std::endl;
+
+    std::cout << "Serializing program..." << std::endl;
+    auto serialize_result = program.serialize_binary();
+    if (!serialize_result) {
+        std::cerr << "serialize program: " << serialize_result.error() << std::endl;
+        return 1;
+    }
+
+    regorus::Buffer buffer(reinterpret_cast<RegorusBuffer*>(serialize_result.pointer()));
+    bool is_partial = false;
+    std::cout << "Deserializing program (" << buffer.size() << " bytes)..." << std::endl;
+    auto deserialize_result = regorus::Program::deserialize_binary(
+        buffer.data(),
+        buffer.size(),
+        &is_partial
+    );
+    if (!deserialize_result) {
+        std::cerr << "deserialize program: " << deserialize_result.error() << std::endl;
+        return 1;
+    }
+
+    if (is_partial) {
+        std::cerr << "deserialized program marked partial" << std::endl;
+        return 1;
+    }
+
+    regorus::Program program2 = deserialize_result.program();
+
+    {
+        std::cout << "Creating VM..." << std::endl;
+        regorus::Rvm vm;
+        auto load_result = vm.load_program(program2);
+        if (!load_result) {
+            std::cerr << "load program: " << load_result.error() << std::endl;
+            return 1;
+        }
+
+        std::cout << "Setting data..." << std::endl;
+        auto data_result = vm.set_data(data_json);
+        if (!data_result) {
+            std::cerr << "set data: " << data_result.error() << std::endl;
+            return 1;
+        }
+
+        std::cout << "Setting input..." << std::endl;
+        auto input_result = vm.set_input(input_json);
+        if (!input_result) {
+            std::cerr << "set input: " << input_result.error() << std::endl;
+            return 1;
+        }
+
+        std::cout << "Executing entry point..." << std::endl;
+        auto exec_result = vm.execute();
+        if (!exec_result) {
+            std::cerr << "execute: " << exec_result.error() << std::endl;
+            return 1;
+        }
+
+        std::cout << "Execution result (data.demo.allow): " << exec_result.output() << std::endl;
+        std::cout << "Decision: user=alice action=read -> allow=" << exec_result.output() << std::endl;
+        if (std::string(exec_result.output()) != "true") {
+            std::cerr << "unexpected result: " << exec_result.output() << std::endl;
+            return 1;
+        }
+    }
+
+    regorus::Engine engine;
+    std::cout << "Compiling program from engine..." << std::endl;
+    auto add_policy_result = engine.add_policy("demo.rego", module_text);
+    if (!add_policy_result) {
+        std::cerr << "engine add policy: " << add_policy_result.error() << std::endl;
+        return 1;
+    }
+
+    auto engine_program_result = regorus::Program::compile_from_engine(
+        engine.raw(),
+        entry_points,
+        1
+    );
+    if (!engine_program_result) {
+        std::cerr << "compile program (engine): " << engine_program_result.error() << std::endl;
+        return 1;
+    }
+
+    regorus::Program engine_program = engine_program_result.program();
+
+    regorus::Rvm engine_vm;
+    auto engine_load_result = engine_vm.load_program(engine_program);
+    if (!engine_load_result) {
+        std::cerr << "engine load program: " << engine_load_result.error() << std::endl;
+        return 1;
+    }
+
+    std::cout << "Setting engine data..." << std::endl;
+    auto engine_data_result = engine_vm.set_data(data_json);
+    if (!engine_data_result) {
+        std::cerr << "engine set data: " << engine_data_result.error() << std::endl;
+        return 1;
+    }
+
+    std::cout << "Setting engine input..." << std::endl;
+    auto engine_input_result = engine_vm.set_input(input_json);
+    if (!engine_input_result) {
+        std::cerr << "engine set input: " << engine_input_result.error() << std::endl;
+        return 1;
+    }
+
+    std::cout << "Executing engine entry point..." << std::endl;
+    auto engine_exec_result = engine_vm.execute();
+    if (!engine_exec_result) {
+        std::cerr << "engine execute: " << engine_exec_result.error() << std::endl;
+        return 1;
+    }
+
+    std::cout << "Engine execution result (data.demo.allow): " << engine_exec_result.output() << std::endl;
+    std::cout << "Decision: user=alice action=read -> allow=" << engine_exec_result.output() << std::endl;
+    if (std::string(engine_exec_result.output()) != "true") {
+        std::cerr << "unexpected engine result: " << engine_exec_result.output() << std::endl;
+        return 1;
+    }
+
+    std::cout << "\n--- HostAwait example (suspendable execution) ---" << std::endl;
+    RegorusPolicyModule host_module;
+    host_module.id = "host_await.rego";
+    host_module.content = host_module_text;
+    const char* host_entry_points[] = {"data.demo.allow"};
+
+    auto host_program_result = regorus::Program::compile_from_modules(
+        host_data_json,
+        &host_module,
+        1,
+        host_entry_points,
+        1
+    );
+    if (!host_program_result) {
+        std::cerr << "compile host await program: " << host_program_result.error() << std::endl;
+        return 1;
+    }
+
+    regorus::Program host_program = host_program_result.program();
+    regorus::Rvm host_vm;
+    auto host_mode_result = host_vm.set_execution_mode(1);
+    if (!host_mode_result) {
+        std::cerr << "set execution mode: " << host_mode_result.error() << std::endl;
+        return 1;
+    }
+
+    auto host_load_result = host_vm.load_program(host_program);
+    if (!host_load_result) {
+        std::cerr << "load host await program: " << host_load_result.error() << std::endl;
+        return 1;
+    }
+
+    auto host_data_result = host_vm.set_data(host_data_json);
+    if (!host_data_result) {
+        std::cerr << "set host data: " << host_data_result.error() << std::endl;
+        return 1;
+    }
+
+    auto host_input_result = host_vm.set_input(host_input_json);
+    if (!host_input_result) {
+        std::cerr << "set host input: " << host_input_result.error() << std::endl;
+        return 1;
+    }
+
+    auto host_exec_result = host_vm.execute();
+    if (!host_exec_result) {
+        std::cerr << "execute host await: " << host_exec_result.error() << std::endl;
+        return 1;
+    }
+    std::cout << "HostAwait initial result: " << host_exec_result.output() << std::endl;
+
+    auto host_state_result = host_vm.get_execution_state();
+    if (!host_state_result) {
+        std::cerr << "get execution state: " << host_state_result.error() << std::endl;
+        return 1;
+    }
+    std::cout << "Execution state: " << host_state_result.output() << std::endl;
+
+    auto host_resume_result = host_vm.resume("{\"tier\":\"gold\"}", true);
+    if (!host_resume_result) {
+        std::cerr << "resume host await: " << host_resume_result.error() << std::endl;
+        return 1;
+    }
+    std::cout << "HostAwait resumed result: " << host_resume_result.output() << std::endl;
+    if (std::string(host_resume_result.output()) != "true") {
+        std::cerr << "unexpected host await result: " << host_resume_result.output() << std::endl;
+        return 1;
+    }
+
+    return 0;
+}

bindings/csharp/API.md

@@ -0,0 +1,421 @@
+# Regorus C# API Documentation
+
+This document describes the C# API for Regorus, focusing on the compiled policy approach for high-performance policy evaluation.
+
+## Overview
+
+The Regorus C# bindings provide a modern, thread-safe API for compiling and evaluating Open Policy Agent (OPA) Rego policies. The API is designed around pre-compiled policies that can be evaluated efficiently multiple times with different inputs.
+
+## Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                    CompiledPolicy Workflow                      │
+└─────────────────────────────────────────────────────────────────┘
+
+┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
+│  Policy Modules │    │   Target/Schema  │    │   Static Data   │
+│  (.rego files)  │    │    Registries    │    │     (JSON)      │
+└─────────┬───────┘    └────────┬─────────┘    └─────────┬───────┘
+          │                     │                        │
+          └─────────────────────┼────────────────────────┘
+                                │
+                                ▼
+                    ┌─────────────────────────┐
+                    │        Compile          │
+                    │  ┌─────────────────────┐│
+                    │  │ Parse & Analyze     ││
+                    │  │ Infer Resource Types││
+                    │  │ Build AST & Rules   ││
+                    │  │ Target Integration  ││
+                    │  └─────────────────────┘│
+                    └─────────────┬───────────┘
+                                  │
+                                  ▼
+                      ┌─────────────────────────┐
+                      │    CompiledPolicy       │
+                      │ ┌─────────────────────┐ │
+                      │ │ AST & Rules         │ │
+                      │ │ Target Info         │ │
+                      │ │ Resource Types      │ │
+                      │ │ Function Table      │ │
+                      │ │ Compiled Modules    │ │
+                      │ └─────────────────────┘ │
+                      └─────────────┬───────────┘
+                                    │
+                                    ▼
+                          ┌─────────────────────┐
+                          │    Service Cache    │
+                          │ (Policy Framework,  │
+                          │  MS Graph, etc.)    │
+                          │ ┌─────────────────┐ │
+                          │ │ CompiledPolicy  │ │ ◄─── Same LOCK-FREE policy
+                          │ │    (cached)     │ │      instance shared across
+                          │ └─────────────────┘ │      all threads
+                          └─────────┬───────────┘
+                                    │
+                            ┌───────┼───────┬───────┐
+                            │       │       │       │
+                            ▼       ▼       ▼       ▼
+                    ┌─────────────┐ ┌─────────────┐ ┌─────────────┐
+                    │  Thread 1   │ │  Thread 2   │ │  Thread N   │
+                    │             │ │             │ │             │
+                    │ input1 ────▶│ │ input2 ────▶│ │ inputN ────▶│
+                    │ ◄─── result │ │ ◄─── result │ │ ◄─── result │
+                    └─────────────┘ └─────────────┘ └─────────────┘
+
+┌─────────────────────────────────────────────────────────────────┐
+│                        Key Benefits                             │
+├─────────────────────────────────────────────────────────────────┤
+│ ✓ Compile Once, Evaluate Many     ✓ Lock-Free Concurrent Eval   │
+│ ✓ No Re-parsing Overhead          ✓ Reference Counting Safety   │
+│ ✓ Reduced GC Pressure             ✓ Proper Resource Management  │
+│ ✓ Cache-Friendly Design           ✓ Target System Integration   │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Key Features
+
+- **Pre-compiled Policies**: Compile once, evaluate many times for optimal performance
+- **Target System Support**: Built-in support for Azure Policy targets with resource type inference
+- **Thread Safety**: All operations are thread-safe without external synchronization
+- **Registry Management**: Centralized management of targets and schemas
+- **Policy Introspection**: Rich metadata about compiled policies
+
+## Core Classes
+
+### CompiledPolicy
+
+The `CompiledPolicy` class represents a pre-compiled Rego policy that can be evaluated efficiently.
+
+```csharp
+public sealed class CompiledPolicy : IDisposable
+{
+    // Evaluate the policy with input data
+    public string? EvalWithInput(string inputJson);
+    
+    // Get comprehensive policy metadata
+    public PolicyInfo GetPolicyInfo();
+    
+    // Dispose of unmanaged resources
+    public void Dispose();
+}
+```
+
+**Thread Safety**: All methods are thread-safe. Multiple threads can call `EvalWithInput()` concurrently, and `Dispose()` will safely wait for active evaluations to complete.
+
+### Compiler
+
+The `Compiler` class provides static methods for compiling policies.
+
+```csharp
+public static class Compiler
+{
+    // Compile a policy with a specific entrypoint rule
+    public static CompiledPolicy CompilePolicyWithEntrypoint(
+        string dataJson, 
+        IEnumerable<PolicyModule> modules, 
+        string entryPointRule);
+    
+    // Compile a target-aware policy (requires azure_policy feature)
+    public static CompiledPolicy CompilePolicyForTarget(
+        string dataJson, 
+        IEnumerable<PolicyModule> modules);
+}
+```
+
+### PolicyModule
+
+Represents a single policy module to be compiled. Each PolicyModule corresponds to a Rego file (.rego), and each Rego file defines a Rego package using the `package` declaration at the top of the file.
+
+```csharp
+public struct PolicyModule
+{
+    public string Id { get; set; }
+    public string Content { get; set; }
+    
+    public PolicyModule(string id, string content);
+}
+```
+
+**Properties:**
+- `Id`: A unique identifier for the module, typically the filename (e.g., "policy.rego", "rules/storage.rego")
+- `Content`: The complete Rego policy content, including the `package` declaration and all rules
+
+**Example:**
+```csharp
+var module = new PolicyModule("storage-policy.rego", @"
+    package azure.storage
+    import rego.v1
+    
+    default allow := false
+    allow if input.type == ""Microsoft.Storage/storageAccounts""
+");
+```
+
+### PolicyInfo
+
+Provides comprehensive metadata about a compiled policy.
+
+```csharp
+public class PolicyInfo
+{
+    // List of module identifiers
+    public List<string> ModuleIds { get; set; }
+    
+    // Target name (for target-aware policies)
+    public string? TargetName { get; set; }
+    
+    // Resource types this policy can evaluate
+    public List<string> ApplicableResourceTypes { get; set; }
+    
+    // Primary rule/entrypoint
+    public string EntrypointRule { get; set; }
+    
+    // Effect rule (for target-aware policies)
+    public string? EffectRule { get; set; }
+    
+    // Policy parameters
+    public List<PolicyParameters> Parameters { get; set; }
+}
+```
+
+## Registry Classes
+
+### TargetRegistry
+
+Manages target definitions for Azure Policy-style evaluations.
+
+```csharp
+public static class TargetRegistry
+{
+    // Register a target from JSON
+    public static void RegisterFromJson(string targetJson);
+    
+    // Check if a target exists
+    public static bool Contains(string name);
+    
+    // List all registered targets
+    public static string ListNames();
+    
+    // Remove a target
+    public static bool Remove(string name);
+    
+    // Clear all targets
+    public static void Clear();
+    
+    // Get count of registered targets
+    public static int Count { get; }
+    
+    // Check if registry is empty
+    public static bool IsEmpty { get; }
+}
+```
+
+### SchemaRegistry
+
+Manages schema definitions for validation.
+
+```csharp
+public static class SchemaRegistry
+{
+    // Register resource schemas
+    public static void RegisterResourceSchema(string name, string schemaJson);
+    public static bool ContainsResourceSchema(string name);
+    public static string ListResourceSchemas();
+    
+    // Register effect schemas
+    public static void RegisterEffectSchema(string name, string schemaJson);
+    public static bool ContainsEffectSchema(string name);
+    public static string ListEffectSchemas();
+    
+    // Clear methods
+    public static void ClearResourceSchemas();
+    public static void ClearEffectSchemas();
+}
+```
+
+## Usage Examples
+
+### Basic Policy Compilation and Evaluation
+
+```csharp
+// Define policy modules
+var modules = new List<PolicyModule>
+{
+    new PolicyModule("policy.rego", @"
+        package example
+        import rego.v1
+        
+        default allow := false
+        allow if input.user == ""admin""
+    ")
+};
+
+// Compile the policy
+using var policy = Compiler.CompilePolicyWithEntrypoint("{}", modules, "data.example.allow");
+
+// Evaluate with different inputs
+var result1 = policy.EvalWithInput(@"{""user"": ""admin""}");  // true
+var result2 = policy.EvalWithInput(@"{""user"": ""guest""}");  // false
+```
+
+### Target-Aware Policy (Azure Policy Style)
+
+```csharp
+// Register target definition
+TargetRegistry.RegisterFromJson(@"{
+    ""name"": ""azure.storage"",
+    ""resource_schema_selector"": ""type"",
+    ""resource_types"": {
+        ""Microsoft.Storage/storageAccounts"": {
+            ""schema"": { /* JSON Schema */ }
+        }
+    }
+}");
+
+// Define policy with target
+var modules = new List<PolicyModule>
+{
+    new PolicyModule("policy.rego", @"
+        package policy
+        import rego.v1
+        
+        __target__ := ""azure.storage""
+        
+        default effect := ""deny""
+        effect := ""allow"" if {
+            input.type == ""Microsoft.Storage/storageAccounts""
+            input.properties.supportsHttpsTrafficOnly == true
+        }
+    ")
+};
+
+// Compile for target
+using var policy = Compiler.CompilePolicyForTarget("{}", modules);
+
+// Evaluate Azure resource
+var resource = @"{
+    ""type"": ""Microsoft.Storage/storageAccounts"",
+    ""properties"": {
+        ""supportsHttpsTrafficOnly"": true
+    }
+}";
+
+var result = policy.EvalWithInput(resource);  // "allow"
+```
+
+### Policy Introspection
+
+```csharp
+// Get policy metadata
+var info = policy.GetPolicyInfo();
+
+Console.WriteLine($"Target: {info.TargetName}");
+Console.WriteLine($"Effect Rule: {info.EffectRule}");
+Console.WriteLine($"Modules: {string.Join(", ", info.ModuleIds)}");
+Console.WriteLine($"Resource Types: {string.Join(", ", info.ApplicableResourceTypes)}");
+
+// Access parameters
+if (info.Parameters != null && info.Parameters.Count > 0)
+{
+    foreach (var parameterSet in info.Parameters)
+    {
+        Console.WriteLine($"Module: {parameterSet.SourceFile}");
+        foreach (var param in parameterSet.Parameters)
+        {
+            Console.WriteLine($"Parameter: {param.Name} ({param.Type})");
+            if (param.Default != null)
+                Console.WriteLine($"  Default: {param.Default}");
+        }
+    }
+}
+```
+
+### Concurrent Evaluation
+
+```csharp
+// CompiledPolicy is thread-safe
+var tasks = Enumerable.Range(0, 100).Select(i => 
+    Task.Run(() => policy.EvalWithInput($@"{{""id"": {i}}}"))
+).ToArray();
+
+var results = await Task.WhenAll(tasks);
+```
+
+## Performance Considerations
+
+### Compilation Overhead
+
+- Policy compilation has significant overhead due to parsing and analysis
+- **Best Practice**: Compile once, reuse many times
+- Consider caching compiled policies for repeated use
+
+### Memory Management
+
+- `CompiledPolicy` manages unmanaged resources
+- **Always** dispose of compiled policies using `using` statements or explicit `Dispose()`
+- Disposal is thread-safe and waits for active evaluations
+
+### Thread Safety
+
+- All classes are thread-safe for concurrent reads/evaluations
+- Registry modifications should be done during initialization
+- No external synchronization required
+
+## Error Handling
+
+All methods throw `Exception` on errors with descriptive messages:
+
+```csharp
+try
+{
+    var policy = Compiler.CompilePolicyWithEntrypoint(data, modules, rule);
+    var result = policy.EvalWithInput(input);
+}
+catch (Exception ex)
+{
+    Console.WriteLine($"Error: {ex.Message}");
+}
+```
+
+## Feature Flags
+
+Some functionality requires specific Rust feature flags:
+
+- **azure_policy**: Required for target-aware compilation and policy parameters
+- Without this feature, target-related methods will not be available
+
+## Version Compatibility
+
+- Requires .NET Standard 2.0 or later
+- Compatible with .NET Framework 4.6.1+, .NET Core 2.0+, .NET 5+
+- Uses System.Text.Json for JSON serialization (added as dependency)
+
+## Best Practices
+
+1. **Compile Once, Evaluate Many**: Pre-compile policies for repeated evaluation
+2. **Use Disposable Pattern**: Always dispose of CompiledPolicy instances
+3. **Thread-Safe Design**: Take advantage of built-in thread safety
+4. **Registry Setup**: Configure targets and schemas during application startup
+5. **Error Handling**: Wrap operations in try-catch blocks for robust error handling
+6. **Performance Monitoring**: Monitor evaluation times for performance optimization
+
+## Migration from Engine-Based API
+
+If migrating from an engine-based approach:
+
+```csharp
+// Old approach (if it existed)
+// var engine = new Engine();
+// engine.AddPolicy("policy.rego", policyContent);
+// engine.SetInputJson(inputJson);
+// var result = engine.EvalRule("data.policy.allow");
+
+// New compiled approach
+var modules = new[] { new PolicyModule("policy.rego", policyContent) };
+using var policy = Compiler.CompilePolicyWithEntrypoint("{}", modules, "data.policy.allow");
+var result = policy.EvalWithInput(inputJson);
+```
+
+The compiled approach provides better performance for repeated evaluations and clearer resource management.

bindings/csharp/Benchmarks/Benchmarks.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>Enable</Nullable>
+  </PropertyGroup>
+  
+  <PropertyGroup>
+    <!-- If the environment variable is set (such as in a Github Action run), append the suffix to the version number -->
+    <RegorusPackageVersionSuffix Condition="'$(VersionSuffix)' != ''">-$(VersionSuffix)</RegorusPackageVersionSuffix>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- If the environment variable is set (such as in a Github Action run), append the suffix to the version number -->
+    <RegorusPackageVersionSuffix Condition="'$(VersionSuffix)' != ''">-$(VersionSuffix)</RegorusPackageVersionSuffix>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Regorus" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="../../ffi/target/release/libregorus_ffi.dylib" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+</Project>

bindings/csharp/Benchmarks/CompiledPolicyEvaluationBenchmark.cs

@@ -0,0 +1,312 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Regorus;
+
+namespace Benchmarks
+{
+    public class CompiledPolicyEvaluationBenchmark
+    {
+        private static readonly string TestDataPath = Path.Combine(
+            Directory.GetCurrentDirectory(),
+            "..", "..", "..",
+            "benches", "evaluation", "test_data"
+        );
+
+        private static readonly (string PolicyFile, string[] InputFiles)[] PolicyInputFiles = new[]
+        {
+            ("rbac_policy.rego", new[] { "rbac_input.json", "rbac_input2.json", "rbac_input3.json" }),
+            ("api_access_policy.rego", new[] { "api_access_input.json", "api_access_input2.json", "api_access_input3.json" }),
+            ("data_sensitivity_policy.rego", new[] { "data_sensitivity_input.json", "data_sensitivity_input2.json", "data_sensitivity_input3.json" }),
+            ("time_based_policy.rego", new[] { "time_based_input.json", "time_based_input2.json", "time_based_input3.json" }),
+            ("data_processing_policy.rego", new[] { "data_processing_input.json", "data_processing_input2.json", "data_processing_input3.json" }),
+            ("azure_vm_policy.rego", new[] { "azure_vm_input.json", "azure_vm_input2.json", "azure_vm_input3.json" }),
+            ("azure_storage_policy.rego", new[] { "azure_storage_input.json", "azure_storage_input2.json", "azure_storage_input3.json" }),
+            ("azure_keyvault_policy.rego", new[] { "azure_keyvault_input.json", "azure_keyvault_input2.json", "azure_keyvault_input3.json" }),
+            ("azure_nsg_policy.rego", new[] { "azure_nsg_input.json", "azure_nsg_input2.json", "azure_nsg_input3.json" })
+        };
+
+        private static readonly string[] PolicyNames = new[]
+        {
+            "rbac_policy",
+            "api_access_policy",
+            "data_sensitivity_policy",
+            "time_based_policy",
+            "data_processing_policy",
+            "azure_vm_policy",
+            "azure_storage_policy",
+            "azure_keyvault_policy",
+            "azure_nsg_policy"
+        };
+
+        private static List<(string Policy, string[] Inputs)> LoadPoliciesWithInputs()
+        {
+            var result = new List<(string Policy, string[] Inputs)>();
+
+            foreach (var (policyFile, inputFiles) in PolicyInputFiles)
+            {
+                var policyPath = Path.Combine(TestDataPath, "policies", policyFile);
+                var policy = File.ReadAllText(policyPath);
+
+                var inputs = inputFiles.Select(inputFile =>
+                {
+                    var inputPath = Path.Combine(TestDataPath, "inputs", inputFile);
+                    return File.ReadAllText(inputPath);
+                }).ToArray();
+
+                result.Add((policy, inputs));
+            }
+
+            return result;
+        }
+
+        private static List<CompiledPolicy> PrepareSharedCompiledPolicies()
+        {
+            var policiesWithInputs = LoadPoliciesWithInputs();
+            var compiledPolicies = new List<CompiledPolicy>();
+
+            foreach (var (policy, _) in policiesWithInputs)
+            {
+                var modules = new[] { new PolicyModule("policy.rego", policy) };
+                var compiled = Compiler.CompilePolicyWithEntrypoint("{}", modules, "data.bench.allow");
+                compiledPolicies.Add(compiled);
+            }
+
+            return compiledPolicies;
+        }
+
+        public static void RunCompiledPolicyEvaluationBenchmark()
+        {
+            var cpuCount = Environment.ProcessorCount;
+            var maxThreads = cpuCount * 2;
+            var threadCounts = new List<int> { 1, 2 };
+
+            // Add even numbers from 4 to maxThreads
+            for (int i = 4; i <= maxThreads; i += 2)
+            {
+                threadCounts.Add(i);
+            }
+
+            Console.WriteLine($"Running compiled policy benchmark with max_threads: {maxThreads}");
+            Console.WriteLine($"Testing with thread counts: {string.Join(", ", threadCounts)}");
+            Console.WriteLine();
+
+            // Benchmark both shared policies and per-iteration compilation
+            var configurations = new[]
+            {
+                (true, "compiled_shared_policies"),
+                (false, "compiled_per_iteration")
+            };
+
+            foreach (var (useSharedPolicies, groupName) in configurations)
+            {
+                Console.WriteLine($"=== {groupName} ===");
+
+                foreach (var threads in threadCounts)
+                {
+                    RunCompiledPolicyBenchmark(threads, useSharedPolicies, groupName);
+                }
+                Console.WriteLine();
+            }
+        }
+
+        public static void RunCompiledPolicyBenchmark(int threads, bool useSharedPolicies, string groupName)
+        {
+            const int warmupSeconds = 3;
+            const int durationSeconds = 3;
+            var policiesWithInputs = LoadPoliciesWithInputs();
+            List<CompiledPolicy>? compiledPolicies = null;
+
+            if (useSharedPolicies)
+            {
+                compiledPolicies = PrepareSharedCompiledPolicies();
+            }
+
+            Console.WriteLine($"Warming up with {threads} threads for {warmupSeconds} seconds...");
+
+            // Warmup phase
+            var (_, _, _, _) = RunBenchmarkPhase(threads, warmupSeconds, policiesWithInputs, compiledPolicies, useSharedPolicies, isWarmup: true);
+
+            Console.WriteLine($"Running benchmark with {threads} threads for {durationSeconds} seconds...");
+
+            // Actual benchmark phase
+            var (totalEvaluations, evaluationTime, policyCounters, allocatedBytes) = RunBenchmarkPhase(threads, durationSeconds, policiesWithInputs, compiledPolicies, useSharedPolicies, isWarmup: false);
+
+            // Calculate throughput based on pure evaluation time (consistent with Rust benchmark)
+            var evalsPerSecond = totalEvaluations / evaluationTime.TotalSeconds;
+            var kelemsPerSecond = evalsPerSecond / 1000.0;
+
+            Console.WriteLine($"{groupName}/eval/{threads} threads");
+            Console.WriteLine($"                        time:   [{evaluationTime.TotalMilliseconds:F2} ms]");
+            Console.WriteLine($"                        thrpt:  [{kelemsPerSecond:F2} Kelem/s]");
+
+            if (totalEvaluations > 0)
+            {
+                var bytesPerEval = allocatedBytes / (double)totalEvaluations;
+                Console.WriteLine($"                        alloc:  [{bytesPerEval:F2} B/op] (total {allocatedBytes} B)");
+            }
+
+            // Clean up compiled policies if we created them
+            if (compiledPolicies != null)
+            {
+                foreach (var policy in compiledPolicies)
+                {
+                    DisposeCompiledPolicy(policy);
+                }
+            }
+
+            // Verify that all policies were evaluated
+            var allEvaluated = policyCounters.Values.All(count => count > 0);
+
+            if (allEvaluated)
+            {
+                Console.WriteLine("✓ All policies were evaluated successfully");
+            }
+            else
+            {
+                Console.WriteLine("ERROR: Some policies were never evaluated successfully!");
+            }
+        }
+
+        private static (int totalEvaluations, TimeSpan evaluationTime, Dictionary<string, int> policyCounters, long allocatedBytes) RunBenchmarkPhase(
+            int threads,
+            int durationSeconds,
+            List<(string Policy, string[] Inputs)> policiesWithInputs,
+            List<CompiledPolicy>? compiledPolicies,
+            bool useSharedPolicies,
+            bool isWarmup)
+        {
+            var barrier = new Barrier(threads);
+            var tasks = new Task[threads];
+            var policyCounters = new Dictionary<string, int>();
+            var evaluationTimes = new Dictionary<int, TimeSpan>();
+            var lockObject = new object();
+            var stopExecution = false;
+            long allocatedBytes = 0;
+
+            // Initialize counters
+            foreach (var policyName in PolicyNames)
+            {
+                policyCounters[policyName] = 0;
+            }
+
+            var stopwatch = Stopwatch.StartNew();
+
+            for (int threadId = 0; threadId < threads; threadId++)
+            {
+                int tid = threadId;
+                tasks[threadId] = Task.Run(() =>
+                {
+                    long allocationStart = 0;
+                    if (!isWarmup)
+                    {
+                        allocationStart = GC.GetAllocatedBytesForCurrentThread();
+                    }
+
+                    barrier.SignalAndWait();
+
+                    int evaluationCount = 0;
+                    var localEvaluationTime = TimeSpan.Zero;
+
+                    while (!stopExecution)
+                    {
+                        // Use different policy for each iteration
+                        int policyIdx = (tid + evaluationCount) % policiesWithInputs.Count;
+                        var (policy, inputs) = policiesWithInputs[policyIdx];
+
+                        // Use different input for the same policy based on iteration
+                        int inputIdx = evaluationCount % inputs.Length;
+                        var input = inputs[inputIdx];
+
+                        try
+                        {
+                            // Measure only the evaluation call
+                            var evalStopwatch = Stopwatch.StartNew();
+
+                            if (useSharedPolicies)
+                            {
+                                var result = compiledPolicies![policyIdx].EvalWithInput(input);
+                            }
+                            else
+                            {
+                                // Compile policy in each iteration.
+                                var modules = new[] { new PolicyModule("policy.rego", policy) };
+                                var compiled = Compiler.CompilePolicyWithEntrypoint("{}", modules, "data.bench.allow");
+                                try
+                                {
+                                    var result = compiled.EvalWithInput(input);
+                                }
+                                finally
+                                {
+                                    DisposeCompiledPolicy(compiled);
+                                }
+                            }
+
+                            evalStopwatch.Stop();
+                            localEvaluationTime += evalStopwatch.Elapsed;
+
+                            // Track successful evaluations (only during actual benchmark, not warmup)
+                            if (!isWarmup)
+                            {
+                                lock (lockObject)
+                                {
+                                    policyCounters[PolicyNames[policyIdx]]++;
+                                }
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            // Ignore evaluation errors for benchmarking purposes
+                        }
+
+                        evaluationCount++;
+                    }
+
+                    // Store the actual evaluation time for this thread
+                    if (!isWarmup)
+                    {
+                        lock (lockObject)
+                        {
+                            if (!evaluationTimes.ContainsKey(tid))
+                                evaluationTimes[tid] = TimeSpan.Zero;
+                            evaluationTimes[tid] = localEvaluationTime;
+                        }
+
+                        var allocationEnd = GC.GetAllocatedBytesForCurrentThread();
+                        System.Threading.Interlocked.Add(ref allocatedBytes, allocationEnd - allocationStart);
+                    }
+                });
+            }
+
+            // Stop execution after the specified duration
+            Task.Delay(TimeSpan.FromSeconds(durationSeconds)).ContinueWith(_ => stopExecution = true);
+
+            Task.WaitAll(tasks);
+            stopwatch.Stop();
+
+            var totalEvaluations = policyCounters.Values.Sum();
+            var totalEvaluationTime = evaluationTimes.Values.Aggregate(TimeSpan.Zero, (sum, time) => sum + time);
+
+            // Use pure evaluation time (consistent with Rust benchmark)
+            var evaluationTime = totalEvaluationTime == TimeSpan.Zero ? stopwatch.Elapsed : totalEvaluationTime;
+
+            return (totalEvaluations, evaluationTime, policyCounters, allocatedBytes);
+        }
+
+        private static void DisposeCompiledPolicy(CompiledPolicy policy)
+        {
+            try
+            {
+                policy.Dispose();
+            }
+            catch (TimeoutException ex)
+            {
+                Console.WriteLine($"Warning: {ex.Message}");
+            }
+        }
+    }
+}

bindings/csharp/Benchmarks/EngineEvaluationBenchmark.cs

@@ -0,0 +1,293 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Regorus;
+
+namespace Benchmarks
+{
+    public class EngineEvaluationBenchmark
+    {
+        private static readonly string TestDataPath = Path.Combine(
+            Directory.GetCurrentDirectory(),
+            "..", "..", "..",
+            "benches", "evaluation", "test_data"
+        );
+
+        private static readonly (string PolicyFile, string[] InputFiles)[] PolicyInputFiles = new[]
+        {
+            ("rbac_policy.rego", new[] { "rbac_input.json", "rbac_input2.json", "rbac_input3.json" }),
+            ("api_access_policy.rego", new[] { "api_access_input.json", "api_access_input2.json", "api_access_input3.json" }),
+            ("data_sensitivity_policy.rego", new[] { "data_sensitivity_input.json", "data_sensitivity_input2.json", "data_sensitivity_input3.json" }),
+            ("time_based_policy.rego", new[] { "time_based_input.json", "time_based_input2.json", "time_based_input3.json" }),
+            ("data_processing_policy.rego", new[] { "data_processing_input.json", "data_processing_input2.json", "data_processing_input3.json" }),
+            ("azure_vm_policy.rego", new[] { "azure_vm_input.json", "azure_vm_input2.json", "azure_vm_input3.json" }),
+            ("azure_storage_policy.rego", new[] { "azure_storage_input.json", "azure_storage_input2.json", "azure_storage_input3.json" }),
+            ("azure_keyvault_policy.rego", new[] { "azure_keyvault_input.json", "azure_keyvault_input2.json", "azure_keyvault_input3.json" }),
+            ("azure_nsg_policy.rego", new[] { "azure_nsg_input.json", "azure_nsg_input2.json", "azure_nsg_input3.json" })
+        };
+
+        private static readonly string[] PolicyNames = new[]
+        {
+            "rbac_policy",
+            "api_access_policy",
+            "data_sensitivity_policy",
+            "time_based_policy",
+            "data_processing_policy",
+            "azure_vm_policy",
+            "azure_storage_policy",
+            "azure_keyvault_policy",
+            "azure_nsg_policy"
+        };
+
+        private static List<(string Policy, string[] Inputs)> LoadPoliciesWithInputs()
+        {
+            var result = new List<(string Policy, string[] Inputs)>();
+
+            foreach (var (policyFile, inputFiles) in PolicyInputFiles)
+            {
+                var policyPath = Path.Combine(TestDataPath, "policies", policyFile);
+                var policy = File.ReadAllText(policyPath);
+
+                var inputs = inputFiles.Select(inputFile =>
+                {
+                    var inputPath = Path.Combine(TestDataPath, "inputs", inputFile);
+                    return File.ReadAllText(inputPath);
+                }).ToArray();
+
+                result.Add((policy, inputs));
+            }
+
+            return result;
+        }
+
+        private static List<Engine> PrepareClonedEngines()
+        {
+            var policiesWithInputs = LoadPoliciesWithInputs();
+            var engines = new List<Engine>();
+
+            foreach (var (policy, _) in policiesWithInputs)
+            {
+                var engine = new Engine();
+                engine.AddPolicy("policy.rego", policy);
+
+                // Warm up the engine to ensure it's fully prepared for evaluation
+                // This prevents each cloned engine from repeating preparation work
+                engine.SetInputJson("{}");
+                try
+                {
+                    engine.EvalRule("data.bench.allow");
+                }
+                catch
+                {
+                    // Ignore warmup errors
+                }
+
+                engines.Add(engine);
+            }
+
+            return engines;
+        }
+
+        public static void RunEngineEvaluationBenchmark()
+        {
+            var cpuCount = Environment.ProcessorCount;
+            var maxThreads = cpuCount * 2;
+            var threadCounts = new List<int> { 1, 2 };
+
+            // Add even numbers from 4 to maxThreads
+            for (int i = 4; i <= maxThreads; i += 2)
+            {
+                threadCounts.Add(i);
+            }
+
+            Console.WriteLine($"Running engine benchmark with max_threads: {maxThreads}");
+            Console.WriteLine($"Testing with thread counts: {string.Join(", ", threadCounts)}");
+            Console.WriteLine();
+
+            // Benchmark both cloned engines and fresh engines
+            var configurations = new[]
+            {
+                (true, "cloned_engines"),
+                (false, "fresh_engines")
+            };
+
+            foreach (var (useClonedEngines, groupName) in configurations)
+            {
+                Console.WriteLine($"=== {groupName} ===");
+
+                foreach (var threads in threadCounts)
+                {
+                    RunEngineEvaluationBenchmark(threads, useClonedEngines, groupName);
+                }
+                Console.WriteLine();
+            }
+        }
+
+        public static void RunEngineEvaluationBenchmark(int threads, bool useClonedEngines, string groupName)
+        {
+            const int warmupSeconds = 3;
+            const int durationSeconds = 3;
+            var policiesWithInputs = LoadPoliciesWithInputs();
+
+            Console.WriteLine($"Warming up with {threads} threads for {warmupSeconds} seconds...");
+
+            // Warmup phase
+            var (_, _, _) = RunBenchmarkPhase(threads, warmupSeconds, policiesWithInputs, useClonedEngines, isWarmup: true);
+
+            Console.WriteLine($"Running benchmark with {threads} threads for {durationSeconds} seconds...");
+
+            // Actual benchmark phase
+            var (totalEvaluations, evaluationTime, policyCounters) = RunBenchmarkPhase(threads, durationSeconds, policiesWithInputs, useClonedEngines, isWarmup: false);
+
+            // Calculate throughput based on pure evaluation time (consistent with Rust benchmark)
+            var evalsPerSecond = totalEvaluations / evaluationTime.TotalSeconds;
+            var kelemsPerSecond = evalsPerSecond / 1000.0;
+
+            Console.WriteLine($"{groupName}/eval/{threads} threads");
+            Console.WriteLine($"                        time:   [{evaluationTime.TotalMilliseconds:F2} ms]");
+            Console.WriteLine($"                        thrpt:  [{kelemsPerSecond:F2} Kelem/s]");
+
+            // Verify that all policies were evaluated
+            var allEvaluated = policyCounters.Values.All(count => count > 0);
+
+            if (allEvaluated)
+            {
+                Console.WriteLine("✓ All policies were evaluated successfully");
+            }
+            else
+            {
+                Console.WriteLine("ERROR: Some policies were never evaluated successfully!");
+            }
+        }
+
+        private static (int totalEvaluations, TimeSpan evaluationTime, Dictionary<string, int> policyCounters) RunBenchmarkPhase(
+            int threads,
+            int durationSeconds,
+            List<(string Policy, string[] Inputs)> policiesWithInputs,
+            bool useClonedEngines,
+            bool isWarmup)
+        {
+            var barrier = new Barrier(threads);
+            var tasks = new Task[threads];
+            var policyCounters = new Dictionary<string, int>();
+            var evaluationTimes = new Dictionary<int, TimeSpan>();
+            var lockObject = new object();
+            var stopExecution = false;
+
+            // Initialize counters
+            foreach (var policyName in PolicyNames)
+            {
+                policyCounters[policyName] = 0;
+            }
+
+            // Pre-create engines if using cloned engines
+            List<Engine>? clonedEngines = null;
+            if (useClonedEngines)
+            {
+                clonedEngines = PrepareClonedEngines();
+            }
+
+            var stopwatch = Stopwatch.StartNew();
+
+            for (int threadId = 0; threadId < threads; threadId++)
+            {
+                int tid = threadId;
+                tasks[threadId] = Task.Run(() =>
+                {
+                    barrier.SignalAndWait();
+
+                    int evaluationCount = 0;
+                    var localEvaluationTime = TimeSpan.Zero;
+
+                    while (!stopExecution)
+                    {
+                        // Use different policy for each iteration
+                        int policyIdx = (tid + evaluationCount) % policiesWithInputs.Count;
+                        var (policy, inputs) = policiesWithInputs[policyIdx];
+
+                        // Use different input for the same policy based on iteration
+                        int inputIdx = evaluationCount % inputs.Length;
+                        var input = inputs[inputIdx];
+
+                        try
+                        {
+                            // Measure only the engine operations
+                            var evalStopwatch = Stopwatch.StartNew();
+
+                            Engine engine;
+                            if (useClonedEngines)
+                            {
+                                engine = clonedEngines![policyIdx].Clone();
+                            }
+                            else
+                            {
+                                engine = new Engine();
+                                engine.AddPolicy("policy.rego", policy);
+                            }
+
+                            engine.SetInputJson(input);
+                            var result = engine.EvalRule("data.bench.allow");
+                            engine.Dispose();
+
+                            evalStopwatch.Stop();
+                            localEvaluationTime += evalStopwatch.Elapsed;
+
+                            // Track successful evaluations (only during actual benchmark, not warmup)
+                            if (!isWarmup)
+                            {
+                                lock (lockObject)
+                                {
+                                    policyCounters[PolicyNames[policyIdx]]++;
+                                }
+                            }
+                        }
+                        catch (Exception)
+                        {
+                            // Ignore evaluation errors for benchmarking purposes
+                        }
+
+                        evaluationCount++;
+                    }
+
+                    // Store the actual evaluation time for this thread
+                    if (!isWarmup)
+                    {
+                        lock (lockObject)
+                        {
+                            if (!evaluationTimes.ContainsKey(tid))
+                                evaluationTimes[tid] = TimeSpan.Zero;
+                            evaluationTimes[tid] = localEvaluationTime;
+                        }
+                    }
+                });
+            }
+
+            // Stop execution after the specified duration
+            Task.Delay(TimeSpan.FromSeconds(durationSeconds)).ContinueWith(_ => stopExecution = true);
+
+            Task.WaitAll(tasks);
+            stopwatch.Stop();
+
+            // Clean up cloned engines if we created them
+            if (clonedEngines != null)
+            {
+                foreach (var engine in clonedEngines)
+                {
+                    engine.Dispose();
+                }
+            }
+
+            var totalEvaluations = policyCounters.Values.Sum();
+            var totalEvaluationTime = evaluationTimes.Values.Aggregate(TimeSpan.Zero, (sum, time) => sum + time);
+
+            // Use pure evaluation time (consistent with Rust benchmark)
+            var evaluationTime = totalEvaluationTime == TimeSpan.Zero ? stopwatch.Elapsed : totalEvaluationTime;
+
+            return (totalEvaluations, evaluationTime, policyCounters);
+        }
+    }
+}

bindings/csharp/Benchmarks/Program.cs

@@ -0,0 +1,36 @@
+using System;
+
+namespace Benchmarks
+{
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            Console.WriteLine("=== Regorus C# Benchmarks ===\n");
+
+            try
+            {
+                Console.WriteLine("Running Engine Evaluation Benchmark...");
+                EngineEvaluationBenchmark.RunEngineEvaluationBenchmark();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Engine benchmark failed: {ex.Message}");
+            }
+
+            Console.WriteLine("\n" + new string('=', 80) + "\n");
+
+            try
+            {
+                Console.WriteLine("Running Compiled Policy Evaluation Benchmark...");
+                CompiledPolicyEvaluationBenchmark.RunCompiledPolicyEvaluationBenchmark();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Compiled policy benchmark failed: {ex.Message}");
+            }
+
+            Console.WriteLine("\n=== Benchmarks Complete ===");
+        }
+    }
+}

bindings/csharp/Benchmarks/compiled_policy_evaluation_benchmark.md

@@ -0,0 +1,140 @@
+# Compiled Policy Evaluation Benchmark Results (C#/.NET)
+
+## Test Environment
+- **Platform**: Apple Silicon (M-Series)
+- **CPU**: 16 cores
+- **Architecture**: ARM64 (aarch64-apple-darwin)
+- **.NET Version**: 8.0
+- **Allocator**: mimalloc (default allocator for Rust FFI)
+- **Benchmark Framework**: Custom time-based benchmarking
+- **Test Data**: 20,000 inputs per evaluation (distributed across threads)
+- **Policy**: Complex authorization policy with nested rules
+- **Warmup Duration**: 3 seconds per configuration
+- **Evaluation Duration**: 3 seconds per configuration
+
+## Benchmark Overview
+
+The C# compiled policy evaluation benchmark tests Regorus compiled policy performance across multiple thread configurations (1-32 threads). It measures throughput (thousands of evaluations per second) for different combinations of compiled policy compilation strategies.
+
+## Configuration Combinations
+
+1. **Compiled Shared Policies**: All threads share pre-compiled policy instances - optimal for performance
+2. **Compiled Per Iteration**: Each thread compiles the policy for each evaluation iteration
+
+*Note: The C# implementation uses a simpler configuration model compared to Rust, which also varies input data handling (cloned vs fresh inputs). The C# benchmarks focus on compilation strategies with consistent input handling.*
+
+## Performance Results
+
+### Compiled Shared Policies (Best Performance)
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                    2905.41 |                  273 |
+|       2 |                    5808.07 |                  240 |
+|       4 |                   11631.23 |                  227 |
+|       6 |                   17431.95 |                  216 |
+|       8 |                   23183.42 |                  126 |
+|      10 |                   28886.11 |                  118 |
+|      12 |                   34659.87 |                  108 |
+|      14 |                   40564.07 |                   84 |
+|      16 |                   46446.38 |                   72 |
+|      18 |                   52047.06 |                   63 |
+|      20 |                   56983.45 |                   58 |
+|      22 |                  404931.47 |                   55 |
+|      24 |                   61673.71 |                   55 |
+|      26 |                   64370.41 |                   51 |
+|      28 |                   56897.04 |                   59 |
+|      30 |                  406850.06 |                   52 |
+|      32 |                   56786.24 |                   58 |
+
+### Compiled Per Iteration
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                    2978.06 |                   49 |
+|       2 |                    5965.09 |                   47 |
+|       4 |                   11928.23 |                   46 |
+|       6 |                   17892.58 |                   45 |
+|       8 |                   23773.82 |                   43 |
+|      10 |                   29705.61 |                   42 |
+|      12 |                   35631.97 |                   40 |
+|      14 |                   41563.35 |                   34 |
+|      16 |                   47452.93 |                   31 |
+|      18 |                   53505.42 |                   27 |
+|      20 |                   59393.86 |                   25 |
+|      22 |                  436115.28 |                   23 |
+|      24 |                   71088.08 |                   21 |
+|      26 |                   76928.70 |                   19 |
+|      28 |                   82759.27 |                   18 |
+|      30 |                  560658.97 |                   17 |
+|      32 |                   93949.39 |                   16 |
+
+## Analysis
+
+The C# compiled policy benchmark demonstrates important performance characteristics with mimalloc as the default allocator:
+
+1. **Compilation Strategy Impact**: Shared compiled policies significantly outperform per-iteration compilation (~5.6x at 1 thread)
+2. **Scaling Patterns with mimalloc**: 
+   - Best throughput achieved at 1 thread for shared policies
+   - Performance generally degrades with increased thread count, but mimalloc provides better allocation efficiency
+3. **Performance Hierarchy**:
+   - Shared compiled policies: Best performance (optimal configuration)
+   - Per-iteration compilation: ~82% reduction from optimal
+4. **Compilation Overhead**: Per-iteration compilation creates substantial overhead, similar to fresh engine creation
+5. **Thread Contention**: Significant performance degradation beyond 8 threads for both configurations, though mimalloc helps mitigate some allocation-related issues
+
+## Comparison with Rust Compiled Policy Evaluation
+
+### Multi-Thread Performance Comparison
+
+| Configuration    | 1 Thread (Kelem/s) | 4 Threads (Kelem/s) | 8 Threads (Kelem/s) |
+|:-----------------|:-------------------|:--------------------|:--------------------|
+|                  | C# / Rust          | C# / Rust           | C# / Rust           |
+| Shared Policies  | 273 / 426          | 227 / 342           | 126 / 185           |
+| Per-iteration    | 49 / 55            | 46 / 50             | 43 / 50             |
+
+### Threading Efficiency Analysis
+
+| Configuration    | Low Contention (1-4t) | Medium Contention (6-12t) | High Contention (16+t) |
+|:-----------------|:----------------------|:--------------------------|:-----------------------|
+|                  | Avg C# / Rust         | Avg C# / Rust             | Avg C# / Rust          |
+| Shared Policies  | 249 / 384             | 150 / 203                 | 58 / 123               |
+| Per-iteration    | 47 / 54               | 40 / 50                   | 22 / 42                |
+
+**Key Observations:**
+- **Single-threaded performance**: C# achieves 64% of Rust performance for shared policies, 89% for per-iteration
+- **Threading scaling**: Both platforms show similar degradation patterns, but Rust maintains better absolute performance
+- **Contention resistance**: Per-iteration compilation shows more consistent relative performance across thread counts
+- **Platform differences**: C# shows more pronounced performance drops at higher thread counts, particularly for shared policies
+
+*Note: Rust benchmarks include additional input data variations (cloned vs fresh inputs) that are not present in the C# implementation.*
+
+## Comparison with C# Engine Evaluation
+
+### Multi-Thread Performance Comparison
+
+| Configuration   | 1 Thread (Kelem/s) | 4 Threads (Kelem/s) | 8 Threads (Kelem/s) |
+|:----------------|:-------------------|:--------------------|:--------------------|
+|                 | CP / EE            | CP / EE             | CP / EE             |
+| Shared Policies | 273 / 279          | 227 / 217           | 126 / 114           |
+| Per-iteration   | 49 / 50            | 46 / 47             | 43 / 45             |
+
+### Threading Efficiency Analysis
+
+| Configuration   | Low Contention (1-4t) | Medium Contention (6-12t) | High Contention (16+t) |
+|:----------------|:----------------------|:--------------------------|:-----------------------|
+|                 | Avg CP / EE           | Avg CP / EE               | Avg CP / EE            |
+| Shared Policies | 249 / 248             | 150 / 128                 | 58 / 54                |
+| Per-iteration   | 47 / 48               | 40 / 39                   | 22 / 27                |
+
+**Key Observations:**
+- **Single-threaded parity**: Both systems perform nearly identically at 1 thread
+- **Threading behavior**: Compiled policies slightly outperform engine evaluation at higher thread counts for shared policies
+- **Contention resistance**: Per-iteration configurations show very similar performance characteristics across all thread counts
+- **Platform consistency**: Both C# implementations show similar scaling patterns and contention behavior
+
+## Performance Insights
+
+1. **C# vs Rust Performance**: C# compiled policies achieve 65% average performance of Rust for shared policies, 87% average for per-iteration across low contention scenarios
+2. **Engine vs Compiled**: In C#, engine and compiled policy evaluation show very similar average performance (compiled policies achieve 100% of engine performance for shared policies, 98% for per-iteration)
+3. **mimalloc Impact**: The use of mimalloc as the default allocator in the underlying Rust FFI provides better memory allocation efficiency and improved threading characteristics
+4. **Threading Scaling**: Both C# configurations demonstrate similar contention patterns, with shared policies showing more pronounced degradation under high thread contention compared to per-iteration compilation
+

bindings/csharp/Benchmarks/engine_evaluation_benchmark.md

@@ -0,0 +1,118 @@
+# Engine Evaluation Benchmark Results (C#/.NET)
+
+## Test Environment
+- **Platform**: Apple Silicon (M-Series)
+- **CPU**: 16 cores
+- **Architecture**: ARM64 (aarch64-apple-darwin)
+- **.NET Version**: 8.0
+- **Allocator**: mimalloc (default allocator for Rust FFI)
+- **Benchmark Framework**: Custom time-based benchmarking
+- **Test Data**: 20,000 inputs per evaluation (distributed across threads)
+- **Policy**: Complex authorization policy with nested rules
+- **Warmup Duration**: 3 seconds per configuration
+- **Evaluation Duration**: 3 seconds per configuration
+
+## Benchmark Overview
+
+The C# engine evaluation benchmark tests Regorus policy evaluation performance across multiple thread configurations (1-32 threads). It measures throughput (thousands of evaluations per second) for different combinations of engine reuse strategies.
+
+## Configuration Combinations
+
+1. **Cloned Engines**: Each thread uses its own cloned engine instance - optimal for performance
+2. **Fresh Engines**: Each thread creates a new engine for each evaluation iteration
+
+*Note: The C# implementation uses a simpler configuration model compared to Rust, which also varies input data handling (cloned vs fresh inputs). The C# benchmarks focus on engine reuse strategies with consistent input handling.*
+
+## Performance Results
+
+### Cloned Engines (Best Performance)
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                    2903.43 |                  279 |
+|       2 |                    5808.35 |                  227 |
+|       4 |                   11645.08 |                  217 |
+|       6 |                   17469.69 |                  207 |
+|       8 |                   23268.07 |                  114 |
+|      10 |                   28996.14 |                  104 |
+|      12 |                   34808.60 |                   98 |
+|      14 |                   40703.21 |                   72 |
+|      16 |                   46488.23 |                   63 |
+|      18 |                   52078.52 |                   56 |
+|      20 |                   57014.31 |                   51 |
+|      22 |                   60482.22 |                   47 |
+|      24 |                   62445.67 |                   46 |
+|      26 |                   65128.74 |                   45 |
+|      28 |                   58001.92 |                   50 |
+|      30 |                   66154.78 |                   42 |
+|      32 |                   64999.03 |                   45 |
+
+### Fresh Engines
+| Threads | Total Evaluation Time (ms) | Throughput (Kelem/s) |
+|--------:|---------------------------:|---------------------:|
+|       1 |                    2982.28 |                   50 |
+|       2 |                    5962.62 |                   48 |
+|       4 |                   11917.94 |                   47 |
+|       6 |                   17874.77 |                   46 |
+|       8 |                   23729.94 |                   45 |
+|      10 |                   29635.17 |                   42 |
+|      12 |                   35574.71 |                   38 |
+|      14 |                   41482.61 |                   34 |
+|      16 |                   47425.16 |                   32 |
+|      18 |                   53248.87 |                   29 |
+|      20 |                   58424.34 |                   27 |
+|      22 |                   61302.24 |                   26 |
+|      24 |                   67430.08 |                   23 |
+|      26 |                   65226.79 |                   24 |
+|      28 |                   73118.48 |                   22 |
+|      30 |                  326472.94 |                   23 |
+|      32 |                   63805.03 |                   24 |
+
+## Analysis
+
+The C# benchmark results demonstrate important performance characteristics with mimalloc as the default allocator:
+
+1. **Engine Reuse Impact**: Cloned engines significantly outperform fresh engines (~5.6x at 1 thread)
+2. **Scaling Patterns with mimalloc**: 
+   - Best throughput achieved at 1 thread for both configurations
+   - Performance degrades with increased thread count due to contention, but mimalloc provides better allocation efficiency
+   - Cloned engines show better relative scaling characteristics
+3. **Performance Hierarchy**: 
+   - Cloned engines: Best performance (optimal configuration)
+   - Fresh engines: ~82% reduction from optimal
+4. **Thread Contention**: Significant performance drop beyond 8 threads, especially for fresh engines, though mimalloc helps mitigate some allocation-related issues
+5. **C# vs Rust Performance**: C# shows ~66% of Rust performance for equivalent cloned engine configuration
+
+## Comparison with Rust Engine Evaluation
+
+### Multi-Thread Performance Comparison
+
+| Configuration  | 1 Thread (Kelem/s) | 4 Threads (Kelem/s) | 8 Threads (Kelem/s) |
+|:---------------|:-------------------|:--------------------|:--------------------|
+|                | C# / Rust          | C# / Rust           | C# / Rust           |
+| Cloned Engines | 279 / 423          | 217 / 406           | 114 / 341           |
+| Fresh Engines  | 50 / 56            | 47 / 54             | 45 / 53             |
+
+### Threading Efficiency Analysis
+
+| Configuration  | Low Contention (1-4t) | Medium Contention (6-12t) | High Contention (16+t) |
+|:---------------|:----------------------|:--------------------------|:-----------------------|
+|                | Avg C# / Rust         | Avg C# / Rust             | Avg C# / Rust          |
+| Cloned Engines | 253 / 414             | 128 / 329                 | 54 / 250               |
+| Fresh Engines  | 48 / 55               | 39 / 52                   | 27 / 42                |
+
+**Key Observations:**
+- **Single-threaded performance**: C# achieves 66% of Rust performance for cloned engines, 89% for fresh engines
+- **Threading scaling**: Both platforms show similar degradation patterns, but Rust maintains better absolute performance
+- **Contention resistance**: Fresh engines show more consistent relative performance across thread counts
+- **Platform differences**: C# shows more pronounced performance drops at higher thread counts, particularly for cloned engines
+
+*Note: Rust benchmarks include additional input data variations (cloned vs fresh inputs) that are not present in the C# implementation.*
+
+## Performance Insights
+
+1. **Engine Creation Overhead**: Fresh engine creation has significant performance impact in C# (~5.6x slower than cloned engines)
+2. **Thread Scaling**: C# shows moderate thread contention with better characteristics when using mimalloc
+3. **Memory Management**: .NET garbage collection patterns combined with mimalloc allocation efficiency
+4. **Interop Performance**: C# bindings achieve 66% of Rust performance for cloned engines, demonstrating effective FFI implementation
+5. **mimalloc Benefits**: The use of mimalloc as the default allocator in the underlying Rust FFI provides improved memory allocation efficiency and better threading characteristics
+

bindings/csharp/Directory.Packages.props

@@ -0,0 +1,14 @@
+<Project>
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+    <RegorusPackageVersion>0.9.1</RegorusPackageVersion>
+    <RegorusPackageVersionSuffix Condition="'$(VersionSuffix)' != ''">-$(VersionSuffix)</RegorusPackageVersionSuffix>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- Centralize Regorus package version with optional CI suffix -->
+    <PackageVersion Include="Regorus" Version="$(RegorusPackageVersion)$(RegorusPackageVersionSuffix)" />
+    <PackageVersion Include="MSTest" Version="3.8.2" />
+    <PackageVersion Include="System.Text.Json" Version="8.0.5" />
+  </ItemGroup>
+</Project>

bindings/csharp/Program.cs

@@ -1,51 +0,0 @@
-using System.Diagnostics;
-
-long nanosecPerTick = (1000L*1000L*1000L) / Stopwatch.Frequency;
-var w = new Stopwatch();
-
-
-// Force load of modules.
-{
-    var _e = new Regorus.Engine();
-    var _j = System.Text.Json.JsonDocument.Parse("{}");
-}
-
-w.Restart();
-
-var engine = new Regorus.Engine();
-
-w.Stop();
-var newEngineTicks = w.ElapsedTicks;
-
-
-w.Restart();
-
-// Load policies and data.
-engine.AddPolicyFromFile("../../tests/aci/framework.rego");
-engine.AddPolicyFromFile("../../tests/aci/api.rego");
-engine.AddPolicyFromFile("../../tests/aci/policy.rego");
-engine.AddDataFromJsonFile("../../tests/aci/data.json");
-
-
-w.Stop();
-var loadPoliciesTicks = w.ElapsedTicks;
-
-
-w.Restart();
-
-// Set input and eval query.
-engine.SetInputFromJsonFile("../../tests/aci/input.json");
-var results = engine.EvalQuery("data.framework.mount_overlay = x");
-var resultsDoc = System.Text.Json.JsonDocument.Parse(results);
-
-w.Stop();
-var evalTicks = w.ElapsedTicks;
-
-Console.WriteLine("{0}", results);
-
-
-Console.WriteLine("Engine creation took {0} msecs", (newEngineTicks*nanosecPerTick)/(1000.0*1000.0));
-Console.WriteLine("Load policies and data took {0} msecs", (loadPoliciesTicks*nanosecPerTick)/(1000.0*1000.0));
-Console.WriteLine("EvalQuery took {0} msecs", (evalTicks*nanosecPerTick)/(1000.0*1000.0));
-
-

bindings/csharp/README.md

@@ -0,0 +1,106 @@
+# Regorus CSharp
+
+**Regorus** is
+
+  - *Rego*-*Rus(t)*  - A fast, light-weight [Rego](https://www.openpolicyagent.org/docs/latest/policy-language/)
+   interpreter written in Rust.
+  - *Rigorous* - A rigorous enforcer of well-defined Rego semantics.
+
+See main [Regorus page](https://github.com/microsoft/regorus) for more details about the project.
+
+# Building
+
+## Github Actions
+
+The simplest way to build a Nuget for Regorus' C# bindings is to use Github Actions. The action to do so is named `bindings/csharp` and is defined in `.github/workflows/test-csharp.yml`.
+
+There are two ways to trigger a Nuget build.
+1. Runs are triggered automatically whenever a push or pull request is made to the `main` branch.
+2. A run can be triggered manually by navigating to the action in the Github UI and clicking `Run workflow`. This option allows you to generate a Nuget for any branch, which is useful when testing the integration of in-progress changes to Regorus with other projects. Nuget files that are generated via this flow will have a `manualtrigger` suffix appended to their version number, making it easy to distinguish them from Nugets generated using the `main` branch.
+![Image displaying the run workflow button](docs/images/readme/manuallytriggeringrun.png)
+
+Once the workflow run completes, the generated Nuget can be downloaded by following these steps:
+1. Open the run.
+2. Click on `Build Regorus nuget` on the left.
+3. Expand the `Upload Regorus nuget` step.
+4. Click the `Artifact download URL` link at the bottom.
+5. Save and extract the downloaded zip file to find the `.nupkg` file.
+![Image displaying the download URL link](docs/images/readme/downloadnuget.png)
+
+## Local
+
+The `cargo xtask` runner provides helpers for local builds:
+
+1. `cargo xtask ffi` builds the `bindings/ffi` crate for the host platform in debug mode. Add `--target <triple>` (repeatable) to cross-compile, or `--release` to produce optimised artefacts. Results land under `bindings/ffi/target/<triple>/<profile>`.
+2. `cargo xtask nuget` reuses those artefacts to pack the C# library. It defaults to debug builds for the host but accepts `--target`, `--release`, `--artifacts-dir <path>` to reuse existing binaries, and `--enforce-artifacts` to require every officially supported platform.
+3. `cargo xtask test-csharp` ensures a NuGet is available (rebuilding when required or when `--force-nuget` is passed) and then runs `Regorus.Tests`, `TestApp`, and `TargetExampleApp` against it. The command accepts the same build flags as `cargo xtask nuget`.
+
+## Memory Usage Safeguards
+
+The C# bindings expose allocator-backed memory tracking utilities via the static `Regorus.MemoryLimits` helper. Typical usage:
+
+```csharp
+// Restrict total allocations to 128 MiB for the process
+Regorus.MemoryLimits.SetGlobalMemoryLimit(128 * 1024 * 1024);
+
+// Optional: tune how frequently each thread flushes its allocation counters
+Regorus.MemoryLimits.SetThreadFlushThresholdOverride(256 * 1024);
+
+// Engine operations throw InvalidOperationException with the allocator message if the budget is exceeded
+using var engine = new Regorus.Engine();
+var veryLargeJson = new string('x', 128 * 1024);
+try
+{
+    engine.SetInputJson(veryLargeJson);
+}
+catch (InvalidOperationException ex)
+{
+    Console.WriteLine($"Allocator reported: {ex.Message}");
+}
+
+// Restore defaults once done
+Regorus.MemoryLimits.SetGlobalMemoryLimit(null);
+Regorus.MemoryLimits.SetThreadFlushThresholdOverride(null);
+```
+
+See bindings/csharp/Regorus.Tests/RegorusTests.cs for scenario coverage and bindings/csharp/TargetExampleApp/Program.cs for end-to-end usage.
+
+## RVM Usage Example
+
+The RVM API lets you compile a program from modules/entrypoints and execute it in a VM:
+
+```csharp
+using Regorus;
+
+const string Policy = """
+package demo
+default allow = false
+allow if {
+  input.user == "alice"
+  some role in data.roles[input.user]
+  role == "admin"
+}
+""";
+
+const string Data = """
+{ "roles": { "alice": ["admin"] } }
+""";
+
+const string Input = """
+{ "user": "alice" }
+""";
+
+var modules = new[] { new PolicyModule("demo.rego", Policy) };
+var entryPoints = new[] { "data.demo.allow" };
+
+using var program = Program.CompileFromModules(Data, modules, entryPoints);
+var listing = program.GenerateListing();
+
+using var vm = new Rvm();
+vm.LoadProgram(program);
+vm.SetDataJson(Data);
+vm.SetInputJson(Input);
+
+var result = vm.Execute();
+Console.WriteLine($"allow: {result}");
+```

bindings/csharp/Regorus.Tests/ExecutionTimerTests.cs

@@ -0,0 +1,131 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Linq;
+using System.Text.Json;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Regorus;
+
+namespace Regorus.Tests;
+
+[DoNotParallelize] // Uses global fallback config; must run sequentially.
+[TestClass]
+public class ExecutionTimerTests
+{
+    private const string Policy = @"
+package limits.timer
+import rego.v1
+
+triplet_count := count([1 |
+  x := data.values[_]
+  y := data.values[_]
+  z := data.values[_]
+])
+";
+
+    private const string Query = "data.limits.timer.triplet_count";
+    private const int ValueCount = 160;
+
+    [TestMethod]
+    public void Engine_limit_enforced()
+    {
+        Engine.ClearFallbackExecutionTimerConfig();
+        using var engine = CreateEngine(ValueCount);
+        var config = new ExecutionTimerConfig(TimeSpan.FromMilliseconds(2), checkInterval: 1);
+        engine.SetExecutionTimerConfig(config);
+
+        var ex = Assert.ThrowsException<InvalidOperationException>(() => engine.EvalRule(Query));
+        StringAssert.Contains(ex.Message, "execution exceeded time limit");
+    }
+
+    [TestMethod]
+    public void Fallback_applies_to_new_engines()
+    {
+        var fallback = new ExecutionTimerConfig(TimeSpan.FromMilliseconds(2), checkInterval: 1);
+        Engine.SetFallbackExecutionTimerConfig(fallback);
+        try
+        {
+            using var engine = CreateEngine(ValueCount);
+            var ex = Assert.ThrowsException<InvalidOperationException>(() => engine.EvalRule(Query));
+            StringAssert.Contains(ex.Message, "execution exceeded time limit");
+        }
+        finally
+        {
+            Engine.ClearFallbackExecutionTimerConfig();
+        }
+    }
+
+    [TestMethod]
+    public void Engine_override_relaxes_fallback()
+    {
+        var fallback = new ExecutionTimerConfig(TimeSpan.FromMilliseconds(2), checkInterval: 1);
+        Engine.SetFallbackExecutionTimerConfig(fallback);
+        try
+        {
+            using var engine = CreateEngine(ValueCount);
+            var relaxed = new ExecutionTimerConfig(TimeSpan.FromSeconds(12), checkInterval: 1);
+            engine.SetExecutionTimerConfig(relaxed);
+
+            var resultJson = engine.EvalRule(Query);
+            var result = JsonSerializer.Deserialize<int>(resultJson!);
+            Assert.IsTrue(result > 0, "Expected a positive triplet count when limit is relaxed.");
+
+            engine.ClearExecutionTimerConfig();
+            var ex = Assert.ThrowsException<InvalidOperationException>(() => engine.EvalRule(Query));
+            StringAssert.Contains(ex.Message, "execution exceeded time limit");
+        }
+        finally
+        {
+            Engine.ClearFallbackExecutionTimerConfig();
+        }
+    }
+
+    [TestMethod]
+    public void CompiledPolicy_limit_enforced()
+    {
+        var fallback = new ExecutionTimerConfig(TimeSpan.FromMilliseconds(2), checkInterval: 1);
+        Engine.SetFallbackExecutionTimerConfig(fallback);
+        try
+        {
+            using var policy = CreateCompiledPolicy(ValueCount);
+            var ex = Assert.ThrowsException<InvalidOperationException>(() => policy.EvalWithInput("null"));
+            StringAssert.Contains(ex.Message, "execution exceeded time limit");
+        }
+        finally
+        {
+            Engine.ClearFallbackExecutionTimerConfig();
+        }
+    }
+
+    [TestMethod]
+    public void CompiledPolicy_uses_engine_limits_only()
+    {
+        // Compiled policies no longer store per-policy execution timers; limits are managed by Engine.
+        Engine.ClearFallbackExecutionTimerConfig();
+        using var policy = CreateCompiledPolicy(ValueCount);
+        var resultJson = policy.EvalWithInput("null");
+        var result = JsonSerializer.Deserialize<int>(resultJson!);
+        Assert.IsTrue(result > 0, "CompiledPolicy should evaluate using engine defaults without its own timer");
+    }
+
+    private static Engine CreateEngine(int valueCount)
+    {
+        var engine = new Engine();
+        engine.AddPolicy("limits_timer.rego", Policy);
+        engine.AddDataJson(CreateData(valueCount));
+        return engine;
+    }
+
+    private static CompiledPolicy CreateCompiledPolicy(int valueCount)
+    {
+        var modules = new[] { new PolicyModule("limits_timer.rego", Policy) };
+        return Compiler.CompilePolicyWithEntrypoint(CreateData(valueCount), modules, Query);
+    }
+
+    private static string CreateData(int valueCount)
+    {
+        var payload = new { values = Enumerable.Range(0, valueCount).ToArray() };
+        return JsonSerializer.Serialize(payload);
+    }
+}

bindings/csharp/Regorus.Tests/MemoryGrowthTests.cs

@@ -0,0 +1,320 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Diagnostics;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Regorus;
+
+namespace Regorus.Tests;
+
+[TestClass]
+[DoNotParallelize]
+public class MemoryGrowthTests
+{
+    private static int Iterations =>
+        int.TryParse(Environment.GetEnvironmentVariable("REGORUS_MEMORY_TEST_ITERS"), out var value) ? value : 50_000;
+
+    private static int LogEvery =>
+        int.TryParse(Environment.GetEnvironmentVariable("REGORUS_MEMORY_TEST_LOG_EVERY"), out var value) ? value : 500;
+
+    private static int GcEvery
+    {
+        get
+        {
+            if (!int.TryParse(Environment.GetEnvironmentVariable("REGORUS_MEMORY_TEST_GC_EVERY"), out var value))
+            {
+                value = LogEvery;
+            }
+
+            return value <= 0 ? LogEvery : value;
+        }
+    }
+
+    private static long? MaxWorkingSetDeltaBytes
+    {
+        get
+        {
+            if (!long.TryParse(Environment.GetEnvironmentVariable("REGORUS_MEMORY_TEST_MAX_DELTA_MB"), out var mb))
+            {
+                mb = 32;
+            }
+
+            if (mb <= 0)
+            {
+                return null;
+            }
+
+            return mb * 1024L * 1024L;
+        }
+    }
+
+    private static ulong? GlobalRegorusMemoryLimitBytes
+    {
+        get
+        {
+            if (!ulong.TryParse(Environment.GetEnvironmentVariable("REGORUS_MEMORY_TEST_GLOBAL_REGORUS_LIMIT_MB"), out var mb))
+            {
+                return null;
+            }
+
+            if (mb == 0)
+            {
+                return null;
+            }
+
+            return mb * 1024UL * 1024UL;
+        }
+    }
+
+    private static void WithOptionalGlobalRegorusMemoryLimit(Action action)
+    {
+        var priorLimit = MemoryLimits.GetGlobalMemoryLimit();
+        try
+        {
+            if (GlobalRegorusMemoryLimitBytes is { } limit)
+            {
+                MemoryLimits.SetGlobalMemoryLimit(limit);
+            }
+
+            action();
+        }
+        finally
+        {
+            MemoryLimits.SetGlobalMemoryLimit(priorLimit);
+        }
+    }
+
+    private static void ForceFullGc()
+    {
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+    }
+
+
+    [TestMethod]
+    public void Engine_create_eval_dispose_does_not_grow_working_set()
+    {
+        WithOptionalGlobalRegorusMemoryLimit(() =>
+        {
+            var process = Process.GetCurrentProcess();
+            process.Refresh();
+            var baseline = process.WorkingSet64;
+            var maxDelta = 0L;
+            var baselineManaged = GC.GetTotalMemory(false);
+            var maxManagedDelta = 0L;
+
+            for (var i = 1; i <= Iterations; i++)
+            {
+                using (var engine = new Engine())
+                {
+                    engine.AddPolicy("test.rego", "package test\nx = 1\nmessage = `Hello`");
+                    _ = engine.EvalRule("data.test.message");
+                }
+
+                if (i % LogEvery == 0)
+                {
+                    process.Refresh();
+                    var workingSet = process.WorkingSet64;
+                    var managed = GC.GetTotalMemory(false);
+                    var delta = workingSet - baseline;
+                    var managedDelta = managed - baselineManaged;
+                    if (delta > maxDelta)
+                    {
+                        maxDelta = delta;
+                    }
+                    if (managedDelta > maxManagedDelta)
+                    {
+                        maxManagedDelta = managedDelta;
+                    }
+                    Console.WriteLine($"\n\n\u001b[1m{i} ws_mb={workingSet / 1048576.0:F1} managed_mb={managed / 1048576.0:F1} delta_mb={delta / 1048576.0:F1}\u001b[0m\n\n");
+                }
+            }
+
+            if (MaxWorkingSetDeltaBytes is { } limit)
+            {
+                Console.WriteLine($"\n\n\u001b[1mSUMMARY: max ws delta {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB); max managed delta {maxManagedDelta / 1048576.0:F1} MB.\u001b[0m\n\n");
+                Assert.IsTrue(
+                    maxDelta <= limit,
+                    $"Working set grew by {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB). Managed heap max delta {maxManagedDelta / 1048576.0:F1} MB.");
+            }
+        });
+    }
+
+    [TestMethod]
+    public void Engine_create_eval_finalize_does_not_grow_working_set()
+    {
+        WithOptionalGlobalRegorusMemoryLimit(() =>
+        {
+            var process = Process.GetCurrentProcess();
+            process.Refresh();
+            var baseline = process.WorkingSet64;
+            var maxDelta = 0L;
+            var baselineManaged = GC.GetTotalMemory(false);
+            var maxManagedDelta = 0L;
+
+            for (var i = 1; i <= Iterations; i++)
+            {
+                var engine = new Engine();
+                engine.AddPolicy("test.rego", "package test\nx = 1\nmessage = `Hello`");
+                _ = engine.EvalRule("data.test.message");
+
+                if (i % GcEvery == 0)
+                {
+                    ForceFullGc();
+                }
+
+                if (i % LogEvery == 0)
+                {
+                    process.Refresh();
+                    var workingSet = process.WorkingSet64;
+                    var managed = GC.GetTotalMemory(false);
+                    var delta = workingSet - baseline;
+                    var managedDelta = managed - baselineManaged;
+                    if (delta > maxDelta)
+                    {
+                        maxDelta = delta;
+                    }
+                    if (managedDelta > maxManagedDelta)
+                    {
+                        maxManagedDelta = managedDelta;
+                    }
+                    Console.WriteLine($"\n\n\u001b[1m{i} ws_mb={workingSet / 1048576.0:F1} managed_mb={managed / 1048576.0:F1} delta_mb={delta / 1048576.0:F1}\u001b[0m\n\n");
+                }
+            }
+
+            if (MaxWorkingSetDeltaBytes is { } limit)
+            {
+                Console.WriteLine($"\n\n\u001b[1mSUMMARY: max ws delta {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB); max managed delta {maxManagedDelta / 1048576.0:F1} MB.\u001b[0m\n\n");
+                Assert.IsTrue(
+                    maxDelta <= limit,
+                    $"Working set grew by {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB). Managed heap max delta {maxManagedDelta / 1048576.0:F1} MB.");
+            }
+        });
+    }
+
+
+    [TestMethod]
+    public void Rvm_rehydrate_execute_dispose_does_not_grow_working_set()
+    {
+        WithOptionalGlobalRegorusMemoryLimit(() =>
+        {
+            var modules = new[]
+            {
+                new PolicyModule("test.rego", "package test\nallow = true"),
+            };
+
+            using var compiled = Program.CompileFromModules("{}", modules, new[] { "data.test.allow" });
+            var serialized = compiled.SerializeBinary();
+
+            var process = Process.GetCurrentProcess();
+            process.Refresh();
+            var baseline = process.WorkingSet64;
+            var maxDelta = 0L;
+            var baselineManaged = GC.GetTotalMemory(false);
+            var maxManagedDelta = 0L;
+
+            for (var i = 1; i <= Iterations; i++)
+            {
+                using (var vm = new Rvm())
+                using (var program = Program.DeserializeBinary(serialized, out _))
+                {
+                    vm.LoadProgram(program);
+                    vm.SetDataJson("{}");
+                    vm.SetInputJson("{}");
+                    _ = vm.ExecuteEntryPoint(0);
+                }
+
+                if (i % LogEvery == 0)
+                {
+                    process.Refresh();
+                    var workingSet = process.WorkingSet64;
+                    var managed = GC.GetTotalMemory(false);
+                    var delta = workingSet - baseline;
+                    var managedDelta = managed - baselineManaged;
+                    if (delta > maxDelta)
+                    {
+                        maxDelta = delta;
+                    }
+                    if (managedDelta > maxManagedDelta)
+                    {
+                        maxManagedDelta = managedDelta;
+                    }
+                    Console.WriteLine($"\n\n\u001b[1m{i} ws_mb={workingSet / 1048576.0:F1} managed_mb={managed / 1048576.0:F1} delta_mb={delta / 1048576.0:F1}\u001b[0m\n\n");
+                }
+            }
+
+            if (MaxWorkingSetDeltaBytes is { } limit)
+            {
+                Console.WriteLine($"\n\n\u001b[1mSUMMARY: max ws delta {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB); max managed delta {maxManagedDelta / 1048576.0:F1} MB.\u001b[0m\n\n");
+                Assert.IsTrue(
+                    maxDelta <= limit,
+                    $"Working set grew by {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB). Managed heap max delta {maxManagedDelta / 1048576.0:F1} MB.");
+            }
+        });
+    }
+
+    [TestMethod]
+    public void Rvm_rehydrate_execute_finalize_does_not_grow_working_set()
+    {
+        WithOptionalGlobalRegorusMemoryLimit(() =>
+        {
+            var modules = new[]
+            {
+                new PolicyModule("test.rego", "package test\nallow = true"),
+            };
+
+            using var compiled = Program.CompileFromModules("{}", modules, new[] { "data.test.allow" });
+            var serialized = compiled.SerializeBinary();
+
+            var process = Process.GetCurrentProcess();
+            process.Refresh();
+            var baseline = process.WorkingSet64;
+            var maxDelta = 0L;
+            var baselineManaged = GC.GetTotalMemory(false);
+            var maxManagedDelta = 0L;
+
+            for (var i = 1; i <= Iterations; i++)
+            {
+                var vm = new Rvm();
+                var program = Program.DeserializeBinary(serialized, out _);
+                vm.LoadProgram(program);
+                vm.SetDataJson("{}");
+                vm.SetInputJson("{}");
+                _ = vm.ExecuteEntryPoint(0);
+
+                if (i % GcEvery == 0)
+                {
+                    ForceFullGc();
+                }
+
+                if (i % LogEvery == 0)
+                {
+                    process.Refresh();
+                    var workingSet = process.WorkingSet64;
+                    var managed = GC.GetTotalMemory(false);
+                    var delta = workingSet - baseline;
+                    var managedDelta = managed - baselineManaged;
+                    if (delta > maxDelta)
+                    {
+                        maxDelta = delta;
+                    }
+                    if (managedDelta > maxManagedDelta)
+                    {
+                        maxManagedDelta = managedDelta;
+                    }
+                    Console.WriteLine($"\n\n\u001b[1m{i} ws_mb={workingSet / 1048576.0:F1} managed_mb={managed / 1048576.0:F1} delta_mb={delta / 1048576.0:F1}\u001b[0m\n\n");
+                }
+            }
+
+            if (MaxWorkingSetDeltaBytes is { } limit)
+            {
+                Console.WriteLine($"\n\n\u001b[1mSUMMARY: max ws delta {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB); max managed delta {maxManagedDelta / 1048576.0:F1} MB.\u001b[0m\n\n");
+                Assert.IsTrue(
+                    maxDelta <= limit,
+                    $"Working set grew by {maxDelta / 1048576.0:F1} MB (limit {limit / 1048576.0:F1} MB). Managed heap max delta {maxManagedDelta / 1048576.0:F1} MB.");
+            }
+        });
+    }
+}

bindings/csharp/Regorus.Tests/PanicGuardTests.cs

@@ -0,0 +1,84 @@
+#if REGORUS_FFI_TEST_HOOKS
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Runtime.InteropServices;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Regorus.Internal;
+
+namespace Regorus.Tests;
+
+[TestClass]
+public sealed class PanicGuardTests
+{
+    [TestInitialize]
+    public void Initialize()
+    {
+        API.regorus_engine_test_reset_poison();
+    }
+
+    [TestCleanup]
+    public void Cleanup()
+    {
+        API.regorus_engine_test_reset_poison();
+    }
+
+    [TestMethod]
+    public void Panic_produces_invalid_operation_exception()
+    {
+        var panic = Assert.ThrowsException<InvalidOperationException>(TriggerPanic);
+        StringAssert.Contains(panic.Message, "panicked", "panic message should capture payload");
+    }
+
+    [TestMethod]
+    public void Poison_flag_blocks_subsequent_calls()
+    {
+        _ = Assert.ThrowsException<InvalidOperationException>(TriggerPanic);
+        var poisoned = Assert.ThrowsException<InvalidOperationException>(TriggerPanic);
+        StringAssert.Contains(poisoned.Message, "poisoned", "poisoned message should explain guard state");
+    }
+
+    private static unsafe void TriggerPanic()
+    {
+        var result = API.regorus_engine_test_trigger_panic();
+        try
+        {
+            if (result.status == RegorusStatus.Ok)
+            {
+                return;
+            }
+
+            var message = PtrToStringUtf8((IntPtr)result.error_message);
+            throw result.status.CreateException(message);
+        }
+        finally
+        {
+            API.regorus_result_drop(result);
+        }
+    }
+
+    private static string? PtrToStringUtf8(IntPtr ptr)
+    {
+#if NETSTANDARD2_1
+        return Marshal.PtrToStringUTF8(ptr);
+#else
+        if (ptr == IntPtr.Zero)
+        {
+            return null;
+        }
+
+        var len = 0;
+        while (Marshal.ReadByte(ptr, len) != 0)
+        {
+            len++;
+        }
+
+        var buffer = new byte[len];
+        Marshal.Copy(ptr, buffer, 0, buffer.Length);
+        return System.Text.Encoding.UTF8.GetString(buffer);
+#endif
+    }
+}
+
+#endif

bindings/csharp/Regorus.Tests/Regorus.Tests.csproj

@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <Nullable>Enable</Nullable>
+    <TargetFramework>net8.0</TargetFramework>
+    <EnableMSTestRunner>true</EnableMSTestRunner>
+    <!-- More info about dotnet test integration https://learn.microsoft.com/dotnet/core/testing/unit-testing-platform-integration-dotnet-test -->
+    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
+    <TestingPlatformShowTestsFailure>true</TestingPlatformShowTestsFailure>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  
+  <PropertyGroup>
+    <!-- If the environment variable is set (such as in a Github Action run), append the suffix to the version number -->
+    <RegorusPackageVersionSuffix Condition="'$(VersionSuffix)' != ''">-$(VersionSuffix)</RegorusPackageVersionSuffix>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Include="../../../tests/**/*.*" Link="tests/%(RecursiveDir)%(Filename)%(Extension)" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="MSTest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Regorus" />
+  </ItemGroup>
+</Project>

bindings/csharp/Regorus.Tests/RegorusTests.cs

@@ -0,0 +1,468 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Regorus;
+
+namespace Regorus.Tests;
+
+[TestClass]
+public class RegorusTests
+{
+    private static readonly object LimitLock = new();
+
+    [TestMethod]
+    public void Basic_evaluation_succeeds()
+    {
+        using var engine = new Engine();
+        engine.AddPolicy(
+            "test.rego",
+            "package test\nx = 1\nmessage = `Hello`");
+
+        var result = engine.EvalRule("data.test.message");
+
+        Assert.AreEqual("\"Hello\"", result);
+    }
+
+    [TestMethod]
+    public void Evaluation_using_file_policies_succeeds()
+    {
+        using var engine = new Engine();
+        engine.SetRegoV0(true);
+
+        // Load policies and data.
+        engine.AddPolicyFromFile("tests/aci/framework.rego");
+        engine.AddPolicyFromFile("tests/aci/api.rego");
+        engine.AddPolicyFromFile("tests/aci/policy.rego");
+        engine.AddDataFromJsonFile("tests/aci/data.json");
+
+        // Set input and eval rule.
+        engine.SetInputFromJsonFile("tests/aci/input.json");
+        var result = engine.EvalRule("data.framework.mount_overlay");
+
+        var expected = """
+{
+  "allowed": true,
+  "metadata": [
+    {
+      "action": "add",
+      "key": "container0",
+      "name": "matches",
+      "value": [
+        {
+          "allow_elevated": true,
+          "allow_stdio_access": false,
+          "capabilities": {
+            "ambient": [
+              "CAP_SYS_ADMIN"
+            ],
+            "bounding": [
+              "CAP_SYS_ADMIN"
+            ],
+            "effective": [
+              "CAP_SYS_ADMIN"
+            ],
+            "inheritable": [
+              "CAP_SYS_ADMIN"
+            ],
+            "permitted": [
+              "CAP_SYS_ADMIN"
+            ]
+          },
+          "command": [
+            "rustc",
+            "--help"
+          ],
+          "env_rules": [
+            {
+              "pattern": "PATH=/usr/local/cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+              "required": true,
+              "strategy": "string"
+            },
+            {
+              "pattern": "RUSTUP_HOME=/usr/local/rustup",
+              "required": true,
+              "strategy": "string"
+            },
+            {
+              "pattern": "CARGO_HOME=/usr/local/cargo",
+              "required": true,
+              "strategy": "string"
+            },
+            {
+              "pattern": "RUST_VERSION=1.52.1",
+              "required": true,
+              "strategy": "string"
+            },
+            {
+              "pattern": "TERM=xterm",
+              "required": false,
+              "strategy": "string"
+            },
+            {
+              "pattern": "PREFIX_.+=.+",
+              "required": false,
+              "strategy": "re2"
+            }
+          ],
+          "exec_processes": [
+            {
+              "command": [
+                "top"
+              ],
+              "signals": []
+            }
+          ],
+          "layers": [
+            "fe84c9d5bfddd07a2624d00333cf13c1a9c941f3a261f13ead44fc6a93bc0e7a",
+            "4dedae42847c704da891a28c25d32201a1ae440bce2aecccfa8e6f03b97a6a6c",
+            "41d64cdeb347bf236b4c13b7403b633ff11f1cf94dbc7cf881a44d6da88c5156",
+            "eb36921e1f82af46dfe248ef8f1b3afb6a5230a64181d960d10237a08cd73c79",
+            "e769d7487cc314d3ee748a4440805317c19262c7acd2fdbdb0d47d2e4613a15c",
+            "1b80f120dbd88e4355d6241b519c3e25290215c469516b49dece9cf07175a766"
+          ],
+          "mounts": [
+            {
+              "destination": "/container/path/one",
+              "options": [
+                "rbind",
+                "rshared",
+                "rw"
+              ],
+              "source": "sandbox:///host/path/one",
+              "type": "bind"
+            },
+            {
+              "destination": "/container/path/two",
+              "options": [
+                "rbind",
+                "rshared",
+                "ro"
+              ],
+              "source": "sandbox:///host/path/two",
+              "type": "bind"
+            }
+          ],
+          "no_new_privileges": true,
+          "seccomp_profile_sha256": "",
+          "signals": [],
+          "user": {
+            "group_idnames": [
+              {
+                "pattern": "",
+                "strategy": "any"
+              }
+            ],
+            "umask": "0022",
+            "user_idname": {
+              "pattern": "",
+              "strategy": "any"
+            }
+          },
+          "working_dir": "/home/user"
+        }
+      ]
+    },
+    {
+      "action": "add",
+      "key": "/run/gcs/c/container0/rootfs",
+      "name": "overlayTargets",
+      "value": true
+    }
+  ]
+}
+""";
+
+        Assert.IsTrue(JsonNode.DeepEquals(JsonNode.Parse(expected), JsonNode.Parse(result!)), $"Actual: {result}");
+    }
+
+    [TestMethod]
+    public void GetPolicyPackageNames_succeeds()
+    {
+        using var engine = new Engine();
+        engine.AddPolicy(
+            "test.rego",
+            "package test\nx = 1\nmessage = `Hello`");
+
+        engine.AddPolicy(
+            "test.rego",
+            "package test.nested.name\nx = 1\nmessage = `Hello`");
+
+        var result = engine.GetPolicyPackageNames();
+
+        Assert.IsNotNull(result);
+
+        var packageNames = JsonNode.Parse(result);
+        Assert.IsNotNull(packageNames);
+
+        var packageArray = packageNames.AsArray();
+        var firstPackage = packageArray[0]?.AsObject();
+        var secondPackage = packageArray[1]?.AsObject();
+
+        Assert.IsNotNull(firstPackage);
+        Assert.IsNotNull(secondPackage);
+        Assert.AreEqual("test", firstPackage!["package_name"]!.GetValue<string>());
+        Assert.AreEqual("test.nested.name", secondPackage!["package_name"]!.GetValue<string>());
+    }
+
+    [TestMethod]
+    public void GetPolicyParameters_succeeds()
+    {
+        using var engine = new Engine();
+        engine.AddPolicy(
+            "test.rego",
+            "package test\n default parameters.a = 5\nparameters.b = 10\nx = 1\nmessage = `Hello`");
+
+        var result = engine.GetPolicyParameters();
+
+        Assert.IsNotNull(result);
+
+        var parameters = JsonNode.Parse(result);
+        Assert.IsNotNull(parameters);
+
+        var parametersArray = parameters.AsArray();
+        var firstEntry = parametersArray[0]?.AsObject();
+        Assert.IsNotNull(firstEntry);
+
+        var parameterList = firstEntry!["parameters"]!.AsArray();
+        var modifierList = firstEntry["modifiers"]!.AsArray();
+
+        Assert.AreEqual(1, parameterList.Count);
+        Assert.AreEqual(1, modifierList.Count);
+
+        var parameterName = parameterList[0]?.AsObject()?["name"]?.GetValue<string>();
+        var modifierName = modifierList[0]?.AsObject()?["name"]?.GetValue<string>();
+
+        Assert.AreEqual("a", parameterName);
+        Assert.AreEqual("b", modifierName);
+    }
+
+    [TestMethod]
+    public void Global_memory_limit_can_be_set_and_cleared()
+    {
+        lock (LimitLock)
+        {
+            using var guard = new MemoryLimitScope();
+
+            MemoryLimits.SetGlobalMemoryLimit(null);
+            Assert.IsNull(MemoryLimits.GetGlobalMemoryLimit());
+
+            const ulong limit = 32 * 1024;
+            MemoryLimits.SetGlobalMemoryLimit(limit);
+            Assert.AreEqual(limit, MemoryLimits.GetGlobalMemoryLimit());
+
+            MemoryLimits.SetGlobalMemoryLimit(null);
+            Assert.IsNull(MemoryLimits.GetGlobalMemoryLimit());
+        }
+    }
+
+    [TestMethod]
+    public void Memory_limit_violations_surface_from_engine_calls()
+    {
+        lock (LimitLock)
+        {
+            using var guard = new MemoryLimitScope();
+            using var engine = new Engine();
+
+            const ulong limit = 1;
+            var payload = new string('x', 128 * 1024);
+
+            MemoryLimits.FlushThreadMemoryCounters();
+            MemoryLimits.SetGlobalMemoryLimit(limit);
+
+            try
+            {
+                var ex = Assert.ThrowsException<InvalidOperationException>(
+                  () => engine.SetInputJson($"{{\"payload\":\"{payload}\"}}"));
+                StringAssert.Contains(ex.Message, "execution exceeded memory limit");
+            }
+            finally
+            {
+                MemoryLimits.SetGlobalMemoryLimit(null);
+                MemoryLimits.FlushThreadMemoryCounters();
+            }
+        }
+    }
+
+    [TestMethod]
+    public void Evaluation_fails_when_input_pushes_policy_over_global_limit()
+    {
+        lock (LimitLock)
+        {
+            using var guard = new MemoryLimitScope();
+            using var engine = new Engine();
+
+            const string policy = """
+package memorylimit
+
+import rego.v1
+
+stretched := concat("", [input.block | numbers.range(0, input.repeat - 1)[_]])
+""";
+
+            engine.AddPolicy("memorylimit.rego", policy);
+
+            MemoryLimits.FlushThreadMemoryCounters();
+            const ulong limit = 4 * 1024 * 1024;
+            MemoryLimits.SetGlobalMemoryLimit(limit);
+
+            var block = new string('x', 16 * 1024);
+
+            var smallInput = JsonSerializer.Serialize(new { block, repeat = 16 });
+            engine.SetInputJson(smallInput);
+            var smallResult = engine.EvalRule("data.memorylimit.stretched");
+            Assert.IsNotNull(smallResult);
+            var stretched = JsonSerializer.Deserialize<string>(smallResult);
+            Assert.IsNotNull(stretched, "Policy should return a string result.");
+            Assert.AreEqual(block.Length * 16, stretched!.Length, "Policy should expand the payload under the limit.");
+
+            var largeInput = JsonSerializer.Serialize(new { block, repeat = 4096 });
+            engine.SetInputJson(largeInput);
+
+            var ex = Assert.ThrowsException<InvalidOperationException>(
+              () => engine.EvalRule("data.memorylimit.stretched"));
+            StringAssert.Contains(ex.Message, "execution exceeded memory limit");
+        }
+    }
+
+    [TestMethod]
+    public void Thread_flush_threshold_roundtrips()
+    {
+        lock (LimitLock)
+        {
+            var original = MemoryLimits.GetThreadMemoryFlushThreshold();
+            try
+            {
+                const ulong threshold = 256 * 1024;
+                MemoryLimits.SetThreadFlushThresholdOverride(threshold);
+                Assert.AreEqual(threshold, MemoryLimits.GetThreadMemoryFlushThreshold());
+
+                MemoryLimits.SetThreadFlushThresholdOverride(null);
+                var restored = MemoryLimits.GetThreadMemoryFlushThreshold();
+                Assert.IsTrue(restored.HasValue, "Clearing override should restore allocator default.");
+                if (original.HasValue)
+                {
+                    Assert.AreEqual(original, restored);
+                }
+            }
+            finally
+            {
+                MemoryLimits.SetThreadFlushThresholdOverride(original);
+            }
+        }
+    }
+
+    [TestMethod]
+    public void SetInputJson_has_negligible_allocations_after_warmup()
+    {
+        using var engine = new Engine();
+        const string payload = "{}";
+
+        // Warm up the engine and JIT to ensure subsequent measurements are representative.
+        for (int i = 0; i < 16; i++)
+        {
+            engine.SetInputJson(payload);
+        }
+
+        GC.Collect();
+        GC.WaitForPendingFinalizers();
+        GC.Collect();
+
+        const int iterations = 256;
+        var before = GC.GetAllocatedBytesForCurrentThread();
+
+        for (int i = 0; i < iterations; i++)
+        {
+            engine.SetInputJson(payload);
+        }
+
+        var after = GC.GetAllocatedBytesForCurrentThread();
+        var allocated = Math.Max(0, after - before);
+        var bytesPerOp = allocated / (double)iterations;
+
+        // Runtime bookkeeping (delegate caches, GC write barriers) differs across platforms, so
+        // we measure bytes per call rather than absolute totals and allow a small budget.
+        // CI will flag regressions where marshalling starts allocating per invocation.
+
+        // Allow a small budget for delegates and runtime bookkeeping while still flagging regressions.
+        Assert.IsTrue(
+          bytesPerOp <= 512,
+          $"Expected ≤512 B/op after warmup, but observed {bytesPerOp:F2} B/op (total {allocated} bytes)."
+        );
+    }
+
+    [TestMethod]
+    public void Disposed_objects_throw_object_disposed_exception()
+    {
+        var engine = new Engine();
+        engine.Dispose();
+        Assert.ThrowsException<ObjectDisposedException>(() => engine.EvalRule("data.test.message"));
+
+        var program = Program.CreateEmpty();
+        program.Dispose();
+        Assert.ThrowsException<ObjectDisposedException>(() => program.SerializeBinary());
+
+        var rvm = new Rvm();
+        rvm.Dispose();
+        Assert.ThrowsException<ObjectDisposedException>(() => rvm.Execute());
+
+        var modules = new[] { new PolicyModule("test.rego", "package test\nallow = true") };
+        var compiled = Compiler.CompilePolicyWithEntrypoint("{}", modules, "data.test.allow");
+        compiled.Dispose();
+        Assert.ThrowsException<ObjectDisposedException>(() => compiled.EvalWithInput("{}"));
+    }
+
+    [TestMethod]
+    public void Registry_helpers_return_empty_after_clear()
+    {
+        TargetRegistry.Clear();
+        Assert.IsTrue(TargetRegistry.IsEmpty);
+        Assert.AreEqual(0, TargetRegistry.GetNames().Count);
+
+        SchemaRegistry.ClearResources();
+        SchemaRegistry.ClearEffects();
+        Assert.IsTrue(SchemaRegistry.IsResourceRegistryEmpty);
+        Assert.IsTrue(SchemaRegistry.IsEffectRegistryEmpty);
+        Assert.AreEqual(0, SchemaRegistry.GetResourceNames().Count);
+        Assert.AreEqual(0, SchemaRegistry.GetEffectNames().Count);
+    }
+
+    [TestMethod]
+    public void Utf8_marshalling_handles_large_unicode_payloads()
+    {
+        var payload = string.Concat(new string('ß', 2048), "-✓-", new string('漢', 1024));
+
+        using var engine = new Engine();
+        engine.AddPolicy("test.rego", "package test\nmessage = input.msg");
+        engine.SetInputJson(JsonSerializer.Serialize(new { msg = payload }));
+
+        var result = engine.EvalRule("data.test.message");
+
+        Assert.IsNotNull(result);
+
+        // Compare by parsing the JSON string to avoid encoder differences across platforms.
+        var parsed = JsonSerializer.Deserialize<string>(result);
+        Assert.IsNotNull(parsed);
+
+        Assert.AreEqual(payload, parsed);
+    }
+
+    private sealed class MemoryLimitScope : IDisposable
+    {
+        private readonly ulong? _originalLimit;
+
+        public MemoryLimitScope()
+        {
+            _originalLimit = MemoryLimits.GetGlobalMemoryLimit();
+        }
+
+        public void Dispose()
+        {
+            MemoryLimits.SetGlobalMemoryLimit(_originalLimit);
+            MemoryLimits.FlushThreadMemoryCounters();
+        }
+    }
+}